Changeset 2087

code/trunk

Property svn:mergeinfo changed

/code/branches/objecthierarchy (added)	merged: 1912,1916-1918,1938-1950,1952-1953,1955,1957-1962,1968-1970,1989-1990,1993-1994,2001-2013,2016-2020,2023-2035,2037,2039-2042,2044-2046,2048,2062-2067,2069-2075,2078-2080,2082,2084-2085
/code/branches/script_trigger (added)	merged: 1296,1307,1383,1541,1550,1671,1693,1851,1904,1906

code/trunk/TODO

-                      r1907
+                      r2087
 todo:
+        bidirectional
+        minimize synchronisableHeader
         !!! check that enet does not cause a packet traffic jam when a reliable packet gets missed !!!
-        [implemented] new gamestate concept
         !!! ensure that objects get synched, when newly created, even if not their tick
 …
 REMARKS:
         try to allocate sort the bytestream before copy (putt all 0's in one place)
+        try to sort the bytestream before copy (putt all 0's in one place)

code/trunk/bin/def_keybindings.ini

-                      r1887
+                      r2087
 [Keys]
 KeyA="scale -1 moveLateral"
+KeyA="scale -1 moveRightLeft"
 KeyABNT_C1=
 KeyABNT_C2=
 …
 KeyBack=
 KeyBackslash=
 KeyC=
+KeyC=switchCamera
 KeyCalculator=
 KeyCapsLock=
 …
 KeyComma=
 KeyConvert=
 KeyD="scale 1 moveLateral"
+KeyD="scale 1 moveRightLeft"
 KeyDelete=
 KeyDivide=
 KeyDown=
 KeyE="scale -1 moveRoll"
+KeyE="scale -1 rotateRoll"
 KeyEnd=
 KeyEquals=
 KeyEscape="exit"
 KeyF=
+KeyF="scale -1 moveUpDown"
 KeyF1="OverlayGroup toggleVisibility Debug"
 KeyF10=
 …
 KeyF8=
 KeyF9=
 KeyG=
+KeyG=greet
 KeyGrave="openConsole"
 KeyH=
 …
 KeyPower=
 KeyPreviousTrack=
 KeyQ="scale 1 moveRoll"
 KeyR=
+KeyQ="scale 1 rotateRoll"
+KeyR="scale 1 moveUpDown"
 KeyReturn=
 KeyRight=
 …
 KeyRightShift=
 KeyRightWindows=
 KeyS="scale -1 moveLongitudinal"
+KeyS="scale -1 moveFrontBack"
 KeyScrollLock=
 KeySemicolon=
 …
 KeyVolumeDown=
 KeyVolumeUp=
 KeyW="scale 1 moveLongitudinal"
+KeyW="scale 1 moveFrontBack"
 KeyWake=
 KeyWebBack=
 …
 [MouseAxes]
 MouseXNeg="scale 1 moveYaw"
 MouseXPos="scale -1 moveYaw"
 MouseYNeg="scale 1 movePitch"
 MouseYPos="scale -1 movePitch"
+MouseXNeg="scale -1 rotateYaw"
+MouseXPos="scale 1 rotateYaw"
+MouseYNeg="scale 1 rotatePitch"
+MouseYPos="scale -1 rotatePitch"

code/trunk/init/common/def_keybindings.ini

-                      r1897
+                      r2087
 [Keys]
 KeyA="scale -1 moveLateral"
+KeyA="scale -1 moveRightLeft"
 KeyABNT_C1=
 KeyABNT_C2=
 …
 KeyComma=
 KeyConvert=
 KeyD="scale 1 moveLateral"
+KeyD="scale 1 moveRightLeft"
 KeyDelete=
 KeyDivide=
 KeyDown=
 KeyE="scale -1 moveRoll"
+KeyE="scale -1 rotateRoll"
 KeyEnd=
 KeyEquals=
 KeyEscape="exit"
 KeyF=
+KeyF="scale -1 moveUpDown"
 KeyF1="OverlayGroup toggleVisibility Debug"
 KeyF10=
 …
 KeyF8=
 KeyF9=
 KeyG=
+KeyG=greet
 KeyGrave="openConsole"
 KeyH=
 …
 KeyPower=
 KeyPreviousTrack=
 KeyQ="scale 1 moveRoll"
 KeyR=
+KeyQ="scale 1 rotateRoll"
+KeyR="scale 1 moveUpDown"
 KeyReturn=
 KeyRight=
 …
 KeyRightShift=
 KeyRightWindows=
 KeyS="scale -1 moveLongitudinal"
+KeyS="scale -1 moveFrontBack"
 KeyScrollLock=
 KeySemicolon=
 …
 KeyVolumeDown=
 KeyVolumeUp=
 KeyW="scale 1 moveLongitudinal"
+KeyW="scale 1 moveFrontBack"
 KeyWake=
 KeyWebBack=
 …
 [MouseAxes]
 MouseXNeg="scale 1 moveYaw"
 MouseXPos="scale -1 moveYaw"
 MouseYNeg="scale 1 movePitch"
 MouseYPos="scale -1 movePitch"
+MouseXNeg="scale -1 rotateYaw"
+MouseXPos="scale 1 rotateYaw"
+MouseYNeg="scale 1 rotatePitch"
+MouseYPos="scale -1 rotatePitch"

code/trunk/src/core/ArgumentCompletionFunctions.cc

r1505	r2087
30	30	#include <map>
31	31
32		#include ~~"boost/filesystem.hpp"~~
	32	#include <boost/filesystem.hpp>
33	33
34	34	#include "ArgumentCompletionFunctions.h"

code/trunk/src/core/BaseObject.cc

-                      r1625
+                      r2087
 #include "tinyxml/tinyxml.h"
 #include "CoreIncludes.h"
+#include "EventIncludes.h"
 #include "XMLPort.h"
+#include "Level.h"
+#include "XMLFile.h"
+#include "XMLNameListener.h"
+#include "Template.h"
+#include "util/String.h"
 namespace orxonox
 …
         @brief Constructor: Registers the object in the BaseObject-list.
     */
     BaseObject::BaseObject() : bInitialized_(false)
+    BaseObject::BaseObject(BaseObject* creator) : bInitialized_(false)
+    {
         RegisterRootObject(BaseObject);
 …
         this->bActive_ = true;
         this->bVisible_ = true;
+        this->level_ = 0;
+        this->namespace_ = 0;
+        this->oldGametype_ = 0;
+        this->setCreator(creator);
+        if (this->creator_)
+        {
+            this->setFile(this->creator_->getFile());
+            this->setNamespace(this->creator_->getNamespace());
+            this->setScene(this->creator_->getScene());
+            this->setGametype(this->creator_->getGametype());
+        }
+        else
+        {
+            this->file_ = 0;
+            this->namespace_ = 0;
+            this->scene_ = 0;
+            this->gametype_ = 0;
+        }
+    }
 …
     BaseObject::~BaseObject()
+    {
+        for (std::list<BaseObject*>::const_iterator it = this->events_.begin(); it != this->events_.end(); ++it)
+            (*it)->unregisterEventListener(this);
+        for (std::map<BaseObject*, std::string>::const_iterator it = this->eventListeners_.begin(); it != this->eventListeners_.end(); ++it)
+            it->first->removeEvent(this);
+    }
 …
     void BaseObject::XMLPort(Element& xmlelement, XMLPort::Mode mode)
+    {
         XMLPortParam(BaseObject, "name", setName, getName, xmlelement, mode);
+        XMLPortParam(BaseObject, "name", setXMLName, getName, xmlelement, mode);
         XMLPortParam(BaseObject, "visible", setVisible, isVisible, xmlelement, mode);
         XMLPortParam(BaseObject, "active", setActive, isActive, xmlelement, mode);
+        XMLPortObjectTemplate(BaseObject, Template, "templates", addTemplate, getTemplate, xmlelement, mode, Template*);
+        Element* events = xmlelement.FirstChildElement("events", false);
+        if (events)
+        {
+            std::list<std::string> eventnames;
+            if (mode == XMLPort::LoadObject)
+            {
+                for (ticpp::Iterator<ticpp::Element> child = events->FirstChildElement(false); child != child.end(); child++)
+                    eventnames.push_back(child->Value());
+            }
+            else if (mode == XMLPort::SaveObject)
+            {
+                for (std::map<std::string, XMLPortObjectContainer*>::const_iterator it = this->getIdentifier()->getXMLPortEventMapBegin(); it != this->getIdentifier()->getXMLPortEventMapEnd(); ++it)
+                    eventnames.push_back(it->first);
+            }
+            for (std::list<std::string>::iterator it = eventnames.begin(); it != eventnames.end(); ++it)
+            {
+                std::string sectionname = (*it);
+                ExecutorMember<BaseObject>* loadexecutor = createExecutor(createFunctor(&BaseObject::addEvent), std::string( "BaseObject" ) + "::" + "addEvent");
+                ExecutorMember<BaseObject>* saveexecutor = createExecutor(createFunctor(&BaseObject::getEvent), std::string( "BaseObject" ) + "::" + "getEvent");
+                loadexecutor->setDefaultValue(1, sectionname);
+                XMLPortClassObjectContainer<BaseObject, BaseObject>* container = 0;
+                container = (XMLPortClassObjectContainer<BaseObject, BaseObject>*)(this->getIdentifier()->getXMLPortEventContainer(sectionname));
+                if (!container)
+                {
+                    container = new XMLPortClassObjectContainer<BaseObject, BaseObject>(sectionname, this->getIdentifier(), loadexecutor, saveexecutor, false, true);
+                    this->getIdentifier()->addXMLPortEventContainer(sectionname, container);
+                }
+                container->port(this, *events, mode);
+            }
+        }
+    }
+    /**
+        @brief Loads the name of the object through XML and calls all XMLNameListener.
+        @param name The name of the object
+    */
+    void BaseObject::setXMLName(const std::string& name)
+    {
+        this->setName(name);
+        for (ObjectList<XMLNameListener>::iterator it = ObjectList<XMLNameListener>::begin(); it != ObjectList<XMLNameListener>::end(); ++it)
+            it->loadedNewXMLName(this);
+    }
 …
         @return The levelfile
     */
+    const std::string& BaseObject::getLevelfile() const
+    {
+        return this->level_->getFile();
+    const std::string& BaseObject::getFilename() const
+    {
+        if (this->file_)
+            return this->file_->getFilename();
+        else
+            return BLANKSTRING;
+    }
+    /**
+        @brief Adds a Template to the object.
+        @param name The name of the Template
+    */
+    void BaseObject::addTemplate(const std::string& name)
+    {
+        Template* temp = Template::getTemplate(name);
+        if (temp)
+            this->addTemplate(temp);
+        else
+            COUT(1) << "Error: \"" << name << "\" is not a valid Template name (in class: " << this->getIdentifier()->getName() << ", name: " << this->getName() << ")." << std::endl;
+    }
+    /**
+        @brief Adds a Template to the object.
+        @param temp The Template
+    */
+    void BaseObject::addTemplate(Template* temp)
+    {
+        this->templates_.insert(temp);
+        temp->applyOn(this);
+    }
+    /**
+        @brief Returns the Template with the given index.
+        @param index The index
+    */
+    Template* BaseObject::getTemplate(unsigned int index) const
+    {
+        unsigned int i = 0;
+        for (std::set<Template*>::const_iterator it = this->templates_.begin(); it != this->templates_.end(); ++it)
+        {
+            if (i == index)
+                return (*it);
+            i++;
+        }
+        return 0;
+    }
+    void BaseObject::addEvent(BaseObject* event, const std::string& sectionname)
+    {
+        event->registerEventListener(this, sectionname);
+        this->events_.push_back(event);
+    }
+    void BaseObject::removeEvent(BaseObject* event)
+    {
+        this->events_.remove(event);
+    }
+    BaseObject* BaseObject::getEvent(unsigned int index) const
+    {
+        unsigned int i = 0;
+        for (std::list<BaseObject*>::const_iterator it = this->events_.begin(); it != this->events_.end(); ++it)
+        {
+            if (i == index)
+                return (*it);
+            ++i;
+        }
+        return 0;
+    }
+    void BaseObject::addEventContainer(const std::string& sectionname, EventContainer* container)
+    {
+        std::map<std::string, EventContainer*>::const_iterator it = this->eventContainers_.find(sectionname);
+        if (it != this->eventContainers_.end())
+        {
+            COUT(2) << "Warning: Overwriting EventContainer in class " << this->getIdentifier()->getName() << "." << std::endl;
+            delete (it->second);
+        }
+        this->eventContainers_[sectionname] = container;
+    }
+    EventContainer* BaseObject::getEventContainer(const std::string& sectionname) const
+    {
+        std::map<std::string, EventContainer*>::const_iterator it = this->eventContainers_.find(sectionname);
+        if (it != this->eventContainers_.end())
+            return ((*it).second);
+        else
+            return 0;
+    }
+    void BaseObject::fireEvent()
+    {
+        this->fireEvent(true);
+        this->fireEvent(false);
+    }
+    void BaseObject::fireEvent(bool activate)
+    {
+        this->fireEvent(activate, this);
+    }
+    void BaseObject::fireEvent(bool activate, BaseObject* originator)
+    {
+        Event event(activate, originator);
+        for (std::map<BaseObject*, std::string>::iterator it = this->eventListeners_.begin(); it != this->eventListeners_.end(); ++it)
+        {
+            event.sectionname_ = it->second;
+            it->first->processEvent(event);
+        }
+    }
+    void BaseObject::fireEvent(Event& event)
+    {
+        for (std::map<BaseObject*, std::string>::iterator it = this->eventListeners_.begin(); it != this->eventListeners_.end(); ++it)
+            it->first->processEvent(event);
+    }
+    void BaseObject::processEvent(Event& event)
+    {
+        SetEvent(BaseObject, "activity", setActive, event);
+        SetEvent(BaseObject, "visibility", setVisible, event);
+    }
+}

code/trunk/src/core/BaseObject.h

-                      r1841
+                      r2087
 #define _BaseObject_H__
+#include <map>
 #include "CorePrereqs.h"
 …
 #include "OrxonoxClass.h"
 #include "XMLIncludes.h"
+#include "Event.h"
 namespace orxonox
+{
+    class Scene;
+    class Gametype;
     //! The BaseObject is the parent of all classes representing an instance in the game.
     class _CoreExport BaseObject : virtual public OrxonoxClass
+    {
-        friend class WorldEntity;
         public:
             BaseObject();
+            BaseObject(BaseObject* creator);
             virtual ~BaseObject();
             virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
 …
             /** @brief Sets the name of the object. @param name The name */
             inline void setName(const std::string& name) { this->name_ = name; this->changedName(); }
             /** @brief Returns the name of the object. @return The name */
+            inline void setName(const std::string& name) { this->oldName_ = this->name_; this->name_ = name; this->changedName(); }
+            /** @brief Returns the name of the object. */
             inline const std::string& getName() const { return this->name_; }
+            /** @brief Returns the old name of the object. */
+            inline const std::string& getOldName() const { return this->oldName_; }
             /** @brief This function gets called if the name of the object changes. */
             virtual void changedName() {}
 …
             virtual void changedVisibility() {}
+            /** @brief Sets a pointer to the level that loaded this object. @param level The pointer to the level */
+            inline void setLevel(const Level* level) { this->level_ = level; }
+            /** @brief Returns a pointer to the level that loaded this object. @return The level */
+            inline const Level* getLevel() const { return this->level_; }
+            const std::string& getLevelfile() const;
+            /** @brief Sets a pointer to the xml file that loaded this object. @param file The pointer to the XMLFile */
+            inline void setFile(const XMLFile* file) { this->file_ = file; }
+            /** @brief Returns a pointer to the XMLFile that loaded this object. @return The XMLFile */
+            inline const XMLFile* getFile() const { return this->file_; }
+            const std::string& getFilename() const;
+            void addTemplate(const std::string& name);
+            void addTemplate(Template* temp);
+            /** @brief Returns the set of all aplied templates. */
+            inline const std::set<Template*>& getTemplates() const
+                { return this->templates_; }
             virtual inline void setNamespace(Namespace* ns) { this->namespace_ = ns; }
             inline Namespace* getNamespace() const { return this->namespace_; }
+            inline void setCreator(BaseObject* creator) { this->creator_ = creator; }
+            inline BaseObject* getCreator() const { return this->creator_; }
+            inline void setScene(Scene* scene) { this->scene_ = scene; }
+            inline Scene* getScene() const { return this->scene_; }
+            inline void setGametype(Gametype* gametype) { this->oldGametype_ = this->gametype_; this->gametype_ = gametype; this->changedGametype(); }
+            inline Gametype* getGametype() const { return this->gametype_; }
+            inline Gametype* getOldGametype() const { return this->oldGametype_; }
+            virtual inline void changedGametype() {}
+            void fireEvent();
+            void fireEvent(bool activate);
+            void fireEvent(bool activate, BaseObject* originator);
+            void fireEvent(Event& event);
+            virtual void processEvent(Event& event);
+            inline void registerEventListener(BaseObject* object, const std::string& sectionname)
+                { this->eventListeners_[object] = sectionname; }
+            inline void unregisterEventListener(BaseObject* object)
+                { this->eventListeners_.erase(object); }
+            void addEvent(BaseObject* event, const std::string& sectionname);
+            void removeEvent(BaseObject* event);
+            BaseObject* getEvent(unsigned int index) const;
+            void addEventContainer(const std::string& sectionname, EventContainer* container);
+            EventContainer* getEventContainer(const std::string& sectionname) const;
             /** @brief Sets the indentation of the debug output in the Loader. @param indentation The indentation */
 …
             inline const std::string& getLoaderIndentation() const { return this->loaderIndentation_; }
         private:
+        protected:
             std::string name_;                          //!< The name of the object
             bool bInitialized_;                         //!< True if the object was initialized (passed the object registration)
+            std::string oldName_;                       //!< The old name of the object
             bool bActive_;                              //!< True = the object is active
             bool bVisible_;                             //!< True = the object is visible
+            const Level* level_;                        //!< The level that loaded this object
+            std::string loaderIndentation_;             //!< Indentation of the debug output in the Loader
+            Namespace* namespace_;
+        private:
+            void setXMLName(const std::string& name);
+            Template* getTemplate(unsigned int index) const;
+            bool                  bInitialized_;         //!< True if the object was initialized (passed the object registration)
+            const XMLFile*        file_;                 //!< The XMLFile that loaded this object
+            std::string           loaderIndentation_;    //!< Indentation of the debug output in the Loader
+            Namespace*            namespace_;
+            BaseObject*           creator_;
+            Scene*                scene_;
+            Gametype*             gametype_;
+            Gametype*             oldGametype_;
+            std::set<Template*>   templates_;
+            std::map<BaseObject*, std::string> eventListeners_;
+            std::list<BaseObject*> events_;
+            std::map<std::string, EventContainer*> eventContainers_;
     };
 …
     SUPER_FUNCTION(2, BaseObject, changedActivity, false);
     SUPER_FUNCTION(3, BaseObject, changedVisibility, false);
+    SUPER_FUNCTION(4, BaseObject, processEvent, false);
+}

code/trunk/src/core/CMakeLists.txt

-                      r1887
+                      r2087
   ConfigValueContainer.cc
   Core.cc
+  Event.cc
   GameState.cc
   Language.cc
+  LuaBind.cc
   ObjectListBase.cc
   OrxonoxClass.cc
   RootGameState.cc
-  Script.cc
   # command
 …
   Namespace.cc
   NamespaceNode.cc
+  Template.cc
   XMLPort.cc
+  XMLNameListener.cc
   # shell
 …
     tolua_orxonox
     tolua/tolua.pkg
     Script.h
+    LuaBind.h
     CommandExecutor.h
   WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}/bin/lib

code/trunk/src/core/ClassFactory.h

-                      r1747
+                      r2087
+    {
         public:
             static bool create(const std::string& name);
             BaseObject* fabricate();
+            static bool create(const std::string& name, bool bLoadable = true);
+            BaseObject* fabricate(BaseObject* creator);
         private:
 …
             virtual ~ClassFactory() {}                      // Don't delete
             static T* createNewObject();
+            static T* createNewObject(BaseObject* creator);
     };
     /**
         @brief Adds the ClassFactory to the Identifier of the same type and the Identifier to the Factory.
+        @param name The name of the class
+        @param bLoadable True if the class can be loaded through XML
         @return Always true (this is needed because the compiler only allows assignments before main())
     */
     template <class T>
     bool ClassFactory<T>::create(const std::string& name)
+    bool ClassFactory<T>::create(const std::string& name, bool bLoadable)
+    {
         COUT(4) << "*** ClassFactory: Create entry for " << name << " in Factory." << std::endl;
         ClassIdentifier<T>::getIdentifier(name)->addFactory(new ClassFactory<T>);
+        ClassIdentifier<T>::getIdentifier()->setLoadable(bLoadable);
         Factory::add(name, ClassIdentifier<T>::getIdentifier());
 …
     */
     template <class T>
     BaseObject* ClassFactory<T>::fabricate()
+    BaseObject* ClassFactory<T>::fabricate(BaseObject* creator)
+    {
         return ClassFactory<T>::createNewObject();
+        return ClassFactory<T>::createNewObject(creator);
+    }
 …
     */
     template <class T>
     T* ClassFactory<T>::createNewObject()
+    T* ClassFactory<T>::createNewObject(BaseObject* creator)
+    {
         return new T;
+        return new T(creator);
+    }
+}

code/trunk/src/core/CommandEvaluation.cc

r1879	r2087
78	78	if (this->bEvaluatedParams_ && this->function_)
79	79	{
80		COUT(5) << "CE_execute (evaluation): " << this->function_->getName() << " " << this->param_[0] << " " << this->param_[1] << " " << this->param_[2] << " " << this->param_[3] << " " << this->param_[4] << std::endl;
	80	COUT(6) << "CE_execute (evaluation): " << this->function_->getName() << " " << this->param_[0] << " " << this->param_[1] << " " << this->param_[2] << " " << this->param_[3] << " " << this->param_[4] << std::endl;
81	81	(*this->function_)(this->param_[0], this->param_[1], this->param_[2], this->param_[3], this->param_[4]);
82	82	return true;

code/trunk/src/core/CommandLine.cc

-                      r1755
+                      r2087
     /**
     @brief
+        Parses a value string for a command line argument.
+        It simply uses convertValue(Output, Input) to do that.
+        Bools are treated specially. That is necessary
+        so that you can have simple command line switches.
+    */
+    void CommandLineArgument::parse(const std::string& value)
+    {
+        if (value_.getType() == MT_bool)
+        {
+            // simulate command line switch
+            bool temp;
+            if (convertValue(&temp, value))
+            {
+                this->bHasDefaultValue_ = false;
+                this->value_ = temp;
+            }
+            else if (value == "")
+            {
+                this->bHasDefaultValue_ = false;
+                this->value_ = true;
+            }
+            else
+            {
+                ThrowException(Argument, "Could not read command line argument '" + getName() + "'.");
+            }
+        }
+        else
+        {
+            if (!value_.setValue(value))
+            {
+                value_.setValue(defaultValue_);
+                ThrowException(Argument, "Could not read command line argument '" + getName() + "'.");
+            }
+            else
+                this->bHasDefaultValue_ = false;
+        }
+    }
+    /**
+    @brief
         Destructor destroys all CommandLineArguments with it.
     */
     CommandLine::~CommandLine()
+    {
         for (std::map<std::string, BaseCommandLineArgument*>::const_iterator it = cmdLineArgs_.begin();
+        for (std::map<std::string, CommandLineArgument*>::const_iterator it = cmdLineArgs_.begin();
             it != cmdLineArgs_.end(); ++it)
+        {
 …
+        {
             // first shove all the shortcuts in a map
             for (std::map<std::string, BaseCommandLineArgument*>::const_iterator it = cmdLineArgs_.begin();
+            for (std::map<std::string, CommandLineArgument*>::const_iterator it = cmdLineArgs_.begin();
                 it != cmdLineArgs_.end(); ++it)
+            {
 …
     void CommandLine::checkFullArgument(const std::string& name, const std::string& value)
+    {
         std::map<std::string, BaseCommandLineArgument*>::const_iterator it = cmdLineArgs_.find(name);
+        std::map<std::string, CommandLineArgument*>::const_iterator it = cmdLineArgs_.find(name);
         if (it == cmdLineArgs_.end())
             ThrowException(Argument, "Command line argument '" + name + "' does not exist.");
 …
     void CommandLine::checkShortcut(const std::string& shortcut, const std::string& value)
+    {
         std::map<std::string, BaseCommandLineArgument*>::const_iterator it = cmdLineArgsShortcut_.find(shortcut);
+        std::map<std::string, CommandLineArgument*>::const_iterator it = cmdLineArgsShortcut_.find(shortcut);
         if (it == cmdLineArgsShortcut_.end())
             ThrowException(Argument, "Command line shortcut '" + shortcut + "' does not exist.");
 …
         CommandLine* inst = &_getInstance();
         std::string infoStr;
         for (std::map<std::string, BaseCommandLineArgument*>::const_iterator it = inst->cmdLineArgs_.begin();
+        for (std::map<std::string, CommandLineArgument*>::const_iterator it = inst->cmdLineArgs_.begin();
             it != inst->cmdLineArgs_.end(); ++it)
+        {
 …
+    }
+    /**
+    @brief
+        Retrieves a CommandLineArgument.
+        The method throws an exception if 'name' was not found or the value could not be converted.
+    @note
+        You shold of course not call this method before the command line has been parsed.
+    */
+    const CommandLineArgument* CommandLine::getArgument(const std::string& name)
+    {
+        std::map<std::string, CommandLineArgument*>::const_iterator it = _getInstance().cmdLineArgs_.find(name);
+        if (it == _getInstance().cmdLineArgs_.end())
+        {
+            ThrowException(Argument, "Could find command line argument '" + name + "'.");
+        }
+        else
+        {
+            return it->second;
+        }
+    }
+}

code/trunk/src/core/CommandLine.h

-                      r1764
+                      r2087
 #include "util/Debug.h"
 #include "util/Exception.h"
+#include "util/MultiType.h"
 #define SetCommandLineArgument(name, defaultValue) \
     BaseCommandLineArgument& CmdArgumentDummyBoolVar##name \
+    CommandLineArgument& CmdArgumentDummyBoolVar##name \
     = orxonox::CommandLine::addArgument(#name, defaultValue)
 #define SetCommandLineSwitch(name) \
     BaseCommandLineArgument& CmdArgumentDummyBoolVar##name \
+    CommandLineArgument& CmdArgumentDummyBoolVar##name \
     = orxonox::CommandLine::addArgument(#name, false)
 …
     /**
     @brief
+        Template struct which creates a distinct type for every integer constant.
+    @note
+        This allows to select a different function depending on a boolean value
+        when creating a new CommandLineArgument.
+        From 'Modern C++ Design' (Alexandrescu 2001).
+        Container class for a command line argument of any type supported by MultiType.
+        Whenever you want to have an option specified by a command line switch,
+        you need to first define it with SetCommandLineArgument(name, defaultValue).
+        It is then added to a map and possibly changed when the command line is being parsed.
+        If the option was not given, you can detect this by asking hasDefaultValue().
+        There is a possibility to define a short cut so you can write "-p 20" instead of "--port 20".
+        Note the difference between "-" and "--"!
+        Also, there is no restriction to the number of strings you add after --name.
+        So "--startVector (2, 4, 5)" is perfectly legal.
+        Retrieving an argument is possible with the getCommandLineArgument function of the
+        CommandLine class. It is a Singleton, but the public interface is static.
     */
+    template <int v>
+    struct Int2Type
+    {
+        enum { value = v };
+    };
+    /**
+    @brief
+        Base class for CommandLineArguments.
+    */
+    class _CoreExport BaseCommandLineArgument
+    class _CoreExport CommandLineArgument
+    {
         friend class CommandLine;
 …
         const std::string& getShortcut() const { return shortcut_; }
         //! Sets the shortcut for the argument
         BaseCommandLineArgument& setShortcut(const std::string& shortcut)
+        CommandLineArgument& shortcut(const std::string& shortcut)
         { this->shortcut_ = shortcut; return *this; }
 …
         const std::string& getInformation() const { return this->usageInformation_; }
         //! Sets the option information when displaying orxonox usage.
         BaseCommandLineArgument& setInformation(const std::string& usage)
+        CommandLineArgument& information(const std::string& usage)
         { this->usageInformation_ = usage; return *this; }
+    protected:
+        BaseCommandLineArgument(const std::string& name)
+        //! Returns the actual value of the argument. Can be equal to default value.
+        MultiType getValue() const { return value_; }
+        //! Returns the given default value as type T.
+        MultiType getDefaultValue() const { return defaultValue_; }
+    private:
+        //! Constructor initialises both value_ and defaultValue_ with defaultValue.
+        CommandLineArgument(const std::string& name, const MultiType& defaultValue)
             : bHasDefaultValue_(true)
             , name_(name)
+            , value_(defaultValue)
+            , defaultValue_(defaultValue)
         { }
         //! Undefined copy constructor
         BaseCommandLineArgument(const BaseCommandLineArgument& instance);
         virtual ~BaseCommandLineArgument() { }
+        CommandLineArgument(const CommandLineArgument& instance);
+        ~CommandLineArgument() { }
         //! Parses the value string of a command line argument.
         virtual void parse(const std::string& value) = 0;
+        void parse(const std::string& value);
         //! Tells whether the value has been changed by the command line.
 …
         std::string shortcut_;         //!< Shortcut of the argument. @see getShortcut().
         std::string usageInformation_; //!< Tells about the usage of this parameter
+        MultiType value_;            //!< The actual value
+        MultiType defaultValue_;     //!< Default value. Should not be changed.
     };
-    /**
-    @brief
-        Container class for a command line argument of type T.
-        Whenever you want to have an option specified by a command line switch,
-        you need to first define it with SetCommandLineArgument(name, defaultValue).
-        It is then added to a map and possibly changed when the command line is being parsed.
-        If the option was not given, you can detect this by asking hasDefaultValue().
-        There is a possibility to define a short cut so you can write "-p 20" instead of "--port 20".
-        Note the difference between "-" and "--"!
-        Also, there is no restriction to the number of strings you add after --name.
-        So "--startVector (2, 4, 5)" is perfectly legal.
-        Retrieving an argument is possible with the getCommandLineArgument function of the
-        CommandLine class. It is a Singleton, but the public interface is static.
-    */
-    template <class T>
-    class CommandLineArgument : public BaseCommandLineArgument
+    {
-        // Only let CommandLine change the value.
-        friend class CommandLine;
-    public:
-        //! Returns the actual value of the argument. Can be equal to default value.
-        T getValue() const { return value_; }
-        //! Returns the given default value as type T.
-        T getDefaultValue() const { return defaultValue_; }
-    private:
-        //! Constructor initialises both value_ and defaultValue_ with defaultValue.
-        CommandLineArgument(const std::string& name, const T& defaultValue)
-            : BaseCommandLineArgument(name)
-            , value_(defaultValue)
-            , defaultValue_(defaultValue)
-        { }
-        virtual void parse(const std::string& value);
-        T value_;            //!< The actual value
-        T defaultValue_;     //!< Default value. Should not be changed.
-    };
-    /**
-    @brief
-        Parses a value string for a command line argument.
-        It simply uses convertValue(Output, Input) to do that.
-    */
-    template <class T>
-    void CommandLineArgument<T>::parse(const std::string& value)
+    {
-        if (convertValue(&this->value_, value))
+        {
-            this->bHasDefaultValue_ = false;
+        }
-        else
+        {
-            ThrowException(Argument, "Could not read command line argument '" + getName() + "'.");
+        }
+    }
-    /**
-    @brief
-        Parses a value string for a command line argument.
-        It simply uses convertValue(Output, Input) to do that.
-        This is a template specialisation for bool type. That is necessary
-        so that you can have simple command line switches.
-    */
-    template <>
-    inline void CommandLineArgument<bool>::parse(const std::string& value)
+    {
-        if (convertValue(&this->value_, value))
+        {
-            this->bHasDefaultValue_ = false;
+        }
-        else if (value == "")
+        {
-            this->bHasDefaultValue_ = false;
-            this->value_ = true;
+        }
-        else
+        {
-            ThrowException(Argument, "Could not read command line argument '" + getName() + "'.");
+        }
+    }
 …
         static std::string getUsageInformation();
+        template <class T>
+        static const CommandLineArgument<T>* getArgument(const std::string& name);
+        static const CommandLineArgument* getArgument(const std::string& name);
         //! Writes the argument value in the given parameter.
         template <class T>
         static void getValue(const std::string& name, T* value)
+        { *value = getArgument<T>(name)->getValue(); }
+        { *value = (T)(getArgument(name)->getValue()); }
+        static MultiType getValue(const std::string& name)
+        { return getArgument(name)->getValue(); }
         template <class T>
+        static BaseCommandLineArgument& addArgument(const std::string& name, T defaultValue);
+        static CommandLineArgument& addArgument(const std::string& name, T defaultValue);
+        static bool existsArgument(const std::string& name)
+        {
+            std::map<std::string, CommandLineArgument*>::const_iterator it = _getInstance().cmdLineArgs_.find(name);
+            return !(it == _getInstance().cmdLineArgs_.end());
+        }
     private:
 …
         void checkShortcut(const std::string& shortcut, const std::string& value);
-        template <class T>
-        BaseCommandLineArgument* createArg(const std::string& name, T defaultValue, Int2Type<0> isString);
-        template <class T>
-        BaseCommandLineArgument* createArg(const std::string& name, T defaultValue, Int2Type<1> isString);
         /**
             Tells whether we parse the first expression. The CommmandLineArguments are added before main().
+            Tells whether we parsed for the first time. The CommmandLineArguments are added before main().
             So when we call parse() the first time, we need to create a map with all shortcuts since these
             get added after addCommandLineArgument().
 …
         //! Holds all pointers to the arguments and serves as a search map by name.
         std::map<std::string, BaseCommandLineArgument*> cmdLineArgs_;
+        std::map<std::string, CommandLineArgument*> cmdLineArgs_;
         //! Search map by chortcut for the arguments.
         std::map<std::string, BaseCommandLineArgument*> cmdLineArgsShortcut_;
+        std::map<std::string, CommandLineArgument*> cmdLineArgsShortcut_;
     };
+    /**
+    @brief
+        Retrieves a CommandLineArgument.
+        The method throws an exception if 'name' was not found or the value could not be converted.
+    @note
+        You shold of course not call this method before the command line has been parsed.
+    */
+    template <class T>
+    const CommandLineArgument<T>* CommandLine::getArgument(const std::string& name)
+    {
+        std::map<std::string, BaseCommandLineArgument*>::const_iterator it = _getInstance().cmdLineArgs_.find(name);
+        if (it == _getInstance().cmdLineArgs_.end())
+        {
+            ThrowException(Argument, "Could find command line argument '" + name + "'.");
+        }
+        else
+        {
+            CommandLineArgument<T>* arg = dynamic_cast<CommandLineArgument<T>* >(it->second);
+            if (arg == 0)
+            {
+                ThrowException(Argument, "Could not convert command line argument value to requested type. " \
+                    "You should use exactly the same type as predefined.");
+            }
+            else
+            {
+                return arg;
+            }
+        }
+    template <>
+    inline void CommandLine::getValue<std::string>(const std::string& name, std::string* value)
+    {
+        *value = (std::string)(getArgument(name)->getValue().getString());
+    }
 …
     @param defaultValue
         Default value that is used when argument was not given.
-    @note
-        In order to store char* strings as std::string too, there's
-        little bit of template programming involved:
-        StaticConversions::exists determines whether T converts to std::string.
-        Int2Type<int> is then used to call the right function. One returns
-        a CommandLineArgument<T> and the other CommandLineArgument<std::string>.
     */
     template <class T>
+    BaseCommandLineArgument& CommandLine::addArgument(const std::string& name, T defaultValue)
+    {
+        std::map<std::string, BaseCommandLineArgument*>::const_iterator it = _getInstance().cmdLineArgs_.find(name);
+        OrxAssert(it == _getInstance().cmdLineArgs_.end(),
+    CommandLineArgument& CommandLine::addArgument(const std::string& name, T defaultValue)
+    {
+        OrxAssert(!_getInstance().existsArgument(name),
             "Cannot add a command line argument with name '" + name + "' twice.");
+        return *(_getInstance().cmdLineArgs_[name] =
+            _getInstance().createArg(name, defaultValue, Int2Type<StaticConversion<T, std::string>::exists>()));
+    }
+    /**
+        Returns a new CommandLineArgument<T>.
+    */
+    template <class T>
+    BaseCommandLineArgument* CommandLine::createArg(const std::string& name, T defaultValue, Int2Type<0> isPrime)
+    {
+        return new CommandLineArgument<T>(name, defaultValue);
+    }
+    /**
+        Returns a new CommandLineArgument<std::string>.
+    */
+    template <class T>
+    BaseCommandLineArgument* CommandLine::createArg(const std::string& name, T defaultValue, Int2Type<1> isPrime)
+    {
+        return new CommandLineArgument<std::string>(name, defaultValue);
+        return *(_getInstance().cmdLineArgs_[name] = new CommandLineArgument(name, defaultValue));
+    }
+}

code/trunk/src/core/ConfigValueContainer.h

-                      r1887
+                      r2087
 #include "util/MultiType.h"
 #include "ConfigFileManager.h"
+#include "Identifier.h"
 namespace orxonox
 …
             inline virtual ~ConfigValueCallback() {}
             inline virtual void call(void* object)
                 { (((T*)object)->*this->function_)(); }
+                { if (!Identifier::isCreatingHierarchy()) { (((T*)object)->*this->function_)(); } }
         private:

code/trunk/src/core/ConsoleCommand.cc

-                      r1755
+                      r2087
         this->keybindMode_ = KeybindMode::OnPress;
+        this->axisParamIndex_ = -1;
+        this->bAxisRelative_ = false;
+        this->inputConfiguredParam_ = -1;
+    }

code/trunk/src/core/ConsoleCommand.h

-                      r1755
+                      r2087
                 { return this->argumentList_.end(); }
+            inline ConsoleCommand& setAsInputCommand()
+            {
+                this->keybindMode(KeybindMode::OnHold);
+                this->defaultValue(0, Vector2(0.0f, 0.0f));
+                this->inputConfiguredParam(0);
+                return *this;
+            }
             inline ConsoleCommand& keybindMode(KeybindMode::Enum mode)
                 { this->keybindMode_ = mode; return *this; }
 …
                 { return this->keybindMode_; }
+            inline ConsoleCommand& axisParamIndex(int index)
+                { this->axisParamIndex_ = index; return *this; }
+            inline int getAxisParamIndex() const
+                { return this->axisParamIndex_; }
+            inline ConsoleCommand& isAxisRelative(bool val)
+                { this->bAxisRelative_ = val; return *this; }
+            inline int getIsAxisRelative() const
+                { return this->bAxisRelative_; }
+            inline ConsoleCommand& inputConfiguredParam(int index)
+                { this->inputConfiguredParam_ = index; return *this; }
+            inline int getInputConfiguredParam_() const
+                { return this->inputConfiguredParam_; }
         private:
 …
             KeybindMode::Enum keybindMode_;
+            int axisParamIndex_;
+            bool bAxisRelative_;
+            int inputConfiguredParam_;
     };

code/trunk/src/core/Core.cc

-                      r1762
+                      r2087
 #include "CoreIncludes.h"
 #include "ConfigValueIncludes.h"
-//#include "input/InputManager.h"
-//#include "TclThreadManager.h"
 namespace orxonox
+{
+    bool Core::bShowsGraphics_s = false;
+    bool Core::bHasServer_s     = false;
+    bool Core::bIsClient_s      = false;
+    bool Core::bIsStandalone_s  = false;
+    bool Core::bIsMaster_s      = false;
     /**
         @brief Constructor: Registers the object and sets the config-values.
 …
         ResetConfigValue(language_);
+    }
-    ///**
-    //    @brief Ticks every core class in a specified sequence. Has to be called
-    //           every Orxonox tick!
-    //    @param dt Delta Time
-    //*/
-    //void Core::tick(float dt)
-    //{
-    //    TclThreadManager::getInstance().tick(dt);
-    //    InputManager::getInstance().tick(dt);
-    //}
+}

code/trunk/src/core/Core.h

-                      r1755
+                      r2087
             static void resetLanguage();
+            //static void tick(float dt);
+            // fast access global variables.
+            static bool showsGraphics() { return bShowsGraphics_s; }
+            static bool hasServer()     { return bHasServer_s; }
+            static bool isClient()      { return bIsClient_s; }
+            static bool isStandalone()  { return bIsStandalone_s; }
+            static bool isMaster()      { return bIsMaster_s; }
+            static void setShowsGraphics(bool val) { bShowsGraphics_s = val; updateIsMaster(); }
+            static void setHasServer    (bool val) { bHasServer_s     = val; updateIsMaster(); }
+            static void setIsClient     (bool val) { bIsClient_s      = val; updateIsMaster(); }
+            static void setIsStandalone (bool val) { bIsStandalone_s  = val; updateIsMaster(); }
+            static void updateIsMaster  ()         { bIsMaster_s      = (bHasServer_s || bIsStandalone_s); }
         private:
 …
             int softDebugLevelShell_;                       //!< The debug level for the ingame shell
             std::string language_;                          //!< The language
+            static bool bShowsGraphics_s;                   //!< global variable that tells whether to show graphics
+            static bool bHasServer_s;                       //!< global variable that tells whether this is a server
+            static bool bIsClient_s;
+            static bool bIsStandalone_s;
+            static bool bIsMaster_s;
     };
+}

code/trunk/src/core/CoreIncludes.h

-                      r1856
+                      r2087
 #include "Factory.h"
 #include "ClassFactory.h"
+#include "Functor.h"
 #include "util/Debug.h"
 …
 */
 #define CreateFactory(ClassName) \
+    bool bCreated##ClassName##Factory = orxonox::ClassFactory<ClassName>::create(#ClassName)
+    bool bCreated##ClassName##Factory = orxonox::ClassFactory<ClassName>::create(#ClassName, true)
+/**
+    @brief Creates the entry in the Factory for classes which should not be loaded through XML.
+    @param ClassName The name of the class
+*/
+#define CreateUnloadableFactory(ClassName) \
+    bool bCreated##ClassName##Factory = orxonox::ClassFactory<ClassName>::create(#ClassName, false)
 /**
 …
 */
 #define Class(ClassName) \
     ClassIdentifier<ClassName>::getIdentifier()
+    orxonox::ClassIdentifier<ClassName>::getIdentifier()
 /**
 …
     @param String The name of the class
 */
 #define ClassByName(String) \
+#define ClassByString(String) \
     orxonox::Factory::getIdentifier(String)
 …
     orxonox::Factory::getIdentifier(networkID)
+/**
+    @brief Registers a member function as callback when an object of 'type' is created.
+    @param
+*/
+#define RegisterConstructionCallback(ThisClassName, TargetClassName, FunctionName) \
+    orxonox::ClassIdentifier<TargetClassName>::getIdentifier()->addConstructionCallback( \
+        createFunctor(&ThisClassName::FunctionName)->setObject(this))
 #endif /* _CoreIncludes_H__ */

code/trunk/src/core/CorePrereqs.h

-                      r1757
+                      r2087
   class CommandExecutor;
   class CommandLine;
-  class BaseCommandLineArgument;
-  template <class T>
   class CommandLineArgument;
   class ConfigFile;
 …
   class ConsoleCommand;
   class Core;
+  struct Event;
+  class EventContainer;
   class Executor;
   template <class T>
 …
   class Language;
   class LanguageEntry;
-  class Level;
   class Loader;
   class MetaObjectList;
 …
   struct TclInterpreterBundle;
   class TclThreadManager;
+  class Template;
   class Tickable;
+  class XMLFile;
+  class XMLNameListener;
   template <class T, class O>
   class XMLPortClassObjectContainer;

code/trunk/src/core/Factory.cc

r1856	r2087
46	46	Identifier* Factory::getIdentifier(const std::string& name)
47	47	{
48		return getFactoryPointer()->identifierStringMap_[name];
	48	std::map<std::string, Identifier*>::const_iterator it = getFactoryPointer()->identifierStringMap_.find(name);
	49	if (it != getFactoryPointer()->identifierStringMap_.end())
	50	return it->second;
	51	else
	52	return 0;
49	53	}
50	54
…	…
56	60	Identifier* Factory::getIdentifier(const unsigned int id)
57	61	{
58		return getFactoryPointer()->identifierNetworkIDMap_[id];
	62	std::map<unsigned int, Identifier*>::const_iterator it = getFactoryPointer()->identifierNetworkIDMap_.find(id);
	63	if (it != getFactoryPointer()->identifierNetworkIDMap_.end())
	64	return it->second;
	65	else
	66	return 0;
59	67	}
60	68
…	…
68	76	getFactoryPointer()->identifierStringMap_[name] = identifier;
69	77	getFactoryPointer()->identifierNetworkIDMap_[identifier->getNetworkID()] = identifier;
	78	//std::cout << identifier->getName() << ": " << identifier->getNetworkID() << std::endl;
70	79	}
71	80
…	…
80	89	getFactoryPointer()->identifierNetworkIDMap_.erase(oldID);
81	90	getFactoryPointer()->identifierNetworkIDMap_[newID] = identifier;
	91	//std::cout << identifier->getName() << ": " << oldID << " -> " << newID << std::endl;
82	92	}
83	93
…	…
94	104	{
95	105	// To create the new branch of the class-hierarchy, we create a new object and delete it afterwards.
96		BaseObject* temp = (*it).second->fabricate();
	106	BaseObject* temp = (*it).second->fabricate(0);
97	107	delete temp;
98	108	}

code/trunk/src/core/Factory.h

r1856	r2087
93	93	{
94	94	public:
95		virtual BaseObject* fabricate() = 0;
	95	virtual BaseObject* fabricate(BaseObject* creator) = 0;
96	96	virtual ~BaseFactory() {};
97	97	};

code/trunk/src/core/Functor.h

r1889	r2087
106	106	inline const MultiType& getReturnvalue() const { return this->returnedValue_; }
107	107
108		const std::string& getTypenameParam(unsigned int param) const { return (param < 5) ? this->typeParam_[param] : ~~blankString~~; }
	108	const std::string& getTypenameParam(unsigned int param) const { return (param < 5) ? this->typeParam_[param] : BLANKSTRING; }
109	109	const std::string& getTypenameReturnvalue() const { return this->typeReturnvalue_; }
110	110
…	…
167	167	}
168	168
169		~~void~~ setObject(T* object)
	169	FunctorMember* setObject(T* object)
170	170	{
171	171	this->bConstObject_ = false;
172	172	this->object_ = object;
	173	return this;
173	174	}
174	175
175		~~void~~ setObject(const T* object)
	176	FunctorMember* setObject(const T* object)
176	177	{
177	178	this->bConstObject_ = true;
178	179	this->constObject_ = object;
	180	return this;
179	181	}
180	182

code/trunk/src/core/Identifier.cc

-                      r1856
+                      r2087
         this->bSetName_ = false;
         this->factory_ = 0;
+        this->bLoadable_ = true;
         this->bHasConfigValues_ = false;
         this->bHasConsoleCommands_ = false;
+        this->bHasConstructionCallback_ = false;
         this->children_ = new std::set<const Identifier*>();
 …
         @return The new object
     */
     BaseObject* Identifier::fabricate()
+    BaseObject* Identifier::fabricate(BaseObject* creator)
+    {
         if (this->factory_)
+        {
             return this->factory_->fabricate(); // We have to return a BaseObject, because we don't know the exact type.
+            return this->factory_->fabricate(creator); // We have to return a BaseObject, because we don't know the exact type.
+        }
         else
 …
     XMLPortParamContainer* Identifier::getXMLPortParamContainer(const std::string& paramname)
+    {
         std::map<std::string, XMLPortParamContainer*>::const_iterator it = xmlportParamContainers_.find(paramname);
         if (it != xmlportParamContainers_.end())
+        std::map<std::string, XMLPortParamContainer*>::const_iterator it = this->xmlportParamContainers_.find(paramname);
+        if (it != this->xmlportParamContainers_.end())
             return ((*it).second);
         else
 …
     void Identifier::addXMLPortParamContainer(const std::string& paramname, XMLPortParamContainer* container)
+    {
+        std::map<std::string, XMLPortParamContainer*>::const_iterator it = this->xmlportParamContainers_.find(paramname);
+        if (it != this->xmlportParamContainers_.end())
+        {
+            COUT(2) << "Warning: Overwriting XMLPortParamContainer in class " << this->getName() << "." << std::endl;
+            delete (it->second);
+        }
         this->xmlportParamContainers_[paramname] = container;
+    }
 …
     XMLPortObjectContainer* Identifier::getXMLPortObjectContainer(const std::string& sectionname)
+    {
         std::map<std::string, XMLPortObjectContainer*>::const_iterator it = xmlportObjectContainers_.find(sectionname);
         if (it != xmlportObjectContainers_.end())
+        std::map<std::string, XMLPortObjectContainer*>::const_iterator it = this->xmlportObjectContainers_.find(sectionname);
+        if (it != this->xmlportObjectContainers_.end())
             return ((*it).second);
         else
 …
     void Identifier::addXMLPortObjectContainer(const std::string& sectionname, XMLPortObjectContainer* container)
+    {
+        std::map<std::string, XMLPortObjectContainer*>::const_iterator it = this->xmlportObjectContainers_.find(sectionname);
+        if (it != this->xmlportObjectContainers_.end())
+        {
+            COUT(2) << "Warning: Overwriting XMLPortObjectContainer in class " << this->getName() << "." << std::endl;
+            delete (it->second);
+        }
         this->xmlportObjectContainers_[sectionname] = container;
+    }
+    /**
+        @brief Returns a XMLPortEventContainer that attaches an event to this class.
+        @param sectionname The name of the section that contains the event
+        @return The container
+    */
+    XMLPortObjectContainer* Identifier::getXMLPortEventContainer(const std::string& eventname)
+    {
+        std::map<std::string, XMLPortObjectContainer*>::const_iterator it = this->xmlportEventContainers_.find(eventname);
+        if (it != this->xmlportEventContainers_.end())
+            return ((*it).second);
+        else
+            return 0;
+    }
+    /**
+        @brief Adds a new XMLPortEventContainer that attaches an event to this class.
+        @param sectionname The name of the section that contains the event
+        @param container The container
+    */
+    void Identifier::addXMLPortEventContainer(const std::string& eventname, XMLPortObjectContainer* container)
+    {
+        std::map<std::string, XMLPortObjectContainer*>::const_iterator it = this->xmlportEventContainers_.find(eventname);
+        if (it != this->xmlportEventContainers_.end())
+        {
+            COUT(2) << "Warning: Overwriting XMLPortEventContainer in class " << this->getName() << "." << std::endl;
+            delete (it->second);
+        }
+        this->xmlportEventContainers_[eventname] = container;
+    }
+    /**
+        @brief Adds a construction callback functor that gets called every time an object is created.
+        @param functor Functor pointer to any function with no argument.
+    */
+    void Identifier::addConstructionCallback(Functor* functor)
+    {
+        for (unsigned int i = 0; i < this->constructionCallbacks_.size(); ++i)
+        {
+            if (this->constructionCallbacks_[i] == functor)
+                return;
+        }
+        this->constructionCallbacks_.push_back(functor);
+        this->bHasConstructionCallback_ = true;
+    }
+    /**
+        @brief Removes a construction callback functor that gets called every time an object is created.
+        @param functor Functor pointer to any function with no argument.
+    */
+    void Identifier::removeConstructionCallback(Functor* functor)
+    {
+        for (unsigned int i = 0; i < this->constructionCallbacks_.size(); ++i)
+        {
+            if (this->constructionCallbacks_[i] == functor)
+            {
+                this->constructionCallbacks_.erase(this->constructionCallbacks_.begin() + i);
+            }
+        }
+        if (constructionCallbacks_.empty())
+            this->bHasConstructionCallback_ = false;
+    }

code/trunk/src/core/Identifier.h

-                      r1856
+                      r2087
 #include <set>
 #include <map>
+#include <vector>
 #include <string>
 #include <utility>
 #include <typeinfo>
 #include <stdlib.h>
+#include <cassert>
 #include "MetaObjectList.h"
 #include "Iterator.h"
 #include "Super.h"
+#include "Functor.h"
 #include "util/Debug.h"
 #include "util/String.h"
 …
             inline void addFactory(BaseFactory* factory) { this->factory_ = factory; }
             BaseObject* fabricate();
+            BaseObject* fabricate(BaseObject* creator);
             bool isA(const Identifier* identifier) const;
             bool isExactlyA(const Identifier* identifier) const;
 …
             bool isDirectParentOf(const Identifier* identifier) const;
+            /** @brief Returns true if the class can be loaded through XML. */
+            inline bool isLoadable() const { return this->bLoadable_; }
+            /** @brief Set the class to be loadable through XML or not. */
+            inline void setLoadable(bool bLoadable) { this->bLoadable_ = bLoadable; }
             /** @brief Returns the list of all existing objects of this class. @return The list */
             inline ObjectListBase* getObjects() const
 …
             inline std::map<std::string, XMLPortObjectContainer*>::const_iterator getXMLPortObjectMapEnd() const { return this->xmlportObjectContainers_.end(); }
+            /** @brief Returns the map that stores all XMLPort events. @return The const_iterator */
+            inline const std::map<std::string, XMLPortObjectContainer*>& getXMLPortEventMap() const { return this->xmlportEventContainers_; }
+            /** @brief Returns a const_iterator to the beginning of the map that stores all XMLPort events. @return The const_iterator */
+            inline std::map<std::string, XMLPortObjectContainer*>::const_iterator getXMLPortEventMapBegin() const { return this->xmlportEventContainers_.begin(); }
+            /** @brief Returns a const_iterator to the end of the map that stores all XMLPort events. @return The const_iterator */
+            inline std::map<std::string, XMLPortObjectContainer*>::const_iterator getXMLPortEventMapEnd() const { return this->xmlportEventContainers_.end(); }
             /** @brief Returns true if this class has at least one config value. @return True if this class has at least one config value */
             inline bool hasConfigValues() const { return this->bHasConfigValues_; }
             /** @brief Returns true if this class has at least one console command. @return True if this class has at least one console command */
             inline bool hasConsoleCommands() const { return this->bHasConsoleCommands_; }
+            /** @brief Returns true if this class has at least one construction callback Functor registered. */
+            inline bool hasConstructionCallback() const { return this->bHasConstructionCallback_; }
             /** @brief Returns true, if a branch of the class-hierarchy is being created, causing all new objects to store their parents. @return The status of the class-hierarchy creation */
 …
             XMLPortObjectContainer* getXMLPortObjectContainer(const std::string& sectionname);
+            void addXMLPortEventContainer(const std::string& eventname, XMLPortObjectContainer* container);
+            XMLPortObjectContainer* getXMLPortEventContainer(const std::string& eventname);
             ConsoleCommand& addConsoleCommand(ConsoleCommand* command, bool bCreateShortcut);
             ConsoleCommand* getConsoleCommand(const std::string& name) const;
             ConsoleCommand* getLowercaseConsoleCommand(const std::string& name) const;
+            void addConstructionCallback(Functor* functor);
+            void removeConstructionCallback(Functor* functor);
             void initializeClassHierarchy(std::set<const Identifier*>* parents, bool bRootClass);
 …
             inline std::set<const Identifier*>& getDirectChildrenIntern() const { return (*this->directChildren_); }
+            bool bHasConstructionCallback_;                                //!< True if at least one Functor is registered to get informed when an object of type T is created.
+            std::vector<Functor*> constructionCallbacks_;                  //!< All construction callback Functors of this class.
             ObjectListBase* objects_;                                      //!< The list of all objects of this class
 …
             bool bCreatedOneObject_;                                       //!< True if at least one object of the given type was created (used to determine the need of storing the parents)
             bool bSetName_;                                                //!< True if the name is set
+            bool bLoadable_;                                               //!< False = it's not permitted to load the object through XML
             std::string name_;                                             //!< The name of the class the Identifier belongs to
             BaseFactory* factory_;                                         //!< The Factory, able to create new objects of the given class (if available)
 …
             std::map<std::string, XMLPortParamContainer*> xmlportParamContainers_;     //!< All loadable parameters
             std::map<std::string, XMLPortObjectContainer*> xmlportObjectContainers_;   //!< All attachable objects
+            std::map<std::string, XMLPortObjectContainer*> xmlportEventContainers_;    //!< All events
     };
 …
         COUT(5) << "*** ClassIdentifier: Added object to " << this->getName() << "-list." << std::endl;
         object->getMetaList().add(this->objects_, this->objects_->add(new ObjectListElement<T>(object)));
+        if (this->bHasConstructionCallback_)
+        {
+            // Call all registered callbacks that a new object of type T has been created.
+            // Do NOT deliver a T* pointer here because it's way too risky (object not yet fully created).
+            for (unsigned int i = 0; i < this->constructionCallbacks_.size(); ++i)
+                (*constructionCallbacks_[i])();
+        }
+    }
 …
             SubclassIdentifier<T>& operator=(Identifier* identifier)
+            {
                 if (!identifier->isA(ClassIdentifier<T>::getIdentifier()))
+                if (!identifier || !identifier->isA(ClassIdentifier<T>::getIdentifier()))
+                {
                     COUT(1) << "An error occurred in SubclassIdentifier (Identifier.h):" << std::endl;
+                    COUT(1) << "Error: Class " << identifier->getName() << " is not a " << ClassIdentifier<T>::getIdentifier()->getName() << "!" << std::endl;
+                    COUT(1) << "Error: SubclassIdentifier<" << ClassIdentifier<T>::getIdentifier()->getName() << "> = Class(" << identifier->getName() << ") is forbidden." << std::endl;
+                    COUT(1) << "Aborting..." << std::endl;
+                    abort();
+                    if (identifier)
+                    {
+                        COUT(1) << "Error: Class " << identifier->getName() << " is not a " << ClassIdentifier<T>::getIdentifier()->getName() << "!" << std::endl;
+                        COUT(1) << "Error: SubclassIdentifier<" << ClassIdentifier<T>::getIdentifier()->getName() << "> = Class(" << identifier->getName() << ") is forbidden." << std::endl;
+                    }
+                    else
+                    {
+                        COUT(1) << "Error: Can't assign NULL identifier" << std::endl;
+                    }
+                }
+                this->identifier_ = identifier;
+                else
+                {
+                    this->identifier_ = identifier;
+                }
                 return *this;
+            }
 …
                 @brief Overloading of the * operator: returns the assigned identifier.
             */
             inline Identifier* operator*()
+            inline Identifier* operator*() const
+            {
                 return this->identifier_;
 …
                 @return The new object
             */
             T* fabricate()
+            {
                 BaseObject* newObject = this->identifier_->fabricate();
+            T* fabricate(BaseObject* creator) const
+            {
+                BaseObject* newObject = this->identifier_->fabricate(creator);
                 // Check if the creation was successful
 …
+                    }
+                    abort();
+                    assert(false);
+                    return 0;
+                }
+            }

code/trunk/src/core/Loader.cc

-                      r1755
+                      r2087
 #include "Loader.h"
 #include "Level.h"
+#include "XMLFile.h"
 #include "BaseObject.h"
 #include "Identifier.h"
 …
 #include "ObjectList.h"
 #include "CoreIncludes.h"
 #include "Script.h"
+#include "LuaBind.h"
 #include "Namespace.h"
 #include "util/Debug.h"
 …
 namespace orxonox
+{
     std::vector<std::pair<const Level*, ClassTreeMask> > Loader::levels_s;
+    std::vector<std::pair<const XMLFile*, ClassTreeMask> > Loader::files_s;
     ClassTreeMask Loader::currentMask_s;
     bool Loader::open(const Level* level, const ClassTreeMask& mask)
+    bool Loader::open(const XMLFile* file, const ClassTreeMask& mask)
+    {
         Loader::add(level, mask);
         return Loader::load(level, mask);
+        Loader::add(file, mask);
+        return Loader::load(file, mask);
+    }
 …
+    {
         Loader::unload();
         Loader::levels_s.clear();
+        Loader::files_s.clear();
+    }
     void Loader::close(const Level* level)
+    void Loader::close(const XMLFile* file)
+    {
         Loader::unload(level);
         Loader::remove(level);
+        Loader::unload(file);
+        Loader::remove(file);
+    }
     void Loader::add(const Level* level, const ClassTreeMask& mask)
+    void Loader::add(const XMLFile* file, const ClassTreeMask& mask)
+    {
         if (!level)
+        if (!file)
             return;
         Loader::levels_s.insert(Loader::levels_s.end(), std::pair<const Level*, ClassTreeMask>(level, mask));
+        Loader::files_s.insert(Loader::files_s.end(), std::pair<const XMLFile*, ClassTreeMask>(file, mask));
+    }
     void Loader::remove(const Level* level)
+    void Loader::remove(const XMLFile* file)
+    {
         if (!level)
+        if (!file)
             return;
         for (std::vector<std::pair<const Level*, ClassTreeMask> >::iterator it = Loader::levels_s.begin(); it != Loader::levels_s.end(); ++it)
+        for (std::vector<std::pair<const XMLFile*, ClassTreeMask> >::iterator it = Loader::files_s.begin(); it != Loader::files_s.end(); ++it)
+        {
             if ((*it).first == level)
+            if ((*it).first == file)
+            {
                 Loader::levels_s.erase(it);
+                Loader::files_s.erase(it);
                 break;
+            }
 …
+    {
         bool success = true;
         for (std::vector<std::pair<const Level*, ClassTreeMask> >::iterator it = Loader::levels_s.begin(); it != Loader::levels_s.end(); ++it)
+        for (std::vector<std::pair<const XMLFile*, ClassTreeMask> >::iterator it = Loader::files_s.begin(); it != Loader::files_s.end(); ++it)
             if (!Loader::load((*it).first, (*it).second * mask))
                 success = false;
 …
+    }
     bool Loader::load(const Level* level, const ClassTreeMask& mask)
+    bool Loader::load(const XMLFile* file, const ClassTreeMask& mask)
+    {
         if (!level)
+        if (!file)
             return false;
         Loader::currentMask_s = level->getMask() * mask;
+        Loader::currentMask_s = file->getMask() * mask;
         // let Lua work this out:
+        //Script* lua;
+        /*Script::loadFile(level->getFile(), true);
+        Script::init(Script::getLuaState());
+        Script::run();*/
+        Script* lua = Script::getInstance();
+        LuaBind* lua = LuaBind::getInstance();
         lua->clearLuaOutput();
         lua->loadFile(level->getFile(), true);
+        lua->loadFile(file->getFilename(), true);
         lua->run();
         try
+        {
             COUT(0) << "Start loading " << level->getFile() << "..." << std::endl;
+            COUT(0) << "Start loading " << file->getFilename() << "..." << std::endl;
             COUT(3) << "Mask: " << Loader::currentMask_s << std::endl;
             //ticpp::Document xmlfile(level->getFile());
+            //ticpp::Document xmlfile(file->getFilename());
             //xmlfile.LoadFile();
             //ticpp::Element myelement(*Script::getFileString());
 …
             COUT(4) << "  creating root-namespace..." << std::endl;
             Namespace* rootNamespace = new Namespace();
+            Namespace* rootNamespace = new Namespace(0);
             rootNamespace->setLoaderIndentation("    ");
             rootNamespace->setLevel(level);
+            rootNamespace->setFile(file);
             rootNamespace->setNamespace(rootNamespace);
             rootNamespace->setRoot(true);
             rootNamespace->XMLPort(rootElement, XMLPort::LoadObject);
             COUT(0) << "Finished loading " << level->getFile() << "." << std::endl;
+            COUT(0) << "Finished loading " << file->getFilename() << "." << std::endl;
             COUT(4) << "Namespace-tree:" << std::endl << rootNamespace->toString("  ") << std::endl;
 …
+        {
             COUT(1) << std::endl;
             COUT(1) << "An error occurred in Loader.cc while loading " << level->getFile() << ":" << std::endl;
+            COUT(1) << "An error occurred in Loader.cc while loading " << file->getFilename() << ":" << std::endl;
             COUT(1) << ex.what() << std::endl;
             COUT(1) << "Loading aborted." << std::endl;
 …
+    }
     void Loader::unload(const Level* level, const ClassTreeMask& mask)
+    void Loader::unload(const XMLFile* file, const ClassTreeMask& mask)
+    {
         if (!level)
+        if (!file)
             return;
         for (ObjectList<BaseObject>::iterator it = ObjectList<BaseObject>::begin(); it; )
+        {
             if ((it->getLevel() == level) && mask.isIncluded(it->getIdentifier()))
+            if ((it->getFile() == file) && mask.isIncluded(it->getIdentifier()))
                 delete (*(it++));
             else
 …
+    }
     bool Loader::reload(const Level* level, const ClassTreeMask& mask)
+    bool Loader::reload(const XMLFile* file, const ClassTreeMask& mask)
+    {
         Loader::unload(level, mask);
         return Loader::load(level, mask);
+        Loader::unload(file, mask);
+        return Loader::load(file, mask);
+    }
+}

code/trunk/src/core/Loader.h

-                      r1505
+                      r2087
 #include "ClassTreeMask.h"
-#include "Level.h"
 namespace orxonox
 …
+    {
         public:
             static bool open(const Level* level, const ClassTreeMask& mask = ClassTreeMask());
+            static bool open(const XMLFile* file, const ClassTreeMask& mask = ClassTreeMask());
             static void close();
             static void close(const Level* level);
+            static void close(const XMLFile* file);
             static void add(const Level* level, const ClassTreeMask& mask = ClassTreeMask());
             static void remove(const Level* level);
+            static void add(const XMLFile* file, const ClassTreeMask& mask = ClassTreeMask());
+            static void remove(const XMLFile* file);
             static bool load(const ClassTreeMask& mask = ClassTreeMask());
 …
             static bool reload(const ClassTreeMask& mask = ClassTreeMask());
             static bool load(const Level* level, const ClassTreeMask& mask = ClassTreeMask());
             static void unload(const Level* level, const ClassTreeMask& mask = ClassTreeMask());
             static bool reload(const Level* level, const ClassTreeMask& mask = ClassTreeMask());
+            static bool load(const XMLFile* file, const ClassTreeMask& mask = ClassTreeMask());
+            static void unload(const XMLFile* file, const ClassTreeMask& mask = ClassTreeMask());
+            static bool reload(const XMLFile* file, const ClassTreeMask& mask = ClassTreeMask());
             static ClassTreeMask currentMask_s;
         private:
             static std::vector<std::pair<const Level*, ClassTreeMask> > levels_s;
+            static std::vector<std::pair<const XMLFile*, ClassTreeMask> > files_s;
     };
+}

code/trunk/src/core/Namespace.cc

r1889	r2087
37	37	CreateFactory(Namespace);
38	38
39		Namespace::Namespace(~~) :~~
	39	Namespace::Namespace(BaseObject* creator) : BaseObject(creator),
40	40	bAutogeneratedFileRootNamespace_(false),
41	41	bRoot_(false),

code/trunk/src/core/Namespace.h

r1841	r2087
42	42	{
43	43	public:
44		Namespace();
	44	Namespace(BaseObject* creator);
45	45	virtual ~Namespace();
46	46

code/trunk/src/core/RootGameState.cc

-                      r1824
+                      r2087
 namespace orxonox
+{
     SetCommandLineArgument(state, "gui").setShortcut("s");
+    SetCommandLineArgument(state, "gui").shortcut("s");
     RootGameState::RootGameState(const std::string& name)
 …
             // get initial state from command line
+            std::string initialState;
+            CommandLine::getValue<std::string>("state", &initialState);
+            gotoState(initialState);
+            gotoState(CommandLine::getValue("state"));
             while (this->activeChild_)

code/trunk/src/core/Super.h

-                      r1841
+                      r2087
 #include "util/Debug.h"
 #include "XMLIncludes.h"
+#include "Event.h"
 ///////////////////////
 …
     #define SUPER_changedVisibility(classname, functionname, ...) \
         SUPER_NOARGS(classname, functionname)
+    #define SUPER_processEvent(classname, functionname, ...) \
+        SUPER_ARGS(classname, functionname, __VA_ARGS__)
     // (1/3) --> HERE <-- --> HERE <-- --> HERE <-- --> HERE <-- --> HERE <-- --> HERE <-- --> HERE <--
 …
             ()
         SUPER_FUNCTION_GLOBAL_DECLARATION_PART2;
+        SUPER_FUNCTION_GLOBAL_DECLARATION_PART1(4, processEvent, true, Event& event)
+            (event)
+        SUPER_FUNCTION_GLOBAL_DECLARATION_PART2;
         // (2/3) --> HERE <-- --> HERE <-- --> HERE <-- --> HERE <-- --> HERE <-- --> HERE <-- --> HERE <--
 …
     SUPER_INTRUSIVE_DECLARATION(changedActivity);
     SUPER_INTRUSIVE_DECLARATION(changedVisibility);
+    SUPER_INTRUSIVE_DECLARATION(processEvent);
     // (3/3) --> HERE <-- --> HERE <-- --> HERE <-- --> HERE <-- --> HERE <-- --> HERE <-- --> HERE <--

code/trunk/src/core/XMLIncludes.h

Property svn:mergeinfo changed (with no actual effect on merging)

code/trunk/src/core/XMLPort.h

-                      r1889
+                      r2087
 */
 #define XMLPortParam(classname, paramname, loadfunction, savefunction, xmlelement, mode) \
+    XMLPortParamGeneric(xmlcontainer##loadfunction##savefunction, classname, classname, this, paramname, orxonox::createExecutor(orxonox::createFunctor(&classname::loadfunction), std::string( #classname ) + "::" + #loadfunction), orxonox::createExecutor(orxonox::createFunctor(&classname::savefunction), std::string( #classname ) + "::" + #savefunction), xmlelement, mode)
+    static ExecutorMember<classname>* xmlcontainer##loadfunction##savefunction##loadexecutor = orxonox::createExecutor(orxonox::createFunctor(&classname::loadfunction), std::string( #classname ) + "::" + #loadfunction); \
+    static ExecutorMember<classname>* xmlcontainer##loadfunction##savefunction##saveexecutor = orxonox::createExecutor(orxonox::createFunctor(&classname::savefunction), std::string( #classname ) + "::" + #savefunction); \
+    XMLPortParamGeneric(xmlcontainer##loadfunction##savefunction, classname, classname, this, paramname, xmlcontainer##loadfunction##savefunction##loadexecutor, xmlcontainer##loadfunction##savefunction##saveexecutor, xmlelement, mode)
 /**
     @brief This is the same as XMLPortParam, but you can set the template arguments needed to store the loadfunction.
 …
 */
 #define XMLPortParamTemplate(classname, paramname, loadfunction, savefunction, xmlelement, mode, ...) \
+    XMLPortParamGeneric(xmlcontainer##loadfunction##savefunction, classname, classname, this, paramname, orxonox::createExecutor(orxonox::createFunctor<classname, __VA_ARGS__ >(&classname::loadfunction), std::string( #classname ) + "::" + #loadfunction), orxonox::createExecutor(orxonox::createFunctor(&classname::savefunction), std::string( #classname ) + "::" + #savefunction), xmlelement, mode)
+    static ExecutorMember<classname>* xmlcontainer##loadfunction##savefunction##loadexecutor = orxonox::createExecutor(orxonox::createFunctor<classname, __VA_ARGS__ >(&classname::loadfunction), std::string( #classname ) + "::" + #loadfunction); \
+    static ExecutorMember<classname>* xmlcontainer##loadfunction##savefunction##saveexecutor = orxonox::createExecutor(orxonox::createFunctor(&classname::savefunction), std::string( #classname ) + "::" + #savefunction); \
+    XMLPortParamGeneric(xmlcontainer##loadfunction##savefunction, classname, classname, this, paramname, xmlcontainer##loadfunction##savefunction##loadexecutor, xmlcontainer##loadfunction##savefunction##saveexecutor, xmlelement, mode)
 // --------------------
 …
 */
 #define XMLPortParamLoadOnly(classname, paramname, loadfunction, xmlelement, mode) \
+    XMLPortParamGeneric(xmlcontainer##loadfunction##0, classname, classname, this, paramname, orxonox::createExecutor(orxonox::createFunctor(&classname::loadfunction), std::string( #classname ) + "::" + #loadfunction), 0, xmlelement, mode)
+    static ExecutorMember<classname>* xmlcontainer##loadfunction##0##loadexecutor = orxonox::createExecutor(orxonox::createFunctor(&classname::loadfunction), std::string( #classname ) + "::" + #loadfunction); \
+    XMLPortParamGeneric(xmlcontainer##loadfunction##0, classname, classname, this, paramname, xmlcontainer##loadfunction##0##loadexecutor, 0, xmlelement, mode)
 /**
     @brief This is the same as XMLPortParamTemplate, but for load-only attributes (see XMLPortParamLoadOnly).
 */
 #define XMLPortParamLoadOnlyTemplate(classname, paramname, loadfunction, xmlelement, mode, ...) \
+    XMLPortParamGeneric(xmlcontainer##loadfunction##0, classname, classname, this, paramname, orxonox::createExecutor(orxonox::createFunctor<classname, __VA_ARGS__ >(&classname::loadfunction), std::string( #classname ) + "::" + #loadfunction), 0, xmlelement, mode)
+    static ExecutorMember<classname>* xmlcontainer##loadfunction##0##loadexecutor = orxonox::createExecutor(orxonox::createFunctor<classname, __VA_ARGS__ >(&classname::loadfunction), std::string( #classname ) + "::" + #loadfunction); \
+    XMLPortParamGeneric(xmlcontainer##loadfunction##0, classname, classname, this, paramname, xmlcontainer##loadfunction##0##loadexecutor, 0, xmlelement, mode)
 // ------------------
 …
 */
 #define XMLPortParamExtern(classname, externclass, object, paramname, loadfunction, savefunction, xmlelement, mode) \
+    XMLPortParamGeneric(xmlcontainer##loadfunction##savefunction, classname, externclass, object, paramname, orxonox::createExecutor(orxonox::createFunctor(&externclass::loadfunction), std::string( #externclass ) + "::" + #loadfunction), orxonox::createExecutor(orxonox::createFunctor(&externclass::savefunction), std::string( #externclass ) + "::" + #savefunction), xmlelement, mode);
+    static ExecutorMember<externclass>* xmlcontainer##loadfunction##savefunction##loadexecutor = orxonox::createExecutor(orxonox::createFunctor(&externclass::loadfunction), std::string( #externclass ) + "::" + #loadfunction); \
+    static ExecutorMember<externclass>* xmlcontainer##loadfunction##savefunction##saveexecutor = orxonox::createExecutor(orxonox::createFunctor(&externclass::savefunction), std::string( #externclass ) + "::" + #savefunction); \
+    XMLPortParamGeneric(xmlcontainer##loadfunction##savefunction, classname, externclass, object, paramname, xmlcontainer##loadfunction##savefunction##loadexecutor, xmlcontainer##loadfunction##savefunction##saveexecutor, xmlelement, mode);
 /**
     @brief This is the same as XMLPortParamTemplate, but for extern attributes (see XMLPortParamExtern).
 */
 #define XMLPortParamExternTemplate(classname, externclass, object, paramname, loadfunction, savefunction, xmlelement, mode, ...) \
+    XMLPortParamGeneric(xmlcontainer##loadfunction##savefunction, classname, externclass, object, paramname, orxonox::createExecutor(orxonox::createFunctor<externclass, __VA_ARGS__ >(&externclass::loadfunction), std::string( #externclass ) + "::" + #loadfunction), orxonox::createExecutor(orxonox::createFunctor(&externclass::savefunction), std::string( #externclass ) + "::" + #savefunction), xmlelement, mode);
+    static ExecutorMember<externclass>* xmlcontainer##loadfunction##savefunction##loadexecutor = orxonox::createExecutor(orxonox::createFunctor<externclass, __VA_ARGS__ >(&externclass::loadfunction), std::string( #externclass ) + "::" + #loadfunction); \
+    static ExecutorMember<externclass>* xmlcontainer##loadfunction##savefunction##saveexecutor = orxonox::createExecutor(orxonox::createFunctor(&externclass::savefunction), std::string( #externclass ) + "::" + #savefunction); \
+    XMLPortParamGeneric(xmlcontainer##loadfunction##savefunction, classname, externclass, object, paramname, xmlcontainer##loadfunction##savefunction##loadexecutor, xmlcontainer##loadfunction##savefunction##saveexecutor, xmlelement, mode);
 // -------------------
 …
 */
 #define XMLPortObjectExtended(classname, objectclass, sectionname, loadfunction, savefunction, xmlelement, mode, bApplyLoaderMask, bLoadBefore) \
+    XMLPortObjectGeneric(xmlcontainer##loadfunction##savefunction, classname, objectclass, sectionname, orxonox::createExecutor(orxonox::createFunctor(&classname::loadfunction), std::string( #classname ) + "::" + #loadfunction), orxonox::createExecutor(orxonox::createFunctor(&classname::savefunction), std::string( #classname ) + "::" + #savefunction), xmlelement, mode, bApplyLoaderMask, bLoadBefore)
+    static ExecutorMember<classname>* xmlcontainer##loadfunction##savefunction##loadexecutor = orxonox::createExecutor(orxonox::createFunctor(&classname::loadfunction), std::string( #classname ) + "::" + #loadfunction); \
+    static ExecutorMember<classname>* xmlcontainer##loadfunction##savefunction##saveexecutor = orxonox::createExecutor(orxonox::createFunctor(&classname::savefunction), std::string( #classname ) + "::" + #savefunction); \
+    XMLPortObjectGeneric(xmlcontainer##loadfunction##savefunction, classname, objectclass, sectionname, xmlcontainer##loadfunction##savefunction##loadexecutor, xmlcontainer##loadfunction##savefunction##saveexecutor, xmlelement, mode, bApplyLoaderMask, bLoadBefore)
 /**
     @brief This is the same as XMLPortObjectExtended, but you can specify the loadfunction by adding the param types. See XMLPortParamTemplate for more details about the types.
 */
 #define XMLPortObjectExtendedTemplate(classname, objectclass, sectionname, loadfunction, savefunction, xmlelement, mode, bApplyLoaderMask, bLoadBefore, ...) \
+    XMLPortObjectGeneric(xmlcontainer##loadfunction##savefunction, classname, objectclass, sectionname, orxonox::createExecutor(orxonox::createFunctor< __VA_ARGS__ >(&classname::loadfunction), std::string( #classname ) + "::" + #loadfunction), orxonox::createExecutor(orxonox::createFunctor(&classname::savefunction), std::string( #classname ) + "::" + #savefunction), xmlelement, mode, bApplyLoaderMask, bLoadBefore)
+    static ExecutorMember<classname>* xmlcontainer##loadfunction##savefunction##loadexecutor = orxonox::createExecutor(orxonox::createFunctor<classname, __VA_ARGS__ >(&classname::loadfunction), std::string( #classname ) + "::" + #loadfunction); \
+    static ExecutorMember<classname>* xmlcontainer##loadfunction##savefunction##saveexecutor = orxonox::createExecutor(orxonox::createFunctor(&classname::savefunction), std::string( #classname ) + "::" + #savefunction); \
+    XMLPortObjectGeneric(xmlcontainer##loadfunction##savefunction, classname, objectclass, sectionname, xmlcontainer##loadfunction##savefunction##loadexecutor, xmlcontainer##loadfunction##savefunction##saveexecutor, xmlelement, mode, bApplyLoaderMask, bLoadBefore)
 // -------------
 …
 */
 #define XMLPortObject(classname, objectclass, sectionname, loadfunction, savefunction, xmlelement, mode) \
+    XMLPortObjectGeneric(xmlcontainer##loadfunction##savefunction, classname, objectclass, sectionname, orxonox::createExecutor(orxonox::createFunctor(&classname::loadfunction), std::string( #classname ) + "::" + #loadfunction), orxonox::createExecutor(orxonox::createFunctor(&classname::savefunction), std::string( #classname ) + "::" + #savefunction), xmlelement, mode, false, true)
+    static ExecutorMember<classname>* xmlcontainer##loadfunction##savefunction##loadexecutor = orxonox::createExecutor(orxonox::createFunctor(&classname::loadfunction), std::string( #classname ) + "::" + #loadfunction); \
+    static ExecutorMember<classname>* xmlcontainer##loadfunction##savefunction##saveexecutor = orxonox::createExecutor(orxonox::createFunctor(&classname::savefunction), std::string( #classname ) + "::" + #savefunction); \
+    XMLPortObjectGeneric(xmlcontainer##loadfunction##savefunction, classname, objectclass, sectionname, xmlcontainer##loadfunction##savefunction##loadexecutor, xmlcontainer##loadfunction##savefunction##saveexecutor, xmlelement, mode, false, true)
 /**
     @brief This is the same as XMLPortObject, but you can specify the loadfunction by adding the param types. See XMLPortParamTemplate for more details about the types.
 */
 #define XMLPortObjectTemplate(classname, objectclass, sectionname, loadfunction, savefunction, xmlelement, mode, ...) \
+    XMLPortObjectGeneric(xmlcontainer##loadfunction##savefunction, classname, objectclass, sectionname, orxonox::createExecutor(orxonox::createFunctor< __VA_ARGS__ >(&classname::loadfunction), std::string( #classname ) + "::" + #loadfunction), orxonox::createExecutor(orxonox::createFunctor(&classname::savefunction), std::string( #classname ) + "::" + #savefunction), xmlelement, mode, false, true)
+    static ExecutorMember<classname>* xmlcontainer##loadfunction##savefunction##loadexecutor = orxonox::createExecutor(orxonox::createFunctor<classname, __VA_ARGS__ >(&classname::loadfunction), std::string( #classname ) + "::" + #loadfunction); \
+    static ExecutorMember<classname>* xmlcontainer##loadfunction##savefunction##saveexecutor = orxonox::createExecutor(orxonox::createFunctor(&classname::savefunction), std::string( #classname ) + "::" + #savefunction); \
+    XMLPortObjectGeneric(xmlcontainer##loadfunction##savefunction, classname, objectclass, sectionname, xmlcontainer##loadfunction##savefunction##loadexecutor, xmlcontainer##loadfunction##savefunction##saveexecutor, xmlelement, mode, false, true)
 // --------------------
 …
+                    {
                         COUT(1) << std::endl;
                         COUT(1) << "An error occurred in XMLPort.h while loading attribute '" << this->paramname_ << "' of '" << this->identifier_->getName() << "' (objectname: " << this->owner_->getName() << ") in " << this->owner_->getLevelfile() << ":" << std::endl;
+                        COUT(1) << "An error occurred in XMLPort.h while loading attribute '" << this->paramname_ << "' of '" << this->identifier_->getName() << "' (objectname: " << this->owner_->getName() << ") in " << this->owner_->getFilename() << ":" << std::endl;
                         COUT(1) << ex.what() << std::endl;
+                    }
 …
                             for (ticpp::Iterator<ticpp::Element> child = xmlsubelement->FirstChildElement(false); child != child.end(); child++)
+                            {
                                 Identifier* identifier = ClassByName(child->Value());
+                                Identifier* identifier = ClassByString(child->Value());
                                 if (identifier)
+                                {
                                     if (identifier->isA(Class(O)))
+                                    {
                                         if (this->identifierIsIncludedInLoaderMask(identifier))
+                                        if (identifier->isLoadable())
+                                        {
+                                            COUT(4) << ((BaseObject*)object)->getLoaderIndentation() << "fabricating " << child->Value() << "..." << std::endl;
+                                            BaseObject* newObject = identifier->fabricate();
+                                            newObject->setLoaderIndentation(((BaseObject*)object)->getLoaderIndentation() + "  ");
+                                            newObject->setLevel(((BaseObject*)object)->getLevel());
+                                            newObject->setNamespace(((BaseObject*)object)->getNamespace());
+                                            if (this->bLoadBefore_)
+                                            if (this->identifierIsIncludedInLoaderMask(identifier))
+                                            {
+                                                newObject->XMLPort(*child, XMLPort::LoadObject);
+                                                COUT(4) << ((BaseObject*)object)->getLoaderIndentation() << "assigning " << child->Value() << " (objectname " << newObject->getName() << ") to " << this->identifier_->getName() << " (objectname " << ((BaseObject*)object)->getName() << ")" << std::endl;
+                                                COUT(4) << ((BaseObject*)object)->getLoaderIndentation() << "fabricating " << child->Value() << "..." << std::endl;
+                                                BaseObject* newObject = identifier->fabricate((BaseObject*)object);
+                                                assert(newObject);
+                                                newObject->setLoaderIndentation(((BaseObject*)object)->getLoaderIndentation() + "  ");
+                                                O* castedObject = dynamic_cast<O*>(newObject);
+                                                assert(castedObject);
+                                                if (this->bLoadBefore_)
+                                                {
+                                                    newObject->XMLPort(*child, XMLPort::LoadObject);
+                                                    COUT(4) << ((BaseObject*)object)->getLoaderIndentation() << "assigning " << child->Value() << " (objectname " << newObject->getName() << ") to " << this->identifier_->getName() << " (objectname " << ((BaseObject*)object)->getName() << ")" << std::endl;
+                                                }
+                                                else
+                                                {
+                                                    COUT(4) << ((BaseObject*)object)->getLoaderIndentation() << "assigning " << child->Value() << " (object not yet loaded) to " << this->identifier_->getName() << " (objectname " << ((BaseObject*)object)->getName() << ")" << std::endl;
+                                                }
+                                                COUT(5) << ((BaseObject*)object)->getLoaderIndentation();
+                                                (*this->loadexecutor_)(object, castedObject);
+                                                if (!this->bLoadBefore_)
+                                                    newObject->XMLPort(*child, XMLPort::LoadObject);
+                                                COUT(5) << ((BaseObject*)object)->getLoaderIndentation() << "...fabricated " << child->Value() << " (objectname " << newObject->getName() << ")." << std::endl;
+                                            }
+                                            else
+                                            {
+                                                COUT(4) << ((BaseObject*)object)->getLoaderIndentation() << "assigning " << child->Value() << " (object not yet loaded) to " << this->identifier_->getName() << " (objectname " << ((BaseObject*)object)->getName() << ")" << std::endl;
+                                            }
+                                            COUT(5) << ((BaseObject*)object)->getLoaderIndentation();
+                                            (*this->loadexecutor_)(object, newObject);
+                                            if (!this->bLoadBefore_)
+                                                newObject->XMLPort(*child, XMLPort::LoadObject);
+                                            COUT(5) << ((BaseObject*)object)->getLoaderIndentation() << "...fabricated " << child->Value() << " (objectname " << newObject->getName() << ")." << std::endl;
+                                        }
+                                        else
+                                        {
+                                            COUT(2) << ((BaseObject*)object)->getLoaderIndentation() << "Warning: '" << child->Value() << "' is not loadable." << std::endl;
+                                        }
+                                    }
 …
                                 else
+                                {
+                                    COUT(2) << object->getLoaderIndentation() << "Warning: '" << child->Value() << "' is not a valid classname." << std::endl;
+                                    if (this->sectionname_ != "")
+                                    {
+                                        COUT(2) << object->getLoaderIndentation() << "Warning: '" << child->Value() << "' is not a valid classname." << std::endl;
+                                    }
+                                    else
+                                    {
+                                        // It's probably just another subsection
+                                    }
+                                }
+                            }
 …
+                    {
                         COUT(1) << std::endl;
                         COUT(1) << "An error occurred in XMLPort.h while loading a '" << Class(O)->getName() << "' in '" << this->sectionname_ << "' of '" << this->identifier_->getName() << "' (objectname: " << ((BaseObject*)object)->getName() << ") in " << object->getLevelfile() << ":" << std::endl;
+                        COUT(1) << "An error occurred in XMLPort.h while loading a '" << Class(O)->getName() << "' in '" << this->sectionname_ << "' of '" << this->identifier_->getName() << "' (objectname: " << ((BaseObject*)object)->getName() << ") in " << object->getFilename() << ":" << std::endl;
                         COUT(1) << ex.what() << std::endl;
+                    }

code/trunk/src/core/input/Button.cc

-                      r1887
+                      r2087
                 // check for param command
                 int paramIndex = eval.getConsoleCommand()->getAxisParamIndex();
+                int paramIndex = eval.getConsoleCommand()->getInputConfiguredParam_();
                 if (paramIndex >= 0)
+                {
                     // parameter supported command
                     ParamCommand* cmd = new ParamCommand();
+                    cmd->paramModifier_ = paramModifier;
+                    cmd->bRelative_ = eval.getConsoleCommand()->getIsAxisRelative();
+                    cmd->scale_ = paramModifier;
                     // add command to the buffer if not yet existing
                     for (unsigned int iParamCmd = 0; iParamCmd < paramCommandBuffer_->size(); iParamCmd++)
+                    {
                         if (getLowercase((*paramCommandBuffer_)[iParamCmd]->evaluation_.getOriginalCommand())
                             == getLowercase(commandStr))
+                        if ((*paramCommandBuffer_)[iParamCmd]->evaluation_.getConsoleCommand()
+                            == eval.getConsoleCommand())
+                        {
                             // already in list

code/trunk/src/core/input/HalfAxis.h

-                      r1887
+                      r2087
             , paramCommands_(0)
             , nParamCommands_(0)
             , wasDown_(false)
+            , pressed_(false)
             , hasChanged_(false)
         { }
 …
         // button related
         bool wasDown_;
+        bool pressed_;
         bool hasChanged_;
     };

code/trunk/src/core/input/InputCommands.cc

-                      r1887
+                      r2087
 #include "InputCommands.h"
+#include "util/Math.h"
 #include "core/CommandExecutor.h"
 …
     bool BufferedParamCommand::execute()
+    {
         if (nValuesAdded_)
+        if (this->abs_ != 0.0f || this->rel_ != 0.0f)
+        {
+            BufferedParamCommand& cmd = *this;
+            cmd.evaluation_.setEvaluatedParameter(cmd.paramIndex_, cmd.value_);
+            evaluation_.setEvaluatedParameter(paramIndex_, Vector2(abs_, rel_));
             // reset
             cmd.nValuesAdded_ = 0;
             cmd.value_ = 0;
             return cmd.evaluation_.execute();
+            rel_ = 0.0;
+            abs_ = 0.0;
+            return evaluation_.execute();
+        }
         else
 …
         BufferedParamCommand& cmd = *paramCommand_;
         // command has an additional parameter
         if (bRelative_)
+        if (rel != 0.0f)
+        {
+            if (rel != 0.0f)
+            {
+                // we have to calculate a relative movement.
+                // paramModifier_ says how much one keystroke is
+                cmd.value_ += paramModifier_ * rel;
+            }
+            // calculate relative movement.
+            // scale_ says how much one keystroke is
+            cmd.rel_ += scale_ * rel;
+        }
+        else if (abs != 0.0f)
+        if (abs != 0.0f)
+        {
+            // Usually, joy sticks create 'noise' (they return values if they're in 0 position)
+            // and normally this is caught in tickInput(), but that threshold cannot be to high
+            // in order to preserve accuracy. Instead, we have to catch the problem here. An example:
+            // Someone only uses buttons with an active joystick. The joy stick value could then
+            // be 0.05 for instance and the the key value 1. Without handling the problem, the final
+            // value would be computed to (1+0.05)/2=0.5025 which is not what the user expects.
+            float absQ = abs * abs;
+            float valueQ = cmd.value_ * cmd.value_;
+            if (absQ > 50.0f * valueQ) // ease up comparison by using quadratics
+            {
+                cmd.value_ = abs * paramModifier_;
+                cmd.nValuesAdded_ = 1;
+            }
+            else if (absQ * 50.0f < valueQ)
+            {
+                // abs is too small, we just don't do anything
+            }
+            else
+            {
+                // we have to calculate the absolute position of the axis.
+                // Since there might be another axis that is affected, we have to wait and
+                // store the result in a temporary place
+                cmd.value_ = (cmd.value_ * cmd.nValuesAdded_ + paramModifier_ * abs) / ++cmd.nValuesAdded_;
+            }
+            cmd.abs_ += scale_ * abs;
+            if (cmd.abs_ > 1.0)
+                cmd.abs_ = 1.0;
+            if (cmd.abs_ < -1.0)
+                cmd.abs_ = -1.0;
+        }
         return true;

code/trunk/src/core/input/InputCommands.h

-                      r1887
+                      r2087
+    {
     public:
         BufferedParamCommand() : value_(0.0f), nValuesAdded_(0), paramIndex_(-1) { }
+        BufferedParamCommand() : abs_(0.0f), rel_(0.0), paramIndex_(-1) { }
         bool execute();
         float value_;
         unsigned int nValuesAdded_;
+        float abs_;
+        float rel_;
         int paramIndex_;
         CommandEvaluation evaluation_;
 …
+    {
     public:
         ParamCommand() : bRelative_(false), paramModifier_(1.0f), paramCommand_(0) { }
+        ParamCommand() : scale_(1.0f), paramCommand_(0) { }
         bool execute(float abs = 1.0f, float rel = 1.0f);
+        bool bRelative_;
+        float paramModifier_;
+        float scale_;
         BufferedParamCommand* paramCommand_;
     };

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

-                      r1887
+                      r2087
         SetConfigValue(analogThreshold_, 0.05f)
             .description("Threshold for analog axes until which the state is 0.");
+        SetConfigValue(bFilterAnalogNoise_, false)
+            .description("Specifies whether to filter small analog values like joy stick fluctuations.");
         SetConfigValue(mouseSensitivity_, 1.0f)
             .description("Mouse sensitivity.");
 …
         SetConfigValue(mouseSensitivityDerived_, 1.0f)
             .description("Mouse sensitivity if mouse input is derived.");
         SetConfigValue(mouseWheelStepSize_, 120.0f)
+        SetConfigValue(mouseWheelStepSize_, 120)
             .description("Equals one step of the mousewheel.");
         SetConfigValue(buttonThreshold_, 0.80f)
 …
     void KeyBinder::tickMouse(float dt)
+    {
-        tickDevices(mouseAxes_, mouseAxes_ + MouseAxisCode::numberOfAxes * 2);
         if (bDeriveMouseInput_)
+        {
+            // only update when derive dt has passed
             if (deriveTime_ > derivePeriod_)
+            {
 …
                 deriveTime_ += dt;
+        }
+    }
+    void KeyBinder::tickDevices(HalfAxis* begin, HalfAxis* end)
+    {
+        for (HalfAxis* current = begin; current < end; ++current) // pointer arithmetic
+        {
+            // button mode
+            // TODO: optimize out all the half axes that don't act as a button at the moment
+            if (current->hasChanged_)
+            {
+                if (!current->wasDown_ && current->absVal_ > current->buttonThreshold_)
+                {
+                    current->wasDown_ = true;
+                    if (current->nCommands_[KeybindMode::OnPress])
+                        current->execute(KeybindMode::OnPress);
+                }
+                else if (current->wasDown_ && current->absVal_ < current->buttonThreshold_)
+                {
+                    current->wasDown_ = false;
+                    if (current->nCommands_[KeybindMode::OnRelease])
+                        current->execute(KeybindMode::OnRelease);
+                }
+                current->hasChanged_ = false;
+            }
+            if (current->wasDown_)
+            {
+                if (current->nCommands_[KeybindMode::OnHold])
+                    current->execute(KeybindMode::OnHold);
+            }
+            // these are the actually useful axis bindings for analog input
+            if (current->relVal_ > analogThreshold_ || current->absVal_ > analogThreshold_)
+            {
+                current->execute();
+            }
+        for (unsigned int i = 0; i < MouseAxisCode::numberOfAxes * 2; i++)
+        {
+            // Why dividing relative value by dt? The reason lies in the simple fact, that when you
+            // press a button that has relative movement, that value has to be multiplied by dt to be
+            // frame rate independant. This can easily (and only) be done in tickInput(float).
+            // Hence we need to divide by dt here for the mouse to compensate, because the relative
+            // move movements have nothing to do with dt.
+            if (dt != 0.0f)
+            {
+                // just ignore if dt == 0.0 because we have multiplied by 0.0 anyway..
+                mouseAxes_[i].relVal_ /= dt;
+            }
+            tickHalfAxis(mouseAxes_[i]);
+        }
+    }
+    void KeyBinder::tickJoyStick(float dt, unsigned int joyStick)
+    {
+        for (unsigned int i = 0; i < JoyStickAxisCode::numberOfAxes * 2; i++)
+        {
+            tickHalfAxis(joyStickAxes_[joyStick][i]);
+        }
+    }
+    void KeyBinder::tickHalfAxis(HalfAxis& halfAxis)
+    {
+        // button mode
+        // TODO: optimize out all the half axes that don't act as a button at the moment
+        if (halfAxis.hasChanged_)
+        {
+            if (!halfAxis.pressed_ && halfAxis.absVal_ > halfAxis.buttonThreshold_)
+            {
+                // key pressed event
+                halfAxis.pressed_ = true;
+                if (halfAxis.nCommands_[KeybindMode::OnPress])
+                    halfAxis.execute(KeybindMode::OnPress);
+            }
+            else if (halfAxis.pressed_ && halfAxis.absVal_ < halfAxis.buttonThreshold_)
+            {
+                // key released event
+                halfAxis.pressed_ = false;
+                if (halfAxis.nCommands_[KeybindMode::OnRelease])
+                    halfAxis.execute(KeybindMode::OnRelease);
+            }
+            halfAxis.hasChanged_ = false;
+        }
+        if (halfAxis.pressed_)
+        {
+            // key held event
+            if (halfAxis.nCommands_[KeybindMode::OnHold])
+                halfAxis.execute(KeybindMode::OnHold);
+        }
+        // these are the actually useful axis bindings for analog input
+        if (!bFilterAnalogNoise_ || halfAxis.relVal_ > analogThreshold_ || halfAxis.absVal_ > analogThreshold_)
+        {
+            halfAxis.execute();
+        }
+    }
 …
         int rel[] = { rel_.x, -rel_.y };
+        if (!bDeriveMouseInput_)
+        if (bDeriveMouseInput_)
+        {
+            mouseRelative_[0] += rel[0];
+            mouseRelative_[1] += rel[1];
+        }
+        else
+        {
             for (int i = 0; i < 2; i++)
 …
+            }
+        }
-        else
+        {
-            mouseRelative_[0] += rel[0];
-            mouseRelative_[1] += rel[1];
+        }
         // relative

code/trunk/src/core/input/KeyBinder.h

-                      r1888
+                      r2087
         void tickJoyStick(float dt, unsigned int joyStick);
         // internal
         void tickDevices(HalfAxis* begin, HalfAxis* end);
+        void tickHalfAxis(HalfAxis& halfAxis);
         void buttonThresholdChanged();
 …
         //! Filename of default keybindings.
         std::string defaultKeybindings_;
+        //! Whether to filter small value analog input
+        bool bFilterAnalogNoise_;
         //! Threshold for analog triggers until which the state is 0.
         float analogThreshold_;
 …
         float mouseSensitivityDerived_;
         //! Equals one step of the mousewheel
         float mouseWheelStepSize_;
+        int mouseWheelStepSize_;
         //##### Constant config variables #####
 …
     { joyStickButtons_[joyStickID][id].execute(KeybindMode::OnHold); }
-    inline void KeyBinder::tickJoyStick(float dt, unsigned int joyStick)
+    {
-        tickDevices(&joyStickAxes_[joyStick][0], &joyStickAxes_[joyStick][JoyStickAxisCode::numberOfAxes * 2]);
+    }
     inline void KeyBinder::tickInput(float dt)
+    {
         // execute all buffered bindings (additional parameter)
         for (unsigned int i = 0; i < paramCommandBuffer_.size(); i++)
+        {
+            paramCommandBuffer_[i]->rel_ *= dt;
             paramCommandBuffer_[i]->execute();
+        }
         // always reset the relative movement of the mouse

code/trunk/src/core/tolua/tolua.pkg

r1755	r2087
1		$cfile "../../src/core/~~Script~~.h"
	1	$cfile "../../src/core/LuaBind.h"
2	2	$cfile "../../src/core/CommandExecutor.h"

code/trunk/src/lua/COPYRIGHT

Property svn:eol-style set to native

code/trunk/src/lua/README

Property svn:eol-style set to native

code/trunk/src/network/CMakeLists.txt

-                      r1907
+                      r2087
 SET( NETWORK_SRC_FILES
+  ChatListener.cc
   Client.cc
   ClientConnection.cc
   ClientInformation.cc
+  ClientConnectionListener.cc
   ConnectionManager.cc
   GamestateManager.cc

code/trunk/src/network/Client.cc

-                      r1907
+                      r2087
 //
+#include <cassert>
 #include "Client.h"
 #include "Host.h"
 …
 #include "core/CoreIncludes.h"
 #include "packet/Packet.h"
 // #include "packet/Acknowledgement.h"
 …
   * @param port port of the application on the server
   */
   Client::Client(std::string address, int port) : client_connection(port, address){
+  Client::Client(const std::string& address, int port) : client_connection(port, address){
     isConnected=false;
     isSynched_=false;
 …
+  }
   bool Client::processChat(std::string message, unsigned int playerID){
     COUT(1) << "Player " << playerID << ": " << message << std::endl;
+  bool Client::processChat(const std::string& message, unsigned int playerID){
+//    COUT(1) << "Player " << playerID << ": " << message << std::endl;
     return true;
+  }
   /**
    * This function implements the method of sending a chat message to the server
    * @param message message to be sent
+   * @param message message to be sent
    * @return result(true/false)
    */
   bool Client::chat(std::string message){
+  bool Client::chat(const std::string& message){
     packet::Chat *m = new packet::Chat(message, Host::getPlayerID());
     return m->send();
 …
   /**
    * Processes incoming packets, sends a gamestate to the server and does the cleanup
    * @param time
+   * @param time
    */
   void Client::tick(float time){
 …
       COUT(5) << "tick packet size " << event->packet->dataLength << std::endl;
       packet::Packet *packet = packet::Packet::createPacket(event->packet, event->peer);
+      // note: packet commits suicide here except for the GameState. That is then deleted by a GamestateHandler
       bool b = packet->process();
       assert(b);

code/trunk/src/network/Client.h

-                      r1907
+                      r2087
   public:
     Client();
     Client(std::string address, int port);
+    Client(const std::string& address, int port);
     Client(const char *address, int port);
     ~Client();
     bool establishConnection();
     bool closeConnection();
     bool queuePacket(ENetPacket *packet, int clientID);
+    bool processChat(std::string message, unsigned int playerID);
+    virtual bool chat(std::string message);
+    bool processChat(const std::string& message, unsigned int playerID);
+    virtual bool chat(const std::string& message);
+    virtual bool broadcast(const std::string& message) { return false; }
     //bool sendChat(packet::Chat *chat);
+//    static void Chat( std::string message );
+    //static void setShipID( unsigned int shipID){ dynamic_cast<Client *>(instance_)->shipID_=shipID; }
+    static void setClientID( unsigned int clientID){ dynamic_cast<Client *>(instance_)->clientID_=clientID; }
     void tick(float time);
   private:
     virtual bool isServer_(){return false;}
     ClientConnection client_connection;
     GamestateClient gamestate;
     bool isConnected;
     bool isSynched_;
     bool gameStateFailure_;
   };

code/trunk/src/network/ClientConnection.cc

-                      r1907
+                      r2087
   boost::recursive_mutex ClientConnection::enet_mutex_;
   ClientConnection::ClientConnection(int port, std::string address) {
+  ClientConnection::ClientConnection(int port, const std::string& address) {
     quit=false;
     server=NULL;
 …
   bool ClientConnection::waitEstablished(int milisec) {
     for(int i=0; i<=milisec && !established; i++)
       usleep(1000);
+      msleep(1);
     return established;
 …
       case ENET_EVENT_TYPE_NONE:
         //receiverThread_->yield();
         usleep(1000);
+        msleep(1);
         break;
+      }

code/trunk/src/network/ClientConnection.h

-                      r1907
+                      r2087
   class ClientConnection{
+  class _NetworkExport ClientConnection{
   public:
     ClientConnection(int port, std::string address);
+    ClientConnection(int port, const std::string& address);
     ClientConnection(int port, const char* address);
     ~ClientConnection();
 …
     ENetPeer *server;
     boost::thread *receiverThread_;
     static boost::recursive_mutex enet_mutex_;
   };

code/trunk/src/network/ClientInformation.cc

-                      r1735
+                      r2087
 namespace network
+{
   ClientInformation *ClientInformation::head_=0;
   ClientInformation::ClientInformation() {
     if(!head_)
 …
   ClientInformation::~ClientInformation() {
-    if(this==head_)
-      head_=next();
     if(prev()!=0)
       prev()->setNext(this->next());
     if(next()!=0)
       next()->setPrev(this->prev());
+    if(this==head_)
+      head_=next();
+  }
 …
     return true;
+  }
   bool ClientInformation::setPartialGamestateID(int id){
     if(!this)
 …
+  }
   int ClientInformation::getID() {
+  unsigned int ClientInformation::getID() {
     if(!this)
       return CLIENTID_UNKNOWN;
 …
       return NULL;
+  }
   int ClientInformation::getFailures(){
     return failures_;
 …
     failures_=0;
+  }
   enet_uint32 ClientInformation::getRTT(){
     return peer_->roundTripTime;
+  }
   enet_uint32 ClientInformation::getPacketLoss(){
     return peer_->packetLoss;
+  }
   int ClientInformation::getGamestateID() {
+    return this->peer_->roundTripTime;
+  }
+  double ClientInformation::getPacketLoss(){
+    return ((double)this->peer_->packetLoss)/ENET_PEER_PACKET_LOSS_SCALE;
+  }
+  unsigned int ClientInformation::getGamestateID() {
     if(this)
       return gamestateID_;
     else
       return -1;
+  }
   int ClientInformation::getPartialGamestateID() {
+      return (unsigned int)-1;
+  }
+  unsigned int ClientInformation::getPartialGamestateID() {
     if(this)
       return partialGamestateID_;
     else
       return -1;
+      return (unsigned int)-1;
+  }
   ClientInformation *ClientInformation::insertBack(ClientInformation *ins) {
     ClientInformation *temp = head_;
     if(temp==head_){
+    if(temp==ins){
       return head_;
+    }
 …
+  }
   bool ClientInformation::removeClient(int clientID) {
     if(clientID==CLIENTID_UNKNOWN)
+  bool ClientInformation::removeClient(unsigned int clientID) {
+    if((unsigned int)clientID==CLIENTID_UNKNOWN)
       return false;
     ClientInformation *temp = head_;
 …
   * @return pointer to the last element in the list or 0 if the search was unsuccessfull
   */
   ClientInformation *ClientInformation::findClient(int clientID, bool look_backwards) {
+  ClientInformation *ClientInformation::findClient(unsigned int clientID, bool look_backwards) {
     ClientInformation *temp = head_;
     while(temp!=0 && temp->getID()!=clientID){

code/trunk/src/network/ClientInformation.h

-                      r1735
+                      r2087
 #include <boost/thread/recursive_mutex.hpp>
-#define GAMESTATEID_INITIAL -1
-#define CLIENTID_UNKNOWN -2
 // WATCH OUT: THE CLIENTINFORMATION LIST IS NOT THREADSAFE ANYMORE
 namespace network
+{
+  static const unsigned int GAMESTATEID_INITIAL = (unsigned int)-1;
+  static const unsigned int CLIENTID_UNKNOWN = (unsigned int)-2;
   /**
   * This class implements a list for client informations
   * @author Oliver Scheuss
   */
   class ClientInformation{
+  class _NetworkExport ClientInformation{
   public:
     ClientInformation();
 …
     ClientInformation *prev();
     static ClientInformation *insertBack(ClientInformation *ins);
     // set functions
     void setID(int clientID);
 …
     bool setPartialGamestateID(int id);
     inline void setShipID(unsigned int id){ShipID_=id;}
     // get functions
     inline unsigned int getShipID(){return ShipID_;}
     int getID();
     int getGamestateID();
     int getPartialGamestateID();
+    unsigned int getID();
+    unsigned int getGamestateID();
+    unsigned int getPartialGamestateID();
     ENetPeer *getPeer();
     int getFailures();
     void addFailure();
     void resetFailures();
     enet_uint32 getRTT();
     enet_uint32 getPacketLoss();
     static bool removeClient(int clientID);
+    double getPacketLoss();
+    static bool removeClient(unsigned int clientID);
     static bool removeClient(ENetPeer *peer);
     static ClientInformation *findClient(int clientID, bool look_backwards=false);
+    static ClientInformation *findClient(unsigned int clientID, bool look_backwards=false);
     static ClientInformation *findClient(ENetAddress *address, bool look_backwards=false);
     static ClientInformation *getBegin(){return head_;}
 …
   private:
     static ClientInformation *head_;
     bool setNext(ClientInformation *next);
     bool setPrev(ClientInformation *prev);
     ClientInformation *insertAfter(ClientInformation *ins);
     ClientInformation *insertBefore(ClientInformation *ins);
     ClientInformation *preve;
     ClientInformation *nexte;
     //actual information:
     ENetPeer *peer_;
     int clientID_;
     int gamestateID_;
     int partialGamestateID_;
+    unsigned int clientID_;
+    unsigned int gamestateID_;
+    unsigned int partialGamestateID_;
     unsigned int ShipID_;   // this is the unique objectID
     bool synched_;
     unsigned short failures_;
   };

code/trunk/src/network/ConnectionManager.cc

-                      r1907
+                      r2087
 #include "core/BaseObject.h"
 #include "core/Iterator.h"
-#include "objects/SpaceShip.h"
 #include "util/Math.h"
 #include "util/Sleep.h"
 …
+  }
   ConnectionManager::ConnectionManager(int port, std::string address) :receiverThread_(0) {
+  ConnectionManager::ConnectionManager(int port, const std::string& address) :receiverThread_(0) {
     assert(instance_==0);
     instance_=this;
 …
         case ENET_EVENT_TYPE_NONE:
           //receiverThread_->yield();
           usleep(1000);
+          msleep(1);
           break;
+      }
 …
-  bool ConnectionManager::removeShip(ClientInformation *client){
-    unsigned int id=client->getShipID();
-    orxonox::ObjectList<orxonox::SpaceShip>::iterator it;
-    for(it = orxonox::ObjectList<orxonox::SpaceShip>::begin(); it; ++it){
-      if(it->getObjectID()!=id)
-        continue;
-      delete *it;
+    }
-    return true;
+  }
   void ConnectionManager::disconnectClient(ClientInformation *client){
+    {
 …
       lock.unlock();
+    }
-    removeShip(client);
+  }

code/trunk/src/network/ConnectionManager.h

-                      r1785
+                      r2087
     const int NETWORK_DEFAULT_CHANNEL = 0;
   struct ClientList{
+  struct _NetworkExport ClientList{
     ENetEvent *event;
     int ID;
 …
   };
   class ConnectionManager{
+  class _NetworkExport ConnectionManager{
     public:
     static boost::recursive_mutex enet_mutex;
 …
     ConnectionManager(int port);
     ConnectionManager(int port, const char *address);
     ConnectionManager(int port, std::string address);
+    ConnectionManager(int port, const std::string& address);
     ~ConnectionManager();
     //ENetPacket *getPacket(ENetAddress &address); // thread1
 …
     int getClientID(ENetAddress address);
     ENetPeer *getClientPeer(int clientID);
-    //bool createShip(ClientInformation *client);
-    bool removeShip(ClientInformation *client);
     PacketBuffer buffer;

code/trunk/src/network/GamestateClient.cc

-                      r1907
+                      r2087
 #include "GamestateClient.h"
+#include <cassert>
 #include <zlib.h>
 …
 namespace network
+{
   struct GameStateItem{
+  struct _NetworkExport GameStateItem{
     packet::Gamestate *state;
     int id;
+    unsigned int id;
   };
 …
     last_gamestate_=GAMESTATEID_INITIAL-1;
     tempGamestate_=NULL;
-    myShip_=NULL;
+  }
 …
+  }
   bool GamestateClient::ack(int gamestateID, int clientID){
+  bool GamestateClient::ack(unsigned int gamestateID, unsigned int clientID){
     return true;
+  }
   bool GamestateClient::add(packet::Gamestate *gs, int clientID){
+  bool GamestateClient::add(packet::Gamestate *gs, unsigned int clientID){
     if(tempGamestate_!=NULL){
       //delete the obsolete gamestate
 …
       return false;
     int id = GAMESTATEID_INITIAL;
-    bool b = saveShipCache();
     packet::Gamestate *processed = processGamestate(tempGamestate_);
-    if(!processed){
-      if(b)
-        loadShipCache();
-      return false;
+    }
 //    assert(processed);
+    if (!processed)
+        return false;
     //successfully loaded data from gamestate. now save gamestate for diff and delete the old gs
     tempGamestate_=NULL;
     gamestateMap_[processed->getID()]=processed;
     last_diff_ = processed->getID();
-    if(b)
-      loadShipCache();
     id = processed->getID();
     sendAck(id);
 …
   packet::Gamestate *GamestateClient::getGamestate(){
     packet::Gamestate *gs = new packet::Gamestate();
+    gs->collectData(0);
+    if(!gs->collectData(0)){
+      delete gs;
+      return 0;
+    }
     return gs;
+  }
   void GamestateClient::cleanup(){
     std::map<int, packet::Gamestate*>::iterator temp, it = gamestateMap_.begin();
+    std::map<unsigned int, packet::Gamestate*>::iterator temp, it = gamestateMap_.begin();
     while(it!=gamestateMap_.end()){
       if(it->first>=last_diff_)
 …
   void GamestateClient::printGamestateMap(){
     std::map<int, packet::Gamestate*>::iterator it;
+    std::map<unsigned int, packet::Gamestate*>::iterator it;
     COUT(4) << "gamestates: ";
     for(it=gamestateMap_.begin(); it!=gamestateMap_.end(); it++){
 …
+  }
   bool GamestateClient::sendAck(unsigned int gamestateID){
     packet::Acknowledgement *ack = new packet::Acknowledgement(gamestateID, 0);
 …
+    }
     else{
       COUT(3) << "acked a gamestate: " << gamestateID << std::endl;
+      COUT(5) << "acked a gamestate: " << gamestateID << std::endl;
       return true;
+    }
+  }
-  bool GamestateClient::saveShipCache(){
-    if(myShip_==NULL){
-      myShip_ = orxonox::SpaceShip::getLocalShip();
-//      COUT(2) << "myShip_: " << myShip_ << " getLocalShip(): " << orxonox::SpaceShip::getLocalShip() << std::endl;
-      if(!myShip_)
-        return false;
+    }
-    if(myShip_){
-      //      unsigned char *data = new unsigned char[myShip_->getSize()];
-      int size=myShip_->getSize(0, 0x1);
-      if(size==0)
-        return false;
-      shipCache_ = new unsigned char [size];
-      unsigned char *temp = shipCache_;
-      if(!myShip_->getData(temp, 0, 0x1))
-        COUT(3) << "could not save shipCache" << std::endl;
-      return true;
-    }else
-      return false;
+  }
-  bool GamestateClient::loadShipCache(){
-    myShip_=orxonox::SpaceShip::getLocalShip(); //TODO: remove this (only a hack)
-    if(myShip_ && shipCache_){
-      assert(myShip_->getIdentifier());
-      unsigned char *temp = shipCache_;
-      myShip_->updateData(temp, 0x2);
-      delete shipCache_;
-      return true;
-    }else
-      return false;
+  }
 …
       delete gs;
       gs=undiffed;
       COUT(3) << "successfully undiffed gamestate id: " << undiffed->getID() << std::endl;
+      COUT(5) << "successfully undiffed gamestate id: " << undiffed->getID() << std::endl;
+    }
     if(gs->spreadData())

code/trunk/src/network/GamestateClient.h

-                      r1769
+                      r2087
 #include "core/CorePrereqs.h"
 #include "packet/Gamestate.h"
-#include "objects/SpaceShip.h"
 #include "GamestateHandler.h"
+#define GAMESTATEID_INITIAL -1
+const unsigned int GAMESTATEID_INITIAL = (unsigned int)-1;
 namespace network
+{
   class GamestateClient: public GamestateHandler
+  class _NetworkExport GamestateClient: public GamestateHandler
+  {
   public:
 …
     ~GamestateClient();
     bool add(packet::Gamestate *gs, int clientID);
     bool ack(int gamestateID, int clientID);
+    bool add(packet::Gamestate *gs, unsigned int clientID);
+    bool ack(unsigned int gamestateID, unsigned int clientID);
     bool processGamestates();
 …
     void printGamestateMap();
     bool sendAck(unsigned int gamestateID);
-    bool saveShipCache();
-    bool loadShipCache();
     int           last_diff_;
     int           last_gamestate_;
     std::map<int, packet::Gamestate *> gamestateMap_;
+    unsigned int           last_diff_;
+    unsigned int           last_gamestate_;
+    std::map<unsigned int, packet::Gamestate *> gamestateMap_;
     packet::Gamestate *tempGamestate_; // we save the received gamestates here during processQueue
-    orxonox::SpaceShip *myShip_;
     unsigned char *shipCache_;

code/trunk/src/network/GamestateHandler.h

-                      r1763
+                      r2087
         @author Oliver Scheuss
 */
 class GamestateHandler{
+class _NetworkExport GamestateHandler{
   private:
     virtual bool add(packet::Gamestate *gs, int clientID)=0;
     virtual bool ack(int gamestateID, int clientID)=0;
+    virtual bool add(packet::Gamestate *gs, unsigned int clientID)=0;
+    virtual bool ack(unsigned int gamestateID, unsigned int clientID)=0;
     static GamestateHandler *instance_;
 …
   public:
     static bool addGamestate(packet::Gamestate *gs, int clientID){ return instance_->add(gs, clientID); }
     static bool ackGamestate(int gamestateID, int clientID){ return instance_->ack(gamestateID, clientID); }
+    static bool addGamestate(packet::Gamestate *gs, unsigned int clientID){ return instance_->add(gs, clientID); }
+    static bool ackGamestate(unsigned int gamestateID, unsigned int clientID){ return instance_->ack(gamestateID, clientID); }
 };

code/trunk/src/network/GamestateManager.cc

-                      r1907
+                      r2087
     return getSnapshot();
+  }
   bool GamestateManager::add(packet::Gamestate *gs, int clientID){
+  bool GamestateManager::add(packet::Gamestate *gs, unsigned int clientID){
     assert(gs);
     std::map<int, packet::Gamestate*>::iterator it = gamestateQueue.find(clientID);
+    std::map<unsigned int, packet::Gamestate*>::iterator it = gamestateQueue.find(clientID);
     if(it!=gamestateQueue.end()){
       // delete obsolete gamestate
 …
     return true;
+  }
   bool GamestateManager::processGamestates(){
     std::map<int, packet::Gamestate*>::iterator it;
+    std::map<unsigned int, packet::Gamestate*>::iterator it;
     // now push only the most recent gamestates we received (ignore obsolete ones)
     for(it = gamestateQueue.begin(); it!=gamestateQueue.end(); it++){
+      assert(processGamestate(it->second));
+      bool b = processGamestate(it->second);
+      assert(b);
       delete it->second;
+    }
 …
     return true;
+  }
   bool GamestateManager::getSnapshot(){
     reference = new packet::Gamestate();
     reference->collectData(++id_);
     //COUT(4) << "inserting gamestate: " << reference << std::endl;
     //gamestateMap_.insert(std::pair<int, packet::Gamestate*>(id_, reference));
+//     gamestateUsed[id_]=0;
     return true;
+  }
+    if(!reference->collectData(++id_)){ //we have no data to send
+      delete reference;
+      reference=0;
+    }
+    return true;
+  }
   /**
    * this function is used to keep the memory usage low
    * it tries to delete all the unused gamestates
+   *
+   *
+   *
+   *
    */
 /*  void GamestateManager::cleanup(){
 …
   }*/
   packet::Gamestate *GamestateManager::popGameState(int clientID) {
+  packet::Gamestate *GamestateManager::popGameState(unsigned int clientID) {
     //why are we searching the same client's gamestate id as we searched in
     //Server::sendGameState?
     packet::Gamestate *gs;
+    int gID = ClientInformation::findClient(clientID)->getGamestateID();
+    unsigned int gID = ClientInformation::findClient(clientID)->getGamestateID();
+    if(!reference)
+      return 0;
     gs = reference->doSelection(clientID);
 //     gs = new packet::Gamestate(*reference);
 …
     packet::Gamestate *client=NULL;
     if(gID != GAMESTATEID_INITIAL){
       std::map<unsigned int, std::map<int, packet::Gamestate*> >::iterator clientMap = gamestateMap_.find(clientID);
+      std::map<unsigned int, std::map<unsigned int, packet::Gamestate*> >::iterator clientMap = gamestateMap_.find(clientID);
       if(clientMap!=gamestateMap_.end()){
         std::map<int, packet::Gamestate*>::iterator it = clientMap->second.find(gID);
+        std::map<unsigned int, packet::Gamestate*>::iterator it = clientMap->second.find(gID);
         if(it!=clientMap->second.end())
           client = it->second;
 …
     return gs;
+  }
   bool GamestateManager::ack(int gamestateID, int clientID) {
+  bool GamestateManager::ack(unsigned int gamestateID, unsigned int clientID) {
     ClientInformation *temp = ClientInformation::findClient(clientID);
     assert(temp);
     int curid = temp->getGamestateID();
+    unsigned int curid = temp->getGamestateID();
     if(gamestateID == 0){
       temp->setGamestateID(GAMESTATEID_INITIAL);
       return true;
+    }
     assert(curid<gamestateID);
+    assert(curid==(unsigned int)GAMESTATEID_INITIAL || curid<gamestateID);
     COUT(4) << "acking gamestate " << gamestateID << " for clientid: " << clientID << " curid: " << curid << std::endl;
     std::map<int, packet::Gamestate*>::iterator it, tempit;
+    std::map<unsigned int, packet::Gamestate*>::iterator it, tempit;
     for(it = gamestateMap_[clientID].begin(); it!=gamestateMap_[clientID].end() && it->first<gamestateID; it++){
       delete it->second;
 …
   void GamestateManager::removeClient(ClientInformation* client){
     assert(client);
     std::map<unsigned int, std::map<int, packet::Gamestate*> >::iterator clientMap = gamestateMap_.find(client->getID());
+    std::map<unsigned int, std::map<unsigned int, packet::Gamestate*> >::iterator clientMap = gamestateMap_.find(client->getID());
     // first delete all remained gamestates
     std::map<int, packet::Gamestate*>::iterator it;
+    std::map<unsigned int, packet::Gamestate*>::iterator it;
     for(it=clientMap->second.begin(); it!=clientMap->second.end(); it++)
       delete it->second;
 …
     gamestateMap_.erase(clientMap);
+  }
   bool GamestateManager::processGamestate(packet::Gamestate *gs){
     if(gs->isCompressed())

code/trunk/src/network/GamestateManager.h

-                      r1907
+                      r2087
   * @author Oliver Scheuss
   */
   class GamestateManager: public GamestateHandler{
+  class _NetworkExport GamestateManager: public GamestateHandler{
   public:
     GamestateManager();
     ~GamestateManager();
     bool add(packet::Gamestate *gs, int clientID);
+    bool add(packet::Gamestate *gs, unsigned int clientID);
     bool processGamestates();
     bool update();
     packet::Gamestate *popGameState(int clientID);
+    packet::Gamestate *popGameState(unsigned int clientID);
     bool getSnapshot();
     bool ack(int gamestateID, int clientID);
+    bool ack(unsigned int gamestateID, unsigned int clientID);
     void removeClient(ClientInformation *client);
     private:
 …
     bool processGamestate(packet::Gamestate *gs);
     std::map<unsigned int, std::map<int, packet::Gamestate*> > gamestateMap_;
+    std::map<unsigned int, std::map<unsigned int, packet::Gamestate*> > gamestateMap_;
     //std::map<int, packet::Gamestate*> gamestateMap; //map gsID to gamestate*
     //std::map<int, int> gamestateUsed; // save the number of clients, that use the specific gamestate
     std::map<int, packet::Gamestate*> gamestateQueue;
+    std::map<unsigned int, packet::Gamestate*> gamestateQueue;
     packet::Gamestate *reference;
     int id_;
+    unsigned int id_;
   };

code/trunk/src/network/Host.cc

-                      r1907
+                      r2087
 #include "core/ConsoleCommand.h"
 #include "packet/Packet.h"
+#include "ChatListener.h"
 namespace network {
 …
 Host *Host::instance_=0;
 /**
  * @brief Constructor: assures that only one reference will be created and sets the pointer
 …
  * @return playerID
  */
 unsigned int Host::getPlayerID(){
+unsigned int Host::getPlayerID(){
   if(!instance_)
     return 0;
 …
+}
 bool Host::Chat(std::string message){
+bool Host::Chat(const std::string& message){
   if(!instance_)
     return false;
 …
+}
+bool Host::incomingChat(std::string message, unsigned int playerID){
+bool Host::Broadcast(const std::string& message){
+  if(!instance_)
+    return false;
+  return instance_->broadcast(message);
+}
+bool Host::incomingChat(const std::string& message, unsigned int playerID){
+  for (orxonox::ObjectList<ChatListener>::iterator it = orxonox::ObjectList<ChatListener>::begin(); it != orxonox::ObjectList<ChatListener>::end(); ++it)
+    it->incomingChat(message, playerID);
   return instance_->processChat(message, playerID);
+}

code/trunk/src/network/Host.h

-                      r1907
+                      r2087
 *       @author Oliver Scheuss
 */
 class Host{
+class _NetworkExport Host{
   private:
     //TODO add theese functions or adequate
 …
     //virtual bool sendChat(packet::Chat *chat)=0;
     virtual bool queuePacket(ENetPacket *packet, int clientID)=0;
+    virtual bool chat(std::string message)=0;
+    virtual bool processChat(std::string message, unsigned int playerID)=0;
+    virtual bool chat(const std::string& message)=0;
+    virtual bool broadcast(const std::string& message)=0;
+    virtual bool processChat(const std::string& message, unsigned int playerID)=0;
     virtual bool isServer_()=0;
 …
     static void setClientID(unsigned int id){ instance_->clientID_ = id; }
     static void setShipID(unsigned int id){ instance_->shipID_ = id; }
+    static bool isServer(){ return instance_->isServer_(); }
+    static bool Chat(std::string message);
+    static bool incomingChat(std::string message, unsigned int playerID);
+    static bool isServer(){ return instance_->isServer_(); }
+    static bool Chat(const std::string& message);
+    static bool Broadcast(const std::string& message);
+    static bool incomingChat(const std::string& message, unsigned int playerID);
   private:
 };

code/trunk/src/network/NetworkCallback.h

-                      r1536
+                      r2087
 #define _NETWORK_CALLBACK__
+#include "NetworkPrereqs.h"
 namespace network{
   class NetworkCallbackBase
+  class _NetworkExport NetworkCallbackBase
+  {
     public:
 …
           virtual ~NetworkCallbackBase() {}
   };
   template <class T>
   class NetworkCallback: public NetworkCallbackBase
 …
       virtual void call()
         { (this->object_->*function_)(); }
     private:
       T* object_;
       void (T::*function_) (void);
   };
+  };

code/trunk/src/network/NetworkPrereqs.h

r1735	r2087
63	63	class Client;
64	64	class ClientConnection;
	65	class ClientConnectionListener;
65	66	class ClientFrameListener;
66	67	class ClientInformation;

code/trunk/src/network/PacketBuffer.h

-                      r1505
+                      r2087
 namespace network
+{
   struct PacketEnvelope{
+  struct _NetworkExport PacketEnvelope{
     int length;
     int data;
   };
   struct QueueItem{
+  struct _NetworkExport QueueItem{
     ENetEvent *event;
     //ENetAddress address;
 …
   };
   class PacketBuffer{
+  class _NetworkExport PacketBuffer{
   public:
     PacketBuffer();

code/trunk/src/network/Server.cc

-                      r1907
+                      r2087
 #include "ConnectionManager.h"
+#include "ClientConnectionListener.h"
 #include "GamestateManager.h"
 #include "ClientInformation.h"
 #include "util/Sleep.h"
-#include "objects/SpaceShip.h"
 #include "core/ConsoleCommand.h"
 #include "core/CoreIncludes.h"
 …
 #include "packet/DeleteObjects.h"
 #include <util/Convert.h>
+#include "ChatListener.h"
 namespace network
+{
+  const int MAX_FAILURES = 20;
+  const int NETWORK_FREQUENCY = 30;
+  const unsigned int MAX_FAILURES = 20;
+  const unsigned int NETWORK_FREQUENCY = 25;
+  const float NETWORK_PERIOD = (float)1/NETWORK_FREQUENCY;
   /**
 …
   * @param bindAddress Address to listen on
   */
   Server::Server(int port, std::string bindAddress) {
+  Server::Server(int port, const std::string& bindAddress) {
     timeSinceLastUpdate_=0;
     connection = new ConnectionManager(port, bindAddress);
 …
     gamestates_ = new GamestateManager();
+  }
   /**
   * @brief Destructor
 …
+  }
   bool Server::processChat(std::string message, unsigned int playerID){
+  bool Server::processChat(const std::string& message, unsigned int playerID){
     ClientInformation *temp = ClientInformation::getBegin();
     packet::Chat *chat;
 …
       temp = temp->next();
+    }
     COUT(1) << "Player " << playerID << ": " << message << std::endl;
+//    COUT(1) << "Player " << playerID << ": " << message << std::endl;
     return true;
+  }
 …
     //this steers our network frequency
     timeSinceLastUpdate_+=time;
     if(timeSinceLastUpdate_>=(1./NETWORK_FREQUENCY)){
       timeSinceLastUpdate_=(float)((int)(timeSinceLastUpdate_*NETWORK_FREQUENCY))/timeSinceLastUpdate_;
+    if(timeSinceLastUpdate_>=NETWORK_PERIOD){
+      timeSinceLastUpdate_ -= static_cast<unsigned int>( timeSinceLastUpdate_ / NETWORK_PERIOD ) * NETWORK_PERIOD;
       gamestates_->processGamestates();
       updateGamestate();
 …
     return connection->addPacket(packet, clientID);
+  }
+  /**
+   * @brief: returns ping time to client in milliseconds
+   */
+  unsigned int Server::getPing(unsigned int clientID){
+    assert(ClientInformation::findClient(clientID));
+    return ClientInformation::findClient(clientID)->getRTT();
+  }
+  /**
+   * @brief: return packet loss ratio to client (scales from 0 to 1)
+   */
+  double Server::getPacketLoss(unsigned int clientID){
+    assert(ClientInformation::findClient(clientID));
+    return ClientInformation::findClient(clientID)->getPacketLoss();
+  }
   /**
   * processes all the packets waiting in the queue
 …
       if(gs==NULL){
         COUT(2) << "Server: could not generate gamestate (NULL from compress)" << std::endl;
+        temp = temp->next();
         continue;
+      }
 …
   bool Server::addClient(ENetEvent *event){
+    static unsigned int newid=1;
+    COUT(2) << "Server: adding client" << std::endl;
     ClientInformation *temp = ClientInformation::insertBack(new ClientInformation);
     if(!temp){
 …
       return false;
+    }
     if(temp==ClientInformation::getBegin()) { //not good if you use anything else than insertBack
       temp->setID(1);
+    /*if(temp==ClientInformation::getBegin()) { //not good if you use anything else than insertBack
+      newid=1;
+    }
     else
+      temp->setID(temp->prev()->getID()+1);
+      newid=temp->prev()->getID()+1;*/
+    temp->setID(newid);
     temp->setPeer(event->peer);
+    // inform all the listeners
+    orxonox::ObjectList<ClientConnectionListener>::iterator listener = orxonox::ObjectList<ClientConnectionListener>::begin();
+    while(listener){
+      listener->clientConnected(newid);
+      listener++;
+    }
+    newid++;
     COUT(3) << "Server: added client id: " << temp->getID() << std::endl;
     return createClient(temp->getID());
+  }
+}
   bool Server::createClient(int clientID){
 …
     COUT(4) << "Con.Man: creating client id: " << temp->getID() << std::endl;
     connection->syncClassid(temp->getID());
-    COUT(5) << "creating spaceship for clientid: " << temp->getID() << std::endl;
-    // TODO: this is only a hack, untill we have a possibility to define default player-join actions
-    if(!createShip(temp))
-      COUT(2) << "Con.Man. could not create ship for clientid: " << clientID << std::endl;
-    else
-      COUT(3) << "created spaceship" << std::endl;
     temp->setSynched(true);
     COUT(3) << "sending welcome" << std::endl;
 …
     g->setClientID(temp->getID());
     b = g->collectData(0);
+    assert(b);
+    if(!b)
+      return false; //no data for the client
     b = g->compressData();
     assert(b);
 …
+  }
-  bool Server::createShip(ClientInformation *client){
-    if(!client)
-      return false;
-    orxonox::Identifier* id = ClassByName("SpaceShip");
-    if(!id){
-      COUT(4) << "We could not create the SpaceShip for client: " << client->getID() << std::endl;
-      return false;
+    }
-    orxonox::SpaceShip *no = dynamic_cast<orxonox::SpaceShip *>(id->fabricate());
-    no->classID = id->getNetworkID();
-    client->setShipID(no->getObjectID());
-    no->setPosition(orxonox::Vector3(0,0,80));
-    no->setScale(10);
-    //no->setYawPitchRoll(orxonox::Degree(-90),orxonox::Degree(-90),orxonox::Degree(0));
-    no->setMesh("assff.mesh");
-    no->setMaxSpeed(500);
-    no->setMaxSideAndBackSpeed(50);
-    no->setMaxRotation(1.0);
-    no->setTransAcc(200);
-    no->setRotAcc(3.0);
-    no->setTransDamp(75);
-    no->setRotDamp(1.0);
-    no->setCamera(std::string("cam_") + convertToString(client->getID()));
-    no->create();
-    return true;
+  }
   bool Server::disconnectClient(ENetEvent *event){
     COUT(4) << "removing client from list" << std::endl;
 …
     //boost::recursive_mutex::scoped_lock lock(head_->mutex_);
-    orxonox::ObjectList<orxonox::SpaceShip>::iterator it = orxonox::ObjectList<orxonox::SpaceShip>::begin();
     ClientInformation *client = ClientInformation::findClient(&event->peer->address);
     if(!client)
       return false;
     gamestates_->removeClient(client);
+    while(it){
+      if(it->getObjectID()!=client->getShipID()){
+        ++it;
+        continue;
+      }
+      orxonox::ObjectList<orxonox::SpaceShip>::iterator temp=it;
+      ++it;
+      delete  *temp;
+      return ClientInformation::removeClient(event->peer);
+    }
+    return false;
+// inform all the listeners
+    orxonox::ObjectList<ClientConnectionListener>::iterator listener = orxonox::ObjectList<ClientConnectionListener>::begin();
+    while(listener){
+      listener->clientDisconnected(client->getID());
+      listener++;
+    }
+    return ClientInformation::removeClient(event->peer);
+  }
 …
     gamestates_->removeClient(client);
+  }
+  bool Server::chat(std::string message){
+  bool Server::chat(const std::string& message){
+      return this->sendChat(message, Host::getPlayerID());
+  }
+  bool Server::broadcast(const std::string& message){
+      return this->sendChat(message, CLIENTID_UNKNOWN);
+  }
+  bool Server::sendChat(const std::string& message, unsigned int clientID){
     ClientInformation *temp = ClientInformation::getBegin();
     packet::Chat *chat;
     while(temp){
       chat = new packet::Chat(message, Host::getPlayerID());
+      chat = new packet::Chat(message, clientID);
       chat->setClientID(temp->getID());
       if(!chat->send())
 …
       temp = temp->next();
+    }
+    COUT(1) << "Player " << Host::getPlayerID() << ": " << message << std::endl;
+//    COUT(1) << "Player " << Host::getPlayerID() << ": " << message << std::endl;
+    for (orxonox::ObjectList<ChatListener>::iterator it = orxonox::ObjectList<ChatListener>::begin(); it != orxonox::ObjectList<ChatListener>::end(); ++it)
+      it->incomingChat(message, clientID);
     return true;
+  }

code/trunk/src/network/Server.h

-                      r1907
+                      r2087
+{
   const int CLIENTID_SERVER = 0;
   /**
   * This class is the root class of the network module for a server.
 …
     Server();
     Server(int port);
     Server(int port, std::string bindAddress);
+    Server(int port, const std::string& bindAddress);
     Server(int port, const char *bindAddress);
     ~Server();
     void open();
     void close();
     bool processChat(std::string message, unsigned int playerID);
+    bool processChat(const std::string& message, unsigned int playerID);
     bool queuePacket(ENetPacket *packet, int clientID);
     void tick(float time);
+    unsigned int getPing(unsigned int clientID);
+    double getPacketLoss(unsigned int clientID);
   protected:
     void processQueue();
 …
     unsigned int shipID(){return 0;}
     unsigned int playerID(){return 0;}
     bool addClient(ENetEvent *event);
     bool createClient(int clientID);
-    bool createShip(ClientInformation *client);
     bool disconnectClient(ENetEvent *event);
     void disconnectClient(int clientID);
 …
     bool sendGameState();
     bool sendObjectDeletes();
+    virtual bool chat(std::string message);
+    virtual bool chat(const std::string& message);
+    virtual bool broadcast(const std::string& message);
+    bool sendChat(const std::string& message, unsigned int clientID);
     //void processChat( chat *data, int clientId);
     ConnectionManager *connection;
     GamestateManager *gamestates_;
     float timeSinceLastUpdate_;
   };

code/trunk/src/network/Synchronisable.cc

-                      r1907
+                      r2087
 #include <cstring>
+#include <string>
 #include <iostream>
 #include <assert.h>
 …
 namespace network
+{
   std::map<unsigned int, Synchronisable *> Synchronisable::objectMap_;
 …
   * Initializes all Variables and sets the right objectID
   */
   Synchronisable::Synchronisable(){
+  Synchronisable::Synchronisable(orxonox::BaseObject* creator){
     RegisterRootObject(Synchronisable);
     static uint32_t idCounter=0;
 …
     objectMode_=0x1; // by default do not send data to server
     objectID=idCounter++;
+    classID = (unsigned int)-1;
     syncList = new std::list<synchronisableVariable *>;
+  }
+  /**
+   * Destructor:
+    this->creatorID = OBJECTID_UNKNOWN;
+    searchcreatorID:
+    if (creator)
+    {
+        Synchronisable* synchronisable_creator = dynamic_cast<Synchronisable*>(creator);
+        if (synchronisable_creator && synchronisable_creator->objectMode_)
+        {
+            this->creatorID = synchronisable_creator->getObjectID();
+        }
+        else if (creator != creator->getCreator())
+        {
+            creator = creator->getCreator();
+            goto searchcreatorID;
+        }
+    }
+  }
+  /**
+   * Destructor:
    * Delete all callback objects and remove objectID from the objectMap_
    */
 …
       for(std::list<synchronisableVariable *>::iterator it = syncList->begin(); it!=syncList->end(); it++)
         delete (*it)->callback;
+      deletedObjects_.push(objectID);
+      if (this->objectMode_ != 0x0)
+        deletedObjects_.push(objectID);
 //       COUT(3) << "destruct synchronisable +++" << objectID << " | " << classID << std::endl;
 //       COUT(3) << " bump ---" << objectID << " | " << &objectMap_ << std::endl;
 …
     this->classID = this->getIdentifier()->getNetworkID();
 //     COUT(4) << "creating synchronisable: setting classid from " << this->getIdentifier()->getName() << " to: " << classID << std::endl;
 //     COUT(3) << "construct synchronisable +++" << objectID << " | " << classID << std::endl;
 //     objectMap_[objectID]=this;
 …
     synchronisableHeader *header = (synchronisableHeader *)mem;
+    COUT(3) << "fabricating object with id: " << header->objectID << std::endl;
+    if(!header->dataAvailable)
+    {
+      mem += header->size;
+      return 0;
+    }
+    COUT(4) << "fabricating object with id: " << header->objectID << std::endl;
     orxonox::Identifier* id = ClassByID(header->classID);
     assert(id);
+    orxonox::BaseObject *bo = id->fabricate();
+    orxonox::BaseObject* creator = 0;
+    if (header->creatorID != OBJECTID_UNKNOWN)
+    {
+      Synchronisable* synchronisable_creator = Synchronisable::getSynchronisable(header->creatorID);
+      if (!synchronisable_creator)
+      {
+        mem += header->size; //.TODO: this suckz.... remove size from header
+        return 0;
+      }
+      else
+        creator = dynamic_cast<orxonox::BaseObject*>(synchronisable_creator);
+    }
+    orxonox::BaseObject *bo = id->fabricate(creator);
+    assert(bo);
     Synchronisable *no = dynamic_cast<Synchronisable *>(bo);
     assert(no);
     no->objectID=header->objectID;
+    no->creatorID=header->creatorID; //TODO: remove this
     no->classID=header->classID;
     COUT(3) << "fabricate objectID: " << no->objectID << " classID: " << no->classID << std::endl;
+    COUT(4) << "fabricate objectID: " << no->objectID << " classID: " << no->classID << std::endl;
           // update data and create object/entity...
     bool b = no->updateData(mem, mode);
+    bool b = no->updateData(mem, mode, true);
     assert(b);
+    b = no->create();
+    assert(b);
+    if (b)
+    {
+        b = no->create();
+        assert(b);
+    }
     return no;
+  }
   /**
    * Finds and deletes the Synchronisable with the appropriate objectID
 …
     return true;
+  }
   /**
    * This function looks up the objectID in the objectMap_ and returns a pointer to the right Synchronisable
 …
+  }
   /**
   * This function is used to register a variable to be synchronized
 …
   */
   void Synchronisable::registerVar(void *var, int size, variableType t, int mode, NetworkCallbackBase *cb){
+    assert( mode==direction::toclient || mode==direction::toserver || mode==direction::serverMaster || mode==direction::clientMaster);
     // create temporary synch.Var struct
     synchronisableVariable *temp = new synchronisableVariable;
 …
     temp->type = t;
     temp->callback = cb;
+    if( ( mode & direction::bidirectional ) )
+    {
+      temp->varBuffer = new uint8_t[size];
+      memcpy(temp->varBuffer, temp->var, size); //now fill the buffer for the first time
+      temp->varReference = 0;
+    }
     COUT(5) << "Syncronisable::registering var with size: " << temp->size << " and type: " << temp->type << std::endl;
     //std::cout << "push temp to syncList (at the bottom) " << datasize << std::endl;
 …
    *             0x2: client->server (not recommended)
    *             0x3: bidirectional
    * @return true: if !isMyTick or if everything was successfully saved
+   * @return true: if !doSync or if everything was successfully saved
    */
   bool Synchronisable::getData(uint8_t*& mem, unsigned int id, int mode){
     //if this tick is we dont synchronise, then abort now
     if(!isMyTick(id))
+    if(!doSync(id))
       return true;
     //std::cout << "inside getData" << std::endl;
 …
     if(classID==0)
       COUT(3) << "classid 0 " << this->getIdentifier()->getName() << std::endl;
+    if (this->classID == (unsigned int)-1)
+        this->classID = this->getIdentifier()->getNetworkID();
     assert(this->classID==this->getIdentifier()->getNetworkID());
 //     this->classID=this->getIdentifier()->getNetworkID(); // TODO: correct this
 …
     header->size = size;
     header->objectID = this->objectID;
+    header->creatorID = this->creatorID;
     header->classID = this->classID;
     header->dataAvailable = true;
 …
         COUT(5) << "not getting data: " << std::endl;
         continue;  // this variable should only be received
+      }
+      // if the variable gets synchronised bidirectional, then add the reference to the bytestream
+      if( ( (*i)->mode & direction::bidirectional ) == direction::bidirectional )
+      {
+        *(uint8_t*)mem = (*i)->varReference;
+        mem += sizeof( (*i)->varReference );
+        tempsize += sizeof( (*i)->varReference );
+      }
       switch((*i)->type){
 …
           break;
         case STRING:
           memcpy( (void *)(mem), (void *)&((*i)->size), sizeof(int) );
           mem+=sizeof(int);
+          memcpy( (void *)(mem), (void *)&((*i)->size), sizeof(size_t) );
+          mem+=sizeof(size_t);
           const char *data = ( ( *(std::string *) (*i)->var).c_str());
           memcpy( mem, (void*)data, (*i)->size);
           COUT(5) << "synchronisable: char: " << (const char *)(mem) << " data: " << data << " string: " << *(std::string *)((*i)->var) << std::endl;
           mem+=(*i)->size;
           tempsize+=(*i)->size + 4;
+          tempsize+=(*i)->size + sizeof(size_t);
           break;
+      }
 …
    * @return true/false
    */
   bool Synchronisable::updateData(uint8_t*& mem, int mode){
+  bool Synchronisable::updateData(uint8_t*& mem, int mode, bool forceCallback){
     if(mode==0x0)
       mode=state_;
 …
     synchronisableHeader *syncHeader = (synchronisableHeader *)mem;
     assert(syncHeader->objectID==this->objectID);
+//    assert(syncHeader->creatorID==this->creatorID);
     if(syncHeader->dataAvailable==false){
       mem+=syncHeader->size;
 …
     assert(this->objectID==syncHeader->objectID);
 //    assert(this->classID==syncHeader->classID); //TODO: fix this!!! maybe a problem with the identifier ?
     COUT(5) << "Synchronisable: objectID " << syncHeader->objectID << ", classID " << syncHeader->classID << " size: " << syncHeader->size << " synchronising data" << std::endl;
     for(i=syncList->begin(); i!=syncList->end() && mem <= data+syncHeader->size; i++){
 …
       switch((*i)->type){
         case DATA:
+          if( ( (*i)->mode & direction::bidirectional ) == direction::bidirectional )
+          {
+            if( ( mode == 0x1 && (*i)->mode == direction::serverMaster ) || \
+                  ( mode == 0x2 && (*i)->mode == direction::clientMaster ) )    // if true we are master on this variable
+            {
+              uint8_t refNr = *(uint8_t *)mem;
+              if( refNr != (*i)->varReference )
+              {
+                mem += sizeof((*i)->varReference) + (*i)->size; // the reference for this variable is not recent, discard data
+                break;
+              }
+            }
+            else //we are slave for this variable
+            {
+              (*i)->varReference = *(uint8_t *)mem; //copy the reference value for this variable
+            }
+            mem += sizeof((*i)->varReference);
+          }
           if((*i)->callback) // check whether this variable changed (but only if callback was set)
             if(strncmp((char *)(*i)->var, (char *)mem, (*i)->size)!=0)
 …
           break;
         case STRING:
+          (*i)->size = *(uint32_t *)mem;
+          if( ( (*i)->mode & direction::bidirectional ) == direction::bidirectional )
+          {
+            if( ( mode == 0x1 && (*i)->mode == direction::serverMaster ) || \
+                  ( mode == 0x2 && (*i)->mode == direction::clientMaster ) )    // if true we are master for this variable
+            {
+              uint8_t refNr = *(uint8_t *)mem;
+              mem += sizeof( (*i)->varReference );
+              if( refNr != (*i)->varReference ){
+                mem += sizeof(size_t) + *(size_t *)mem; // the reference for this variable is not recent, discard data
+                break;
+              }
+            }
+            else //we are slave for this variable
+            {
+              (*i)->varReference = *(uint8_t *)mem; //copy the reference value for this variable
+            }
+            mem += sizeof( (*i)->varReference );
+          }
+          (*i)->size = *(size_t *)mem;
           COUT(5) << "string size: " << (*i)->size << std::endl;
           mem+=sizeof(int);
+          mem += sizeof(size_t);
           if((*i)->callback) // check whether this string changed
             if( *(std::string *)((*i)->var) != std::string((char *)mem) )
 …
+      }
       // call the callback function, if defined
       if(callback && (*i)->callback)
+      if((callback || forceCallback) && (*i)->callback)
         (*i)->callback->call();
+    }
 …
   */
   uint32_t Synchronisable::getSize(unsigned int id, int mode){
     if(!isMyTick(id))
+    if(!doSync(id))
       return 0;
     int tsize=sizeof(synchronisableHeader);
 …
         break;
+      }
+      if( ( (*i)->mode & direction::bidirectional ) == direction::bidirectional )
+      {
+        tsize+=sizeof( (*i)->varReference );
+      }
+    }
     return tsize;
 …
    * @return true/false
    */
   bool Synchronisable::isMyTick(unsigned int id){
     return ( (objectMode_&state_)!=0 );
+  bool Synchronisable::doSync(unsigned int id){
+    return ( (objectMode_&state_)!=0 && (!syncList->empty() ) );
+  }
 …
    */
   void Synchronisable::setObjectMode(int mode){
     assert(mode==0x1 || mode==0x2 || mode==0x3);
+    assert(mode==0x0 || mode==0x1 || mode==0x2 || mode==0x3);
     objectMode_=mode;
+  }

code/trunk/src/network/Synchronisable.h

-                      r1910
+                      r2087
 #include "util/Integers.h"
+#define REGISTERDATA(varname) registerVar(&varname, sizeof(varname), network::DATA)
+#define REGISTERDATA_WITHDIR(varname, mode) registerVar(&varname, sizeof(varname), network::DATA, mode)
+#define REGISTERSTRING(stringname) registerVar(&stringname, stringname.length()+1, network::STRING)
+#define REGISTERSTRING_WITHDIR(stringname, mode) registerVar(&stringname, stringname.length()+1, network::STRING, mode)
+//TODO: this is only a very ugly hack ...
+namespace orxonox{
+class SpaceShip;
+}
+#define REGISTERDATA(varname, ...) \
+    registerVar((void*)&varname, sizeof(varname), network::DATA, __VA_ARGS__)
+#define REGISTERSTRING(stringname, ...) \
+    registerVar(&stringname, stringname.length()+1, network::STRING, __VA_ARGS__)
 namespace network
+{
+  static const unsigned int OBJECTID_UNKNOWN = (unsigned int)-1;
   namespace direction{
     enum syncdirection{
       toclient=0x1,
       toserver=0x2,
+      bidirectional=0x3
+      bidirectional=0x3,
+      serverMaster=0x3,
+      clientMaster=0x7
     };
+  }
   namespace syncmode{
     enum mode{
 …
     };
+  }
   enum variableType{
     DATA,
 …
   };
   struct synchronisableHeader{
+  struct _NetworkExport synchronisableHeader{
     uint32_t size:31;
     bool dataAvailable:1;
     uint32_t objectID;
+    uint32_t creatorID;
     uint32_t classID;
   };
   typedef struct synchronisableVariable{
+  struct _NetworkExport synchronisableVariable{
     unsigned int size;
     int mode; // this determines in which direction the variable gets synchronised
 …
     variableType type;
     NetworkCallbackBase *callback;
+  }SYNCVAR;
+    void *varBuffer;
+    uint8_t varReference;
+  };
   /**
 …
     friend class GamestateClient;
     friend class Server;
-    friend class orxonox::SpaceShip;
     virtual ~Synchronisable();
     virtual bool create();
     static void setClient(bool b);
     static Synchronisable *fabricate(uint8_t*& mem, int mode=0x0);
     static bool deleteObject(unsigned int objectID);
 …
     static unsigned int getNumberOfDeletedObject(){ return deletedObjects_.size(); }
     static unsigned int popDeletedObject(){ unsigned int i = deletedObjects_.front(); deletedObjects_.pop(); return i; }
     inline unsigned int getObjectID(){return objectID;}
     inline unsigned int getClassID(){return classID;}
   protected:
     Synchronisable();
+    Synchronisable(orxonox::BaseObject* creator);
     void registerVar(void *var, int size, variableType t, int mode=1, NetworkCallbackBase *cb=0);
     void setObjectMode(int mode);
     void setObjectFrequency(unsigned int freq){ objectFrequency_ = freq; }
+    virtual void registerAllVariables()=0;
   private:
     bool getData(uint8_t*& men, unsigned int id, int mode=0x0);
     uint32_t getSize(unsigned int id, int mode=0x0);
     bool updateData(uint8_t*& mem, int mode=0x0);
+    bool updateData(uint8_t*& mem, int mode=0x0, bool forceCallback=false);
     bool isMyData(uint8_t* mem);
     bool doSelection(unsigned int id);
     bool isMyTick(unsigned int id);
+    bool doSync(unsigned int id);
     unsigned int objectID;
+    unsigned int creatorID;
     unsigned int classID;
     std::list<synchronisableVariable *> *syncList;
     static int state_; // detemines wheter we are server (default) or client

code/trunk/src/network/packet/Acknowledgement.h

-                      r1907
+                      r2087
 #define NETWORKACKNOLEDGEMENT_H
+#include "../NetworkPrereqs.h"
 #include "Packet.h"
 …
 namespace packet {
 /**
         @author
+        @author
 */
 class Acknowledgement : public Packet
+class _NetworkExport Acknowledgement : public Packet
+{
 public:
 …
   Acknowledgement( uint8_t* data, unsigned int clientID );
   ~Acknowledgement();
   inline unsigned int getSize() const;
   bool process();
   unsigned int getAckID();
 private:

code/trunk/src/network/packet/Chat.h

-                      r1907
+                      r2087
 #ifndef NETWORKCHAT_H
 #define NETWORKCHAT_H
+#include "../NetworkPrereqs.h"
 #include <string>
 …
 namespace packet {
 /**
         @author
+        @author
 */
 class Chat : public Packet
+class _NetworkExport Chat : public Packet
+{
 public:
 …
   Chat( uint8_t* data, unsigned int clientID );
   ~Chat();
   inline unsigned int getSize() const;
   bool process();
   unsigned int getMessageLength(){ return messageLength_; };
   unsigned char *getMessage();

code/trunk/src/network/packet/ClassID.h

-                      r1907
+                      r2087
 #define NETWORKCLASSID_H
+#include "../NetworkPrereqs.h"
 #include <string>
 …
 /**
         @author
+        @author
 */
 class ClassID : public Packet
+class _NetworkExport ClassID : public Packet
+{
 public:
 …
   ClassID( uint8_t* data, unsigned int clientID );
   ~ClassID();
   inline unsigned int getSize() const;
   bool process();
   unsigned int getClassID();
   unsigned int getClassNameLength(){ return classNameLength_; }

code/trunk/src/network/packet/DeleteObjects.h

-                      r1907
+                      r2087
 #define NETWORKPACKETDELETEOBJECTS_H
+#include "../NetworkPrereqs.h"
 #include "Packet.h"
 …
 namespace packet {
 /**
         @author
+        @author
 */
 class DeleteObjects : public Packet
+class _NetworkExport DeleteObjects : public Packet
+{
 public:
 …
   DeleteObjects( uint8_t* data, unsigned int clientID );
   ~DeleteObjects();
   bool fetchIDs();
   inline unsigned int getSize() const;
   bool process();
 private:
 };

code/trunk/src/network/packet/Gamestate.cc

-                      r1907
+                      r2087
 #define HEADER GAMESTATE_HEADER(data_)
 #define PACKET_FLAG_GAMESTATE  ENET_PACKET_FLAG_RELIABLE
 Gamestate::Gamestate()
+{
 …
     return false;
+  }
 #ifndef NDEBUG
   std::list<Synchronisable*> slist;
 …
     slist.push_back(*it);
 #endif
     //if(it->doSelection(id))
     dataMap_[mem-data_]=(*it);  // save the mem location of the synchronisable data
 …
     if(!s)
+    {
+      s = Synchronisable::fabricate(mem, mode);
+      assert(s);
+//       if(!s)
+//         return false;
+      Synchronisable::fabricate(mem, mode);
+    }
     else
 …
   HEADER->compressed = true;
   assert(HEADER->compressed);
   COUT(3) << "gamestate compress datasize: " << HEADER->datasize << " compsize: " << HEADER->compsize << std::endl;
+  COUT(4) << "gamestate compress datasize: " << HEADER->datasize << " compsize: " << HEADER->compsize << std::endl;
   return true;
+}
 …
   assert(HEADER);
   assert(HEADER->compressed);
   COUT(3) << "GameStateClient: uncompressing gamestate. id: " << HEADER->id << ", baseid: " << HEADER->base_id << ", datasize: " << HEADER->datasize << ", compsize: " << HEADER->compsize << std::endl;
+  COUT(4) << "GameStateClient: uncompressing gamestate. id: " << HEADER->id << ", baseid: " << HEADER->base_id << ", datasize: " << HEADER->datasize << ", compsize: " << HEADER->compsize << std::endl;
   unsigned int datasize = HEADER->datasize;
   unsigned int compsize = HEADER->compsize;
   unsigned int bufsize;
   assert(compsize<=datasize);
+//  assert(compsize<=datasize);
   bufsize = datasize;
   assert(bufsize!=0);
 …
   //copy over the header
   *GAMESTATE_HEADER(ndata) = *HEADER;
+  //delete old (compressed data)
+  delete[] data_;
+  if (this->bDataENetAllocated_){
+    // Memory was allocated by ENet. --> We let it be since enet_packet_destroy will
+    // deallocated it anyway. So data and packet stay together.
+    this->bDataENetAllocated_ = false;
+  }
+  else{
+    // We allocated the memory in the first place (unlikely). So we destroy the old data
+    // and overwrite it with the new decompressed data.
+    delete[] this->data_;
+  }
   //set new pointers
   data_ = ndata;
 …
   assert(data_);
   std::map<unsigned int, Synchronisable *>::iterator it;
   // allocate memory for new data
   uint8_t *gdata = new uint8_t[HEADER->datasize+sizeof(GamestateHeader)];
 …
   uint8_t *newdata = gdata + sizeof(GamestateHeader);
   uint8_t *origdata = GAMESTATE_START(data_);
   //copy the GamestateHeader
   *(GamestateHeader*)gdata = *HEADER;
   synchronisableHeader *oldobjectheader, *newobjectheader;
   unsigned int objectOffset;
   //copy in the zeros
   for(it=dataMap_.begin(); it!=dataMap_.end(); it++){
 …
     assert(it->second->objectID==oldobjectheader->objectID);
     *newobjectheader = *oldobjectheader;
     objectOffset=sizeof(uint8_t)+sizeof(bool); //skip the size and the availableDate variables in the objectheader
+    objectOffset=sizeof(uint8_t)+sizeof(bool); //skip the size and the availableData variables in the objectheader
     if(it->second->doSelection(HEADER->id)){
       newobjectheader->dataAvailable=true; //TODO: probably not neccessary
 …
   assert(!HEADER->compressed);
   assert(!HEADER->diffed);
   //preparations
   std::map<unsigned int, Synchronisable *>::iterator it;
   uint8_t *origdata, *basedata, *destdata, *ndata;
   unsigned int objectOffset, streamOffset=0;    //data offset
   unsigned int minsize = (HEADER->datasize < GAMESTATE_HEADER(base->data_)->datasize) ? HEADER->datasize : GAMESTATE_HEADER(base->data_)->datasize;
+  unsigned int minsize = (HEADER->datasize < GAMESTATE_HEADER(base->data_)->datasize) ? HEADER->datasize : GAMESTATE_HEADER(base->data_)->datasize;
   synchronisableHeader *origheader;
   synchronisableHeader *destheader;
   origdata = GAMESTATE_START(this->data_);
   basedata = GAMESTATE_START(base->data_);
   ndata = new uint8_t[HEADER->datasize + sizeof(GamestateHeader)];
   destdata = ndata + sizeof(GamestateHeader);
   // do the diff
   for(it=dataMap_.begin(); it!=dataMap_.end(); it++){
 …
     origheader = (synchronisableHeader *)(origdata+streamOffset);
     destheader = (synchronisableHeader *)(destdata+streamOffset);
     //copy and partially diff the object header
     assert(sizeof(synchronisableHeader)==3*sizeof(unsigned int)+sizeof(bool));
 …
     }else{
       *(uint32_t*)(destdata+sizeof(uint32_t)+sizeof(bool)) = 0;
       *(uint32_t*)(destdata+2*sizeof(uint32_t)+sizeof(bool)) = 0;
+      *(uint32_t*)(destdata+2*sizeof(uint32_t)+sizeof(bool)) = 0;
+    }
     objectOffset=sizeof(synchronisableHeader);
     streamOffset+=sizeof(synchronisableHeader);
     //now handle the object data or fill with zeros
     while(objectOffset<origheader->size ){
       if(sendData && streamOffset<minsize)
         *(destdata+objectOffset)=*(basedata+objectOffset)^*(origdata+objectOffset); // do the xor
 …
       else
         *(destdata+objectOffset)=0; // set to 0 because this object should not be transfered
       objectOffset++;
       streamOffset++;
 …
     basedata+=objectOffset;
+  }
   //copy over the gamestate header and set the diffed flag
   *(GamestateHeader *)ndata = *HEADER; //copy over the header
 …
   assert(!HEADER->compressed);
   assert(HEADER->diffed);
   //preparations
   std::map<unsigned int, Synchronisable *>::iterator it;
   uint8_t *origdata, *basedata, *destdata, *ndata;
   unsigned int objectOffset, streamOffset=0;    //data offset
   unsigned int minsize = (HEADER->datasize < GAMESTATE_HEADER(base->data_)->datasize) ? HEADER->datasize : GAMESTATE_HEADER(base->data_)->datasize;
+  unsigned int minsize = (HEADER->datasize < GAMESTATE_HEADER(base->data_)->datasize) ? HEADER->datasize : GAMESTATE_HEADER(base->data_)->datasize;
   synchronisableHeader *origheader;
   synchronisableHeader *destheader;
   origdata = GAMESTATE_START(this->data_);
   basedata = GAMESTATE_START(base->data_);
   ndata = new uint8_t[HEADER->datasize + sizeof(GamestateHeader)];
   destdata = ndata + sizeof(GamestateHeader);
   // do the undiff
   for(it=dataMap_.begin(); it!=dataMap_.end(); it++){
 …
     destheader = (synchronisableHeader *)(destdata+streamOffset);
     bool sendData;
     //copy and partially diff the object header
     assert(sizeof(synchronisableHeader)==3*sizeof(unsigned int)+sizeof(bool));
 …
     }else{
       *(unsigned int*)(destdata+sizeof(unsigned int)+sizeof(bool)) = 0;
       *(unsigned int*)(destdata+2*sizeof(unsigned int)+sizeof(bool)) = 0;
+      *(unsigned int*)(destdata+2*sizeof(unsigned int)+sizeof(bool)) = 0;
+    }
     objectOffset=sizeof(synchronisableHeader);
     streamOffset+=sizeof(synchronisableHeader);
     //now handle the object data or fill with zeros
     while(objectOffset<origheader->size ){
       if(sendData && streamOffset<minsize)
         *(destdata+objectOffset)=*(basedata+objectOffset)^*(origdata+objectOffset); // do the xor
 …
       else
         *(destdata+objectOffset)=0; // set to 0 because this object should not be transfered
       objectOffset++;
       streamOffset++;
 …
     basedata+=objectOffset;
+  }
   //copy over the gamestate header and set the diffed flag
   *(GamestateHeader *)ndata = *HEADER; //copy over the header

code/trunk/src/network/packet/Gamestate.h

-                      r1907
+                      r2087
  */
+#ifndef NETWORK_PACKETGAMESTATE_H
+#define NETWORK_PACKETGAMESTATE_H
+#include "../NetworkPrereqs.h"
 #include "Packet.h"
 #include "network/Synchronisable.h"
 …
 #endif
-#ifndef NETWORK_PACKETGAMESTATE_H
-#define NETWORK_PACKETGAMESTATE_H
 namespace network {
 namespace packet {
 struct GamestateHeader{
+struct _NetworkExport GamestateHeader{
   ENUM::Type packetType;
   int32_t id; // id of the gamestate
 …
         @author Oliver Scheuss
 */
 class Gamestate: public Packet{
+class _NetworkExport Gamestate: public Packet{
   public:
     Gamestate();

code/trunk/src/network/packet/Packet.cc

-                      r1907
+                      r2087
 namespace packet{
 #define PACKET_FLAG_DEFAULT ENET_PACKET_FLAG_NO_ALLOCATE
 #define _PACKETID           0
 std::map<ENetPacket *, Packet *> Packet::packetMap_;
 Packet::Packet(){
   flags_ = PACKET_FLAG_DEFAULT;
 …
   data_=0;
   enetPacket_=0;
+  bDataENetAllocated_ = false;
+}
 …
   data_=data;
   enetPacket_=0;
+  bDataENetAllocated_ = false;
+}
 …
   }else
     data_=0;
+}
+  bDataENetAllocated_ = p.bDataENetAllocated_;
+}
+/**
+@brief
+    Destroys a packet completely.
+    That also means destroying the ENetPacket if one exists. There
+*/
 Packet::~Packet(){
+  if(enetPacket_){
+    assert(enetPacket_->freeCallback==0);
+  // Deallocate data_ memory if necessary.
+  if (this->bDataENetAllocated_){
+    // In this case ENet allocated data_ and will destroy it.
+  }
+  else if (this->data_) {
+    // This destructor was probably called as a consequence to ENet executing our callback.
+    // It simply serves us to be able to deallocate the packet content (data_) ourselves since
+    // we have created it in the first place.
+    delete[] this->data_;
+  }
+  // Destroy the ENetPacket if necessary.
+  // Note: For the case ENet used the callback to destroy the packet, we have already set
+  // enetPacket_ to NULL to avoid destroying it again.
+  if (this->enetPacket_){
+    // enetPacket_->data gets destroyed too by ENet if it was allocated by it.
     enet_packet_destroy(enetPacket_);
+  }
-  if(data_)
-    delete[] data_;
+}
 …
       return false;
+    }
+    // We deliver ENet the data address so that it doesn't memcpy everything again.
+    // --> We have to delete data_ ourselves!
     enetPacket_ = enet_packet_create(getData(), getSize(), getFlags());
     enetPacket_->freeCallback = &Packet::deletePacket;
+//     enetPacket_->freeCallback = &blub;
+    // Add the packet to a global list so we can access it again once enet calls our
+    // deletePacket method. We can of course only give a one argument function to the ENet C library.
     packetMap_[enetPacket_] = this;
+  }
 #ifndef NDEBUG
+#ifndef NDEBUG
   switch( *(ENUM::Type *)(data_ + _PACKETID) )
+  {
 …
+  }
 #endif
   ENetPacket *temp = enetPacket_;
   enetPacket_ = 0; // otherwise we have a double free because enet already handles the deallocation of the packet
   network::Host::addPacket( temp, clientID_);
+//  ENetPacket *temp = enetPacket_;
+//  enetPacket_ = 0; // otherwise we have a double free because enet already handles the deallocation of the packet
+  network::Host::addPacket( enetPacket_, clientID_);
   return true;
+}
 …
 Packet *Packet::createPacket(ENetPacket *packet, ENetPeer *peer){
   uint8_t *data = packet->data;
+  assert(ClientInformation::findClient(&peer->address)->getID() != (unsigned int)-2 || !Host::isServer());
   unsigned int clientID = ClientInformation::findClient(&peer->address)->getID();
   Packet *p;
 …
       break;
+  }
+  // Data was created by ENet
+  p->bDataENetAllocated_ = true;
   return p;
+}
+void Packet::deletePacket(ENetPacket *packet){
+  assert(packetMap_[packet]);
+  assert(packetMap_[packet]->enetPacket_==0);
+  delete packetMap_[packet];
+/**
+@brief
+    ENet calls this method whenever it wants to destroy a packet that contains
+    data we allocated ourselves.
+*/
+void Packet::deletePacket(ENetPacket *enetPacket){
+  // Get our Packet from a gloabal map with all Packets created in the send() method of Packet.
+  std::map<ENetPacket*, Packet*>::iterator it = packetMap_.find(enetPacket);
+  assert(it != packetMap_.end());
+  // Make sure we don't delete it again in the destructor
+  it->second->enetPacket_ = 0;
+  delete it->second;
+  //packetMap_.erase(it);
+  COUT(4) << "PacketMap size: " << packetMap_.size() << std::endl;
+}

code/trunk/src/network/packet/Packet.h

-                      r1907
+                      r2087
 #define NETWORKPACKET_H
+#include "../NetworkPrereqs.h"
 #include <map>
 #include <enet/enet.h>
 …
 namespace packet{
 namespace ENUM{
   enum Direction{
 …
   };
+}
 /**
         @author Oliver Scheuss <scheusso [at] ee.ethz.ch>
 */
 class Packet{
+class _NetworkExport Packet{
   public:
     Packet(const Packet &p);
 …
     static Packet *createPacket(ENetPacket *packet, ENetPeer *peer);
     static void deletePacket(ENetPacket *packet);
     virtual unsigned char *getData(){ return data_; };
     virtual unsigned int getSize() const =0;
 …
     void setClientID( int id )
       { clientID_ = id; }
     bool send();
   protected:
 …
     unsigned int clientID_;
     ENUM::Direction packetDirection_;
+    /** Pointer to the data. Be careful when deleting it because it might
+        point to a location that was allocated by ENet.
+        See bDataENetAllocated_ */
     uint8_t *data_;
+    /** Tells whether data_ was allocated by ENet or ourselves.
+        data_ might no correlate with enetPacket_->data. */
+    bool bDataENetAllocated_;
   private:
     static std::map<ENetPacket *, Packet *> packetMap_;

code/trunk/src/network/packet/Welcome.h

-                      r1907
+                      r2087
 #define NETWORKWELCOME_H
+#include "../NetworkPrereqs.h"
 #include "Packet.h"
 …
 /**
         @author
+        @author
 */
 class Welcome : public Packet
+class _NetworkExport Welcome : public Packet
+{
 public:
 …
   Welcome( uint8_t* data, unsigned int clientID );
   virtual ~Welcome();
   uint8_t *getData();
   inline unsigned int getSize() const;
   bool process();
 private:
 };

code/trunk/src/orxonox/CMakeLists.txt

-                      r1844
+                      r2087
 SET( ORXONOX_SRC_FILES
+  CameraManager.cc
   GraphicsEngine.cc
+  LevelManager.cc
   Main.cc
   Settings.cc
-  SignalHandler.cc
   gamestates/GSClient.cc
 …
   overlays/hud/HUDRadar.cc
   overlays/hud/HUDSpeedBar.cc
+  overlays/hud/ChatOverlay.cc
   tools/BillboardSet.cc
-  tools/Light.cc
   tools/Mesh.cc
   tools/ParticleInterface.cc
 …
   tools/WindowEventListener.cc
+  objects/Ambient.cc
+  objects/Backlight.cc
+  objects/Camera.cc
+  objects/CameraHandler.cc
+  objects/Model.cc
+  objects/NPC.cc
+  objects/ParticleSpawner.cc
+  objects/EventListener.cc
+  objects/EventDispatcher.cc
+  objects/EventTarget.cc
   objects/Radar.cc
   objects/RadarListener.cc
   objects/RadarViewable.cc
-  objects/Skybox.cc
-  objects/SpaceShip.cc
-  objects/SpaceShipAI.cc
   objects/Tickable.cc
+  objects/WorldEntity.cc
+  objects/Test.cc
+  objects/Script.cc
+  objects/Projectile.cc
+  objects/BillboardProjectile.cc
+  objects/RotatingProjectile.cc
+  objects/ParticleProjectile.cc
+  objects/Scene.cc
+  objects/worldentities/WorldEntity.cc
+  objects/worldentities/PositionableEntity.cc
+  objects/worldentities/MovableEntity.cc
+  objects/worldentities/ControllableEntity.cc
+  objects/worldentities/Model.cc
+  objects/worldentities/Billboard.cc
+  objects/worldentities/BlinkingBillboard.cc
+  objects/worldentities/Light.cc
+  objects/worldentities/Camera.cc
+  objects/worldentities/CameraPosition.cc
+  objects/worldentities/SpawnPoint.cc
+  objects/worldentities/ParticleEmitter.cc
+  objects/worldentities/ParticleSpawner.cc
+#  objects/worldentities/Backlight.cc
+  objects/worldentities/triggers/Trigger.cc
+  objects/worldentities/triggers/DistanceTrigger.cc
+  objects/worldentities/triggers/EventTrigger.cc
+  objects/worldentities/pawns/Spectator.cc
+  objects/worldentities/pawns/Pawn.cc
+  objects/worldentities/pawns/SpaceShip.cc
+  objects/controllers/Controller.cc
+  objects/controllers/HumanController.cc
+  objects/infos/Info.cc
+  objects/infos/Level.cc
+  objects/infos/PlayerInfo.cc
+  objects/infos/HumanPlayer.cc
+  objects/gametypes/Gametype.cc
   tolua/tolua_bind.cc
 …
   WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}/bin/lib
+)
 ADD_EXECUTABLE( orxonox ${ORXONOX_SRC_FILES} )
 …
   SET( ORXONOXS_SRC_FILES
     GraphicsEngine.cc
-    objects/Ambient.cc
     objects/Camera.cc
+    objects/CameraHandler.cc
+    objects/Explosion.cc
+    objects/Model.cc
+    objects/NPC.cc
+    objects/Projectile.cc
+    objects/Skybox.cc
+    objects/SpaceShip.cc
+    objects/WorldEntity.cc
+    CameraManager.cc
+  )

code/trunk/src/orxonox/GraphicsEngine.cc

-                      r1755
+                      r2087
     */
     GraphicsEngine::GraphicsEngine()
+        : root_(0)
+        , renderWindow_(0)
+        , levelSceneManager_(0)
+        , viewport_(0)
+//        : root_(0)
+//        , renderWindow_(0)
+//        , viewport_(0)
+    {
         RegisterObject(GraphicsEngine);
 …
         singletonRef_s = 0;
+    }
-    /**
-    @brief
-        Get the width of the render window
-    @return
-        The width of the render window
-    */
-    int GraphicsEngine::getWindowWidth() const
+    {
-        if (this->renderWindow_)
-            return this->renderWindow_->getWidth();
-        else
-            return 0;
+    }
-    /**
-    @brief
-        Get the height of the render window
-    @return
-        The height of the render window
-    */
-    int GraphicsEngine::getWindowHeight() const
+    {
-        if (this->renderWindow_)
-            return this->renderWindow_->getHeight();
-        else
-            return 0;
+    }
-    /**
-    @brief
-        Returns the window aspect ratio height/width.
-    @return
-        The window aspect ratio
-    */
-    float GraphicsEngine::getWindowAspectRatio() const
+    {
-        if (this->renderWindow_)
-            return (float)this->renderWindow_->getHeight() / (float)this->renderWindow_->getWidth();
-        else
-            return 1.0f;
+    }
+}

code/trunk/src/orxonox/GraphicsEngine.h

-                      r1755
+                      r2087
         void detailLevelParticleChanged();
-        void setLevelSceneManager(Ogre::SceneManager* sceneMgr) { this->levelSceneManager_ = sceneMgr; }
-        Ogre::SceneManager* getLevelSceneManager() { return levelSceneManager_; }
-        Ogre::Viewport* getViewport() { return this->viewport_; }
-        Ogre::Root*     getOgreRoot() { return this->root_; }
-        // several window properties
-        int getWindowWidth() const;
-        int getWindowHeight() const;
-        float getWindowAspectRatio() const;
         float getAverageFramesPerSecond() const   { return this->avgFramesPerSecond_; }
         float getAverageTickTime() const          { return this->avgTickTime_; }
 …
         GraphicsEngine(GraphicsEngine&);
-        Ogre::Root*         root_;                  //!< Ogre's root
-        Ogre::RenderWindow* renderWindow_;          //!< the current render window
-        Ogre::SceneManager* levelSceneManager_;     //!< scene manager of the game
-        Ogre::Viewport*     viewport_;              //!< default full size viewport
         // stats
         float               avgTickTime_;           //!< time in ms to tick() one frame

code/trunk/src/orxonox/Main.cc

-                      r1896
+                      r2087
 #include "util/OrxonoxPlatform.h"
 #include "util/Debug.h"
+#include "util/SignalHandler.h"
 #include "core/ConfigFileManager.h"
-#include "SignalHandler.h"
 #include "gamestates/GSRoot.h"

code/trunk/src/orxonox/OrxonoxPrereqs.h

-                      r1755
+                      r2087
     class RadarListener;
+    class CameraManager;
+    class LevelManager;
     // objects
+    class Ambient;
+    class Scene;
+    class WorldEntity;
+    class PositionableEntity;
+    class MovableEntity;
+    class ControllableEntity;
+    class Sublevel;
+    class Model;
+    class Billboard;
+    class BlinkingBillboard;
+    class Light;
     class Backlight;
+    class ParticleEmitter;
+    class ParticleSpawner;
     class Camera;
+    class Model;
+    class NPC;
+    class ParticleSpawner;
+    class Skybox;
+    class CameraPosition;
+    class SpawnPoint;
+    class Spectator;
+    class Pawn;
     class SpaceShip;
-    class SpaceShipAI;
-    class WorldEntity;
+    class Projectile;
+    class BillboardProjectile;
+    class RotatingProjectile;
+    class ParticleProjectile;
+    class Trigger;
+    class DistanceTrigger;
+    class EventTrigger;
+    class EventListener;
+    class EventDispatcher;
+    class EventTarget;
+    class Controller;
+    class HumanController;
+    class Info;
+    class Level;
+    class PlayerInfo;
+    class HumanPlayer;
+    class Gametype;
+    class Scores;
     // tools

code/trunk/src/orxonox/OrxonoxStableHeaders.h

-                      r1841
+                      r2087
 #include "util/OrxonoxPlatform.h"
 #if ORXONOX_COMPILER == ORXONOX_COMPILER_MSVC && !defined(ORXONOX_DISABLE_PCH)
+#if defined(ORXONOX_ENABLE_PCH)
 // including std headers here is useless since they're already precompiled
 …
 #include <Ogre.h>
 #include <CEGUI.h>
+#include "ois/OIS.h"
 #include <boost/thread/recursive_mutex.hpp>
 #include <boost/thread/mutex.hpp>
 #include <boost/thread/condition.hpp>
 #include <boost/thread/thread.hpp>
+//#include <boost/thread/mutex.hpp>
+//#include <boost/thread/condition.hpp>
+//#include <boost/thread/thread.hpp>
+#include <boost/static_assert.hpp>
 #include "tinyxml/ticpp.h"
 #include "tinyxml/tinyxml.h"
+#include "tolua/tolua++.h"
 //Get around Windows hackery (windows.h is included by Ogre)
+//Get around Windows hackery (windows.h is included by Ogre.h)
 #if ORXONOX_PLATFORM == ORXONOX_PLATFORM_WIN32
 #  ifdef max
 …
 //----------- Our files ----------
 //--------------------------------
 // only include when not debugging so that we may find issues with missing headers quicker
 #if defined(NDEBUG)
+//// only include when not debugging so that we may find issues with missing headers quicker
+//#if defined(NDEBUG)
 #include "util/Convert.h"
 #include "util/Debug.h"
+#include "util/Exception.h"
 #include "util/Math.h"
 #include "util/Multitype.h"
-#include "util/OutputBuffer.h"
-#include "util/OutputHandler.h"
 #include "util/Sleep.h"
 #include "util/String.h"
 …
 #include "core/ConfigValueIncludes.h"
 #include "core/CommandExecutor.h"
+#include "core/Core.h"
 #include "core/Executor.h"
+#include "core/ObjectList.h"
+#include "core/Super.h"
 #include "core/XMLIncludes.h"
 #include "core/XMLPort.h"
+#include "core/input/SimpleInputState.h"
+#include "core/input/InputManager.h"
 #include "network/Synchronisable.h"
+//#include "tools/Mesh.h"
+//#include "tools/Timer.h"
+//#include "objects/Model.h"
+//#include "objects/Tickable.h"
+//#include "objects/WorldEntity.h"
+#include "Settings.h"
 #endif /* ifdef NDEBUG */
+//#endif /* ifdef NDEBUG */
 #endif /* ORXONOX_COMPILER == ORXONOX_COMPILER_MSVC && !defined(ORXONOX_DISABLE_PCH) */

code/trunk/src/orxonox/Settings.cc

r1907	r2087
39	39	#include "core/CoreIncludes.h"
40	40	#include "core/ConfigValueIncludes.h"
	41	#include "core/LuaBind.h"
41	42
42	43	namespace orxonox
…	…
49	50	*/
50	51	Settings::Settings()
51		~~: bShowsGraphics_(false)~~
52		~~, bHasServer_(false)~~
53		~~, bIsClient_(false)~~
54	52	{
55	53	RegisterRootObject(Settings);
…	…
65	63	void Settings::setConfigValues()
66	64	{
67		SetConfigValue(dataPath_, "../../Media/").description("Relative path to the game data.").callback(this, &Settings::dataPathChanged);
	65	SetConfigValue(dataPath_, "../../media/").description("Relative path to the game data.").callback(this, &Settings::dataPathChanged);
68	66	}
69	67
…	…
84	82	COUT(2) << "Warning: Data path set to \"/\", is that really correct?" << std::endl;
85	83	}
	84
	85	LuaBind::getInstance()->setIncludePath(this->dataPath_);
86	86	}
87	87

code/trunk/src/orxonox/Settings.h

-                      r1907
+                      r2087
         friend class ClassIdentifier<Settings>;
         friend class GSRoot;
-        friend class GSGraphics;
-        friend class GSServer;
-        friend class GSClient;
-        friend class GSDedicated;
     public:
 …
         { assert(singletonRef_s); singletonRef_s->_tsetDataPath(path); }
-        // an alternative to a global game mode variable
-        static bool showsGraphics() { assert(singletonRef_s); return singletonRef_s->bShowsGraphics_; }
-        static bool hasServer()     { assert(singletonRef_s); return singletonRef_s->bHasServer_; }
-        static bool isClient()      { assert(singletonRef_s); return singletonRef_s->bIsClient_; }
     private:
-        // GSRoot has access to these
-        static void setShowsGraphics(bool val) { assert(singletonRef_s); singletonRef_s->bShowsGraphics_ = val; }
-        static void setHasServer    (bool val) { assert(singletonRef_s); singletonRef_s->bHasServer_     = val; }
-        static void setIsClient     (bool val) { assert(singletonRef_s); singletonRef_s->bIsClient_      = val; }
         Settings();
         Settings(const Settings& instance);
 …
         void setConfigValues();
-        bool bShowsGraphics_;                                  //!< global variable that tells whether to show graphics
-        bool bHasServer_;                                      //!< global variable that tells whether this is a server
-        bool bIsClient_;
         std::string dataPath_;                                 //!< Path to the game data

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

-                      r1907
+                      r2087
 #include "core/input/InputManager.h"
 #include "core/CommandLine.h"
+#include "core/Core.h"
 #include "network/Client.h"
-#include "Settings.h"
 namespace orxonox
+{
     SetCommandLineArgument(ip, "127.0.0.1").setInformation("#.#.#.#");
+    SetCommandLineArgument(ip, "127.0.0.1").information("#.#.#.#");
     GSClient::GSClient()
         : GSLevel("client")
+        : GameState<GSGraphics>("client")
         , client_(0)
+    {
 …
     void GSClient::enter()
+    {
         Settings::_getInstance().bIsClient_ = true;
+        Core::setIsClient(true);
+        GSLevel::enter();
+        int serverPort = CommandLine::getArgument<int>("port")->getValue();
+        std::string serverIP = CommandLine::getArgument<std::string>("ip")->getValue();
+        this->client_ = new network::Client(serverIP, serverPort);
+        this->client_ = new network::Client(CommandLine::getValue("ip").getString(), CommandLine::getValue("port"));
         if(!client_->establishConnection())
             ThrowException(InitialisationFailed, "Could not establish connection with server.");
+        GSLevel::enter(this->getParent()->getViewport());
         client_->tick(0);
-        // level is loaded: we can start capturing the input
-        InputManager::getInstance().requestEnterState("game");
+    }
     void GSClient::leave()
+    {
+        InputManager::getInstance().requestLeaveState("game");
+        // TODO: How do we unload the level in client mode?
+        GSLevel::leave();
         client_->closeConnection();
 …
         delete this->client_;
+        GSLevel::leave();
+        Settings::_getInstance().bIsClient_ = false;
+        Core::setIsClient(false);
+    }

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

-                      r1755
+                      r2087
 #include "network/NetworkPrereqs.h"
 #include "GSLevel.h"
+#include "GSGraphics.h"
 namespace orxonox
+{
     class _OrxonoxExport GSClient : public GSLevel
+    class _OrxonoxExport GSClient : public GameState<GSGraphics>, public GSLevel
+    {
     public:

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

-                      r1790
+                      r2087
 #include "GSDedicated.h"
-#include <OgreRoot.h>
-#include <OgreSceneManager.h>
-#include "core/ConsoleCommand.h"
 #include "core/CommandLine.h"
 #include "core/Loader.h"
+#include "core/Core.h"
 #include "network/Server.h"
-#include "objects/Tickable.h"
-#include "GraphicsEngine.h"
-#include "Settings.h"
 namespace orxonox
 …
     GSDedicated::GSDedicated()
         : GameState<GSRoot>("dedicated")
-        , timeFactor_(0)
         , server_(0)
-        , sceneManager_(0)
-        , startLevel_(0)
+    {
+    }
 …
     void GSDedicated::enter()
+    {
         Settings::_getInstance().bHasServer_ = true;
+        Core::setHasServer(true);
+        // create Ogre SceneManager for the level
+        this->sceneManager_ = Ogre::Root::getSingleton().createSceneManager(Ogre::ST_GENERIC, "LevelSceneManager");
+        COUT(4) << "Created SceneManager: " << sceneManager_->getName() << std::endl;
+        this->server_ = new network::Server(CommandLine::getValue("port"));
+        COUT(0) << "Loading scene in server mode" << std::endl;
+        // temporary hack
+        GraphicsEngine::getInstance().setLevelSceneManager(this->sceneManager_);
+        // reset game speed to normal
+        timeFactor_ = 1.0f;
+        int serverPort = CommandLine::getArgument<int>("port")->getValue();
+        this->server_ = new network::Server(serverPort);
+        // call the loader
+        COUT(0) << "Loading level..." << std::endl;
+        startLevel_ = new Level(Settings::getDataPath() + "levels/sample.oxw");
+        Loader::open(startLevel_);
+        GSLevel::enter(0);
         server_->open();
-        // add console commands
-        FunctorMember01<GSDedicated, float>* functor = createFunctor(&GSDedicated::setTimeFactor);
-        functor->setObject(this);
-        CommandExecutor::addConsoleCommandShortcut(createConsoleCommand(functor, "setTimeFactor")).accessLevel(AccessLevel::Offline).defaultValue(0, 1.0);;
+    }
     void GSDedicated::leave()
+    {
+        // TODO: Remove and destroy console command
+        Loader::unload(startLevel_);
+        delete this->startLevel_;
+        GSLevel::leave();
         this->server_->close();
         delete this->server_;
+        Ogre::Root::getSingleton().destroySceneManager(this->sceneManager_);
+        Settings::_getInstance().bHasServer_ = false;
+        Core::setHasServer(false);
+    }
     void GSDedicated::ticked(const Clock& time)
+    {
+        // Call the scene objects
+        for (ObjectList<Tickable>::iterator it = ObjectList<Tickable>::begin(); it; ++it)
+            it->tick(time.getDeltaTime() * this->timeFactor_);
+        GSLevel::ticked(time);
         server_->tick(time.getDeltaTime());
         this->tickChild(time);
+    }
-    /**
-    @brief
-        Changes the speed of Orxonox
-    */
-    void GSDedicated::setTimeFactor(float factor)
+    {
-        this->timeFactor_ = factor;
+    }
+}

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

-                      r1755
+                      r2087
 #include "OrxonoxPrereqs.h"
 #include "network/NetworkPrereqs.h"
+#include "GSLevel.h"
 #include "GSRoot.h"
 namespace orxonox
+{
     class _OrxonoxExport GSDedicated : public GameState<GSRoot>
+    class _OrxonoxExport GSDedicated : public GameState<GSRoot>, public GSLevel
+    {
     public:
         GSDedicated();
         ~GSDedicated();
-        void setTimeFactor(float factor);
-        float getTimeFactor() { return this->timeFactor_; }
     private:
 …
         void ticked(const Clock& time);
-        void loadLevel();
-        void unloadLevel();
-        float                 timeFactor_;       //!< A factor to change the gamespeed
         network::Server*      server_;
-        Ogre::SceneManager*   sceneManager_;
-        Level*                startLevel_;       //!< current hard coded default level
     };
+}

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

r1755	r2087
31	31
32	32	#include <OgreViewport.h>
33		~~#include "GraphicsEngine.h"~~
34	33	#include "core/input/InputManager.h"
35	34	#include "core/input/SimpleInputState.h"

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

-                      r1891
+                      r2087
 #include "core/ConfigValueIncludes.h"
 #include "core/CoreIncludes.h"
+#include "core/Core.h"
 #include "core/input/InputManager.h"
 #include "core/input/KeyBinder.h"
 #include "core/input/ExtendedInputState.h"
+#include "core/Loader.h"
+#include "core/XMLFile.h"
 #include "overlays/console/InGameConsole.h"
 #include "gui/GUIManager.h"
 #include "tools/WindowEventListener.h"
+#include "objects/Tickable.h"
 #include "Settings.h"
 …
         , renderWindow_(0)
         , viewport_(0)
+        , bWindowEventListenerUpdateRequired_(false)
         , inputManager_(0)
         , console_(0)
 …
         , statisticsStartCount_(0)
         , tickTime_(0)
+        , debugOverlay_(0)
+    {
         RegisterRootObject(GSGraphics);
 …
     void GSGraphics::enter()
+    {
         Settings::_getInstance().bShowsGraphics_ = true;
+        Core::setShowsGraphics(true);
         // initialise graphics engine. Doesn't load the render window yet!
 …
         this->initialiseResources();
+        // HACK: temporary:
+        graphicsEngine_->renderWindow_  = this->renderWindow_;
+        graphicsEngine_->root_          = this->ogreRoot_;
+        graphicsEngine_->viewport_      = this->viewport_;
+        // We want to get informed whenever an object of type WindowEventListener is created
+        // in order to later update the window size.
+        bWindowEventListenerUpdateRequired_ = false;
+        RegisterConstructionCallback(GSGraphics, orxonox::WindowEventListener, requestWindowEventListenerUpdate);
+        // load debug overlay
+        COUT(3) << "Loading Debug Overlay..." << std::endl;
+        this->debugOverlay_ = new XMLFile(Settings::getDataPath() + "overlay/debug.oxo");
+        Loader::open(debugOverlay_);
         // Calls the InputManager which sets up the input devices.
 …
         // Load the InGameConsole
         console_ = new InGameConsole();
         console_->initialise();
+        console_->initialise(this->renderWindow_->getWidth(), this->renderWindow_->getHeight());
         // load the CEGUI interface
 …
         //delete this->masterKeyBinder_;
         delete this->inputManager_;
+        Loader::unload(this->debugOverlay_);
+        delete this->debugOverlay_;
         // destroy render window
 …
         delete graphicsEngine_;
         Settings::_getInstance().bShowsGraphics_ = false;
+        Core::setShowsGraphics(false);
+    }
 …
         this->console_->tick(dt);
         this->tickChild(time);
+        /*** HACK *** HACK ***/
+        // Call the Tickable objects
+        for (ObjectList<Tickable>::iterator it = ObjectList<Tickable>::begin(); it; ++it)
+            it->tick(time.getDeltaTime());
+        /*** HACK *** HACK ***/
+        if (this->bWindowEventListenerUpdateRequired_)
+        {
+            // Update all WindowEventListeners for the case a new one was created.
+            this->windowResized(this->renderWindow_);
+            this->bWindowEventListenerUpdateRequired_ = false;
+        }
         unsigned long long timeAfterTick = time.getRealMicroseconds();
 …
         for (ObjectList<orxonox::WindowEventListener>::iterator it = ObjectList<orxonox::WindowEventListener>::begin(); it; ++it)
             it->windowResized(this->renderWindow_->getWidth(), this->renderWindow_->getHeight());
+        // OIS needs this under linux even if we only use relative input measurement.
+        if (this->inputManager_)
+            this->inputManager_->setWindowExtents(renderWindow_->getWidth(), renderWindow_->getHeight());
+    }
 …
         // instruct InputManager to clear the buffers (core library so we cannot use the interface)
+        InputManager::getInstance().clearBuffers();
+        if (this->inputManager_)
+            this->inputManager_->clearBuffers();
+    }
 …
     void GSGraphics::windowClosed(Ogre::RenderWindow *rw)
+    {
-        // using CommandExecutor in order to avoid depending on Orxonox.h.
-        //CommandExecutor::execute("exit", false);
         this->requestState("root");
+    }

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

-                      r1891
+                      r2087
         void windowClosed      (Ogre::RenderWindow* rw);
+        void requestWindowEventListenerUpdate() { this->bWindowEventListenerUpdateRequired_ = true; }
     private: // variables
         Ogre::RenderWindow*   renderWindow_;          //!< the current render window
         Ogre::Viewport*       viewport_;              //!< default full size viewport
+        bool bWindowEventListenerUpdateRequired_;     //!< True if a new WindowEventListener was created but not yet updated.
         // managed singletons
 …
         unsigned long         statisticsStartCount_;
         unsigned int          tickTime_;
+        XMLFile*              debugOverlay_;
         // config values

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

r1755	r2087
36	36
37	37	#include "core/ConsoleCommand.h"
38		~~#include "core/TclThreadManager.h"~~
39		~~#include "GraphicsEngine.h"~~
40	38
41	39	namespace orxonox

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

-                      r1934
+                      r2087
 #include "GSLevel.h"
-#include <OgreSceneManager.h>
-#include <OgreRoot.h>
 #include "core/input/InputManager.h"
 #include "core/input/SimpleInputState.h"
 #include "core/input/KeyBinder.h"
 #include "core/Loader.h"
+#include "core/XMLFile.h"
 #include "core/CommandExecutor.h"
 #include "core/ConsoleCommand.h"
 …
 #include "core/ConfigValueIncludes.h"
 #include "core/CoreIncludes.h"
+#include "objects/Backlight.h"
+#include "core/Core.h"
+//#include "objects/Backlight.h"
 #include "objects/Tickable.h"
 #include "objects/Radar.h"
+#include "tools/ParticleInterface.h"
+//#include "tools/ParticleInterface.h"
+#include "CameraManager.h"
+#include "LevelManager.h"
 #include "Settings.h"
-#include "GraphicsEngine.h"
 namespace orxonox
+{
+    SetCommandLineArgument(level, "sample.oxw").setShortcut("l");
+    GSLevel::GSLevel(const std::string& name)
+        : GameState<GSGraphics>(name)
+        , timeFactor_(1.0f)
+        , sceneManager_(0)
+    SetCommandLineArgument(level, "sample2.oxw").shortcut("l");
+    GSLevel::GSLevel()
+//        : GameState<GSGraphics>(name)
+        : timeFactor_(1.0f)
         , keyBinder_(0)
         , inputState_(0)
         , radar_(0)
+        , startLevel_(0)
+        , hud_(0)
+        , startFile_(0)
+        , cameraManager_(0)
+        , levelManager_(0)
+    {
         RegisterObject(GSLevel);
 …
+    }
+    void GSLevel::enter()
+    {
+        inputState_ = InputManager::getInstance().createInputState<SimpleInputState>("game", 20);
+        keyBinder_ = new KeyBinder();
+        keyBinder_->loadBindings("keybindings.ini");
+        inputState_->setHandler(keyBinder_);
+        // create Ogre SceneManager for the level
+        this->sceneManager_ = Ogre::Root::getSingleton().createSceneManager(Ogre::ST_GENERIC, "LevelSceneManager");
+        COUT(4) << "Created SceneManager: " << sceneManager_->getName() << std::endl;
+        // temporary hack
+        GraphicsEngine::getInstance().setLevelSceneManager(this->sceneManager_);
+        // Start the Radar
+        this->radar_ = new Radar();
+        // Load the HUD
+        COUT(3) << "Orxonox: Loading HUD" << std::endl;
+        hud_ = new Level(Settings::getDataPath() + "overlay/hud.oxo");
+        Loader::load(hud_);
+        // reset game speed to normal
+        timeFactor_ = 1.0f;
+        // TODO: insert slomo console command with
+        // .accessLevel(AccessLevel::Offline).defaultValue(0, 1.0).axisParamIndex(0).isAxisRelative(false);
+        // keybind console command
+        FunctorMember<GSLevel>* functor1 = createFunctor(&GSLevel::keybind);
+        functor1->setObject(this);
+        CommandExecutor::addConsoleCommandShortcut(createConsoleCommand(functor1, "keybind"));
+        FunctorMember<GSLevel>* functor2 = createFunctor(&GSLevel::tkeybind);
+        functor2->setObject(this);
+        CommandExecutor::addConsoleCommandShortcut(createConsoleCommand(functor2, "tkeybind"));
+        // set our console command as callback for the key detector
+        InputManager::getInstance().setKeyDetectorCallback(std::string("keybind ") + keyDetectorCallbackCode_);
+    void GSLevel::enter(Ogre::Viewport* viewport)
+    {
+        if (Core::showsGraphics())
+        {
+            inputState_ = InputManager::getInstance().createInputState<SimpleInputState>("game", 20);
+            keyBinder_ = new KeyBinder();
+            keyBinder_->loadBindings("keybindings.ini");
+            inputState_->setHandler(keyBinder_);
+            // create the global CameraManager
+            assert(viewport);
+            this->cameraManager_ = new CameraManager(viewport);
+            // Start the Radar
+            this->radar_ = new Radar();
+        }
+        if (Core::isMaster())
+        {
+            // create the global LevelManager
+            this->levelManager_ = new LevelManager();
+            // reset game speed to normal
+            timeFactor_ = 1.0f;
+            this->loadLevel();
+        }
+        if (Core::showsGraphics())
+        {
+            // TODO: insert slomo console command with
+            // .accessLevel(AccessLevel::Offline).defaultValue(0, 1.0).axisParamIndex(0).isAxisRelative(false);
+            // keybind console command
+            FunctorMember<GSLevel>* functor1 = createFunctor(&GSLevel::keybind);
+            functor1->setObject(this);
+            CommandExecutor::addConsoleCommandShortcut(createConsoleCommand(functor1, "keybind"));
+            FunctorMember<GSLevel>* functor2 = createFunctor(&GSLevel::tkeybind);
+            functor2->setObject(this);
+            CommandExecutor::addConsoleCommandShortcut(createConsoleCommand(functor2, "tkeybind"));
+            // set our console command as callback for the key detector
+            InputManager::getInstance().setKeyDetectorCallback(std::string("keybind ") + keyDetectorCallbackCode_);
+            // level is loaded: we can start capturing the input
+            InputManager::getInstance().requestEnterState("game");
+        }
+        if (Core::isMaster())
+        {
+            // time factor console command
+            FunctorMember<GSLevel>* functor = createFunctor(&GSLevel::setTimeFactor);
+            functor->setObject(this);
+            CommandExecutor::addConsoleCommandShortcut(createConsoleCommand(functor, "setTimeFactor")).accessLevel(AccessLevel::Offline).defaultValue(0, 1.0);;
+        }
+    }
     void GSLevel::leave()
+    {
-        Loader::unload(hud_);
-        delete this->hud_;
         // this call will delete every BaseObject!
         // But currently this will call methods of objects that exist no more
 …
         //Loader::close();
+        delete this->radar_;
+        Ogre::Root::getSingleton().destroySceneManager(this->sceneManager_);
+        inputState_->setHandler(0);
+        InputManager::getInstance().requestDestroyState("game");
+        delete this->keyBinder_;
+        if (Core::showsGraphics())
+            InputManager::getInstance().requestLeaveState("game");
+        if (Core::isMaster())
+            this->unloadLevel();
+        if (this->radar_)
+            delete this->radar_;
+        if (this->cameraManager_)
+            delete this->cameraManager_;
+        if (this->levelManager_)
+            delete this->levelManager_;
+        if (Core::showsGraphics())
+        {
+            inputState_->setHandler(0);
+            InputManager::getInstance().requestDestroyState("game");
+            if (this->keyBinder_)
+                delete this->keyBinder_;
+        }
+    }
     void GSLevel::ticked(const Clock& time)
+    {
+        // Call the scene objects
+        for (ObjectList<Tickable>::iterator it = ObjectList<Tickable>::begin(); it; ++it)
+            it->tick(time.getDeltaTime() * this->timeFactor_);
+        // Commented by 1337: Temporarily moved to GSGraphics.
+        //// Call the scene objects
+        //for (ObjectList<Tickable>::iterator it = ObjectList<Tickable>::begin(); it; ++it)
+        //    it->tick(time.getDeltaTime() * this->timeFactor_);
+    }
 …
     void GSLevel::setTimeFactor(float factor)
+    {
+/*
         float change = factor / this->timeFactor_;
+*/
         this->timeFactor_ = factor;
+/*
         for (ObjectList<ParticleInterface>::iterator it = ObjectList<ParticleInterface>::begin(); it; ++it)
             it->setSpeedFactor(it->getSpeedFactor() * change);
 …
         for (ObjectList<Backlight>::iterator it = ObjectList<Backlight>::begin(); it; ++it)
             it->setTimeFactor(timeFactor_);
+*/
+    }
 …
         std::string levelName;
         CommandLine::getValue("level", &levelName);
         startLevel_ = new Level(Settings::getDataPath() + std::string("levels/") + levelName);
         Loader::open(startLevel_);
+        startFile_ = new XMLFile(Settings::getDataPath() + std::string("levels/") + levelName);
+        Loader::open(startFile_);
+    }
     void GSLevel::unloadLevel()
+    {
+        Loader::unload(startLevel_);
+        delete this->startLevel_;
+        //////////////////////////////////////////////////////////////////////////////////////////
+        // TODO // TODO // TODO // TODO // TODO // TODO // TODO // TODO // TODO // TODO // TODO //
+        //////////////////////////////////////////////////////////////////////////////////////////
+        // Loader::unload(startFile_); // TODO: REACTIVATE THIS IF LOADER::UNLOAD WORKS PROPERLY /
+        //////////////////////////////////////////////////////////////////////////////////////////
+        delete this->startFile_;
+    }
 …
     void GSLevel::keybindInternal(const std::string& command, bool bTemporary)
+    {
         static std::string bindingString = "";
         static bool bTemporarySaved = false;
         static bool bound = true;
         // note: We use a long name to make 'sure' that the user doesn't use it accidentally.
         // Howerver there will be no real issue if it happens anyway.
         if (command.find(keyDetectorCallbackCode_) != 0)
+        {
             if (bound)
+        if (Core::showsGraphics())
+        {
+            static std::string bindingString = "";
+            static bool bTemporarySaved = false;
+            static bool bound = true;
+            // note: We use a long name to make 'sure' that the user doesn't use it accidentally.
+            // Howerver there will be no real issue if it happens anyway.
+            if (command.find(keyDetectorCallbackCode_) != 0)
+            {
+                COUT(0) << "Press any button/key or move a mouse/joystick axis" << std::endl;
+                InputManager::getInstance().requestEnterState("detector");
+                bindingString = command;
+                bTemporarySaved = bTemporary;
+                bound = false;
+                if (bound)
+                {
+                    COUT(0) << "Press any button/key or move a mouse/joystick axis" << std::endl;
+                    InputManager::getInstance().requestEnterState("detector");
+                    bindingString = command;
+                    bTemporarySaved = bTemporary;
+                    bound = false;
+                }
+                //else:  We're still in a keybind command. ignore this call.
+            }
+            //else:  We're still in a keybind command. ignore this call.
+        }
+        else
+        {
+            if (!bound)
+            else
+            {
+                // user has pressed the key
+                std::string name = command.substr(this->keyDetectorCallbackCode_.size());
+                COUT(0) << "Binding string \"" << bindingString << "\" on key '" << name << "'" << std::endl;
+                this->keyBinder_->setBinding(bindingString, name, bTemporarySaved);
+                InputManager::getInstance().requestLeaveState("detector");
+                bound = true;
+                if (!bound)
+                {
+                    // user has pressed the key
+                    std::string name = command.substr(this->keyDetectorCallbackCode_.size());
+                    COUT(0) << "Binding string \"" << bindingString << "\" on key '" << name << "'" << std::endl;
+                    this->keyBinder_->setBinding(bindingString, name, bTemporarySaved);
+                    InputManager::getInstance().requestLeaveState("detector");
+                    bound = true;
+                }
+                // else: A key was pressed within the same tick, ignore it.
+            }
-            // else: A key was pressed within the same tick, ignore it.
+        }
+    }

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

-                      r1887
+                      r2087
 namespace orxonox
+{
     class _OrxonoxExport GSLevel : public GameState<GSGraphics>, public OrxonoxClass
+    class _OrxonoxExport GSLevel : public OrxonoxClass //,public GameState<GSGraphics>
+    {
         friend class ClassIdentifier<GSLevel>;
     public:
         GSLevel(const std::string& name);
         virtual ~GSLevel();
+        GSLevel();
+        ~GSLevel();
         // this has to be public because proteced triggers a bug in msvc
 …
     protected:
         virtual void enter();
         virtual void leave();
         virtual void ticked(const Clock& time);
+        void enter(Ogre::Viewport* viewport);
+        void leave();
+        void ticked(const Clock& time);
         void loadLevel();
         void unloadLevel();
         float timeFactor_;       //!< A factor to change the gamespeed
+        float timeFactor_;       //!< A factor that sets the gamespeed. 1 is normal.
         // console commands
 …
         void keybindInternal(const std::string& command, bool bTemporary);
-        Ogre::SceneManager*   sceneManager_;
         KeyBinder*            keyBinder_;        //!< tool that loads and manages the input bindings
         SimpleInputState*     inputState_;
         Radar*                radar_;            //!< represents the Radar (not the HUD part)
+        Level*                startLevel_;       //!< current hard coded default level
+        Level*                hud_;              //!< 'level' object fo the HUD
+        XMLFile*              startFile_;        //!< current hard coded default level
+        CameraManager*        cameraManager_;
+        LevelManager*         levelManager_;
         // config values
         std::string           keyDetectorCallbackCode_;
     private:
         void setConfigValues();

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

-                      r1891
+                      r2087
 #include "core/TclThreadManager.h"
 #include "tools/Timer.h"
-#include "GraphicsEngine.h"
 #include "Settings.h"
 …
 namespace orxonox
+{
     SetCommandLineArgument(dataPath, "").setInformation("PATH");
     SetCommandLineArgument(limitToCPU, 1).setInformation("0: off | #cpu");
+    SetCommandLineArgument(dataPath, "").information("PATH");
+    SetCommandLineArgument(limitToCPU, 1).information("0: off | #cpu");
     GSRoot::GSRoot()
 …
         this->settings_ = new Settings();
+        std::string dataPath;
+        CommandLine::getValue("dataPath", &dataPath);
+        std::string dataPath = CommandLine::getValue("dataPath");
         if (dataPath != "")
+        {
 …
         // do this after ogre has initialised. Somehow Ogre changes the settings again (not through
         // the timer though).
+        int limitToCPU;
+        CommandLine::getValue("limitToCPU", &limitToCPU);
+        int limitToCPU = CommandLine::getValue("limitToCPU");
         if (limitToCPU > 0)
             setThreadAffinity((unsigned int)(limitToCPU - 1));
 …
         Copyright (c) 2000-2008 Torus Knot Software Ltd
         OGRE is licensed under the LGPL. For more info, see ogre license info.
+        OGRE is licensed under the LGPL. For more info, see OGRE license.
     */
     void GSRoot::setThreadAffinity(unsigned int limitToCPU)

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

-                      r1910
+                      r2087
 #include "GSServer.h"
-#include "core/ConsoleCommand.h"
-#include "core/input/InputManager.h"
 #include "core/CommandLine.h"
+#include "core/Core.h"
 #include "network/Server.h"
-#include "Settings.h"
 namespace orxonox
+{
     SetCommandLineArgument(port, 55556).setShortcut("p").setInformation("0-65535");
+    SetCommandLineArgument(port, 55556).shortcut("p").information("0-65535");
     GSServer::GSServer()
         : GSLevel("server")
+        : GameState<GSGraphics>("server")
         , server_(0)
+    {
 …
     void GSServer::enter()
+    {
         Settings::_getInstance().bHasServer_ = true;
+        Core::setHasServer(true);
+        GSLevel::enter();
+        int serverPort = CommandLine::getArgument<int>("port")->getValue();
+        this->server_ = new network::Server(serverPort);
+        this->server_ = new network::Server(CommandLine::getValue("port"));
         COUT(0) << "Loading scene in server mode" << std::endl;
         this->loadLevel();
+        GSLevel::enter(this->getParent()->getViewport());
         server_->open();
-        // add console commands
-        FunctorMember<GSLevel>* functor = createFunctor(&GSLevel::setTimeFactor);
-        functor->setObject(this);
-        CommandExecutor::addConsoleCommandShortcut(createConsoleCommand(functor, "setTimeFactor")).accessLevel(AccessLevel::Offline).defaultValue(0, 1.0);;
-        // level is loaded: we can start capturing the input
-        InputManager::getInstance().requestEnterState("game");
+    }
     void GSServer::leave()
+    {
+        InputManager::getInstance().requestLeaveState("game");
+        // TODO: Remove and destroy console command
+        this->unloadLevel();
+        GSLevel::leave();
         this->server_->close();
         delete this->server_;
+        GSLevel::leave();
+        Settings::_getInstance().bHasServer_ = false;
+        Core::setHasServer(false);
+    }

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

-                      r1755
+                      r2087
 #include "network/NetworkPrereqs.h"
 #include "GSLevel.h"
+#include "GSGraphics.h"
 namespace orxonox
+{
     class _OrxonoxExport GSServer : public GSLevel
+    class _OrxonoxExport GSServer : public GameState<GSGraphics>, public GSLevel
+    {
     public:
         GSServer();
         ~GSServer();
     private:

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

-                      r1755
+                      r2087
 #include "GSStandalone.h"
+#include "core/input/InputManager.h"
+#include "core/ConsoleCommand.h"
+#include "core/Core.h"
 namespace orxonox
+{
     GSStandalone::GSStandalone()
         : GSLevel("standalone")
+        : GameState<GSGraphics>("standalone")
+    {
+    }
 …
     void GSStandalone::enter()
+    {
         GSLevel::enter();
+        Core::setIsStandalone(true);
+        this->loadLevel();
+        // add console commands
+        FunctorMember<GSLevel>* functor = createFunctor(&GSLevel::setTimeFactor);
+        functor->setObject(this);
+        CommandExecutor::addConsoleCommandShortcut(createConsoleCommand(functor, "setTimeFactor")).accessLevel(AccessLevel::Offline).defaultValue(0, 1.0);;
+        // level is loaded: we can start capturing the input
+        InputManager::getInstance().requestEnterState("game");
+        GSLevel::enter(this->getParent()->getViewport());
+    }
     void GSStandalone::leave()
+    {
         InputManager::getInstance().requestLeaveState("game");
+        GSLevel::leave();
+        // TODO: Remove and destroy console command
+        this->unloadLevel();
+        GSLevel::leave();
+        Core::setIsStandalone(false);
+    }

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

-                      r1755
+                      r2087
 #include "OrxonoxPrereqs.h"
 #include "GSLevel.h"
+#include "GSGraphics.h"
 namespace orxonox
+{
     class _OrxonoxExport GSStandalone : public GSLevel
+    class _OrxonoxExport GSStandalone : public GameState<GSGraphics>, public GSLevel
+    {
     public:

code/trunk/src/orxonox/gui/GUIManager.cc

r1887	r2087
47	47	#include "core/Core.h"
48	48	#include "tolua/tolua_bind.h"
49		~~#include "GraphicsEngine.h"~~
50	49	#include "OgreCEGUIRenderer.h"
51	50

code/trunk/src/orxonox/gui/OgreCEGUIRenderer.cpp

r1755	r2087
25	25	*************************************************************************/
26	26
	27	#include "OrxonoxStableHeaders.h"
27	28	#include <CEGUIImagesetManager.h>
28	29	#include <CEGUIImageset.h>

code/trunk/src/orxonox/gui/OgreCEGUIResourceProvider.cpp

r1755	r2087
24	24	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
25	25	*************************************************************************/
	26	#include "OrxonoxStableHeaders.h"
26	27	#include "OgreCEGUIResourceProvider.h"
27	28

code/trunk/src/orxonox/gui/OgreCEGUITexture.cpp

r1755	r2087
25	25	*************************************************************************/
26	26
	27	#include "OrxonoxStableHeaders.h"
27	28	#include <CEGUISystem.h>
28	29	#include <CEGUIExceptions.h>

code/trunk/src/orxonox/objects/Radar.cc

-                      r1818
+                      r2087
 #include <cfloat>
 #include <cassert>
-#include "objects/WorldEntity.h"
-#include "objects/SpaceShip.h"
 #include "core/CoreIncludes.h"
 #include "core/ConsoleCommand.h"
 …
             for (ObjectList<RadarViewable>::iterator itElement = ObjectList<RadarViewable>::begin(); itElement; ++itElement)
+            {
+/*
                 if ((*itElement) != SpaceShip::getLocalShip() && (*itListener)->getRadarSensitivity() > (*itElement)->getRadarObjectCamouflage())
                     (*itListener)->displayObject(*itElement, *itElement == this->focus_);
+*/
+            }
+        }
 …
         else
+        {
             Vector3 localPosition = SpaceShip::getLocalShip()->getPosition();
+            Vector3 localPosition;// = SpaceShip::getLocalShip()->getPosition();
             Vector3 targetPosition = localPosition;
             if (*(this->itFocus_))
 …
             for (ObjectList<RadarViewable>::iterator it = ObjectList<RadarViewable>::begin(); it; ++it)
+            {
+/*
                 if (*it == SpaceShip::getLocalShip())
                     continue;
+*/
                 float targetDistance = localPosition.squaredDistance((*it)->getWorldPosition());
                 if (targetDistance > currentDistance && targetDistance < nextDistance)

code/trunk/src/orxonox/objects/RadarViewable.cc

r1818	r2087
31	31	#include "util/Debug.h"
32	32	#include "core/CoreIncludes.h"
33		#include "objects/WorldEntity.h"
	33	//#include "objects/WorldEntity.h"
34	34	#include "Radar.h"
35	35
…	…
63	63	{
64	64	validate();
65		return this->radarObject_->getWorldPosition();
	65	return Vector3::ZERO;//this->radarObject_->getWorldPosition();
66	66	}
67	67
…	…
69	69	{
70	70	validate();
71		return this->radarObject_->getOrientation() * this->radarObject_->getVelocity();
	71	return Vector3::ZERO;//this->radarObject_->getOrientation() * this->radarObject_->getVelocity();
72	72	}
73	73	}

code/trunk/src/orxonox/objects/RadarViewable.h

r1818	r2087
44	44	class _OrxonoxExport RadarViewable : virtual public OrxonoxClass
45	45	{
	46	class WorldEntity;
	47
46	48	public:
47	49	enum Shape

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

-                      r1755
+                      r2087
 #include "core/XMLPort.h"
 #include "core/ConsoleCommand.h"
-#include "GraphicsEngine.h"
 namespace orxonox
 …
     SetConsoleCommand(OrxonoxOverlay, rotateOverlay, false).accessLevel(AccessLevel::User);
+    OrxonoxOverlay::OrxonoxOverlay()
+        : overlay_(0)
+        , background_(0)
+    OrxonoxOverlay::OrxonoxOverlay(BaseObject* creator)
+        : BaseObject(creator)
+    {
         RegisterObject(OrxonoxOverlay);
+        // add this overlay to the static map of OrxonoxOverlays
+        if (overlays_s.find(this->getName()) != overlays_s.end())
+        {
+            COUT(1) << "Overlay names should be unique or you cannnot access them via console. Name: \"" << this->getName() << "\"" << std::endl;
+        }
+        overlays_s[this->getName()] = this;
+        // create the Ogre::Overlay
+        overlay_ = Ogre::OverlayManager::getSingleton().create("OrxonoxOverlay_overlay_"
+            + convertToString(hudOverlayCounter_s++));
+        // create background panel (can be used to show any picture)
+        this->background_ = static_cast<Ogre::PanelOverlayElement*>(
+            Ogre::OverlayManager::getSingleton().createOverlayElement("Panel",
+            "OrxonoxOverlay_background_" + convertToString(hudOverlayCounter_s++)));
+        this->overlay_->add2D(this->background_);
+        // We'll have to set the aspect ratio to a default value first.
+        // GSGraphics gets informed about our construction here and can update us in the next tick.
+        this->windowAspectRatio_ = 1.0;
+        this->sizeCorrectionChanged();
+        this->changedVisibility();
+        setSize(Vector2(1.0f, 1.0f));
+        setPickPoint(Vector2(0.0f, 0.0f));
+        setPosition(Vector2(0.0f, 0.0f));
+        setRotation(Degree(0.0));
+        setAspectCorrection(true);
+        setBackgroundMaterial("");
+    }
 …
     OrxonoxOverlay::~OrxonoxOverlay()
+    {
+        // erase ourself from the map with all overlays
+        std::map<std::string, OrxonoxOverlay*>::iterator it = overlays_s.find(this->getName());
+        if (it != overlays_s.end())
+            overlays_s.erase(it);
+        if (this->background_)
+        if (this->isInitialized())
+        {
+            // erase ourself from the map with all overlays
+            std::map<std::string, OrxonoxOverlay*>::iterator it = overlays_s.find(this->getName());
+            if (it != overlays_s.end())
+                overlays_s.erase(it);
             Ogre::OverlayManager::getSingleton().destroyOverlayElement(this->background_);
-        if (this->overlay_)
             Ogre::OverlayManager::getSingleton().destroy(this->overlay_);
+        }
+    }
 …
         SUPER(OrxonoxOverlay, XMLPort, xmlElement, mode);
+        if (mode == XMLPort::LoadObject)
+        {
+            // add this overlay to the static map of OrxonoxOverlays
+            if (overlays_s.find(this->getName()) != overlays_s.end())
+            {
+                COUT(1) << "Overlay names should be unique or you cannnot access them via console." << std::endl;
+            }
+            overlays_s[this->getName()] = this;
+            // create the Ogre::Overlay
+            overlay_ = Ogre::OverlayManager::getSingleton().create("OrxonoxOverlay_overlay_"
+                + convertToString(hudOverlayCounter_s++));
+            // create background panel (can be used to show any picture)
+            this->background_ = static_cast<Ogre::PanelOverlayElement*>(
+                Ogre::OverlayManager::getSingleton().createOverlayElement("Panel",
+                "OrxonoxOverlay_background_" + convertToString(hudOverlayCounter_s++)));
+            this->overlay_->add2D(this->background_);
+            // We'll have to get the aspect ratio manually for the first time. Afterwards windowResized() gets
+            // called automatically by the GraphicsEngine.
+            this->windowResized(GraphicsEngine::getInstance().getWindowWidth(),
+                GraphicsEngine::getInstance().getWindowHeight());
+            this->changedVisibility();
+        }
+        XMLPortParam(OrxonoxOverlay, "size",      setSize,      getSize,      xmlElement, mode)
+            .defaultValues(Vector2(1.0f, 1.0f));
+        XMLPortParam(OrxonoxOverlay, "pickPoint", setPickPoint, getPickPoint, xmlElement, mode)
+            .defaultValues(Vector2(0.0f, 0.0f));
+        XMLPortParam(OrxonoxOverlay, "position",  setPosition,  getPosition,  xmlElement, mode)
+            .defaultValues(Vector2(0.0f, 0.0f));
+        XMLPortParam(OrxonoxOverlay, "rotation",  setRotation,  getRotation,  xmlElement, mode)
+            .defaultValues(0.0f);
+        XMLPortParam(OrxonoxOverlay, "correctAspect", setAspectCorrection,   getAspectCorrection,   xmlElement, mode)
+            .defaultValues(true);
+        XMLPortParam(OrxonoxOverlay, "background",    setBackgroundMaterial, getBackgroundMaterial, xmlElement, mode)
+            .defaultValues("");
+        XMLPortParam(OrxonoxOverlay, "size",      setSize,      getSize,      xmlElement, mode);
+        XMLPortParam(OrxonoxOverlay, "pickPoint", setPickPoint, getPickPoint, xmlElement, mode);
+        XMLPortParam(OrxonoxOverlay, "position",  setPosition,  getPosition,  xmlElement, mode);
+        XMLPortParam(OrxonoxOverlay, "rotation",  setRotation,  getRotation,  xmlElement, mode);
+        XMLPortParam(OrxonoxOverlay, "correctAspect", setAspectCorrection,   getAspectCorrection,   xmlElement, mode);
+        XMLPortParam(OrxonoxOverlay, "background",    setBackgroundMaterial, getBackgroundMaterial, xmlElement, mode);
+    }
+    void OrxonoxOverlay::changedName()
+    {
+        OrxonoxOverlay::overlays_s.erase(this->getOldName());
+        if (OrxonoxOverlay::overlays_s.find(this->getName()) != OrxonoxOverlay::overlays_s.end())
+            COUT(1) << "Overlay names should be unique or you cannnot access them via console. Name: \"" << this->getName() << "\"" << std::endl;
+        OrxonoxOverlay::overlays_s[this->getName()] = this;
+    }
 …
             return this->background_->getMaterialName();
         else
             return blankString;
+            return BLANKSTRING;
+    }

code/trunk/src/orxonox/overlays/OrxonoxOverlay.h

-                      r1747
+                      r2087
     public:
         OrxonoxOverlay();
+        OrxonoxOverlay(BaseObject* creator);
         virtual ~OrxonoxOverlay();
         virtual void XMLPort(Element& xmlElement, XMLPort::Mode mode);
+        virtual void changedName();
         //! Shows the overlay with an detour to BaseObject::visibility_

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

-                      r1854
+                      r2087
     SetConsoleCommand(OverlayGroup, scrollGroup, false).accessLevel(AccessLevel::User);
+    OverlayGroup::OverlayGroup()
+    OverlayGroup::OverlayGroup(BaseObject* creator)
+        : BaseObject(creator)
+    {
         RegisterObject(OverlayGroup);
+        setScale(Vector2(1.0, 1.0));
+        setScroll(Vector2(0.0, 0.0));
+    }
+    OverlayGroup::~OverlayGroup()
+    {
+        for (std::map<std::string, OrxonoxOverlay*>::iterator it = hudElements_.begin(); it != hudElements_.end(); ++it)
+            delete it->second;
+    }
 …
         SUPER(OverlayGroup, XMLPort, xmlElement, mode);
         XMLPortParam(OverlayGroup, "scale",  setScale,  getScale,  xmlElement, mode).defaultValues(Vector2(1.0, 1.0));
         XMLPortParam(OverlayGroup, "scroll", setScroll, getScroll, xmlElement, mode).defaultValues(Vector2(0.0, 0.0));
+        XMLPortParam(OverlayGroup, "scale",  setScale,  getScale,  xmlElement, mode);
+        XMLPortParam(OverlayGroup, "scroll", setScroll, getScroll, xmlElement, mode);
         // loads all the child elements
         XMLPortObject(OverlayGroup, OrxonoxOverlay, "", addElement, getElement, xmlElement, mode);
 …
+        }
         else
+        {
             hudElements_[element->getName()] = element;
+            element->setVisible(this->isVisible());
+        }
+    }

code/trunk/src/orxonox/overlays/OverlayGroup.h

-                      r1747
+                      r2087
+    {
     public:
         OverlayGroup();
+        OverlayGroup(BaseObject* creator);
         //! Empty destructor.
         ~OverlayGroup() { }
+        ~OverlayGroup();
         virtual void XMLPort(Element& xmlElement, XMLPort::Mode mode);
 …
         static void scaleGroup(const std::string& name, float scale);
         static void scrollGroup(const std::string& name, const Vector2& scroll);
+        inline const std::map<std::string, OrxonoxOverlay*>& getOverlays() const
+            { return this->hudElements_; }
         void changedVisibility();

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

-                      r1784
+                      r2087
 #include <OgreOverlayManager.h>
-#include <OgreTextAreaOverlayElement.h>
 #include <OgrePanelOverlayElement.h>
 …
     CreateFactory(OverlayText);
     OverlayText::OverlayText()
         : text_(0)
+    OverlayText::OverlayText(BaseObject* creator)
+        : OrxonoxOverlay(creator)
+    {
         RegisterObject(OverlayText);
+        this->text_ = static_cast<Ogre::TextAreaOverlayElement*>(Ogre::OverlayManager::getSingleton()
+            .createOverlayElement("TextArea", "OverlayText_text_" + getUniqueNumberString()));
+        this->text_->setCharHeight(1.0);
+        setFont("Monofur");
+        setColour(ColourValue(1.0, 1.0, 1.0, 1.0));
+        setCaption("");
+        setTextSize(1.0f);
+        setAlignmentString("left");
+        this->background_->addChild(this->text_);
+    }
     OverlayText::~OverlayText()
+    {
         if (this->text_)
+        if (this->isInitialized())
             Ogre::OverlayManager::getSingleton().destroyOverlayElement(this->text_);
+    }
 …
         SUPER(OverlayText, XMLPort, xmlElement, mode);
+        if (mode == XMLPort::LoadObject)
+        {
+            this->text_ = static_cast<Ogre::TextAreaOverlayElement*>(Ogre::OverlayManager::getSingleton()
+                .createOverlayElement("TextArea", "OverlayText_text_" + getUniqueNumberStr()));
+            this->text_->setCharHeight(1.0);
+            this->background_->addChild(this->text_);
+        }
+        XMLPortParam(OverlayText, "font",     setFont,     getFont,     xmlElement, mode).defaultValues("Monofur");
+        XMLPortParam(OverlayText, "caption",  setCaption,  getCaption,  xmlElement, mode).defaultValues("");
+        XMLPortParam(OverlayText, "textSize", setTextSize, getTextSize, xmlElement, mode).defaultValues(1.0f);
+        XMLPortParam(OverlayText, "font",     setFont,            getFont,            xmlElement, mode);
+        XMLPortParam(OverlayText, "colour",   setColour,          getColour,          xmlElement, mode);
+        XMLPortParam(OverlayText, "caption",  setCaption,         getCaption,         xmlElement, mode);
+        XMLPortParam(OverlayText, "textSize", setTextSize,        getTextSize,        xmlElement, mode);
+        XMLPortParam(OverlayText, "align",    setAlignmentString, getAlignmentString, xmlElement, mode);
+    }
     void OverlayText::setFont(const std::string& font)
+    {
         if (this->text_ && font != "")
+        if (font != "")
             this->text_->setFontName(font);
+    }
     const std::string& OverlayText::getFont() const
+    void OverlayText::setAlignmentString(const std::string& alignment)
+    {
+        if (this->text_)
+            return this->text_->getFontName();
+        else
+            return blankString;
+        if (alignment == "right")
+            this->setAlignment(Ogre::TextAreaOverlayElement::Right);
+        else if (alignment == "center")
+            this->setAlignment(Ogre::TextAreaOverlayElement::Center);
+        else // "left" and default
+            this->setAlignment(Ogre::TextAreaOverlayElement::Left);
+    }
+    std::string OverlayText::getAlignmentString() const
+    {
+        Ogre::TextAreaOverlayElement::Alignment alignment = this->text_->getAlignment();
+        switch (alignment)
+        {
+            case Ogre::TextAreaOverlayElement::Right:
+                return "right";
+            case Ogre::TextAreaOverlayElement::Center:
+                return "center";
+            case Ogre::TextAreaOverlayElement::Left:
+                return "left";
+            default:
+                assert(false); return "";
+        }
+    }
     void OverlayText::sizeChanged()
+    {
-        if (!this->overlay_)
-            return;
         if (this->rotState_ == Horizontal)
             this->overlay_->setScale(size_.y * sizeCorrection_.y, size_.y * sizeCorrection_.y);

code/trunk/src/orxonox/overlays/OverlayText.h

-                      r1625
+                      r2087
 #include <string>
 #include <OgrePrerequisites.h>
+#include <OgreTextAreaOverlayElement.h>
 #include "OrxonoxOverlay.h"
 …
+    {
     public:
         OverlayText();
+        OverlayText(BaseObject* creator);
         virtual ~OverlayText();
         virtual void XMLPort(Element& xmlElement, XMLPort::Mode mode);
+        void setCaption(const std::string& caption) { this->text_->setCaption(caption); }
+        std::string getCaption() const              { return this->text_->getCaption(); }
+        void setFont(const std::string& font);
+        const std::string& getFont() const { return this->text_->getFontName(); }
+        void setColour(const ColourValue& colour) { this->text_->setColour(colour); }
+        const ColourValue& getColour() const      { return this->text_->getColour(); }
+        void setAlignment(Ogre::TextAreaOverlayElement::Alignment alignment) { this->text_->setAlignment(alignment); }
+        Ogre::TextAreaOverlayElement::Alignment getAlignment() const         { return this->text_->getAlignment(); }
     protected:
         virtual void sizeChanged();
+        void setCaption(const std::string& caption) { this->caption_ = caption; }
+        const std::string& getCaption() const       { return this->caption_; }
+        void setFont(const std::string& font);
+        const std::string& getFont() const;
+        void setAlignmentString(const std::string& alignment);
+        std::string getAlignmentString() const;
         void setTextSize(float size) { this->setSize(Vector2(size, size)); }
 …
         Ogre::TextAreaOverlayElement* text_;
-    private:
-        std::string caption_;
     };
+}

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

-                      r1879
+                      r2087
 #include "core/input/SimpleInputState.h"
 #include "core/input/InputBuffer.h"
-#include "GraphicsEngine.h"
 namespace orxonox
 …
         @brief Initializes the InGameConsole.
     */
     void InGameConsole::initialise()
+    void InGameConsole::initialise(int windowWidth, int windowHeight)
+    {
         // create the corresponding input state
 …
         this->consoleOverlayContainer_->addChild(this->consoleOverlayNoise_);
         this->windowResized(GraphicsEngine::getInstance().getWindowWidth(), GraphicsEngine::getInstance().getWindowHeight());
+        this->windowResized(windowWidth, windowHeight);
         // move overlay "above" the top edge of the screen
 …
         @return The converted string
     */
     /*static*/ Ogre::UTFString InGameConsole::convert2UTF(std::string s)
+    /*static*/ Ogre::UTFString InGameConsole::convert2UTF(const std::string& text)
+    {
         Ogre::UTFString utf;
         Ogre::UTFString::code_point cp;
         for (unsigned int i = 0; i < s.size(); ++i)
+        {
           cp = s[i];
+        for (unsigned int i = 0; i < text.size(); ++i)
+        {
+          cp = text[i];
           cp &= 0xFF;
           utf.append(1, cp);

code/trunk/src/orxonox/overlays/console/InGameConsole.h

-                      r1879
+                      r2087
         ~InGameConsole();
         void initialise();
+        void initialise(int windowWidth, int windowHeight);
         void destroy();
         void setConfigValues();
 …
         static void openConsole();
         static void closeConsole();
+        static Ogre::UTFString convert2UTF(const std::string& text);
     private: // functions
 …
         // config value related
         void bHidesAllInputChanged();
-        static Ogre::UTFString convert2UTF(std::string s);
     private: // variables

code/trunk/src/orxonox/overlays/debug/DebugFPSText.cc

r1755	r2087
38	38	CreateFactory(DebugFPSText);
39	39
40		DebugFPSText::DebugFPSText()
	40	DebugFPSText::DebugFPSText(BaseObject* creator) : OverlayText(creator)
41	41	{
42	42	RegisterObject(DebugFPSText);
…	…
50	50	{
51	51	float fps = GraphicsEngine::getInstance().getAverageFramesPerSecond();
52		this->~~text_->setCaption(this->getCaption() +~~ convertToString(fps));
	52	this->setCaption(convertToString(fps));
53	53	}
54	54	}

code/trunk/src/orxonox/overlays/debug/DebugFPSText.h

r1747	r2087
40	40	{
41	41	public:
42		DebugFPSText();
	42	DebugFPSText(BaseObject* creator);
43	43	~DebugFPSText();
44	44

code/trunk/src/orxonox/overlays/debug/DebugRTRText.cc

r1755	r2087
38	38	CreateFactory(DebugRTRText);
39	39
40		DebugRTRText::DebugRTRText()
	40	DebugRTRText::DebugRTRText(BaseObject* creator) : OverlayText(creator)
41	41	{
42	42	RegisterObject(DebugRTRText);
…	…
50	50	{
51	51	float rtr = GraphicsEngine::getInstance().getAverageTickTime();
52		this->~~text_->setCaption(this->getCaption() +~~ convertToString(rtr));
	52	this->setCaption(convertToString(rtr));
53	53	}
54	54	}

code/trunk/src/orxonox/overlays/debug/DebugRTRText.h

r1747	r2087
40	40	{
41	41	public:
42		DebugRTRText();
	42	DebugRTRText(BaseObject* creator);
43	43	~DebugRTRText();
44	44

code/trunk/src/orxonox/overlays/hud/HUDBar.cc

-                      r1854
+                      r2087
 #include "util/Convert.h"
+#include "util/String.h"
 #include "core/CoreIncludes.h"
 #include "core/XMLPort.h"
 …
     CreateFactory(BarColour);
     BarColour::BarColour()
         : position_(0.0)
+    BarColour::BarColour(BaseObject* creator)
+        : BaseObject(creator)
+    {
         RegisterObject(BarColour);
+        setColour(ColourValue(1.0, 1.0, 1.0, 1.0));
+        setPosition(0.0);
+    }
 …
         SUPER(BarColour, XMLPort, xmlElement, mode);
+        XMLPortParam(BarColour, "colour", setColour, getColour, xmlElement, mode)
+            .defaultValues(ColourValue(1.0, 1.0, 1.0, 1.0));
+        XMLPortParam(BarColour, "position", setPosition, getPosition, xmlElement, mode).defaultValues(0.0f);
+        XMLPortParam(BarColour, "colour", setColour, getColour, xmlElement, mode);
+        XMLPortParam(BarColour, "position", setPosition, getPosition, xmlElement, mode);
+    }
 …
     unsigned int HUDBar::materialcount_s = 0;
+    HUDBar::HUDBar()
+        : bar_(0)
+        , textureUnitState_(0)
+    HUDBar::HUDBar(BaseObject* creator)
+        : OrxonoxOverlay(creator)
+    {
         RegisterObject(HUDBar);
+        // create new material
+        std::string materialname = "barmaterial" + getConvertedValue<unsigned int, std::string>(materialcount_s++);
+        Ogre::MaterialPtr material = (Ogre::MaterialPtr)Ogre::MaterialManager::getSingleton().create(materialname, "General");
+        material->getTechnique(0)->getPass(0)->setSceneBlending(Ogre::SBT_TRANSPARENT_ALPHA);
+        this->textureUnitState_ = material->getTechnique(0)->getPass(0)->createTextureUnitState();
+        this->textureUnitState_->setTextureName("bar2.tga");
+        // use the default colour
+        this->textureUnitState_->setColourOperationEx(Ogre::LBX_MODULATE, Ogre::LBS_MANUAL, Ogre::LBS_CURRENT, ColourValue(0.2, 0.7, 0.2));
+        this->bar_ = static_cast<Ogre::PanelOverlayElement*>(Ogre::OverlayManager::getSingleton()
+            .createOverlayElement("Panel", "HUDBar_bar_" + getUniqueNumberString()));
+        this->bar_->setMaterialName(materialname);
+        setValue(0.4567654f);
+        setRightToLeft(false);
+        setAutoColour(true);
+        this->background_->addChild(bar_);
+    }
     HUDBar::~HUDBar()
+    {
         if (this->bar_)
+        if (this->isInitialized())
             Ogre::OverlayManager::getSingleton().destroyOverlayElement(this->bar_);
+    }
 …
         SUPER(HUDBar, XMLPort, xmlElement, mode);
+        if (mode == XMLPort::LoadObject)
+        {
+            // create new material
+            std::string materialname = "barmaterial" + getConvertedValue<unsigned int, std::string>(materialcount_s++);
+            Ogre::MaterialPtr material = (Ogre::MaterialPtr)Ogre::MaterialManager::getSingleton().create(materialname, "General");
+            material->getTechnique(0)->getPass(0)->setSceneBlending(Ogre::SBT_TRANSPARENT_ALPHA);
+            this->textureUnitState_ = material->getTechnique(0)->getPass(0)->createTextureUnitState();
+            this->textureUnitState_->setTextureName("bar2.tga");
+            // use the default colour
+            this->textureUnitState_->setColourOperationEx(Ogre::LBX_MODULATE, Ogre::LBS_MANUAL, Ogre::LBS_CURRENT, ColourValue(0.2, 0.7, 0.2));
+            this->bar_ = static_cast<Ogre::PanelOverlayElement*>(Ogre::OverlayManager::getSingleton()
+                .createOverlayElement("Panel", "HUDBar_bar_" + getUniqueNumberStr()));
+            this->bar_->setMaterialName(materialname);
+            this->background_->addChild(bar_);
+        }
+        XMLPortParam(HUDBar, "initialValue", setValue,       getValue,       xmlElement, mode).defaultValues(0.4567654f);
+        XMLPortParam(HUDBar, "rightToLeft",  setRightToLeft, getRightToLeft, xmlElement, mode).defaultValues(false);
+        XMLPortParam(HUDBar, "autoColour",   setAutoColour,  getAutoColour,  xmlElement, mode).defaultValues(true);
+        XMLPortParam(HUDBar, "initialValue", setValue,       getValue,       xmlElement, mode);
+        XMLPortParam(HUDBar, "rightToLeft",  setRightToLeft, getRightToLeft, xmlElement, mode);
+        XMLPortParam(HUDBar, "autoColour",   setAutoColour,  getAutoColour,  xmlElement, mode);
         XMLPortObject(HUDBar, BarColour, "", addColour, getColour, xmlElement, mode);
+    }

code/trunk/src/orxonox/overlays/hud/HUDBar.h

-                      r1747
+                      r2087
+    {
     public:
         BarColour();
+        BarColour(BaseObject* creator);
         ~BarColour() { }
 …
+    {
     public:
         HUDBar();
+        HUDBar(BaseObject* creator);
         virtual ~HUDBar();

code/trunk/src/orxonox/overlays/hud/HUDNavigation.cc

-                      r1819
+                      r2087
 #include "core/XMLPort.h"
 #include "objects/Radar.h"
-#include "objects/SpaceShip.h"
-#include "objects/Projectile.h"
-#include "objects/CameraHandler.h"
 namespace orxonox
 …
     CreateFactory(HUDNavigation);
+    HUDNavigation::HUDNavigation()
+        : navMarker_(0)
+        , aimMarker_(0)
+        , navText_(0)
+    HUDNavigation::HUDNavigation(BaseObject* creator)
+        : OrxonoxOverlay(creator)
+    {
         RegisterObject(HUDNavigation);
+        // create nav text
+        navText_ = static_cast<Ogre::TextAreaOverlayElement*>(Ogre::OverlayManager::getSingleton()
+            .createOverlayElement("TextArea", "HUDNavigation_navText_" + getUniqueNumberString()));
+        // create nav marker
+        navMarker_ = static_cast<Ogre::PanelOverlayElement*>(Ogre::OverlayManager::getSingleton()
+            .createOverlayElement("Panel", "HUDNavigation_navMarker_" + getUniqueNumberString()));
+        navMarker_->setMaterialName("Orxonox/NavArrows");
+        // create aim marker
+        aimMarker_ = static_cast<Ogre::PanelOverlayElement*>(Ogre::OverlayManager::getSingleton()
+            .createOverlayElement("Panel", "HUDNavigation_aimMarker_" + getUniqueNumberString()));
+        aimMarker_->setMaterialName("Orxonox/NavCrosshair");
+        this->wasOutOfView_ = true; // Ensure the material is changed right the first time..
+        setFont("Monofur");
+        setTextSize(0.05f);
+        setNavMarkerSize(0.05f);
+        setAimMarkerSize(0.04f);
+        background_->addChild(navMarker_);
+        background_->addChild(aimMarker_);
+        background_->addChild(navText_);
+        // hide at first
+        this->setVisible(false);
+    }
     HUDNavigation::~HUDNavigation()
+    {
+        if (this->navMarker_)
+        if (this->isInitialized())
+        {
             Ogre::OverlayManager::getSingleton().destroyOverlayElement(this->navMarker_);
-        if (this->navText_)
             Ogre::OverlayManager::getSingleton().destroyOverlayElement(this->navText_);
-        if (this->aimMarker_)
             Ogre::OverlayManager::getSingleton().destroyOverlayElement(this->aimMarker_);
+        }
+    }
 …
         SUPER(HUDNavigation, XMLPort, xmlElement, mode);
+        if (mode == XMLPort::LoadObject)
+        {
+            // create nav text
+            navText_ = static_cast<Ogre::TextAreaOverlayElement*>(Ogre::OverlayManager::getSingleton()
+                .createOverlayElement("TextArea", "HUDNavigation_navText_" + getUniqueNumberStr()));
+            // create nav marker
+            navMarker_ = static_cast<Ogre::PanelOverlayElement*>(Ogre::OverlayManager::getSingleton()
+                .createOverlayElement("Panel", "HUDNavigation_navMarker_" + getUniqueNumberStr()));
+            navMarker_->setMaterialName("Orxonox/NavArrows");
+            wasOutOfView_ = true; // just to ensure the material is changed right the first time..
+            // create aim marker
+            aimMarker_ = static_cast<Ogre::PanelOverlayElement*>(Ogre::OverlayManager::getSingleton()
+                .createOverlayElement("Panel", "HUDNavigation_aimMarker_" + getUniqueNumberStr()));
+            aimMarker_->setMaterialName("Orxonox/NavCrosshair");
+            background_->addChild(navMarker_);
+            background_->addChild(aimMarker_);
+            background_->addChild(navText_);
+            // hide at first
+            this->setVisible(false);
+        }
+        XMLPortParam(HUDNavigation, "font",     setFont,     getFont,     xmlElement, mode).defaultValues("Monofur");
+        XMLPortParam(HUDNavigation, "textSize", setTextSize, getTextSize, xmlElement, mode).defaultValues(0.05f);
+        XMLPortParam(HUDNavigation, "navMarkerSize", setNavMarkerSize, getNavMarkerSize, xmlElement, mode)
+            .defaultValues(0.05f);
+        XMLPortParam(HUDNavigation, "aimMarkerSize", setAimMarkerSize, getAimMarkerSize, xmlElement, mode)
+            .defaultValues(0.04f);
+        XMLPortParam(HUDNavigation, "font",     setFont,     getFont,     xmlElement, mode);
+        XMLPortParam(HUDNavigation, "textSize", setTextSize, getTextSize, xmlElement, mode);
+        XMLPortParam(HUDNavigation, "navMarkerSize", setNavMarkerSize, getNavMarkerSize, xmlElement, mode);
+        XMLPortParam(HUDNavigation, "aimMarkerSize", setAimMarkerSize, getAimMarkerSize, xmlElement, mode);
+    }
 …
             return this->navText_->getFontName();
         else
             return blankString;
+            return BLANKSTRING;
+    }
 …
         float textLength = convertToString(dist).size() * navText_->getCharHeight() * 0.3;
+/*
         Ogre::Camera* navCam = SpaceShip::getLocalShip()->getCamera()->cam_;
         Matrix4 transformationMatrix = navCam->getProjectionMatrix() * navCam->getViewMatrix();
+*/
         // transform to screen coordinates
         Vector3 pos = transformationMatrix * Radar::getInstance().getFocus()->getWorldPosition();
+        Vector3 pos = /*transformationMatrix * */Radar::getInstance().getFocus()->getWorldPosition();
         bool outOfView;
 …
+        {
             // object is in view
+/*
             Vector3 aimpos = transformationMatrix * getPredictedPosition(SpaceShip::getLocalShip()->getPosition(),
                     Projectile::getSpeed(), Radar::getInstance().getFocus()->getWorldPosition(), Radar::getInstance().getFocus()->getOrientedVelocity());
+*/
             if (wasOutOfView_)
+            {
 …
             aimMarker_->show();
+/*
             aimMarker_->setLeft((aimpos.x + 1.0 - aimMarker_->getWidth()) * 0.5);
             aimMarker_->setTop((-aimpos.y + 1.0 - aimMarker_->getHeight()) * 0.5);
+*/
             navText_->setLeft((pos.x + 1.0 + navMarker_->getWidth()) * 0.5);
             navText_->setTop((-pos.y + 1.0 + navMarker_->getHeight()) * 0.5);
 …
     float HUDNavigation::getDist2Focus() const
+    {
+/*
         if (Radar::getInstance().getFocus())
             return (Radar::getInstance().getFocus()->getWorldPosition() - SpaceShip::getLocalShip()->getPosition()).length();
         else
+*/
             return 0;
+    }

code/trunk/src/orxonox/overlays/hud/HUDNavigation.h

r1747	r2087
41	41	{
42	42	public:
43		HUDNavigation();
	43	HUDNavigation(BaseObject* creator);
44	44	~HUDNavigation();
45	45

code/trunk/src/orxonox/overlays/hud/HUDRadar.cc

-                      r1819
+                      r2087
 #include "util/Math.h"
+#include "util/String.h"
 #include "core/ConsoleCommand.h"
 #include "core/CoreIncludes.h"
 #include "core/XMLPort.h"
-#include "objects/SpaceShip.h"
-#include "objects/WorldEntity.h"
 #include "objects/Radar.h"
 #include "tools/TextureGenerator.h"
 …
     CreateFactory(HUDRadar);
     HUDRadar::HUDRadar()
         : marker_(0)
+    HUDRadar::HUDRadar(BaseObject* creator)
+        : OrxonoxOverlay(creator)
+    {
         RegisterObject(HUDRadar);
+        marker_ = static_cast<Ogre::PanelOverlayElement*>(Ogre::OverlayManager::getSingleton()
+            .createOverlayElement("Panel", "HUDRadar_marker_" + getUniqueNumberString()));
+        marker_->setMaterialName("Orxonox/RadarMarker");
+        overlay_->add2D(marker_);
+        marker_->hide();
+        setRadarSensitivity(1.0f);
+        setHalfDotSizeDistance(3000.0f);
+        setMaximumDotSize(0.1f);
+        shapeMaterials_[RadarViewable::Dot]      = "RadarSquare.tga";
+        shapeMaterials_[RadarViewable::Triangle] = "RadarSquare.tga";
+        shapeMaterials_[RadarViewable::Square]   = "RadarSquare.tga";
+    }
     HUDRadar::~HUDRadar()
+    {
+        if (this->marker_)
+        if (this->isInitialized())
+        {
             Ogre::OverlayManager::getSingleton().destroyOverlayElement(this->marker_);
+        for (std::vector<Ogre::PanelOverlayElement*>::iterator it = this->radarDots_.begin();
+            it != this->radarDots_.end(); ++it)
+        {
+            Ogre::OverlayManager::getSingleton().destroyOverlayElement(*it);
+            for (std::vector<Ogre::PanelOverlayElement*>::iterator it = this->radarDots_.begin();
+                it != this->radarDots_.end(); ++it)
+            {
+                Ogre::OverlayManager::getSingleton().destroyOverlayElement(*it);
+            }
+        }
+    }
 …
         SUPER(HUDRadar, XMLPort, xmlElement, mode);
+        if (mode == XMLPort::LoadObject)
+        {
+            marker_ = static_cast<Ogre::PanelOverlayElement*>(Ogre::OverlayManager::getSingleton()
+                .createOverlayElement("Panel", "HUDRadar_marker_" + getUniqueNumberStr()));
+            marker_->setMaterialName("Orxonox/RadarMarker");
+            overlay_->add2D(marker_);
+            marker_->hide();
+        }
+        XMLPortParam(HUDRadar, "sensitivity", setRadarSensitivity, getRadarSensitivity, xmlElement, mode)
+            .defaultValues(1.0f);
+        XMLPortParam(HUDRadar, "halfDotSizeDistance", setHalfDotSizeDistance, getHalfDotSizeDistance,
+            xmlElement, mode).defaultValues(3000.0f);
+        XMLPortParam(HUDRadar, "maximumDotSize", setMaximumDotSize, getMaximumDotSize, xmlElement, mode)
+            .defaultValues(0.1f);
+        shapeMaterials_[RadarViewable::Dot]      = "RadarSquare.tga";
+        shapeMaterials_[RadarViewable::Triangle] = "RadarSquare.tga";
+        shapeMaterials_[RadarViewable::Square]   = "RadarSquare.tga";
+        XMLPortParam(HUDRadar, "sensitivity", setRadarSensitivity, getRadarSensitivity, xmlElement, mode);
+        XMLPortParam(HUDRadar, "halfDotSizeDistance", setHalfDotSizeDistance, getHalfDotSizeDistance, xmlElement, mode);
+        XMLPortParam(HUDRadar, "maximumDotSize", setMaximumDotSize, getMaximumDotSize, xmlElement, mode);
+    }
     void HUDRadar::displayObject(RadarViewable* object, bool bIsMarked)
+    {
+/*
         const WorldEntity* wePointer = object->getWorldEntity();
 …
             return;
+        }
+*/
         // try to find a panel already created
         Ogre::PanelOverlayElement* panel;
 …
             // we have to create a new entry
             panel = static_cast<Ogre::PanelOverlayElement*>(
                 Ogre::OverlayManager::getSingleton().createOverlayElement("Panel", "RadarDot" + getUniqueNumberStr()));
+                Ogre::OverlayManager::getSingleton().createOverlayElement("Panel", "RadarDot" + getUniqueNumberString()));
             radarDots_.push_back(panel);
             // get right material
 …
+        }
         panel->show();
+/*
         // set size to fit distance...
         float distance = (wePointer->getWorldPosition() - SpaceShip::getLocalShip()->getPosition()).length();
 …
             this->marker_->setPosition((1.0 + coord.x - size * 1.5) * 0.5, (1.0 - coord.y - size * 1.5) * 0.5);
+        }
+*/
+    }

code/trunk/src/orxonox/overlays/hud/HUDRadar.h

r1819	r2087
45	45	{
46	46	public:
47		HUDRadar();
	47	HUDRadar(BaseObject* creator);
48	48	~HUDRadar();
49	49

code/trunk/src/orxonox/overlays/hud/HUDSpeedBar.cc

r1755	r2087
31	31	#include "HUDSpeedBar.h"
32	32	#include "core/CoreIncludes.h"
33		~~#include "objects/SpaceShip.h"~~
34	33
35	34	namespace orxonox
…	…
37	36	CreateFactory(HUDSpeedBar);
38	37
39		HUDSpeedBar::HUDSpeedBar()
	38	HUDSpeedBar::HUDSpeedBar(BaseObject* creator)
	39	: HUDBar(creator)
40	40	{
41	41	RegisterObject(HUDSpeedBar);
…	…
49	49	void HUDSpeedBar::tick(float dt)
50	50	{
	51	/*
51	52	SpaceShip* ship = SpaceShip::getLocalShip();
52	53	if (ship)
…	…
57	58	this->setValue(value);
58	59	}
	60	*/
59	61	}
60	62	}

code/trunk/src/orxonox/overlays/hud/HUDSpeedBar.h

r1747	r2087
41	41	{
42	42	public:
43		HUDSpeedBar();
	43	HUDSpeedBar(BaseObject* creator);
44	44	~HUDSpeedBar();
45	45

code/trunk/src/orxonox/tools/BillboardSet.cc

-                      r1755
+                      r2087
 #include <sstream>
+#include <cassert>
 #include <OgreSceneManager.h>
+#include <OgreBillboard.h>
 #include "GraphicsEngine.h"
 #include "util/Math.h"
+#include "util/Convert.h"
+#include "util/String.h"
 namespace orxonox
 …
+    }
     void BillboardSet::setBillboardSet(const std::string& file, int count)
+    BillboardSet::~BillboardSet()
+    {
+        std::ostringstream name;
+        name << (BillboardSet::billboardSetCounter_s++);
+        this->billboardSet_ = GraphicsEngine::getInstance().getLevelSceneManager()->createBillboardSet("Billboard" + name.str(), count);
+        this->billboardSet_->createBillboard(Vector3::ZERO);
+        this->billboardSet_->setMaterialName(file);
+        this->destroyBillboardSet();
+    }
     void BillboardSet::setBillboardSet(const std::string& file, const ColourValue& colour, int count)
+    void BillboardSet::setBillboardSet(Ogre::SceneManager* scenemanager, const std::string& file, int count)
+    {
+        std::ostringstream name;
+        name << (BillboardSet::billboardSetCounter_s++);
+        this->billboardSet_ = GraphicsEngine::getInstance().getLevelSceneManager()->createBillboardSet("Billboard" + name.str(), count);
+        this->billboardSet_->createBillboard(Vector3::ZERO, colour);
+        this->billboardSet_->setMaterialName(file);
+        this->setBillboardSet(scenemanager, file, Vector3::ZERO, count);
+    }
     void BillboardSet::setBillboardSet(const std::string& file, const Vector3& position, int count)
+    void BillboardSet::setBillboardSet(Ogre::SceneManager* scenemanager, const std::string& file, const ColourValue& colour, int count)
+    {
+        std::ostringstream name;
+        name << (BillboardSet::billboardSetCounter_s++);
+        this->billboardSet_ = GraphicsEngine::getInstance().getLevelSceneManager()->createBillboardSet("Billboard" + name.str(), count);
+        this->billboardSet_->createBillboard(position);
+        this->billboardSet_->setMaterialName(file);
+        this->setBillboardSet(scenemanager, file, colour, Vector3::ZERO, count);
+    }
     void BillboardSet::setBillboardSet(const std::string& file, const ColourValue& colour, const Vector3& position, int count)
+    void BillboardSet::setBillboardSet(Ogre::SceneManager* scenemanager, const std::string& file, const Vector3& position, int count)
+    {
+        std::ostringstream name;
+        name << (BillboardSet::billboardSetCounter_s++);
+        this->billboardSet_ = GraphicsEngine::getInstance().getLevelSceneManager()->createBillboardSet("Billboard" + name.str(), count);
+        this->billboardSet_->createBillboard(position, colour);
+        this->billboardSet_->setMaterialName(file);
+        assert(scenemanager);
+        this->destroyBillboardSet();
+        try
+        {
+            this->billboardSet_ = scenemanager->createBillboardSet("Billboard" + convertToString(BillboardSet::billboardSetCounter_s++), count);
+            this->billboardSet_->createBillboard(position);
+            this->billboardSet_->setMaterialName(file);
+        }
+        catch (...)
+        {
+            COUT(1) << "Error: Couln't load billboard \"" << file << "\"" << std::endl;
+        }
+        this->scenemanager_ = scenemanager;
+    }
+    BillboardSet::~BillboardSet()
+    void BillboardSet::setBillboardSet(Ogre::SceneManager* scenemanager, const std::string& file, const ColourValue& colour, const Vector3& position, int count)
+    {
+        assert(scenemanager);
+        this->destroyBillboardSet();
+        try
+        {
+            this->billboardSet_ = scenemanager->createBillboardSet("Billboard" + convertToString(BillboardSet::billboardSetCounter_s++), count);
+            this->billboardSet_->createBillboard(position, colour);
+            this->billboardSet_->setMaterialName(file);
+        }
+        catch (...)
+        {
+            COUT(1) << "Error: Couln't load billboard \"" << file << "\"" << std::endl;
+        }
+        this->scenemanager_ = scenemanager;
+    }
+    void BillboardSet::destroyBillboardSet()
+    {
+        if (this->billboardSet_ && this->scenemanager_)
+            this->scenemanager_->destroyBillboardSet(this->billboardSet_);
+    }
+    const std::string& BillboardSet::getName() const
+    {
         if (this->billboardSet_)
+            GraphicsEngine::getInstance().getLevelSceneManager()->destroyBillboardSet(this->billboardSet_);
+            return this->billboardSet_->getName();
+        else
+            return BLANKSTRING;
+    }
+    void BillboardSet::setVisible(bool visible)
+    {
+        if (this->billboardSet_)
+            this->billboardSet_->setVisible(visible);
+    }
+    bool BillboardSet::getVisible() const
+    {
+        if (this->billboardSet_)
+            return this->billboardSet_->getVisible();
+        else
+            return false;
+    }
+    void BillboardSet::setColour(const ColourValue& colour)
+    {
+        if (this->billboardSet_)
+        {
+            for (int i = 0; i < this->billboardSet_->getNumBillboards(); ++i)
+                this->billboardSet_->getBillboard(i)->setColour(colour);
+        }
+    }
+    const ColourValue& BillboardSet::getColour() const
+    {
+        if (this->billboardSet_ && this->billboardSet_->getNumBillboards() > 0)
+        {
+            return this->billboardSet_->getBillboard(0)->getColour();
+        }
+        else
+            return ColourValue::White;
+    }
+    void BillboardSet::setMaterial(const std::string& material)
+    {
+        if (this->billboardSet_)
+            this->billboardSet_->setMaterialName(material);
+    }
+    const std::string& BillboardSet::getMaterial() const
+    {
+        if (this->billboardSet_)
+            return this->billboardSet_->getMaterialName();
+        else
+            return BLANKSTRING;
+    }
+}

code/trunk/src/orxonox/tools/BillboardSet.h

-                      r1602
+                      r2087
             BillboardSet();
             ~BillboardSet();
+            void setBillboardSet(const std::string& file, int count = 1);
+            void setBillboardSet(const std::string& file, const ColourValue& colour, int count = 1);
+            void setBillboardSet(const std::string& file, const Vector3& position, int count = 1);
+            void setBillboardSet(const std::string& file, const ColourValue& colour, const Vector3& position, int count = 1);
+            void setBillboardSet(Ogre::SceneManager* scenemanager, const std::string& file, int count = 1);
+            void setBillboardSet(Ogre::SceneManager* scenemanager, const std::string& file, const ColourValue& colour, int count = 1);
+            void setBillboardSet(Ogre::SceneManager* scenemanager, const std::string& file, const Vector3& position, int count = 1);
+            void setBillboardSet(Ogre::SceneManager* scenemanager, const std::string& file, const ColourValue& colour, const Vector3& position, int count = 1);
             inline Ogre::BillboardSet* getBillboardSet()
                 { return this->billboardSet_; }
+            inline const std::string& getName() const
+                { return this->billboardSet_->getName(); }
+            const std::string& getName() const;
+            inline void setVisible(bool visible)
+                { this->billboardSet_->setVisible(visible); }
+            inline bool getVisible() const
+                { return this->billboardSet_->getVisible(); }
+            void setVisible(bool visible);
+            bool getVisible() const;
+            void setColour(const ColourValue& colour);
+            const ColourValue& getColour() const;
+            void setMaterial(const std::string& material);
+            const std::string& getMaterial() const;
         private:
+            void destroyBillboardSet();
             static unsigned int billboardSetCounter_s;
             Ogre::BillboardSet* billboardSet_;
+            Ogre::SceneManager* scenemanager_;
     };
+}

code/trunk/src/orxonox/tools/Mesh.cc

-                      r1755
+                      r2087
 #include <sstream>
 #include <OgreSceneManager.h>
+#include "GraphicsEngine.h"
+#include "Settings.h"
+#include <cassert>
+#include "core/Core.h"
+#include "util/Convert.h"
+#include "util/String.h"
 namespace orxonox
 …
     unsigned int Mesh::meshCounter_s = 0;
+    Mesh::Mesh() :
+      entity_(0)
+    Mesh::Mesh()
+    {
+    }
+    void Mesh::setMesh(const std::string& file)
+    {
+        std::ostringstream name;
+        name << (Mesh::meshCounter_s++);
+        if (Settings::showsGraphics())
+            this->entity_ = GraphicsEngine::getInstance().getLevelSceneManager()->createEntity("Mesh" + name.str(), file);
+        this->entity_ = 0;
+        this->bCastShadows_ = true;
+    }
     Mesh::~Mesh()
+    {
+        if (this->entity_ && Settings::showsGraphics())
+            GraphicsEngine::getInstance().getLevelSceneManager()->destroyEntity(this->entity_);
+        if (this->entity_ && this->scenemanager_)
+            this->scenemanager_->destroyEntity(this->entity_);
+    }
+    void Mesh::setMeshSource(Ogre::SceneManager* scenemanager, const std::string& meshsource)
+    {
+        assert(scenemanager);
+        this->scenemanager_ = scenemanager;
+        if (this->entity_)
+            this->scenemanager_->destroyEntity(this->entity_);
+        if (Core::showsGraphics())
+        {
+            try
+            {
+                this->entity_ = this->scenemanager_->createEntity("Mesh" + convertToString(Mesh::meshCounter_s++), meshsource);
+                this->entity_->setCastShadows(this->bCastShadows_);
+            }
+            catch (...)
+            {
+                COUT(1) << "Error: Couln't load mesh \"" << meshsource << "\"" << std::endl;
+            }
+        }
+    }
+    void Mesh::setCastShadows(bool bCastShadows)
+    {
+        this->bCastShadows_ = bCastShadows;
+        if (this->entity_)
+            this->entity_->setCastShadows(this->bCastShadows_);
+    }
+    const std::string& Mesh::getName() const
+    {
+        if (this->entity_)
+            return this->entity_->getName();
+        else
+            return BLANKSTRING;
+    }
+    void Mesh::setVisible(bool bVisible)
+    {
+        if (this->entity_)
+            this->entity_->setVisible(bVisible);
+    }
+    bool Mesh::isVisible() const
+    {
+        if (this->entity_)
+            return this->entity_->getVisible();
+        else
+            return false;
+    }
+}

code/trunk/src/orxonox/tools/Mesh.h

-                      r1627
+                      r2087
+ *
  *   Author:
  *      ...
+ *      Fabian 'x3n' Landau
  *   Co-authors:
  *      ...
 …
 #include <string>
 #include <OgreEntity.h>
 …
             Mesh();
             ~Mesh();
+            void setMesh(const std::string& file);
+            void setMeshSource(Ogre::SceneManager* scenemanager, const std::string& file);
             inline Ogre::Entity* getEntity()
                 { return this->entity_; }
+            inline const std::string& getName() const
+                { return this->entity_->getName(); }
+            const std::string& getName() const;
+            inline void setVisible(bool visible)
+                { if (this->entity_) this->entity_->setVisible(visible); }
+            inline bool getVisible() const
+                { if (this->entity_) return this->entity_->getVisible(); else return false; }
+            void setVisible(bool bVisible);
+            bool isVisible() const;
+            void setCastShadows(bool bCastShadows);
+            inline bool getCastShadows() const
+                { return this->bCastShadows_; }
         private:
             static unsigned int meshCounter_s;
             Ogre::Entity* entity_;
+            bool bCastShadows_;
+            Ogre::SceneManager* scenemanager_;
     };
+}

code/trunk/src/orxonox/tools/ParticleInterface.cc

-                      r1755
+                      r2087
 /*
+*   ORXONOX - the hottest 3D action shooter ever to exist
+*
+*
+*   License notice:
+*
+*   This program is free software; you can redistribute it and/or
+*   modify it under the terms of the GNU General Public License
+*   as published by the Free Software Foundation; either version 2
+*   of the License, or (at your option) any later version.
+*
+*   This program is distributed in the hope that it will be useful,
+*   but WITHOUT ANY WARRANTY; without even the implied warranty of
+*   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+*   GNU General Public License for more details.
+*
+*   You should have received a copy of the GNU General Public License
+*   along with this program; if not, write to the Free Software
+*   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+*
+*   Author:
+*      ...
+*   Co-authors:
+*      ...
+*
+*/
+ *   ORXONOX - the hottest 3D action shooter ever to exist
+ *                    > www.orxonox.net <
+ *
+ *
+ *   License notice:
+ *
+ *   This program is free software; you can redistribute it and/or
+ *   modify it under the terms of the GNU General Public License
+ *   as published by the Free Software Foundation; either version 2
+ *   of the License, or (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ *   Author:
+ *      Fabian 'x3n' Landau
+ *   Co-authors:
+ *      ...
+ *
+ */
 /**
 …
 #include <OgreParticleEmitter.h>
 #include <OgreSceneManager.h>
+#include <cassert>
 #include "GraphicsEngine.h"
 …
 namespace orxonox
+{
+  unsigned int ParticleInterface::counter_s = 0;
+  ParticleInterface* ParticleInterface::currentParticleInterface_s = 0;
+  ParticleInterface::ParticleInterface(const std::string& templateName, LODParticle::LOD detaillevel)
+  {
+    RegisterRootObject(ParticleInterface);
+    this->sceneNode_ = 0;
+    this->bEnabled_ = true;
+    this->detaillevel_ = (unsigned int)detaillevel;
+    this->particleSystem_ = GraphicsEngine::getInstance().getLevelSceneManager()->createParticleSystem("particles" + getConvertedValue<unsigned int, std::string>(ParticleInterface::counter_s++), templateName);
+    //this->particleSystem_->setSpeedFactor(Orxonox::getInstance().getTimeFactor());
+    this->particleSystem_->setSpeedFactor(1.0f);
+    if (GraphicsEngine::getInstance().getDetailLevelParticle() < (unsigned int)this->detaillevel_)
+    {
+      this->bVisible_ = false;
+      this->updateVisibility();
+    }
+    else
+    {
+      this->bVisible_ = true;
+    }
+  }
+  ParticleInterface::~ParticleInterface()
+  {
+    this->particleSystem_->removeAllEmitters();
+    GraphicsEngine::getInstance().getLevelSceneManager()->destroyParticleSystem(particleSystem_);
+  }
+  void ParticleInterface::addToSceneNode(Ogre::SceneNode* sceneNode)
+  {
+    this->sceneNode_ = sceneNode;
+    this->sceneNode_->attachObject(this->particleSystem_);
+  }
+  void ParticleInterface::detachFromSceneNode()
+  {
+    if (this->sceneNode_)
+    {
+      this->sceneNode_->detachObject(this->particleSystem_);
+      this->sceneNode_ = 0;
+    }
+  }
+  Ogre::ParticleEmitter* ParticleInterface::createNewEmitter()
+  {
+    if (this->particleSystem_->getNumEmitters() > 0)
+    {
+      Ogre::ParticleEmitter* newemitter = this->particleSystem_->addEmitter(this->particleSystem_->getEmitter(0)->getType());
+      this->particleSystem_->getEmitter(0)->copyParametersTo(newemitter);
+      return newemitter;
+    }
+    else
+      return 0;
+  }
+  Ogre::ParticleEmitter* ParticleInterface::getEmitter(unsigned int emitterNr) const
+  {
+    if (emitterNr < this->particleSystem_->getNumEmitters())
+      return this->particleSystem_->getEmitter(emitterNr);
+    else
+      return 0;
+  }
+  void ParticleInterface::removeEmitter(unsigned int emitterNr)
+  {
+    if (emitterNr < this->particleSystem_->getNumEmitters())
+      this->particleSystem_->removeEmitter(emitterNr);
+  }
+  void ParticleInterface::removeAllEmitters()
+  {
+    this->particleSystem_->removeAllEmitters();
+  }
+  unsigned int ParticleInterface::getNumEmitters() const
+  {
+    return this->particleSystem_->getNumEmitters();
+  }
+  Ogre::ParticleAffector* ParticleInterface::addAffector(const std::string& name)
+  {
+    return this->particleSystem_->addAffector(name);
+  }
+  Ogre::ParticleAffector* ParticleInterface::getAffector(unsigned int affectorNr) const
+  {
+    if (affectorNr < this->particleSystem_->getNumAffectors())
+      return this->particleSystem_->getAffector(affectorNr);
+    else
+      return 0;
+  }
+  void ParticleInterface::removeAffector(unsigned int affectorNr)
+  {
+    if (affectorNr < this->particleSystem_->getNumAffectors())
+      this->particleSystem_->removeAffector(affectorNr);
+  }
+  void ParticleInterface::removeAllAffectors()
+  {
+    this->particleSystem_->removeAllAffectors();
+  }
+  unsigned int ParticleInterface::getNumAffectors() const
+  {
+    return this->particleSystem_->getNumAffectors();
+  }
+  void ParticleInterface::setEnabled(bool enable)
+  {
+    this->bEnabled_ = enable;
+    this->updateVisibility();
+  }
+  void ParticleInterface::detailLevelChanged(unsigned int newlevel)
+  {
+    if (newlevel >= (unsigned int)this->detaillevel_)
+      this->bVisible_ = true;
+    else
+      this->bVisible_ = false;
+    this->updateVisibility();
+  }
+  void ParticleInterface::updateVisibility()
+  {
+    for (unsigned int i = 0; i < this->particleSystem_->getNumEmitters(); i++)
+      this->particleSystem_->getEmitter(i)->setEnabled(this->bEnabled_ && this->bVisible_);
+  }
+  void ParticleInterface::setSpeedFactor(float factor)
+  {
+    //this->particleSystem_->setSpeedFactor(Orxonox::getInstance().getTimeFactor() * factor);
+    this->particleSystem_->setSpeedFactor(1.0f * factor);
+  }
+  float ParticleInterface::getSpeedFactor() const
+  {
+    //return (this->particleSystem_->getSpeedFactor() / Orxonox::getInstance().getTimeFactor());
+    return (this->particleSystem_->getSpeedFactor() / 1.0f);
+  }
+  bool ParticleInterface::getKeepParticlesInLocalSpace() const
+  {
+    return this->particleSystem_->getKeepParticlesInLocalSpace();
+  }
+  void ParticleInterface::setKeepParticlesInLocalSpace(bool keep)
+  {
+    this->particleSystem_->setKeepParticlesInLocalSpace(keep);
+  }
+    unsigned int ParticleInterface::counter_s = 0;
+    ParticleInterface* ParticleInterface::currentParticleInterface_s = 0;
+    ParticleInterface::ParticleInterface(Ogre::SceneManager* scenemanager, const std::string& templateName, LODParticle::LOD detaillevel)
+    {
+        RegisterRootObject(ParticleInterface);
+        assert(scenemanager);
+        this->scenemanager_ = scenemanager;
+        this->sceneNode_ = 0;
+        this->bEnabled_ = true;
+        this->bVisible_ = true;
+        this->bAllowedByLOD_ = true;
+        this->particleSystem_ = this->scenemanager_->createParticleSystem("particles" + getConvertedValue<unsigned int, std::string>(ParticleInterface::counter_s++), templateName);
+        this->particleSystem_->setSpeedFactor(1.0f);
+        //this->particleSystem_->setSpeedFactor(Orxonox::getInstance().getTimeFactor());
+        this->setDetailLevel((unsigned int)detaillevel);
+    }
+    ParticleInterface::~ParticleInterface()
+    {
+        this->particleSystem_->removeAllEmitters();
+        this->detachFromSceneNode();
+        this->scenemanager_->destroyParticleSystem(particleSystem_);
+    }
+    void ParticleInterface::addToSceneNode(Ogre::SceneNode* sceneNode)
+    {
+        if (this->sceneNode_)
+            this->detachFromSceneNode();
+        this->sceneNode_ = sceneNode;
+        this->sceneNode_->attachObject(this->particleSystem_);
+    }
+    void ParticleInterface::detachFromSceneNode()
+    {
+        if (this->sceneNode_)
+        {
+            this->sceneNode_->detachObject(this->particleSystem_);
+            this->sceneNode_ = 0;
+        }
+    }
+    Ogre::ParticleEmitter* ParticleInterface::createNewEmitter()
+    {
+        if (this->particleSystem_->getNumEmitters() > 0)
+        {
+            Ogre::ParticleEmitter* newemitter = this->particleSystem_->addEmitter(this->particleSystem_->getEmitter(0)->getType());
+            this->particleSystem_->getEmitter(0)->copyParametersTo(newemitter);
+            return newemitter;
+        }
+        else
+            return 0;
+    }
+    Ogre::ParticleEmitter* ParticleInterface::getEmitter(unsigned int emitterNr) const
+    {
+        if (emitterNr < this->particleSystem_->getNumEmitters())
+            return this->particleSystem_->getEmitter(emitterNr);
+        else
+            return 0;
+    }
+    void ParticleInterface::removeEmitter(unsigned int emitterNr)
+    {
+        if (emitterNr < this->particleSystem_->getNumEmitters())
+            this->particleSystem_->removeEmitter(emitterNr);
+    }
+    void ParticleInterface::removeAllEmitters()
+    {
+        this->particleSystem_->removeAllEmitters();
+    }
+    unsigned int ParticleInterface::getNumEmitters() const
+    {
+        return this->particleSystem_->getNumEmitters();
+    }
+    Ogre::ParticleAffector* ParticleInterface::addAffector(const std::string& name)
+    {
+        return this->particleSystem_->addAffector(name);
+    }
+    Ogre::ParticleAffector* ParticleInterface::getAffector(unsigned int affectorNr) const
+    {
+        if (affectorNr < this->particleSystem_->getNumAffectors())
+            return this->particleSystem_->getAffector(affectorNr);
+        else
+            return 0;
+    }
+    void ParticleInterface::removeAffector(unsigned int affectorNr)
+    {
+        if (affectorNr < this->particleSystem_->getNumAffectors())
+            this->particleSystem_->removeAffector(affectorNr);
+    }
+    void ParticleInterface::removeAllAffectors()
+    {
+        this->particleSystem_->removeAllAffectors();
+    }
+    unsigned int ParticleInterface::getNumAffectors() const
+    {
+        return this->particleSystem_->getNumAffectors();
+    }
+    void ParticleInterface::setEnabled(bool enable)
+    {
+        this->bEnabled_ = enable;
+        for (unsigned int i = 0; i < this->particleSystem_->getNumEmitters(); i++)
+            this->particleSystem_->getEmitter(i)->setEnabled(this->bEnabled_ && this->bAllowedByLOD_);
+    }
+    void ParticleInterface::setVisible(bool visible)
+    {
+        this->bVisible_ = visible;
+        this->particleSystem_->setVisible(this->bVisible_ && this->bAllowedByLOD_);
+    }
+    void ParticleInterface::setDetailLevel(unsigned int level)
+    {
+        this->detaillevel_ = level;
+        this->detailLevelChanged(GraphicsEngine::getInstance().getDetailLevelParticle());
+    }
+    void ParticleInterface::detailLevelChanged(unsigned int newlevel)
+    {
+        if (newlevel >= (unsigned int)this->detaillevel_)
+            this->bAllowedByLOD_ = true;
+        else
+            this->bAllowedByLOD_ = false;
+        this->updateVisibility();
+    }
+    void ParticleInterface::updateVisibility()
+    {
+        this->setEnabled(this->isEnabled());
+        this->setVisible(this->isVisible());
+    }
+    void ParticleInterface::setSpeedFactor(float factor)
+    {
+        //this->particleSystem_->setSpeedFactor(Orxonox::getInstance().getTimeFactor() * factor);
+        this->particleSystem_->setSpeedFactor(1.0f * factor);
+    }
+    float ParticleInterface::getSpeedFactor() const
+    {
+        //return (this->particleSystem_->getSpeedFactor() / Orxonox::getInstance().getTimeFactor());
+        return (this->particleSystem_->getSpeedFactor() / 1.0f);
+    }
+    bool ParticleInterface::getKeepParticlesInLocalSpace() const
+    {
+        return this->particleSystem_->getKeepParticlesInLocalSpace();
+    }
+    void ParticleInterface::setKeepParticlesInLocalSpace(bool keep)
+    {
+        this->particleSystem_->setKeepParticlesInLocalSpace(keep);
+    }
+}

code/trunk/src/orxonox/tools/ParticleInterface.h

-                      r1563
+                      r2087
+ *
  *   Author:
  *      ...
+ *      Fabian 'x3n' Landau
  *   Co-authors:
  *      ...
 …
 namespace orxonox
+{
   class _OrxonoxExport ParticleInterface : public OrxonoxClass
+  {
     public:
       ParticleInterface(const std::string& templateName, LODParticle::LOD detaillevel);
       ~ParticleInterface();
+    class _OrxonoxExport ParticleInterface : public OrxonoxClass
+    {
+        public:
+            ParticleInterface(Ogre::SceneManager* scenemanager, const std::string& templateName, LODParticle::LOD detaillevel);
+            virtual ~ParticleInterface();
       inline Ogre::ParticleSystem* getParticleSystem() const
         { return this->particleSystem_; }
+            inline Ogre::ParticleSystem* getParticleSystem() const
+                { return this->particleSystem_; }
       void addToSceneNode(Ogre::SceneNode* sceneNode);
       void detachFromSceneNode();
+            void addToSceneNode(Ogre::SceneNode* sceneNode);
+            void detachFromSceneNode();
       Ogre::ParticleEmitter* createNewEmitter();
       Ogre::ParticleEmitter* getEmitter(unsigned int emitterNr) const;
       void removeEmitter(unsigned int emitterNr);
       void removeAllEmitters();
       unsigned int getNumEmitters() const;
+            Ogre::ParticleEmitter* createNewEmitter();
+            Ogre::ParticleEmitter* getEmitter(unsigned int emitterNr) const;
+            void removeEmitter(unsigned int emitterNr);
+            void removeAllEmitters();
+            unsigned int getNumEmitters() const;
       Ogre::ParticleAffector* addAffector(const std::string& name);
       Ogre::ParticleAffector* getAffector(unsigned int affectorNr) const;
       void removeAffector(unsigned int affectorNr);
       void removeAllAffectors();
       unsigned int getNumAffectors() const;
+            Ogre::ParticleAffector* addAffector(const std::string& name);
+            Ogre::ParticleAffector* getAffector(unsigned int affectorNr) const;
+            void removeAffector(unsigned int affectorNr);
+            void removeAllAffectors();
+            unsigned int getNumAffectors() const;
       float getSpeedFactor() const;
       void setSpeedFactor(float factor);
       bool getKeepParticlesInLocalSpace() const;
       void setKeepParticlesInLocalSpace(bool keep);
+            float getSpeedFactor() const;
+            void setSpeedFactor(float factor);
+            bool getKeepParticlesInLocalSpace() const;
+            void setKeepParticlesInLocalSpace(bool keep);
+      void setEnabled(bool enable);
+      void detailLevelChanged(unsigned int newlevel);
+            void setEnabled(bool enable);
+            inline bool isEnabled() const
+                { return this->bEnabled_; }
+      inline void storeThisAsCurrentParticleInterface()
+        { ParticleInterface::currentParticleInterface_s = this; }
+      inline static ParticleInterface* getCurrentParticleInterface()
+        { return ParticleInterface::currentParticleInterface_s; }
+            void setVisible(bool visible);
+            inline bool isVisible() const
+                { return this->bVisible_; }
     private:
       void updateVisibility();
+            void detailLevelChanged(unsigned int newlevel);
+            void setDetailLevel(unsigned int level);
+      static ParticleInterface* currentParticleInterface_s;
+      static unsigned int counter_s;
+      Ogre::SceneNode* sceneNode_;
+      Ogre::ParticleSystem* particleSystem_;
+      bool bVisible_;
+      bool bEnabled_;
+      unsigned int detaillevel_;                            //!< Detail level of this particle effect (0: off, 1: low, 2: normal, 3: high)
+  };
+            inline void storeThisAsCurrentParticleInterface()
+                { ParticleInterface::currentParticleInterface_s = this; }
+            inline static ParticleInterface* getCurrentParticleInterface()
+                { return ParticleInterface::currentParticleInterface_s; }
+        private:
+            void updateVisibility();
+            static ParticleInterface* currentParticleInterface_s;
+            static unsigned int       counter_s;
+            Ogre::SceneNode*          sceneNode_;
+            Ogre::ParticleSystem*     particleSystem_;
+            bool                      bVisible_;
+            bool                      bEnabled_;
+            bool                      bAllowedByLOD_;
+            unsigned int              detaillevel_;     //!< Detail level of this particle effect (0: off, 1: low, 2: normal, 3: high)
+            Ogre::SceneManager*       scenemanager_;
+    };
+}

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

-                      r1755
+                      r2087
         this->bLoop_ = false;
         this->bActive_ = false;
+        this->bKillAfterCall_ = false;
         this->time_ = 0;
 …
     void TimerBase::run() const
+    {
+        bool temp = this->bKillAfterCall_; // to avoid errors with bKillAfterCall_=false and an exutors which destroy the timer
         (*this->executor_)();
+        if (temp)
+            delete this;
+    }
 …
+            {
                 // It's time to call the function
                 if (this->bLoop_)
+                if (this->bLoop_ && !this->bKillAfterCall_)
+                {
                     this->time_ += this->interval_; // Q: Why '+=' and not '='? A: Think about it. It's more accurate like that. Seriously.

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

-                      r1755
+                      r2087
             TimerBase();
+            Executor* executor_; //!< The executor of the function that should be called when the time expires
+            long long interval_; //!< The time-interval in micro seconds
+            bool bLoop_;         //!< If true, the function gets called every 'interval' seconds
+            bool bActive_;       //!< If true, the Timer ticks and calls the function if the time's up
+            long long time_;     //!< Internal variable, counting the time till the next function-call
+            Executor* executor_;  //!< The executor of the function that should be called when the time expires
+            long long interval_;  //!< The time-interval in micro seconds
+            bool bLoop_;          //!< If true, the function gets called every 'interval' seconds
+            bool bActive_;        //!< If true, the Timer ticks and calls the function if the time's up
+            bool bKillAfterCall_; //!< If true the timer gets deleted after it called the function
+            long long time_;      //!< Internal variable, counting the time till the next function-call
     };
 …
                 @param exeuctor A executor of the function to call
             */
             Timer(float interval, bool bLoop, T* object, ExecutorMember<T>* exeuctor)
+            {
                 this->setTimer(interval, bLoop, object, exeuctor);
+            Timer(float interval, bool bLoop, T* object, ExecutorMember<T>* exeuctor, bool bKillAfterCall = false)
+            {
+                this->setTimer(interval, bLoop, object, exeuctor, bKillAfterCall);
+            }
 …
                 @param exeuctor A executor of the function to call
             */
             void setTimer(float interval, bool bLoop, T* object, ExecutorMember<T>* executor)
+            void setTimer(float interval, bool bLoop, T* object, ExecutorMember<T>* executor, bool bKillAfterCall = false)
+            {
                 this->deleteExecutor();
 …
                 this->time_ = this->interval_;
+                this->bKillAfterCall_ = bKillAfterCall;
+            }
     };
 …
                 @param exeuctor A executor of the function to call
             */
             StaticTimer(float interval, bool bLoop, ExecutorStatic* executor)
+            {
                 this->setTimer(interval, bLoop, executor);
+            StaticTimer(float interval, bool bLoop, ExecutorStatic* executor, bool bKillAfterCall = false)
+            {
+                this->setTimer(interval, bLoop, executor, bKillAfterCall);
+            }
 …
                 @param executor A executor of the function to call
             */
             void setTimer(float interval, bool bLoop, ExecutorStatic* executor)
+            void setTimer(float interval, bool bLoop, ExecutorStatic* executor, bool bKillAfterCall = false)
+            {
                 this->deleteExecutor();
 …
                 this->time_ = this->interval_;
+                this->bKillAfterCall_ = bKillAfterCall;
+            }
     };

code/trunk/src/tinyxml/ticpp.h

-                      r1639
+                      r2087
                 T* m_tiXmlPointer;              /**< Internal pointer to the TiXml Class which is being wrapped */
+    public:
                 /**
                 @internal
 …
                         return m_tiXmlPointer;
+                }
+    protected:
                 /**

code/trunk/src/tolua/lua/array.lua

Property svn:eol-style set to native

code/trunk/src/tolua/lua/basic.lua

Property svn:eol-style set to native

code/trunk/src/tolua/lua/class.lua

Property svn:eol-style set to native

code/trunk/src/tolua/lua/clean.lua

Property svn:eol-style set to native

code/trunk/src/tolua/lua/code.lua

Property svn:eol-style set to native

code/trunk/src/tolua/lua/compat-5.1.lua

Property svn:eol-style set to native

code/trunk/src/tolua/lua/compat.lua

Property svn:eol-style set to native

code/trunk/src/tolua/lua/container.lua

Property svn:eol-style set to native

code/trunk/src/tolua/lua/custom.lua

Property svn:eol-style set to native

code/trunk/src/tolua/lua/custom_hide.lua

Property svn:eol-style set to native

code/trunk/src/tolua/lua/declaration.lua

Property svn:eol-style set to native

code/trunk/src/tolua/lua/define.lua

Property svn:eol-style set to native

code/trunk/src/tolua/lua/doit.lua

Property svn:eol-style set to native

code/trunk/src/tolua/lua/enumerate.lua

Property svn:eol-style set to native

code/trunk/src/tolua/lua/feature.lua

Property svn:eol-style set to native

code/trunk/src/tolua/lua/function.lua

Property svn:eol-style set to native

code/trunk/src/tolua/lua/module.lua

Property svn:eol-style set to native

code/trunk/src/tolua/lua/namespace.lua

Property svn:eol-style set to native

code/trunk/src/tolua/lua/operator.lua

Property svn:eol-style set to native

code/trunk/src/tolua/lua/package.lua

Property svn:eol-style set to native

code/trunk/src/tolua/lua/typedef.lua

Property svn:eol-style set to native

code/trunk/src/tolua/lua/variable.lua

Property svn:eol-style set to native

code/trunk/src/tolua/lua/verbatim.lua

Property svn:eol-style set to native

code/trunk/src/tolua/tolua-5.1.pkg

Property svn:mergeinfo changed (with no actual effect on merging)

code/trunk/src/util

Property svn:mergeinfo set to (toggle deleted branches)

/code/branches/ceguilua/src/util	merged	eligible
/code/branches/script_trigger/src/util	merged	eligible
/code/branches/core3/src/util	1572-1739,1742-2014
/code/branches/gcc43/src/util	1580
/code/branches/gui/src/util	1635-1723
/code/branches/input/src/util	1629-1636

code/trunk/src/util/CMakeLists.txt

r1844	r2087
8	8	OutputBuffer.cc
9	9	OutputHandler.cc
	10	SignalHandler.cc
10	11	String.cc
11	12	SubString.cc

code/trunk/src/util/Convert.h

-                      r1889
+                      r2087
+ *
  *   Author:
+ *      Reto Grieder
  *      Fabian 'x3n' Landau
  *      Benjamin Grauer
 …
 /*!
     @file Convert.h
+    @file
     @brief Definition and Implementation of the Convert class.
 */
 #ifndef _Convert_H__
 #define _Convert_H__
+#ifndef _Converter_H__
+#define _Converter_H__
 #include "UtilPrereqs.h"
 …
 #include <string>
 #include <sstream>
+#include <istream>
+#include <ostream>
 #include <typeinfo>
-#include "Math.h"
 #include "Debug.h"
-#include "SubString.h"
 #include "String.h"
+// disable annoying warning about forcing value to boolean
+// GCC generates warnings when implicitely casting from float to int for instance.
+// This is however exactly what convertValue does, so we need to suppress these warnings.
+// They only occur when using the ImplicitConversion template.
+#if ORXONOX_COMPILER == ORXONOX_COMPILER_GNUC
+#  pragma GCC system_header
+#endif
+///////////////////////////////////////////////
+// Static detection for conversion functions //
+///////////////////////////////////////////////
+/* The idea to use the sizeof() operator on return functions to determine function existance
+   is described in 'Modern C++ design' by Alexandrescu (2001). */
+// disable warnings about possible loss of data
 #if ORXONOX_COMPILER == ORXONOX_COMPILER_MSVC
 #pragma warning(push)
 #pragma warning(disable:4100 4800)
+#  pragma warning(push)
+#  pragma warning(disable:4244)
 #endif
+//////////
+// MAIN //
+//////////
+// Enum to declare the wanted conversion preference in case of equal type-levels
+enum ConversionPreference
+{
+    CP_PreferToType,
+    CP_PreferFromType,
+};
+// Helper classes to determine the preferred partial template specialization
+class _ToType_   {};
+class _FromType_ {};
+class _Explicit_ {};
+// The default convert functions
+template <class FromType, class ToType, class Type>
+struct ConverterSpecialized
+{
+    enum { specialized = false };
+template <class FromType, class ToType>
+class ImplicitConversion
+{
+private:
+    ImplicitConversion(); ImplicitConversion(const ImplicitConversion&); ~ImplicitConversion();
+    // Gets chosen only if there is an implicit conversion from FromType to ToType.
+    static char test(ToType);
+    // Accepts any argument. Why do we not use a template? The reason is that with templates,
+    // the function above is only taken iff it is an exact type match. But since we want to
+    // check for implicit conversion, we have to use the ellipsis.
+    static long long test(...);
+    static FromType object; // helper object to handle private c'tor and d'tor
+public:
+    // test(object) only has 'long long' return type iff the compiler doesn't choose test(...)
+    enum { exists = (sizeof(test(object)) == sizeof(char)) };
+};
+#if ORXONOX_COMPILER == ORXONOX_COMPILER_MSVC
+#  pragma warning(pop)
+#endif
+////////////////////////////////////
+//// ACTUAL CONVERSION SEQUENCE ////
+////////////////////////////////////
+/*
+    There is a distinct priority when choosing the right conversion function:
+    Overwrite:
+. (Partial) template specialisation of ConverterExplicit::convert()
+    Fallbacks:
+. Any possible implicit conversion. This includes 'FooBar' --> 'int' if FooBar defines operator float().
+. Global or member operators for stringstream when converting from or to std::string (or FROM const char*)
+. (Partial) template specialisation of ConverterFallback::convert()
+. Function that simply displays "Could not convert value" with type information obtained from typeid().
+    Notes:
+    There has to be an exact type match when using template specialisations.
+    Template specialisations can be defined after including this file. Any implicit cast function or iostream
+    operator has to be declared BEFORE this file gets parsed.
+    Defining your own functions:
+    There are obviously 4 ways to specifiy a user defined conversion. What should I use?
+    Usually, ConverterFallback fits quite well. You won't have to deal with the conversion from
+    'MyClass' to 'MyClass' by using another explicit template specialisation to avoid ambiguities.
+    However if you want to overwrite an implicit conversion or an iostream operator, you really need to
+    make use of ConverterExplicit.
+*/
+namespace
+{
+    //! Little template that maps integers to entire types (Alexandrescu 2001)
+    template <int I>
+    struct Int2Type { };
+}
+///////////////////
+// No Conversion //
+///////////////////
+// Default template. No conversion available at all.
+template <class FromType, class ToType>
+struct ConverterFallback
+{
     static bool convert(ToType* output, const FromType& input)
+    {
+        COUT(2) << "Warning: Couldn't convert a value: From \"" << typeid(FromType).name() << "\" to \"" << typeid(ToType).name() << "\"" << std::endl;
+        COUT(2) << "Could not convert value of type " << typeid(FromType).name()
+                << " to type " << typeid(ToType).name() << std::endl;
         return false;
+    }
 };
+// The default convert function if both types are the same
+template <class BothTypes>
+struct ConverterSpecialized<BothTypes, BothTypes, _Explicit_>
+{
+    enum { specialized = true };
+    static bool convert(BothTypes* output, const BothTypes& input)
+    { (*output) = input; return true; }
+};
+// The possible levels
+#define __low__  0 // Everything that is or behaves like a primitive type (an can be converted with a typecast to every other low-level type)
+#define __mid__  1 // Everything that has overloaded << and >> operators to operate on a std::stream
+#define __high__ 2 // Everything that doesn't fullfill the lowerlevel-requirements and therefore needs specialized conversions
+// Defines the levels of all types: Default is __high__ so you don't have to define every high-level type
+template <class T> struct ConverterLevel              { enum { level = __high__ }; };
+template <> struct ConverterLevel<std::string>        { enum { level = __mid__ }; };
+template <> struct ConverterLevel<orxonox::Radian>    { enum { level = __mid__ }; };
+template <> struct ConverterLevel<orxonox::Degree>    { enum { level = __mid__ }; };
+template <> struct ConverterLevel<int>                { enum { level = __low__ }; };
+template <> struct ConverterLevel<unsigned int>       { enum { level = __low__ }; };
+template <> struct ConverterLevel<char>               { enum { level = __low__ }; };
+template <> struct ConverterLevel<unsigned char>      { enum { level = __low__ }; };
+template <> struct ConverterLevel<short>              { enum { level = __low__ }; };
+template <> struct ConverterLevel<unsigned short>     { enum { level = __low__ }; };
+template <> struct ConverterLevel<long>               { enum { level = __low__ }; };
+template <> struct ConverterLevel<unsigned long>      { enum { level = __low__ }; };
+template <> struct ConverterLevel<long long>          { enum { level = __low__ }; };
+template <> struct ConverterLevel<unsigned long long> { enum { level = __low__ }; };
+template <> struct ConverterLevel<float>              { enum { level = __low__ }; };
+template <> struct ConverterLevel<double>             { enum { level = __low__ }; };
+template <> struct ConverterLevel<long double>        { enum { level = __low__ }; };
+template <> struct ConverterLevel<bool>               { enum { level = __low__ }; };
+// Calculates the preference based on the levels of FromType and ToType
+template <int from, int to>
+struct ConverterPreference
+{
+    enum
+    {
+        // The maximum of both levels: element of {0, 1, 2}
+        // max 0: Both types are primitives or have a similar behaviour
+        // max 1: At least one type is not a primitive, but both can be put on a std::stream
+        // max 2: There is at least one generic type that needs specialized conversions
+        max = (from > to) ? from : to,
+        // The difference between both levels limited to +-1: element of {-1, 0, 1}
+        // diff -1: The FromType has higher level than the ToType
+        // diff  0: Both types have the same level
+        // diff  1: The ToType has higher level than the FromType
+        diff = ((to - from) > 1) ? 1 : (((to - from) < -1) ? -1 : to - from)
+    };
+};
+// The default conversion: This usually does nothing
+template <int max, class FromType, class ToType>
+struct ConverterDefault
+// If all else fails, try a dynamic_cast for pointer types.
+template <class FromType, class ToType>
+struct ConverterFallback<FromType*, ToType*>
+{
+    static bool convert(ToType** output, FromType* const input)
+    {
+        ToType* temp = dynamic_cast<ToType*>(input);
+        if (temp)
+        {
+            *output = temp;
+            return true;
+        }
+        else
+            return false;
+    }
+};
+///////////////////////
+// ConverterFallback //
+///////////////////////
+// Default template for stringstream
+template <class FromType, class ToType>
+struct ConverterStringStream
+{
     static bool convert(ToType* output, const FromType& input)
+    {
+        COUT(2) << "Warning: Couldn't convert a value: From \"" << typeid(FromType).name() << "\" to \"" << typeid(ToType).name() << "\"" << std::endl;
+        return false;
+    }
+};
+// The default conversion for primitives: A typecast (defined over two partial specialized templates to exclude all non-primitive types and classes)    template <int max, class FromType, class ToType>
+template <class FromType, class ToType>
+struct ConverterDefault<0, FromType, ToType>
+{
+    static bool convert(ToType* output, const FromType& input)
+    {
+        (*output) = (ToType)input;
+        return true;
+    }
+};
+// Converter: Converts input of FromType into output of ToType
+template <int diff, int max, class FromType, class ToType, ConversionPreference pref>
+struct Converter
+{
+    static bool convert(ToType* output, const FromType& input)
+    {
+        return false;
+    }
+};
+// Converter: level{FromType} > level{ToType}
+template <int max, class FromType, class ToType, ConversionPreference pref>
+struct Converter<-1, max, FromType, ToType, pref>
+{   static bool convert(ToType* output, const FromType& input)
+    { return (ConverterSpecialized<FromType, ToType, _Explicit_>::specialized) ? (ConverterSpecialized<FromType, ToType, _Explicit_>::convert(output, input)) : (ConverterSpecialized<FromType, ToType, _FromType_>::specialized) ? (ConverterSpecialized<FromType, ToType, _FromType_>::convert(output, input)) : (ConverterDefault<max, FromType, ToType>::convert(output, input)); } };
+// Converter: level{FromType} < level{ToType}
+template <int max, class FromType, class ToType, ConversionPreference pref>
+struct Converter<1, max, FromType, ToType, pref>
+{   static bool convert(ToType* output, const FromType& input)
+    { return (ConverterSpecialized<FromType, ToType, _Explicit_>::specialized) ? (ConverterSpecialized<FromType, ToType, _Explicit_>::convert(output, input)) : (ConverterSpecialized<FromType, ToType, _ToType_>::specialized) ? (ConverterSpecialized<FromType, ToType, _ToType_>::convert(output, input)) : (ConverterDefault<max, FromType, ToType>::convert(output, input)); } };
+// Converter: level{FromType} = level{ToType}
+// CP_PreferToType
+template <int max, class FromType, class ToType>
+struct Converter<0, max, FromType, ToType, CP_PreferToType>
+{   static bool convert(ToType* output, const FromType& input)
+    { return (ConverterSpecialized<FromType, ToType, _Explicit_>::specialized) ? (ConverterSpecialized<FromType, ToType, _Explicit_>::convert(output, input)) : (ConverterSpecialized<FromType, ToType, _ToType_>::specialized) ? (ConverterSpecialized<FromType, ToType, _ToType_>::convert(output, input)) : (ConverterSpecialized<FromType, ToType, _FromType_>::specialized) ? (ConverterSpecialized<FromType, ToType, _FromType_>::convert(output, input)) : (ConverterDefault<max, FromType, ToType>::convert(output, input)); } };
+// CP_PreferFromType
+template <int max, class FromType, class ToType>
+struct Converter<0, max, FromType, ToType, CP_PreferFromType>
+{   static bool convert(ToType* output, const FromType& input)
+    { return (ConverterSpecialized<FromType, ToType, _Explicit_>::specialized) ? (ConverterSpecialized<FromType, ToType, _Explicit_>::convert(output, input)) : (ConverterSpecialized<FromType, ToType, _FromType_>::specialized) ? (ConverterSpecialized<FromType, ToType, _FromType_>::convert(output, input)) : (ConverterSpecialized<FromType, ToType, _ToType_>::specialized) ? (ConverterSpecialized<FromType, ToType, _ToType_>::convert(output, input)) : (ConverterDefault<max, FromType, ToType>::convert(output, input)); } };
+// Calls the Converter::convertValue function with the correct template type parameters calculated by ConverterPreference
+template <class FromType, class ToType>
+static bool convertValue(ToType* output, const FromType& input, ConversionPreference preference = CP_PreferToType)
+{
+    return (preference == CP_PreferToType) ?
+           Converter<ConverterPreference<ConverterLevel<FromType>::level, ConverterLevel<ToType>::level>::diff,
+                     ConverterPreference<ConverterLevel<FromType>::level, ConverterLevel<ToType>::level>::max,
+                     FromType,
+                     ToType,
+                     CP_PreferToType>::convert(output, input)
+         : Converter<ConverterPreference<ConverterLevel<FromType>::level, ConverterLevel<ToType>::level>::diff,
+                     ConverterPreference<ConverterLevel<FromType>::level, ConverterLevel<ToType>::level>::max,
+                     FromType,
+                     ToType,
+                     CP_PreferFromType>::convert(output, input);
+}
+//////////////////////
+// HELPER FUNCTIONS //
+//////////////////////
+// Helper function: Calls convertValue with and without default value and returns true if the conversion was successful
+template<class FromType, class ToType>
+static bool ConvertValue(ToType* output, const FromType& input, ConversionPreference preference = CP_PreferToType)
+{
+    return convertValue(output, input, preference);
+}
+template<class FromType, class ToType>
+static bool ConvertValue(ToType* output, const FromType& input, const ToType& fallback, ConversionPreference preference = CP_PreferToType)
+{
+    if (convertValue(output, input, preference))
+        return true;
+    (*output) = fallback;
+    return false;
+}
+// Helper function: Calls convertValue with and without default value and returns the converted value
+template<class FromType, class ToType>
+static ToType getConvertedValue(const FromType& input, ConversionPreference preference = CP_PreferToType)
+{
+    ToType output = ToType();
+    ConvertValue(&output, input, preference);
+    return output;
+}
+template<class FromType, class ToType>
+static ToType getConvertedValue(const FromType& input, const ToType& fallback, ConversionPreference preference = CP_PreferToType)
+{
+    ToType output = fallback;
+    ConvertValue(&output, input, fallback, preference);
+    return output;
+}
+/////////////////////
+// SPECIALIZATIONS //
+/////////////////////
+        return ConverterFallback<FromType, ToType>::convert(output, input);
+    }
+};
 /////////////
 // SAMPLES //
+// OStream //
 /////////////
+/*
+// convert everything to xyz
+namespace fallbackTemplates
+{
+    template <class FromType>
+    inline bool operator <<(std::ostream& outstream,  const FromType& input)
+    {
+        std::string temp;
+        if (ConverterFallback<FromType, std::string>::convert(&temp, input))
+        {
+            std::operator <<(outstream, temp);
+            return true;
+        }
+        else
+            return false;
+    }
+}
+// template that evaluates whether we can convert to std::string via ostringstream
 template <class FromType>
+struct ConverterSpecialized<FromType, xyz, _ToType_>
+{
+    enum { specialized = true };
+    static bool convert(xyz* output, const FromType& input)
+    { return ...; }
+};
+// convert xyz to everything
+template <class ToType>
+struct ConverterSpecialized<xyz, ToType, _FromType_>
+{
+    enum { specialized = true };
+    static bool convert(ToType* output, const xyz& input)
+    { return ...; }
+};
+// convert abc to xyz
+template <>
+struct ConverterSpecialized<abc, xyz, _Explicit_>
+{
+    enum { specialized = true };
+    static bool convert(xyz* output, const abc& input)
+    { return ...; }
+};
+*/
+////////////
+// STRING //
+////////////
+// convert to string
+template <class FromType>
+struct ConverterSpecialized<FromType, std::string, _ToType_>
+{
+    enum { specialized = true };
+struct ConverterStringStream<FromType, std::string>
+{
     static bool convert(std::string* output, const FromType& input)
+    {
+        using namespace fallbackTemplates;
+        // this operator call only chooses fallbackTemplates::operator<< if there's no other fitting function
         std::ostringstream oss;
         if (oss << input)
 …
 };
+/////////////
+// IStream //
+/////////////
+namespace fallbackTemplates
+{
+    template <class ToType>
+    inline bool operator >>(std::istream& instream, ToType& output)
+    {
+        return ConverterFallback<std::string, ToType>
+            ::convert(&output, static_cast<std::istringstream&>(instream).str());
+    }
+}
+// template that evaluates whether we can convert from std::string via ostringstream
+template <class ToType>
+struct ConverterStringStream<std::string, ToType>
+{
+    static bool convert(ToType* output, const std::string& input)
+    {
+        using namespace fallbackTemplates;
+        std::istringstream iss(input);
+        // this operator call only chooses fallbackTemplates::operator>> if there's no other fitting function
+        if (iss >> (*output))
+        {
+            return true;
+        }
+        else
+            return false;
+    }
+};
+///////////////////
+// Implicit Cast //
+///////////////////
+// implicit cast not possible, try stringstream conversion next
+template <class FromType, class ToType>
+inline bool convertImplicitely(ToType* output, const FromType& input, ::Int2Type<false>)
+{
+    return ConverterStringStream<FromType, ToType>::convert(output, input);
+}
+// We can cast implicitely
+template <class FromType, class ToType>
+inline bool convertImplicitely(ToType* output, const FromType& input, ::Int2Type<true>)
+{
+    (*output) = static_cast<ToType>(input);
+    return true;
+}
+////////////////////////////////
+// ConverterExplicit Fallback //
+////////////////////////////////
+// Default template if no specialisation is available
+template <class FromType, class ToType>
+struct ConverterExplicit
+{
+    static bool convert(ToType* output, const FromType& input)
+    {
+        // Try implict cast and probe first. If a simple cast is not possible, it will not compile
+        // We therefore have to out source it into another template function
+        const bool probe = ImplicitConversion<FromType, ToType>::exists;
+        return convertImplicitely(output, input, ::Int2Type<probe>());
+    }
+};
+//////////////////////
+// Public Functions //
+//////////////////////
+/**
+@brief
+    Converts any value to any other as long as there exists a conversion.
+    Otherwise, the conversion will generate a runtime warning and return false.
+    For information about the different conversion methods (user defined too), see the section
+    'Actual conversion sequence' in this file above.
+*/
+template <class FromType, class ToType>
+inline bool convertValue(ToType* output, const FromType& input)
+{
+    return ConverterExplicit<FromType, ToType>::convert(output, input);
+}
+// For compatibility reasons. The same, but with capital ConvertValue
+template<class FromType, class ToType>
+inline bool ConvertValue(ToType* output, const FromType& input)
+{
+    return convertValue(output, input);
+}
+// Calls convertValue and returns true if the conversion was successful.
+// Otherwise the fallback is used.
+/**
+@brief
+    Converts any value to any other as long as there exists a conversion.
+    Otherwise, the conversion will generate a runtime warning and return false.
+    For information about the different conversion methods (user defined too), see the section
+    'Actual conversion sequence' in this file above.
+    If the conversion doesn't succeed, 'fallback' is written to '*output'.
+@param fallback
+    A default value that gets written to '*output' if there is no conversion.
+*/
+template<class FromType, class ToType>
+inline bool convertValue(ToType* output, const FromType& input, const ToType& fallback)
+{
+    if (convertValue(output, input))
+        return true;
+    else
+    {
+        (*output) = fallback;
+        return false;
+    }
+}
+// for compatibility reason. (capital 'c' in ConvertValue)
+template<class FromType, class ToType>
+inline bool ConvertValue(ToType* output, const FromType& input, const ToType& fallback)
+{
+    return convertValue(output, input, fallback);
+}
+// Directly returns the converted value, even if the conversion was not successful.
+template<class FromType, class ToType>
+inline ToType getConvertedValue(const FromType& input)
+{
+    ToType output;
+    convertValue(&output, input);
+    return output;
+}
+// Directly returns the converted value, but uses the fallback on failure.
+template<class FromType, class ToType>
+inline ToType getConvertedValue(const FromType& input, const ToType& fallback)
+{
+    ToType output;
+    convertValue(&output, input, fallback);
+    return output;
+}
+// Like getConvertedValue, but the template argument order is in reverse.
+// That means you can call it exactly like static_cast<ToType>(fromTypeValue).
+template<class ToType, class FromType>
+inline ToType omni_cast(const FromType& input)
+{
+    ToType output;
+    convertValue(&output, input);
+    return output;
+}
 // convert to string Shortcut
 template <class FromType>
 std::string convertToString(FromType value)
+inline std::string convertToString(FromType value)
+{
   return getConvertedValue<FromType, std::string>(value);
+}
 // convert from string
+// convert from string Shortcut
 template <class ToType>
+struct ConverterSpecialized<std::string, ToType, _FromType_>
+{
+    enum { specialized = true };
+    static bool convert(ToType* output, const std::string& input)
+    {
+inline ToType convertFromString(std::string str)
+{
+  return getConvertedValue<std::string, ToType>(str);
+}
+////////////////////////////////
+// Special string conversions //
+////////////////////////////////
+// Delegate conversion from const char* to std::string
+template <class ToType>
+struct ConverterExplicit<const char*, ToType>
+{
+    static bool convert(ToType* output, const char* input)
+    {
+        return convertValue<std::string, ToType>(output, input);
+    }
+};
+// These conversions would exhibit ambiguous << or >> operators when using stringstream
+template <>
+struct ConverterExplicit<char, std::string>
+{
+    static bool convert(std::string* output, const char input)
+    {
+        *output = std::string(1, input);
+        return true;
+    }
+};
+template <>
+struct ConverterExplicit<unsigned char, std::string>
+{
+    static bool convert(std::string* output, const unsigned char input)
+    {
+        *output = std::string(1, input);
+        return true;
+    }
+};
+template <>
+struct ConverterExplicit<std::string, char>
+{
+    static bool convert(char* output, const std::string input)
+    {
+        if (input != "")
+            *output = input[0];
+        else
+            *output = '\0';
+        return true;
+    }
+};
+template <>
+struct ConverterExplicit<std::string, unsigned char>
+{
+    static bool convert(unsigned char* output, const std::string input)
+    {
+        if (input != "")
+            *output = input[0];
+        else
+            *output = '\0';
+        return true;
+    }
+};
+// bool to std::string
+template <>
+struct ConverterExplicit<bool, std::string>
+{
+    static bool convert(std::string* output, const bool& input)
+    {
+        if (input)
+          *output = "true";
+        else
+          *output = "false";
+        return false;
+    }
+};
+// std::string to bool
+template <>
+struct ConverterExplicit<std::string, bool>
+{
+    static bool convert(bool* output, const std::string& input)
+    {
+        std::string stripped = getLowercase(removeTrailingWhitespaces(input));
+        if (stripped == "true" || stripped == "on" || stripped == "yes")
+        {
+          *output = true;
+          return true;
+        }
+        else if (stripped == "false" || stripped == "off" || stripped == "no")
+        {
+          *output = false;
+          return true;
+        }
         std::istringstream iss(input);
         if (iss >> (*output))
 …
 };
-// convert from string Shortcut
-template <class ToType>
-ToType convertFromString(std::string str)
+{
-  return getConvertedValue<std::string, ToType>(str);
+}
-//////////
-// MATH //
-//////////
-// convert everything to Degree
-template <class FromType>
-struct ConverterSpecialized<FromType, Ogre::Degree, _ToType_>
+{
-    enum { specialized = true };
-    static bool convert(Ogre::Degree* output, const FromType& input)
+    {
-        float angle = 0;
-        bool success = ConvertValue<FromType, float>(&angle, input);
-        (*output) = angle;
-        return success;
+    }
-};
-// convert everything to Radian
-template <class FromType>
-struct ConverterSpecialized<FromType, Ogre::Radian, _ToType_>
+{
-    enum { specialized = true };
-    static bool convert(Ogre::Radian* output, const FromType& input)
+    {
-        float angle = 0;
-        bool success = ConvertValue<FromType, float>(&angle, input);
-        (*output) = angle;
-        return success;
+    }
-};
-////////////////////
-// MATH TO STRING //
-////////////////////
-// bool to std::string
-template <>
-struct ConverterSpecialized<bool, std::string, _Explicit_>
+{
-    enum { specialized = true };
-    static bool convert(std::string* output, const bool& input)
+    {
-        if (input)
-          *output = "true";
-        else
-          *output = "false";
-        return false;
+    }
-};
-// Vector2 to std::string
-template <>
-struct ConverterSpecialized<orxonox::Vector2, std::string, _Explicit_>
+{
-    enum { specialized = true };
-    static bool convert(std::string* output, const orxonox::Vector2& input)
+    {
-        std::ostringstream ostream;
-        if (ostream << input.x << "," << input.y)
+        {
-            (*output) = ostream.str();
-            return true;
+        }
-        return false;
+    }
-};
-// Vector3 to std::string
-template <>
-struct ConverterSpecialized<orxonox::Vector3, std::string, _Explicit_>
+{
-    enum { specialized = true };
-    static bool convert(std::string* output, const orxonox::Vector3& input)
+    {
-        std::ostringstream ostream;
-        if (ostream << input.x << "," << input.y << "," << input.z)
+        {
-            (*output) = ostream.str();
-            return true;
+        }
-        return false;
+    }
-};
-// Vector4 to std::string
-template <>
-struct ConverterSpecialized<orxonox::Vector4, std::string, _Explicit_>
+{
-    enum { specialized = true };
-    static bool convert(std::string* output, const orxonox::Vector4& input)
+    {
-        std::ostringstream ostream;
-        if (ostream << input.x << "," << input.y << "," << input.z << "," << input.w)
+        {
-            (*output) = ostream.str();
-            return true;
+        }
-        return false;
+    }
-};
-// Quaternion to std::string
-template <>
-struct ConverterSpecialized<orxonox::Quaternion, std::string, _Explicit_>
+{
-    enum { specialized = true };
-    static bool convert(std::string* output, const orxonox::Quaternion& input)
+    {
-        std::ostringstream ostream;
-        if (ostream << input.w << "," << input.x << "," << input.y << "," << input.z)
+        {
-            (*output) = ostream.str();
-            return true;
+        }
-        return false;
+    }
-};
-// ColourValue to std::string
-template <>
-struct ConverterSpecialized<orxonox::ColourValue, std::string, _Explicit_>
+{
-    enum { specialized = true };
-    static bool convert(std::string* output, const orxonox::ColourValue& input)
+    {
-        std::ostringstream ostream;
-        if (ostream << input.r << "," << input.g << "," << input.b << "," << input.a)
+        {
-            (*output) = ostream.str();
-            return true;
+        }
-        return false;
+    }
-};
-////////////////////
-// STRING TO MATH //
-////////////////////
-// std::string to bool
-template <>
-struct ConverterSpecialized<std::string, bool, _Explicit_>
+{
-    enum { specialized = true };
-    static bool convert(bool* output, const std::string& input)
+    {
-        std::string stripped = getLowercase(removeTrailingWhitespaces(input));
-        if (stripped == "true" || stripped == "on" || stripped == "yes")
+        {
-          *output = true;
-          return true;
+        }
-        else if (stripped == "false" || stripped == "off" || stripped == "no")
+        {
-          *output = false;
-          return true;
+        }
-        std::istringstream iss(input);
-        if (iss >> (*output))
-            return true;
-        else
-            return false;
+    }
-};
-// std::string to Vector2
-template <>
-struct ConverterSpecialized<std::string, orxonox::Vector2, _Explicit_>
+{
-    enum { specialized = true };
-    static bool convert(orxonox::Vector2* output, const std::string& input)
+    {
-        size_t opening_parenthesis, closing_parenthesis = input.find(')');
-        if ((opening_parenthesis = input.find('(')) == std::string::npos) { opening_parenthesis = 0; } else { opening_parenthesis++; }
-        SubString tokens(input.substr(opening_parenthesis, closing_parenthesis - opening_parenthesis), ",", SubString::WhiteSpaces, false, '\\', true, '"', true, '\0', '\0', true, '\0');
-        if (tokens.size() >= 2)
+        {
-            if (!ConvertValue(&(output->x), tokens[0]))
-                return false;
-            if (!ConvertValue(&(output->y), tokens[1]))
-                return false;
-            return true;
+        }
-        return false;
+    }
-};
-// std::string to Vector3
-template <>
-struct ConverterSpecialized<std::string, orxonox::Vector3, _Explicit_>
+{
-    enum { specialized = true };
-    static bool convert(orxonox::Vector3* output, const std::string& input)
+    {
-        size_t opening_parenthesis, closing_parenthesis = input.find(')');
-        if ((opening_parenthesis = input.find('(')) == std::string::npos) { opening_parenthesis = 0; } else { opening_parenthesis++; }
-        SubString tokens(input.substr(opening_parenthesis, closing_parenthesis - opening_parenthesis), ",", SubString::WhiteSpaces, false, '\\', true, '"', true, '\0', '\0', true, '\0');
-        if (tokens.size() >= 3)
+        {
-            if (!ConvertValue(&(output->x), tokens[0]))
-                return false;
-            if (!ConvertValue(&(output->y), tokens[1]))
-                return false;
-            if (!ConvertValue(&(output->z), tokens[2]))
-                return false;
-            return true;
+        }
-        return false;
+    }
-};
-// std::string to Vector4
-template <>
-struct ConverterSpecialized<std::string, orxonox::Vector4, _Explicit_>
+{
-    enum { specialized = true };
-    static bool convert(orxonox::Vector4* output, const std::string& input)
+    {
-        size_t opening_parenthesis, closing_parenthesis = input.find(')');
-        if ((opening_parenthesis = input.find('(')) == std::string::npos) { opening_parenthesis = 0; } else { opening_parenthesis++; }
-        SubString tokens(input.substr(opening_parenthesis, closing_parenthesis - opening_parenthesis), ",", SubString::WhiteSpaces, false, '\\', true, '"', true, '\0', '\0', true, '\0');
-        if (tokens.size() >= 4)
+        {
-            if (!ConvertValue(&(output->x), tokens[0]))
-                return false;
-            if (!ConvertValue(&(output->y), tokens[1]))
-                return false;
-            if (!ConvertValue(&(output->z), tokens[2]))
-                return false;
-            if (!ConvertValue(&(output->w), tokens[3]))
-                return false;
-            return true;
+        }
-        return false;
+    }
-};
-// std::string to Quaternion
-template <>
-struct ConverterSpecialized<std::string, orxonox::Quaternion, _Explicit_>
+{
-    enum { specialized = true };
-    static bool convert(orxonox::Quaternion* output, const std::string& input)
+    {
-        size_t opening_parenthesis, closing_parenthesis = input.find(')');
-        if ((opening_parenthesis = input.find('(')) == std::string::npos) { opening_parenthesis = 0; } else { opening_parenthesis++; }
-        SubString tokens(input.substr(opening_parenthesis, closing_parenthesis - opening_parenthesis), ",", SubString::WhiteSpaces, false, '\\', true, '"', true, '\0', '\0', true, '\0');
-        if (tokens.size() >= 4)
+        {
-            if (!ConvertValue(&(output->w), tokens[0]))
-                return false;
-            if (!ConvertValue(&(output->x), tokens[1]))
-                return false;
-            if (!ConvertValue(&(output->y), tokens[2]))
-                return false;
-            if (!ConvertValue(&(output->z), tokens[3]))
-                return false;
-            return true;
+        }
-        return false;
+    }
-};
-// std::string to ColourValue
-template <>
-struct ConverterSpecialized<std::string, orxonox::ColourValue, _Explicit_>
+{
-    enum { specialized = true };
-    static bool convert(orxonox::ColourValue* output, const std::string& input)
+    {
-        size_t opening_parenthesis, closing_parenthesis = input.find(')');
-        if ((opening_parenthesis = input.find('(')) == std::string::npos) { opening_parenthesis = 0; } else { opening_parenthesis++; }
-        SubString tokens(input.substr(opening_parenthesis, closing_parenthesis - opening_parenthesis), ",", SubString::WhiteSpaces, false, '\\', true, '"', true, '\0', '\0', true, '\0');
-        if (tokens.size() >= 3)
+        {
-            if (!ConvertValue(&(output->r), tokens[0]))
-                return false;
-            if (!ConvertValue(&(output->g), tokens[1]))
-                return false;
-            if (!ConvertValue(&(output->b), tokens[2]))
-                return false;
-            if (tokens.size() >= 4)
+            {
-                if (!ConvertValue(&(output->a), tokens[3]))
-                    return false;
+            }
-            else
-                output->a = 1.0;
-            return true;
+        }
-        return false;
+    }
-};
-///////////////////////////
-// Static type detection //
-///////////////////////////
-/**
-    Template class that determines whether type T converts implicitly to type U.
-@note
-    This allows to detect type conversion at compile time.
-    From 'Modern C++ Design' (Alexandrescu 2001).
-*/
-template <class T, class U>
-class StaticConversion
+{
-    class Small { char dummy[1]; };
-    class Big   { char dummy[1024]; };
-    static Small Test(U);
-    static Big   Test(...);
-    static T MakeT();
-public:
-    enum { exists = sizeof(Test(MakeT())) == sizeof(Small) };
-};
-#if ORXONOX_COMPILER == ORXONOX_COMPILER_MSVC
-#pragma warning(pop)
-#endif
 #endif /* _Convert_H__ */

code/trunk/src/util/Debug.h

-                      r1791
+                      r2087
+}
+namespace orxonox
+{
+    using std::endl;
+}
 // DEFINE ERROR MODES

code/trunk/src/util/Exception.cc

Property svn:mergeinfo changed (with no actual effect on merging)

code/trunk/src/util/Exception.h

Property svn:mergeinfo changed (with no actual effect on merging)

code/trunk/src/util/Math.cc

-                      r1791
+                      r2087
 /**
     @file Math.cc
+    @file
     @brief Implementation of several math-functions.
 */
+#include "Math.h"
 #include <OgrePlane.h>
+#include "Math.h"
+#include "Convert.h"
+#include "MathConvert.h"
+#include "SubString.h"
 /**
 …
+}
+std::string getUniqueNumberStr()
+{
+    return convertToString(getUniqueNumber());
+}
+//////////////////////////
+// Conversion functions //
+//////////////////////////
+// std::string to Vector2
+bool ConverterFallback<std::string, orxonox::Vector2>::convert(orxonox::Vector2* output, const std::string& input)
+{
+    size_t opening_parenthesis, closing_parenthesis = input.find(')');
+    if ((opening_parenthesis = input.find('(')) == std::string::npos)
+        opening_parenthesis = 0;
+    else
+        opening_parenthesis++;
+    SubString tokens(input.substr(opening_parenthesis, closing_parenthesis - opening_parenthesis),
+                     ",", SubString::WhiteSpaces, false, '\\', true, '"', true, '\0', '\0', true, '\0');
+    if (tokens.size() >= 2)
+    {
+        if (!ConvertValue(&(output->x), tokens[0]))
+            return false;
+        if (!ConvertValue(&(output->y), tokens[1]))
+            return false;
+        return true;
+    }
+    return false;
+}
+// std::string to Vector3
+bool ConverterFallback<std::string, orxonox::Vector3>::convert(orxonox::Vector3* output, const std::string& input)
+{
+    size_t opening_parenthesis, closing_parenthesis = input.find(')');
+    if ((opening_parenthesis = input.find('(')) == std::string::npos)
+        opening_parenthesis = 0;
+    else
+        opening_parenthesis++;
+    SubString tokens(input.substr(opening_parenthesis, closing_parenthesis - opening_parenthesis),
+                     ",", SubString::WhiteSpaces, false, '\\', true, '"', true, '\0', '\0', true, '\0');
+    if (tokens.size() >= 3)
+    {
+        if (!ConvertValue(&(output->x), tokens[0]))
+            return false;
+        if (!ConvertValue(&(output->y), tokens[1]))
+            return false;
+        if (!ConvertValue(&(output->z), tokens[2]))
+            return false;
+        return true;
+    }
+    return false;
+}
+// std::string to Vector4
+bool ConverterFallback<std::string, orxonox::Vector4>::convert(orxonox::Vector4* output, const std::string& input)
+{
+    size_t opening_parenthesis, closing_parenthesis = input.find(')');
+    if ((opening_parenthesis = input.find('(')) == std::string::npos)
+        opening_parenthesis = 0;
+    else
+        opening_parenthesis++;
+    SubString tokens(input.substr(opening_parenthesis, closing_parenthesis - opening_parenthesis),
+                     ",", SubString::WhiteSpaces, false, '\\', true, '"', true, '\0', '\0', true, '\0');
+    if (tokens.size() >= 4)
+    {
+        if (!ConvertValue(&(output->x), tokens[0]))
+            return false;
+        if (!ConvertValue(&(output->y), tokens[1]))
+            return false;
+        if (!ConvertValue(&(output->z), tokens[2]))
+            return false;
+        if (!ConvertValue(&(output->w), tokens[3]))
+            return false;
+        return true;
+    }
+    return false;
+}
+// std::string to Quaternion
+bool ConverterFallback<std::string, orxonox::Quaternion>::convert(orxonox::Quaternion* output, const std::string& input)
+{
+    size_t opening_parenthesis, closing_parenthesis = input.find(')');
+    if ((opening_parenthesis = input.find('(')) == std::string::npos) { opening_parenthesis = 0; } else { opening_parenthesis++; }
+    SubString tokens(input.substr(opening_parenthesis, closing_parenthesis - opening_parenthesis), ",", SubString::WhiteSpaces, false, '\\', true, '"', true, '\0', '\0', true, '\0');
+    if (tokens.size() >= 4)
+    {
+        if (!ConvertValue(&(output->w), tokens[0]))
+            return false;
+        if (!ConvertValue(&(output->x), tokens[1]))
+            return false;
+        if (!ConvertValue(&(output->y), tokens[2]))
+            return false;
+        if (!ConvertValue(&(output->z), tokens[3]))
+            return false;
+        return true;
+    }
+    return false;
+}
+// std::string to ColourValue
+bool ConverterFallback<std::string, orxonox::ColourValue>::convert(orxonox::ColourValue* output, const std::string& input)
+{
+    size_t opening_parenthesis, closing_parenthesis = input.find(')');
+    if ((opening_parenthesis = input.find('(')) == std::string::npos) { opening_parenthesis = 0; } else { opening_parenthesis++; }
+    SubString tokens(input.substr(opening_parenthesis, closing_parenthesis - opening_parenthesis), ",", SubString::WhiteSpaces, false, '\\', true, '"', true, '\0', '\0', true, '\0');
+    if (tokens.size() >= 3)
+    {
+        if (!ConvertValue(&(output->r), tokens[0]))
+            return false;
+        if (!ConvertValue(&(output->g), tokens[1]))
+            return false;
+        if (!ConvertValue(&(output->b), tokens[2]))
+            return false;
+        if (tokens.size() >= 4)
+        {
+            if (!ConvertValue(&(output->a), tokens[3]))
+                return false;
+        }
+        else
+            output->a = 1.0;
+        return true;
+    }
+    return false;
+}

code/trunk/src/util/Math.h

-                      r1840
+                      r2087
 #include <ostream>
 #include <string>
+#include <boost/static_assert.hpp>
 #include <OgreMath.h>
 …
+}
+template <typename T>
+inline T zeroise()
+{
+    BOOST_STATIC_ASSERT(sizeof(T) == 0);
+    return T();
+}
+template <> inline char                 zeroise<char>()                 { return 0; }
+template <> inline unsigned char        zeroise<unsigned char>()        { return 0; }
+template <> inline short                zeroise<short>()                { return 0; }
+template <> inline unsigned short       zeroise<unsigned short>()       { return 0; }
+template <> inline int                  zeroise<int>()                  { return 0; }
+template <> inline unsigned int         zeroise<unsigned int>()         { return 0; }
+template <> inline long                 zeroise<long>()                 { return 0; }
+template <> inline unsigned long        zeroise<unsigned long>()        { return 0; }
+template <> inline long long            zeroise<long long>()            { return 0; }
+template <> inline unsigned long long   zeroise<unsigned long long>()   { return 0; }
+template <> inline float                zeroise<float>()                { return 0; }
+template <> inline double               zeroise<double>()               { return 0; }
+template <> inline long double          zeroise<long double>()          { return 0; }
+template <> inline bool                 zeroise<bool>()                 { return 0; }
+template <> inline void*                zeroise<void*>()                { return 0; }
+template <> inline std::string          zeroise<std::string>()          { return ""; }
+template <> inline orxonox::Radian      zeroise<orxonox::Radian>()      { return orxonox::Radian(0.0f); }
+template <> inline orxonox::Degree      zeroise<orxonox::Degree>()      { return orxonox::Degree(0.0f); }
+template <> inline orxonox::Vector2     zeroise<orxonox::Vector2>()     { return orxonox::Vector2    (0, 0)      ; }
+template <> inline orxonox::Vector3     zeroise<orxonox::Vector3>()     { return orxonox::Vector3    (0, 0, 0)   ; }
+template <> inline orxonox::Vector4     zeroise<orxonox::Vector4>()     { return orxonox::Vector4    (0, 0, 0, 0); }
+template <> inline orxonox::ColourValue zeroise<orxonox::ColourValue>() { return orxonox::ColourValue(0, 0, 0, 0); }
+template <> inline orxonox::Quaternion  zeroise<orxonox::Quaternion>()  { return orxonox::Quaternion (0, 0, 0, 0); }
 /**
     @brief Interpolates between two values for a time between 0 and 1.
 …
 _UtilExport unsigned long getUniqueNumber();
-_UtilExport std::string getUniqueNumberStr();
 class _UtilExport IntVector2

code/trunk/src/util/MultiType.cc

-                      r1791
+                      r2087
     @param type The type
 */
 void MultiType::convert(MT_Type type)
+bool MultiType::convert(MT_Type type)
+{
     switch (type)
+    {
         case MT_char:
             this->convert<char>(); break;
+            return this->convert<char>(); break;
         case MT_uchar:
             this->convert<unsigned char>(); break;
+            return this->convert<unsigned char>(); break;
         case MT_short:
             this->convert<short>(); break;
+            return this->convert<short>(); break;
         case MT_ushort:
             this->convert<unsigned short>(); break;
+            return this->convert<unsigned short>(); break;
         case MT_int:
             this->convert<int>(); break;
+            return this->convert<int>(); break;
         case MT_uint:
             this->convert<unsigned int>(); break;
+            return this->convert<unsigned int>(); break;
         case MT_long:
             this->convert<long>(); break;
+            return this->convert<long>(); break;
         case MT_ulong:
             this->convert<unsigned long>(); break;
+            return this->convert<unsigned long>(); break;
         case MT_longlong:
             this->convert<long long>(); break;
+            return this->convert<long long>(); break;
         case MT_ulonglong:
             this->convert<unsigned long long>(); break;
+            return this->convert<unsigned long long>(); break;
         case MT_float:
             this->convert<float>(); break;
+            return this->convert<float>(); break;
         case MT_double:
             this->convert<double>(); break;
+            return this->convert<double>(); break;
         case MT_longdouble:
             this->convert<long double>(); break;
+            return this->convert<long double>(); break;
         case MT_bool:
             this->convert<bool>(); break;
+            return this->convert<bool>(); break;
         case MT_void:
             this->convert<void*>(); break;
+            return this->convert<void*>(); break;
         case MT_string:
             this->convert<std::string>(); break;
+            return this->convert<std::string>(); break;
         case MT_vector2:
             this->convert<orxonox::Vector2>(); break;
+            return this->convert<orxonox::Vector2>(); break;
         case MT_vector3:
             this->convert<orxonox::Vector3>(); break;
+            return this->convert<orxonox::Vector3>(); break;
         case MT_vector4:
             this->convert<orxonox::Vector4>(); break;
+            return this->convert<orxonox::Vector4>(); break;
         case MT_colourvalue:
             this->convert<orxonox::ColourValue>(); break;
+            return this->convert<orxonox::ColourValue>(); break;
         case MT_quaternion:
             this->convert<orxonox::Quaternion>(); break;
+            return this->convert<orxonox::Quaternion>(); break;
         case MT_radian:
             this->convert<orxonox::Radian>(); break;
+            return this->convert<orxonox::Radian>(); break;
         case MT_degree:
             this->convert<orxonox::Degree>(); break;
+            return this->convert<orxonox::Degree>(); break;
         default:
             this->reset(); break;
+            this->reset(); return false; break;
     };
+}
 …
 MultiType::operator double()               const { return (this->value_) ? ((this->value_->type_ == MT_double     ) ? ((MT_Value<double>              *)this->value_)->value_ : (*this->value_)) : 0;                      } /** @brief Returns the current value, converted to the requested type. */
 MultiType::operator long double()          const { return (this->value_) ? ((this->value_->type_ == MT_longdouble ) ? ((MT_Value<long double>         *)this->value_)->value_ : (*this->value_)) : 0;                      } /** @brief Returns the current value, converted to the requested type. */
 MultiType::operator bool()                 const { return (this->value_) ? ((this->value_->type_ == MT_bool       ) ? ((MT_Value<bool>                *)this->value_)->value_ : (*this->value_)) : false;                  } /** @brief Returns the current value, converted to the requested type. */
 MultiType::operator void*()                const { return (this->value_) ? ((this->value_->type_ == MT_void       ) ? ((MT_Value<void*>               *)this->value_)->value_ : (*this->value_)) : (void*)0;               } /** @brief Returns the current value, converted to the requested type. */
 MultiType::operator std::string()          const { return (this->value_) ? ((this->value_->type_ == MT_string     ) ? ((MT_Value<std::string>         *)this->value_)->value_ : (*this->value_)) : std::string();          } /** @brief Returns the current value, converted to the requested type. */
 MultiType::operator orxonox::Vector2()     const { return (this->value_) ? ((this->value_->type_ == MT_vector2    ) ? ((MT_Value<orxonox::Vector2>    *)this->value_)->value_ : (*this->value_)) : orxonox::Vector2();     } /** @brief Returns the current value, converted to the requested type. */
 MultiType::operator orxonox::Vector3()     const { return (this->value_) ? ((this->value_->type_ == MT_vector3    ) ? ((MT_Value<orxonox::Vector3>    *)this->value_)->value_ : (*this->value_)) : orxonox::Vector3();     } /** @brief Returns the current value, converted to the requested type. */
 MultiType::operator orxonox::Vector4()     const { return (this->value_) ? ((this->value_->type_ == MT_vector4    ) ? ((MT_Value<orxonox::Vector4>    *)this->value_)->value_ : (*this->value_)) : orxonox::Vector4();     } /** @brief Returns the current value, converted to the requested type. */
 MultiType::operator orxonox::ColourValue() const { return (this->value_) ? ((this->value_->type_ == MT_colourvalue) ? ((MT_Value<orxonox::ColourValue>*)this->value_)->value_ : (*this->value_)) : orxonox::ColourValue(); } /** @brief Returns the current value, converted to the requested type. */
 MultiType::operator orxonox::Quaternion()  const { return (this->value_) ? ((this->value_->type_ == MT_quaternion ) ? ((MT_Value<orxonox::Quaternion> *)this->value_)->value_ : (*this->value_)) : orxonox::Quaternion();  } /** @brief Returns the current value, converted to the requested type. */
 MultiType::operator orxonox::Radian()      const { return (this->value_) ? ((this->value_->type_ == MT_radian     ) ? ((MT_Value<orxonox::Radian>     *)this->value_)->value_ : (*this->value_)) : orxonox::Radian();      } /** @brief Returns the current value, converted to the requested type. */
 MultiType::operator orxonox::Degree()      const { return (this->value_) ? ((this->value_->type_ == MT_degree     ) ? ((MT_Value<orxonox::Degree>     *)this->value_)->value_ : (*this->value_)) : orxonox::Degree();      } /** @brief Returns the current value, converted to the requested type. */
+MultiType::operator bool()                 const { return (this->value_) ? ((this->value_->type_ == MT_bool       ) ? ((MT_Value<bool>                *)this->value_)->value_ : (*this->value_)) : 0;                      } /** @brief Returns the current value, converted to the requested type. */
+MultiType::operator void*()                const { return (this->value_) ? ((this->value_->type_ == MT_void       ) ? ((MT_Value<void*>               *)this->value_)->value_ : (*this->value_)) : 0;                      } /** @brief Returns the current value, converted to the requested type. */
+MultiType::operator std::string()          const { return (this->value_) ? ((this->value_->type_ == MT_string     ) ? ((MT_Value<std::string>         *)this->value_)->value_ : (*this->value_)) : zeroise<std::string>();          } /** @brief Returns the current value, converted to the requested type. */
+MultiType::operator orxonox::Vector2()     const { return (this->value_) ? ((this->value_->type_ == MT_vector2    ) ? ((MT_Value<orxonox::Vector2>    *)this->value_)->value_ : (*this->value_)) : zeroise<orxonox::Vector2>();     } /** @brief Returns the current value, converted to the requested type. */
+MultiType::operator orxonox::Vector3()     const { return (this->value_) ? ((this->value_->type_ == MT_vector3    ) ? ((MT_Value<orxonox::Vector3>    *)this->value_)->value_ : (*this->value_)) : zeroise<orxonox::Vector3>();     } /** @brief Returns the current value, converted to the requested type. */
+MultiType::operator orxonox::Vector4()     const { return (this->value_) ? ((this->value_->type_ == MT_vector4    ) ? ((MT_Value<orxonox::Vector4>    *)this->value_)->value_ : (*this->value_)) : zeroise<orxonox::Vector4>();     } /** @brief Returns the current value, converted to the requested type. */
+MultiType::operator orxonox::ColourValue() const { return (this->value_) ? ((this->value_->type_ == MT_colourvalue) ? ((MT_Value<orxonox::ColourValue>*)this->value_)->value_ : (*this->value_)) : zeroise<orxonox::ColourValue>(); } /** @brief Returns the current value, converted to the requested type. */
+MultiType::operator orxonox::Quaternion()  const { return (this->value_) ? ((this->value_->type_ == MT_quaternion ) ? ((MT_Value<orxonox::Quaternion> *)this->value_)->value_ : (*this->value_)) : zeroise<orxonox::Quaternion>();  } /** @brief Returns the current value, converted to the requested type. */
+MultiType::operator orxonox::Radian()      const { return (this->value_) ? ((this->value_->type_ == MT_radian     ) ? ((MT_Value<orxonox::Radian>     *)this->value_)->value_ : (*this->value_)) : zeroise<orxonox::Radian>();      } /** @brief Returns the current value, converted to the requested type. */
+MultiType::operator orxonox::Degree()      const { return (this->value_) ? ((this->value_->type_ == MT_degree     ) ? ((MT_Value<orxonox::Degree>     *)this->value_)->value_ : (*this->value_)) : zeroise<orxonox::Degree>();      } /** @brief Returns the current value, converted to the requested type. */
 template <> void MultiType::createNewValueContainer(const char& value)                 { this->value_ = new MT_Value<char>                (value, MT_char       ); } /** @brief Creates a new value container for the given type. */

code/trunk/src/util/MultiType.h

-                      r1854
+                      r2087
     a.convert<bool>();         // converts 3.14 to bool, which is true
     a = false;                 // assigns false, this is equivalent to a.setValue(false)
+    @note
+    Whenever a value gets converted, there is a boolean return value telling you whether it was
+    successful or not. If it wasn't a zero value is assigned with the help of zeroise<T>().
 */
 …
     struct _UtilExport MT_ValueBase
+    {
         MT_ValueBase(MT_Type type) : type_(type) {}
+        MT_ValueBase(MT_Type type) : type_(type), bHasDefaultValue_(false) {}
         virtual ~MT_ValueBase() {}
 …
         virtual void reset() = 0;
         virtual void assimilate(const MultiType& other) = 0;
+        virtual bool assimilate(const MultiType& other) = 0;
         /** @brief Returns the type of the current value. */
         const MT_Type& getType() const { return this->type_; }
+        virtual void setValue(const char& value)                 = 0;
+        virtual void setValue(const unsigned char& value)        = 0;
+        virtual void setValue(const short& value)                = 0;
+        virtual void setValue(const unsigned short& value)       = 0;
+        virtual void setValue(const int& value)                  = 0;
+        virtual void setValue(const unsigned int& value)         = 0;
+        virtual void setValue(const long& value)                 = 0;
+        virtual void setValue(const unsigned long& value)        = 0;
+        virtual void setValue(const long long& value)            = 0;
+        virtual void setValue(const unsigned long long& value)   = 0;
+        virtual void setValue(const float& value)                = 0;
+        virtual void setValue(const double& value)               = 0;
+        virtual void setValue(const long double& value)          = 0;
+        virtual void setValue(const bool& value)                 = 0;
+        virtual void setValue(      void* const& value)          = 0;
+        virtual void setValue(const std::string& value)          = 0;
+        virtual void setValue(const orxonox::Vector2& value)     = 0;
+        virtual void setValue(const orxonox::Vector3& value)     = 0;
+        virtual void setValue(const orxonox::Vector4& value)     = 0;
+        virtual void setValue(const orxonox::ColourValue& value) = 0;
+        virtual void setValue(const orxonox::Quaternion& value)  = 0;
+        virtual void setValue(const orxonox::Radian& value)      = 0;
+        virtual void setValue(const orxonox::Degree& value)      = 0;
+        /** @brief Checks whether the value is a default one. */
+        bool hasDefaultValue()   const { return this->bHasDefaultValue_; }
+        virtual bool setValue(const char& value)                 = 0;
+        virtual bool setValue(const unsigned char& value)        = 0;
+        virtual bool setValue(const short& value)                = 0;
+        virtual bool setValue(const unsigned short& value)       = 0;
+        virtual bool setValue(const int& value)                  = 0;
+        virtual bool setValue(const unsigned int& value)         = 0;
+        virtual bool setValue(const long& value)                 = 0;
+        virtual bool setValue(const unsigned long& value)        = 0;
+        virtual bool setValue(const long long& value)            = 0;
+        virtual bool setValue(const unsigned long long& value)   = 0;
+        virtual bool setValue(const float& value)                = 0;
+        virtual bool setValue(const double& value)               = 0;
+        virtual bool setValue(const long double& value)          = 0;
+        virtual bool setValue(const bool& value)                 = 0;
+        virtual bool setValue(      void* const& value)          = 0;
+        virtual bool setValue(const std::string& value)          = 0;
+        virtual bool setValue(const orxonox::Vector2& value)     = 0;
+        virtual bool setValue(const orxonox::Vector3& value)     = 0;
+        virtual bool setValue(const orxonox::Vector4& value)     = 0;
+        virtual bool setValue(const orxonox::ColourValue& value) = 0;
+        virtual bool setValue(const orxonox::Quaternion& value)  = 0;
+        virtual bool setValue(const orxonox::Radian& value)      = 0;
+        virtual bool setValue(const orxonox::Degree& value)      = 0;
+        virtual bool getValue(char*                 value) const = 0;
+        virtual bool getValue(unsigned char*        value) const = 0;
+        virtual bool getValue(short*                value) const = 0;
+        virtual bool getValue(unsigned short*       value) const = 0;
+        virtual bool getValue(int*                  value) const = 0;
+        virtual bool getValue(unsigned int*         value) const = 0;
+        virtual bool getValue(long*                 value) const = 0;
+        virtual bool getValue(unsigned long*        value) const = 0;
+        virtual bool getValue(long long*            value) const = 0;
+        virtual bool getValue(unsigned long long*   value) const = 0;
+        virtual bool getValue(float*                value) const = 0;
+        virtual bool getValue(double*               value) const = 0;
+        virtual bool getValue(long double*          value) const = 0;
+        virtual bool getValue(bool*                 value) const = 0;
+        virtual bool getValue(void**                value) const = 0;
+        virtual bool getValue(std::string*          value) const = 0;
+        virtual bool getValue(orxonox::Vector2*     value) const = 0;
+        virtual bool getValue(orxonox::Vector3*     value) const = 0;
+        virtual bool getValue(orxonox::Vector4*     value) const = 0;
+        virtual bool getValue(orxonox::ColourValue* value) const = 0;
+        virtual bool getValue(orxonox::Quaternion*  value) const = 0;
+        virtual bool getValue(orxonox::Radian*      value) const = 0;
+        virtual bool getValue(orxonox::Degree*      value) const = 0;
         virtual operator char()                 const = 0;
 …
         virtual void toString(std::ostream& outstream) const = 0;
+        MT_Type type_; //!< The type of the current value
+        MT_Type type_;          //!< The type of the current value
+        bool bHasDefaultValue_; //!< True if the last conversion wasn't successful
     };
 …
         inline                       const MultiType& operator=(MT_Type type)           { this->setType(type);   return (*this); } /** @brief Resets the value and changes the type. */
         inline void                                   setValue(const char& value);
         inline void                                   setValue(const unsigned char& value);
         inline void                                   setValue(const short& value);
         inline void                                   setValue(const unsigned short& value);
         inline void                                   setValue(const int& value);
         inline void                                   setValue(const unsigned int& value);
         inline void                                   setValue(const long& value);
         inline void                                   setValue(const unsigned long& value);
         inline void                                   setValue(const long long& value);
         inline void                                   setValue(const unsigned long long& value);
         inline void                                   setValue(const float& value);
         inline void                                   setValue(const double& value);
         inline void                                   setValue(const long double& value);
         inline void                                   setValue(const bool& value);
         inline void                                   setValue(      void* const& value);
         inline void                                   setValue(const std::string& value);
         inline void                                   setValue(const orxonox::Vector2& value);
         inline void                                   setValue(const orxonox::Vector3& value);
         inline void                                   setValue(const orxonox::Vector4& value);
         inline void                                   setValue(const orxonox::ColourValue& value);
         inline void                                   setValue(const orxonox::Quaternion& value);
         inline void                                   setValue(const orxonox::Radian& value);
         inline void                                   setValue(const orxonox::Degree& value);
         inline void                                   setValue(const char* value);
+        inline bool                                   setValue(const char& value);
+        inline bool                                   setValue(const unsigned char& value);
+        inline bool                                   setValue(const short& value);
+        inline bool                                   setValue(const unsigned short& value);
+        inline bool                                   setValue(const int& value);
+        inline bool                                   setValue(const unsigned int& value);
+        inline bool                                   setValue(const long& value);
+        inline bool                                   setValue(const unsigned long& value);
+        inline bool                                   setValue(const long long& value);
+        inline bool                                   setValue(const unsigned long long& value);
+        inline bool                                   setValue(const float& value);
+        inline bool                                   setValue(const double& value);
+        inline bool                                   setValue(const long double& value);
+        inline bool                                   setValue(const bool& value);
+        inline bool                                   setValue(      void* const& value);
+        inline bool                                   setValue(const std::string& value);
+        inline bool                                   setValue(const orxonox::Vector2& value);
+        inline bool                                   setValue(const orxonox::Vector3& value);
+        inline bool                                   setValue(const orxonox::Vector4& value);
+        inline bool                                   setValue(const orxonox::ColourValue& value);
+        inline bool                                   setValue(const orxonox::Quaternion& value);
+        inline bool                                   setValue(const orxonox::Radian& value);
+        inline bool                                   setValue(const orxonox::Degree& value);
+        inline bool                                   setValue(const char* value);
         /** @brief Assigns a pointer. */
         template <typename V> inline void             setValue(V* value)               { if (this->value_) { this->value_->setValue((void*)value); } else { this->assignValue((void*)value); } }
+        template <typename V> inline bool             setValue(V* value)               { if (this->value_) { return this->value_->setValue((void*)value); } else { return this->assignValue((void*)value); } }
         /** @brief Assigns the value of the other MultiType and converts it to the current type. */
         void                                          setValue(const MultiType& other) { if (this->value_) { this->value_->assimilate(other); } else { if (other.value_) { this->value_ = other.value_->clone(); } } }
+        bool                                          setValue(const MultiType& other) { if (this->value_) { return this->value_->assimilate(other); } else { if (other.value_) { this->value_ = other.value_->clone(); } return true; } }
         /** @brief Changes the type to T and assigns the new value (which might be of another type than T - it gets converted). */
         template <typename T, typename V> inline void setValue(const V& value)         { this->setType<T>(); this->setValue(value); }
+        template <typename T, typename V> inline bool setValue(const V& value) { this->setType<T>(); return this->setValue(value); }
 …
         inline void                       copy(const MultiType& other)    { if (this == &other) { return; } if (this->value_) { delete this->value_; } this->value_ = (other.value_) ? other.value_->clone() : 0; }
         template <typename T> inline void convert()                       { this->setValue<T>((T)(*this));  } /** @brief Converts the current value to type T. */
         inline void                       convert(const MultiType& other) { this->convert(other.getType()); } /** @brief Converts the current value to the type of the other MultiType. */
         void                              convert(MT_Type type);
         /** @brief Resets the value to the defaultvalue of the current type. */
         inline void                       reset()                         { if (this->value_) { delete this->value_; this->value_ = 0; } }
+        template <typename T> inline bool convert()                       { return this->setValue<T>((T)(*this));  } /** @brief Converts the current value to type T. */
+        inline bool                       convert(const MultiType& other) { return this->convert(other.getType()); } /** @brief Converts the current value to the type of the other MultiType. */
+        bool                              convert(MT_Type type);
+        /** @brief Current content gets deleted. New type is MT_null */
+        inline void                       reset()                         { if (this->value_) this->value_->reset(); }
         template <typename T> inline void setType()                       { this->assignValue(T());                            } /** @brief Resets the value and changes the internal type to T. */
 …
         template <typename T> inline bool isType()                  const { return false; } // Only works for specialized values - see below
         std::string                       getTypename()             const;
+        /** @brief Checks whether the value is a default one. */
+        bool                              hasDefaultValue()         const { return this->value_->hasDefaultValue(); }
         operator char()                  const;
 …
         template <class T> operator T*() const { return ((T*)this->operator void*()); }
         inline void getValue(char*                 value) const { if (this->value_) { (*value) = (*this->value_); } } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
         inline void getValue(unsigned char*        value) const { if (this->value_) { (*value) = (*this->value_); } } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
         inline void getValue(short*                value) const { if (this->value_) { (*value) = (*this->value_); } } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
         inline void getValue(unsigned short*       value) const { if (this->value_) { (*value) = (*this->value_); } } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
         inline void getValue(int*                  value) const { if (this->value_) { (*value) = (*this->value_); } } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
         inline void getValue(unsigned int*         value) const { if (this->value_) { (*value) = (*this->value_); } } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
         inline void getValue(long*                 value) const { if (this->value_) { (*value) = (*this->value_); } } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
         inline void getValue(unsigned long*        value) const { if (this->value_) { (*value) = (*this->value_); } } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
         inline void getValue(long long*            value) const { if (this->value_) { (*value) = (*this->value_); } } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
         inline void getValue(unsigned long long*   value) const { if (this->value_) { (*value) = (*this->value_); } } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
         inline void getValue(float*                value) const { if (this->value_) { (*value) = (*this->value_); } } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
         inline void getValue(double*               value) const { if (this->value_) { (*value) = (*this->value_); } } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
         inline void getValue(long double*          value) const { if (this->value_) { (*value) = (*this->value_); } } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
         inline void getValue(bool*                 value) const { if (this->value_) { (*value) = (*this->value_); } } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
         inline void getValue(void*                 value) const { if (this->value_) {   value  = (*this->value_); } } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
         inline void getValue(std::string*          value) const { if (this->value_) { (*value) = this->value_->operator std::string();          } } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
         inline void getValue(orxonox::Vector2*     value) const { if (this->value_) { (*value) = this->value_->operator orxonox::Vector2();     } } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
         inline void getValue(orxonox::Vector3*     value) const { if (this->value_) { (*value) = this->value_->operator orxonox::Vector3();     } } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
         inline void getValue(orxonox::Vector4*     value) const { if (this->value_) { (*value) = this->value_->operator orxonox::Vector4();     } } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
         inline void getValue(orxonox::ColourValue* value) const { if (this->value_) { (*value) = this->value_->operator orxonox::ColourValue(); } } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
         inline void getValue(orxonox::Quaternion*  value) const { if (this->value_) { (*value) = this->value_->operator orxonox::Quaternion();  } } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
         inline void getValue(orxonox::Radian*      value) const { if (this->value_) { (*value) = this->value_->operator orxonox::Radian();      } } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
         inline void getValue(orxonox::Degree*      value) const { if (this->value_) { (*value) = this->value_->operator orxonox::Degree();      } } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
+        inline bool getValue(char*                 value) const { if (this->value_) { return this->value_->getValue(value); } return false; } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
+        inline bool getValue(unsigned char*        value) const { if (this->value_) { return this->value_->getValue(value); } return false; } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
+        inline bool getValue(short*                value) const { if (this->value_) { return this->value_->getValue(value); } return false; } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
+        inline bool getValue(unsigned short*       value) const { if (this->value_) { return this->value_->getValue(value); } return false; } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
+        inline bool getValue(int*                  value) const { if (this->value_) { return this->value_->getValue(value); } return false; } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
+        inline bool getValue(unsigned int*         value) const { if (this->value_) { return this->value_->getValue(value); } return false; } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
+        inline bool getValue(long*                 value) const { if (this->value_) { return this->value_->getValue(value); } return false; } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
+        inline bool getValue(unsigned long*        value) const { if (this->value_) { return this->value_->getValue(value); } return false; } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
+        inline bool getValue(long long*            value) const { if (this->value_) { return this->value_->getValue(value); } return false; } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
+        inline bool getValue(unsigned long long*   value) const { if (this->value_) { return this->value_->getValue(value); } return false; } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
+        inline bool getValue(float*                value) const { if (this->value_) { return this->value_->getValue(value); } return false; } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
+        inline bool getValue(double*               value) const { if (this->value_) { return this->value_->getValue(value); } return false; } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
+        inline bool getValue(long double*          value) const { if (this->value_) { return this->value_->getValue(value); } return false; } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
+        inline bool getValue(bool*                 value) const { if (this->value_) { return this->value_->getValue(value); } return false; } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
+        inline bool getValue(void**                value) const { if (this->value_) { return this->value_->getValue(value); } return false; } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
+        inline bool getValue(std::string*          value) const { if (this->value_) { return this->value_->getValue(value); } return false; } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
+        inline bool getValue(orxonox::Vector2*     value) const { if (this->value_) { return this->value_->getValue(value); } return false; } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
+        inline bool getValue(orxonox::Vector3*     value) const { if (this->value_) { return this->value_->getValue(value); } return false; } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
+        inline bool getValue(orxonox::Vector4*     value) const { if (this->value_) { return this->value_->getValue(value); } return false; } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
+        inline bool getValue(orxonox::ColourValue* value) const { if (this->value_) { return this->value_->getValue(value); } return false; } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
+        inline bool getValue(orxonox::Quaternion*  value) const { if (this->value_) { return this->value_->getValue(value); } return false; } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
+        inline bool getValue(orxonox::Radian*      value) const { if (this->value_) { return this->value_->getValue(value); } return false; } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
+        inline bool getValue(orxonox::Degree*      value) const { if (this->value_) { return this->value_->getValue(value); } return false; } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
         inline char                     getChar()             const { return this->operator char();                 } /** @brief Returns the current value, converted to the requested type. */
 …
     private:
         inline void assignValue(const char& value)                 { if (this->value_ && this->value_->type_ == MT_char)        { this->value_->setValue(value); } else { this->changeValueContainer<char>(value);                 } } /** @brief Assigns a new value by changing type and creating a new container. */
         inline void assignValue(const unsigned char& value)        { if (this->value_ && this->value_->type_ == MT_uchar)       { this->value_->setValue(value); } else { this->changeValueContainer<unsigned char>(value);        } } /** @brief Assigns a new value by changing type and creating a new container. */
         inline void assignValue(const short& value)                { if (this->value_ && this->value_->type_ == MT_short)       { this->value_->setValue(value); } else { this->changeValueContainer<short>(value);                } } /** @brief Assigns a new value by changing type and creating a new container. */
         inline void assignValue(const unsigned short& value)       { if (this->value_ && this->value_->type_ == MT_ushort)      { this->value_->setValue(value); } else { this->changeValueContainer<unsigned short>(value);       } } /** @brief Assigns a new value by changing type and creating a new container. */
         inline void assignValue(const int& value)                  { if (this->value_ && this->value_->type_ == MT_int)         { this->value_->setValue(value); } else { this->changeValueContainer<int>(value);                  } } /** @brief Assigns a new value by changing type and creating a new container. */
         inline void assignValue(const unsigned int& value)         { if (this->value_ && this->value_->type_ == MT_uint)        { this->value_->setValue(value); } else { this->changeValueContainer<unsigned int>(value);         } } /** @brief Assigns a new value by changing type and creating a new container. */
         inline void assignValue(const long& value)                 { if (this->value_ && this->value_->type_ == MT_long)        { this->value_->setValue(value); } else { this->changeValueContainer<long>(value);                 } } /** @brief Assigns a new value by changing type and creating a new container. */
         inline void assignValue(const unsigned long& value)        { if (this->value_ && this->value_->type_ == MT_ulong)       { this->value_->setValue(value); } else { this->changeValueContainer<unsigned long>(value);        } } /** @brief Assigns a new value by changing type and creating a new container. */
         inline void assignValue(const long long& value)            { if (this->value_ && this->value_->type_ == MT_longlong)    { this->value_->setValue(value); } else { this->changeValueContainer<long long>(value);            } } /** @brief Assigns a new value by changing type and creating a new container. */
         inline void assignValue(const unsigned long long& value)   { if (this->value_ && this->value_->type_ == MT_ulonglong)   { this->value_->setValue(value); } else { this->changeValueContainer<unsigned long long>(value);   } } /** @brief Assigns a new value by changing type and creating a new container. */
         inline void assignValue(const float& value)                { if (this->value_ && this->value_->type_ == MT_float)       { this->value_->setValue(value); } else { this->changeValueContainer<float>(value);                } } /** @brief Assigns a new value by changing type and creating a new container. */
         inline void assignValue(const double& value)               { if (this->value_ && this->value_->type_ == MT_double)      { this->value_->setValue(value); } else { this->changeValueContainer<double>(value);               } } /** @brief Assigns a new value by changing type and creating a new container. */
         inline void assignValue(const long double& value)          { if (this->value_ && this->value_->type_ == MT_longdouble)  { this->value_->setValue(value); } else { this->changeValueContainer<long double>(value);          } } /** @brief Assigns a new value by changing type and creating a new container. */
         inline void assignValue(const bool& value)                 { if (this->value_ && this->value_->type_ == MT_bool)        { this->value_->setValue(value); } else { this->changeValueContainer<bool>(value);                 } } /** @brief Assigns a new value by changing type and creating a new container. */
         inline void assignValue(      void* const& value)          { if (this->value_ && this->value_->type_ == MT_void)        { this->value_->setValue(value); } else { this->changeValueContainer<void*>(value);                } } /** @brief Assigns a new value by changing type and creating a new container. */
         inline void assignValue(const std::string& value)          { if (this->value_ && this->value_->type_ == MT_string)      { this->value_->setValue(value); } else { this->changeValueContainer<std::string>(value);          } } /** @brief Assigns a new value by changing type and creating a new container. */
         inline void assignValue(const orxonox::Vector2& value)     { if (this->value_ && this->value_->type_ == MT_vector2)     { this->value_->setValue(value); } else { this->changeValueContainer<orxonox::Vector2>(value);     } } /** @brief Assigns a new value by changing type and creating a new container. */
         inline void assignValue(const orxonox::Vector3& value)     { if (this->value_ && this->value_->type_ == MT_vector3)     { this->value_->setValue(value); } else { this->changeValueContainer<orxonox::Vector3>(value);     } } /** @brief Assigns a new value by changing type and creating a new container. */
         inline void assignValue(const orxonox::Vector4& value)     { if (this->value_ && this->value_->type_ == MT_vector4)     { this->value_->setValue(value); } else { this->changeValueContainer<orxonox::Vector4>(value);     } } /** @brief Assigns a new value by changing type and creating a new container. */
         inline void assignValue(const orxonox::ColourValue& value) { if (this->value_ && this->value_->type_ == MT_colourvalue) { this->value_->setValue(value); } else { this->changeValueContainer<orxonox::ColourValue>(value); } } /** @brief Assigns a new value by changing type and creating a new container. */
         inline void assignValue(const orxonox::Quaternion& value)  { if (this->value_ && this->value_->type_ == MT_quaternion)  { this->value_->setValue(value); } else { this->changeValueContainer<orxonox::Quaternion>(value);  } } /** @brief Assigns a new value by changing type and creating a new container. */
         inline void assignValue(const orxonox::Radian& value)      { if (this->value_ && this->value_->type_ == MT_radian)      { this->value_->setValue(value); } else { this->changeValueContainer<orxonox::Radian>(value);      } } /** @brief Assigns a new value by changing type and creating a new container. */
         inline void assignValue(const orxonox::Degree& value)      { if (this->value_ && this->value_->type_ == MT_degree)      { this->value_->setValue(value); } else { this->changeValueContainer<orxonox::Degree>(value);      } } /** @brief Assigns a new value by changing type and creating a new container. */
+        inline bool assignValue(const char& value)                 { if (this->value_ && this->value_->type_ == MT_char)        { return this->value_->setValue(value); } else { this->changeValueContainer<char>(value);                 return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
+        inline bool assignValue(const unsigned char& value)        { if (this->value_ && this->value_->type_ == MT_uchar)       { return this->value_->setValue(value); } else { this->changeValueContainer<unsigned char>(value);        return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
+        inline bool assignValue(const short& value)                { if (this->value_ && this->value_->type_ == MT_short)       { return this->value_->setValue(value); } else { this->changeValueContainer<short>(value);                return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
+        inline bool assignValue(const unsigned short& value)       { if (this->value_ && this->value_->type_ == MT_ushort)      { return this->value_->setValue(value); } else { this->changeValueContainer<unsigned short>(value);       return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
+        inline bool assignValue(const int& value)                  { if (this->value_ && this->value_->type_ == MT_int)         { return this->value_->setValue(value); } else { this->changeValueContainer<int>(value);                  return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
+        inline bool assignValue(const unsigned int& value)         { if (this->value_ && this->value_->type_ == MT_uint)        { return this->value_->setValue(value); } else { this->changeValueContainer<unsigned int>(value);         return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
+        inline bool assignValue(const long& value)                 { if (this->value_ && this->value_->type_ == MT_long)        { return this->value_->setValue(value); } else { this->changeValueContainer<long>(value);                 return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
+        inline bool assignValue(const unsigned long& value)        { if (this->value_ && this->value_->type_ == MT_ulong)       { return this->value_->setValue(value); } else { this->changeValueContainer<unsigned long>(value);        return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
+        inline bool assignValue(const long long& value)            { if (this->value_ && this->value_->type_ == MT_longlong)    { return this->value_->setValue(value); } else { this->changeValueContainer<long long>(value);            return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
+        inline bool assignValue(const unsigned long long& value)   { if (this->value_ && this->value_->type_ == MT_ulonglong)   { return this->value_->setValue(value); } else { this->changeValueContainer<unsigned long long>(value);   return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
+        inline bool assignValue(const float& value)                { if (this->value_ && this->value_->type_ == MT_float)       { return this->value_->setValue(value); } else { this->changeValueContainer<float>(value);                return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
+        inline bool assignValue(const double& value)               { if (this->value_ && this->value_->type_ == MT_double)      { return this->value_->setValue(value); } else { this->changeValueContainer<double>(value);               return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
+        inline bool assignValue(const long double& value)          { if (this->value_ && this->value_->type_ == MT_longdouble)  { return this->value_->setValue(value); } else { this->changeValueContainer<long double>(value);          return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
+        inline bool assignValue(const bool& value)                 { if (this->value_ && this->value_->type_ == MT_bool)        { return this->value_->setValue(value); } else { this->changeValueContainer<bool>(value);                 return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
+        inline bool assignValue(      void* const& value)          { if (this->value_ && this->value_->type_ == MT_void)        { return this->value_->setValue(value); } else { this->changeValueContainer<void*>(value);                return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
+        inline bool assignValue(const std::string& value)          { if (this->value_ && this->value_->type_ == MT_string)      { return this->value_->setValue(value); } else { this->changeValueContainer<std::string>(value);          return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
+        inline bool assignValue(const orxonox::Vector2& value)     { if (this->value_ && this->value_->type_ == MT_vector2)     { return this->value_->setValue(value); } else { this->changeValueContainer<orxonox::Vector2>(value);     return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
+        inline bool assignValue(const orxonox::Vector3& value)     { if (this->value_ && this->value_->type_ == MT_vector3)     { return this->value_->setValue(value); } else { this->changeValueContainer<orxonox::Vector3>(value);     return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
+        inline bool assignValue(const orxonox::Vector4& value)     { if (this->value_ && this->value_->type_ == MT_vector4)     { return this->value_->setValue(value); } else { this->changeValueContainer<orxonox::Vector4>(value);     return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
+        inline bool assignValue(const orxonox::ColourValue& value) { if (this->value_ && this->value_->type_ == MT_colourvalue) { return this->value_->setValue(value); } else { this->changeValueContainer<orxonox::ColourValue>(value); return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
+        inline bool assignValue(const orxonox::Quaternion& value)  { if (this->value_ && this->value_->type_ == MT_quaternion)  { return this->value_->setValue(value); } else { this->changeValueContainer<orxonox::Quaternion>(value);  return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
+        inline bool assignValue(const orxonox::Radian& value)      { if (this->value_ && this->value_->type_ == MT_radian)      { return this->value_->setValue(value); } else { this->changeValueContainer<orxonox::Radian>(value);      return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
+        inline bool assignValue(const orxonox::Degree& value)      { if (this->value_ && this->value_->type_ == MT_degree)      { return this->value_->setValue(value); } else { this->changeValueContainer<orxonox::Degree>(value);      return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
         /** @brief Changes the value container. */
         template <typename T> inline void changeValueContainer(const T& value) { if (this->value_) { delete this->value_; } this->createNewValueContainer<T>(value); }
         /** @brief Creates a new value container (works only with specialized types). */
         template <typename T>        void createNewValueContainer(const T& value) { BOOST_STATIC_ASSERT(sizeof(T) == 0); }
+        template <typename T>        void createNewValueContainer(const T& value) { BOOST_STATIC_ASSERT(sizeof(T) == 0); return false; }
         MT_ValueBase* value_; //!< A pointer to the value container
 …
 // Specialization to avoid ambiguities with the conversion operator
 template <> inline void MultiType::convert<std::string>()          { this->setValue<std::string>         (this->operator std::string());          } /** @brief Converts the current value to the given type. */
 template <> inline void MultiType::convert<orxonox::Vector2>()     { this->setValue<orxonox::Vector2>    (this->operator orxonox::Vector2());     } /** @brief Converts the current value to the given type. */
 template <> inline void MultiType::convert<orxonox::Vector3>()     { this->setValue<orxonox::Vector3>    (this->operator orxonox::Vector3());     } /** @brief Converts the current value to the given type. */
 template <> inline void MultiType::convert<orxonox::Vector4>()     { this->setValue<orxonox::Vector4>    (this->operator orxonox::Vector4());     } /** @brief Converts the current value to the given type. */
 template <> inline void MultiType::convert<orxonox::ColourValue>() { this->setValue<orxonox::ColourValue>(this->operator orxonox::ColourValue()); } /** @brief Converts the current value to the given type. */
 template <> inline void MultiType::convert<orxonox::Quaternion>()  { this->setValue<orxonox::Quaternion> (this->operator orxonox::Quaternion());  } /** @brief Converts the current value to the given type. */
 template <> inline void MultiType::convert<orxonox::Radian>()      { this->setValue<orxonox::Radian>     (this->operator orxonox::Radian());      } /** @brief Converts the current value to the given type. */
 template <> inline void MultiType::convert<orxonox::Degree>()      { this->setValue<orxonox::Degree>     (this->operator orxonox::Degree());      } /** @brief Converts the current value to the given type. */
+template <> inline bool MultiType::convert<std::string>()          { return this->setValue<std::string>         (this->operator std::string());          } /** @brief Converts the current value to the given type. */
+template <> inline bool MultiType::convert<orxonox::Vector2>()     { return this->setValue<orxonox::Vector2>    (this->operator orxonox::Vector2());     } /** @brief Converts the current value to the given type. */
+template <> inline bool MultiType::convert<orxonox::Vector3>()     { return this->setValue<orxonox::Vector3>    (this->operator orxonox::Vector3());     } /** @brief Converts the current value to the given type. */
+template <> inline bool MultiType::convert<orxonox::Vector4>()     { return this->setValue<orxonox::Vector4>    (this->operator orxonox::Vector4());     } /** @brief Converts the current value to the given type. */
+template <> inline bool MultiType::convert<orxonox::ColourValue>() { return this->setValue<orxonox::ColourValue>(this->operator orxonox::ColourValue()); } /** @brief Converts the current value to the given type. */
+template <> inline bool MultiType::convert<orxonox::Quaternion>()  { return this->setValue<orxonox::Quaternion> (this->operator orxonox::Quaternion());  } /** @brief Converts the current value to the given type. */
+template <> inline bool MultiType::convert<orxonox::Radian>()      { return this->setValue<orxonox::Radian>     (this->operator orxonox::Radian());      } /** @brief Converts the current value to the given type. */
+template <> inline bool MultiType::convert<orxonox::Degree>()      { return this->setValue<orxonox::Degree>     (this->operator orxonox::Degree());      } /** @brief Converts the current value to the given type. */
 // Specialization to avoid ambiguities with the conversion operator
 template <> inline void MultiType::convert<const std::string&>()          { this->convert<std::string>();          } /** @brief Converts the current value to the given type. */
 template <> inline void MultiType::convert<const orxonox::Vector2&>()     { this->convert<orxonox::Vector2>();     } /** @brief Converts the current value to the given type. */
 template <> inline void MultiType::convert<const orxonox::Vector3&>()     { this->convert<orxonox::Vector3>();     } /** @brief Converts the current value to the given type. */
 template <> inline void MultiType::convert<const orxonox::Vector4&>()     { this->convert<orxonox::Vector4>();     } /** @brief Converts the current value to the given type. */
 template <> inline void MultiType::convert<const orxonox::ColourValue&>() { this->convert<orxonox::ColourValue>(); } /** @brief Converts the current value to the given type. */
 template <> inline void MultiType::convert<const orxonox::Quaternion&>()  { this->convert<orxonox::Quaternion>();  } /** @brief Converts the current value to the given type. */
 template <> inline void MultiType::convert<const orxonox::Radian&>()      { this->convert<orxonox::Radian>();      } /** @brief Converts the current value to the given type. */
 template <> inline void MultiType::convert<const orxonox::Degree&>()      { this->convert<orxonox::Degree>();      } /** @brief Converts the current value to the given type. */
+template <> inline bool MultiType::convert<const std::string&>()          { return this->convert<std::string>();          } /** @brief Converts the current value to the given type. */
+template <> inline bool MultiType::convert<const orxonox::Vector2&>()     { return this->convert<orxonox::Vector2>();     } /** @brief Converts the current value to the given type. */
+template <> inline bool MultiType::convert<const orxonox::Vector3&>()     { return this->convert<orxonox::Vector3>();     } /** @brief Converts the current value to the given type. */
+template <> inline bool MultiType::convert<const orxonox::Vector4&>()     { return this->convert<orxonox::Vector4>();     } /** @brief Converts the current value to the given type. */
+template <> inline bool MultiType::convert<const orxonox::ColourValue&>() { return this->convert<orxonox::ColourValue>(); } /** @brief Converts the current value to the given type. */
+template <> inline bool MultiType::convert<const orxonox::Quaternion&>()  { return this->convert<orxonox::Quaternion>();  } /** @brief Converts the current value to the given type. */
+template <> inline bool MultiType::convert<const orxonox::Radian&>()      { return this->convert<orxonox::Radian>();      } /** @brief Converts the current value to the given type. */
+template <> inline bool MultiType::convert<const orxonox::Degree&>()      { return this->convert<orxonox::Degree>();      } /** @brief Converts the current value to the given type. */
 template <> void MultiType::createNewValueContainer(const char& value);
 …
 template <> void MultiType::createNewValueContainer(const orxonox::Degree& value);
 inline void MultiType::setValue(const char& value)                  { if (this->value_) { this->value_->setValue(value); } else { this->assignValue(value); } } /** @brief Assigns the given value and converts it to the current type. */
 inline void MultiType::setValue(const unsigned char& value)         { if (this->value_) { this->value_->setValue(value); } else { this->assignValue(value); } } /** @brief Assigns the given value and converts it to the current type. */
 inline void MultiType::setValue(const short& value)                 { if (this->value_) { this->value_->setValue(value); } else { this->assignValue(value); } } /** @brief Assigns the given value and converts it to the current type. */
 inline void MultiType::setValue(const unsigned short& value)        { if (this->value_) { this->value_->setValue(value); } else { this->assignValue(value); } } /** @brief Assigns the given value and converts it to the current type. */
 inline void MultiType::setValue(const int& value)                   { if (this->value_) { this->value_->setValue(value); } else { this->assignValue(value); } } /** @brief Assigns the given value and converts it to the current type. */
 inline void MultiType::setValue(const unsigned int& value)          { if (this->value_) { this->value_->setValue(value); } else { this->assignValue(value); } } /** @brief Assigns the given value and converts it to the current type. */
 inline void MultiType::setValue(const long& value)                  { if (this->value_) { this->value_->setValue(value); } else { this->assignValue(value); } } /** @brief Assigns the given value and converts it to the current type. */
 inline void MultiType::setValue(const unsigned long& value)         { if (this->value_) { this->value_->setValue(value); } else { this->assignValue(value); } } /** @brief Assigns the given value and converts it to the current type. */
 inline void MultiType::setValue(const long long& value)             { if (this->value_) { this->value_->setValue(value); } else { this->assignValue(value); } } /** @brief Assigns the given value and converts it to the current type. */
 inline void MultiType::setValue(const unsigned long long& value)    { if (this->value_) { this->value_->setValue(value); } else { this->assignValue(value); } } /** @brief Assigns the given value and converts it to the current type. */
 inline void MultiType::setValue(const float& value)                 { if (this->value_) { this->value_->setValue(value); } else { this->assignValue(value); } } /** @brief Assigns the given value and converts it to the current type. */
 inline void MultiType::setValue(const double& value)                { if (this->value_) { this->value_->setValue(value); } else { this->assignValue(value); } } /** @brief Assigns the given value and converts it to the current type. */
 inline void MultiType::setValue(const long double& value)           { if (this->value_) { this->value_->setValue(value); } else { this->assignValue(value); } } /** @brief Assigns the given value and converts it to the current type. */
 inline void MultiType::setValue(const bool& value)                  { if (this->value_) { this->value_->setValue(value); } else { this->assignValue(value); } } /** @brief Assigns the given value and converts it to the current type. */
 inline void MultiType::setValue(      void* const& value)           { if (this->value_) { this->value_->setValue(value); } else { this->assignValue(value); } } /** @brief Assigns the given value and converts it to the current type. */
 inline void MultiType::setValue(const std::string& value)           { if (this->value_) { this->value_->setValue(value); } else { this->assignValue(value); } } /** @brief Assigns the given value and converts it to the current type. */
 inline void MultiType::setValue(const orxonox::Vector2& value)      { if (this->value_) { this->value_->setValue(value); } else { this->assignValue(value); } } /** @brief Assigns the given value and converts it to the current type. */
 inline void MultiType::setValue(const orxonox::Vector3& value)      { if (this->value_) { this->value_->setValue(value); } else { this->assignValue(value); } } /** @brief Assigns the given value and converts it to the current type. */
 inline void MultiType::setValue(const orxonox::Vector4& value)      { if (this->value_) { this->value_->setValue(value); } else { this->assignValue(value); } } /** @brief Assigns the given value and converts it to the current type. */
 inline void MultiType::setValue(const orxonox::ColourValue& value)  { if (this->value_) { this->value_->setValue(value); } else { this->assignValue(value); } } /** @brief Assigns the given value and converts it to the current type. */
 inline void MultiType::setValue(const orxonox::Quaternion& value)   { if (this->value_) { this->value_->setValue(value); } else { this->assignValue(value); } } /** @brief Assigns the given value and converts it to the current type. */
 inline void MultiType::setValue(const orxonox::Radian& value)       { if (this->value_) { this->value_->setValue(value); } else { this->assignValue(value); } } /** @brief Assigns the given value and converts it to the current type. */
 inline void MultiType::setValue(const orxonox::Degree& value)       { if (this->value_) { this->value_->setValue(value); } else { this->assignValue(value); } } /** @brief Assigns the given value and converts it to the current type. */
 inline void MultiType::setValue(const char* value)                  { if (this->value_) { this->value_->setValue(std::string(value)); } else { this->assignValue(std::string(value)); } }  /** @brief Assigns the given value and converts it to the current type. */
+inline bool MultiType::setValue(const char& value)                  { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } /** @brief Assigns the given value and converts it to the current type. */
+inline bool MultiType::setValue(const unsigned char& value)         { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } /** @brief Assigns the given value and converts it to the current type. */
+inline bool MultiType::setValue(const short& value)                 { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } /** @brief Assigns the given value and converts it to the current type. */
+inline bool MultiType::setValue(const unsigned short& value)        { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } /** @brief Assigns the given value and converts it to the current type. */
+inline bool MultiType::setValue(const int& value)                   { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } /** @brief Assigns the given value and converts it to the current type. */
+inline bool MultiType::setValue(const unsigned int& value)          { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } /** @brief Assigns the given value and converts it to the current type. */
+inline bool MultiType::setValue(const long& value)                  { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } /** @brief Assigns the given value and converts it to the current type. */
+inline bool MultiType::setValue(const unsigned long& value)         { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } /** @brief Assigns the given value and converts it to the current type. */
+inline bool MultiType::setValue(const long long& value)             { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } /** @brief Assigns the given value and converts it to the current type. */
+inline bool MultiType::setValue(const unsigned long long& value)    { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } /** @brief Assigns the given value and converts it to the current type. */
+inline bool MultiType::setValue(const float& value)                 { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } /** @brief Assigns the given value and converts it to the current type. */
+inline bool MultiType::setValue(const double& value)                { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } /** @brief Assigns the given value and converts it to the current type. */
+inline bool MultiType::setValue(const long double& value)           { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } /** @brief Assigns the given value and converts it to the current type. */
+inline bool MultiType::setValue(const bool& value)                  { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } /** @brief Assigns the given value and converts it to the current type. */
+inline bool MultiType::setValue(      void* const& value)           { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } /** @brief Assigns the given value and converts it to the current type. */
+inline bool MultiType::setValue(const std::string& value)           { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } /** @brief Assigns the given value and converts it to the current type. */
+inline bool MultiType::setValue(const orxonox::Vector2& value)      { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } /** @brief Assigns the given value and converts it to the current type. */
+inline bool MultiType::setValue(const orxonox::Vector3& value)      { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } /** @brief Assigns the given value and converts it to the current type. */
+inline bool MultiType::setValue(const orxonox::Vector4& value)      { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } /** @brief Assigns the given value and converts it to the current type. */
+inline bool MultiType::setValue(const orxonox::ColourValue& value)  { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } /** @brief Assigns the given value and converts it to the current type. */
+inline bool MultiType::setValue(const orxonox::Quaternion& value)   { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } /** @brief Assigns the given value and converts it to the current type. */
+inline bool MultiType::setValue(const orxonox::Radian& value)       { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } /** @brief Assigns the given value and converts it to the current type. */
+inline bool MultiType::setValue(const orxonox::Degree& value)       { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } /** @brief Assigns the given value and converts it to the current type. */
+inline bool MultiType::setValue(const char* value)                  { if (this->value_) { return this->value_->setValue(std::string(value)); } else { return this->assignValue(std::string(value)); } }  /** @brief Assigns the given value and converts it to the current type. */
 #endif /* _MultiType_H__ */

code/trunk/src/util/MultiTypeValue.h

-                      r1854
+                      r2087
 #include "UtilPrereqs.h"
 #include "Convert.h"
+#include "MathConvert.h"
 #include "MultiType.h"
 …
     /** @brief Resets the current value to the default. */
     inline void reset() { this->value_ = T(); }
+    inline void reset() { this->value_ = zeroise<T>(); bHasDefaultValue_ = true; }
     /** @brief Assigns the value of the other MultiType, converted to T. @param other The other MultiType */
+    inline void assimilate(const MultiType& other) { if (other.value_) { T temp; other.getValue(&temp); this->value_ = temp; } else { this->value_ = T(); } }
+    inline bool assimilate(const MultiType& other)
+    {
+        if (other.value_)
+        {
+            return !(bHasDefaultValue_ = !other.value_->getValue(&value_));
+        }
+        else
+        {
+            this->value_ = zeroise<T>();
+            return !(bHasDefaultValue_ = true);
+        }
+    }
+    inline void setValue(const char& value)                 { this->value_ = getConvertedValue<char,                 T>(value); } /** @brief Assigns the value by converting it to T. */
+    inline void setValue(const unsigned char& value)        { this->value_ = getConvertedValue<unsigned char,        T>(value); } /** @brief Assigns the value by converting it to T. */
+    inline void setValue(const short& value)                { this->value_ = getConvertedValue<short,                T>(value); } /** @brief Assigns the value by converting it to T. */
+    inline void setValue(const unsigned short& value)       { this->value_ = getConvertedValue<unsigned short,       T>(value); } /** @brief Assigns the value by converting it to T. */
+    inline void setValue(const int& value)                  { this->value_ = getConvertedValue<int,                  T>(value); } /** @brief Assigns the value by converting it to T. */
+    inline void setValue(const unsigned int& value)         { this->value_ = getConvertedValue<unsigned int,         T>(value); } /** @brief Assigns the value by converting it to T. */
+    inline void setValue(const long& value)                 { this->value_ = getConvertedValue<long,                 T>(value); } /** @brief Assigns the value by converting it to T. */
+    inline void setValue(const unsigned long& value)        { this->value_ = getConvertedValue<unsigned long,        T>(value); } /** @brief Assigns the value by converting it to T. */
+    inline void setValue(const long long& value)            { this->value_ = getConvertedValue<long long,            T>(value); } /** @brief Assigns the value by converting it to T. */
+    inline void setValue(const unsigned long long& value)   { this->value_ = getConvertedValue<unsigned long long,   T>(value); } /** @brief Assigns the value by converting it to T. */
+    inline void setValue(const float& value)                { this->value_ = getConvertedValue<float,                T>(value); } /** @brief Assigns the value by converting it to T. */
+    inline void setValue(const double& value)               { this->value_ = getConvertedValue<double,               T>(value); } /** @brief Assigns the value by converting it to T. */
+    inline void setValue(const long double& value)          { this->value_ = getConvertedValue<long double,          T>(value); } /** @brief Assigns the value by converting it to T. */
+    inline void setValue(const bool& value)                 { this->value_ = getConvertedValue<bool,                 T>(value); } /** @brief Assigns the value by converting it to T. */
+    inline void setValue(      void* const& value)          { this->value_ = getConvertedValue<void*,                T>(value); } /** @brief Assigns the value by converting it to T. */
+    inline void setValue(const std::string& value)          { this->value_ = getConvertedValue<std::string,          T>(value); } /** @brief Assigns the value by converting it to T. */
+    inline void setValue(const orxonox::Vector2& value)     { this->value_ = getConvertedValue<orxonox::Vector2,     T>(value); } /** @brief Assigns the value by converting it to T. */
+    inline void setValue(const orxonox::Vector3& value)     { this->value_ = getConvertedValue<orxonox::Vector3,     T>(value); } /** @brief Assigns the value by converting it to T. */
+    inline void setValue(const orxonox::Vector4& value)     { this->value_ = getConvertedValue<orxonox::Vector4,     T>(value); } /** @brief Assigns the value by converting it to T. */
+    inline void setValue(const orxonox::ColourValue& value) { this->value_ = getConvertedValue<orxonox::ColourValue, T>(value); } /** @brief Assigns the value by converting it to T. */
+    inline void setValue(const orxonox::Quaternion& value)  { this->value_ = getConvertedValue<orxonox::Quaternion,  T>(value); } /** @brief Assigns the value by converting it to T. */
+    inline void setValue(const orxonox::Radian& value)      { this->value_ = getConvertedValue<orxonox::Radian,      T>(value); } /** @brief Assigns the value by converting it to T. */
+    inline void setValue(const orxonox::Degree& value)      { this->value_ = getConvertedValue<orxonox::Degree,      T>(value); } /** @brief Assigns the value by converting it to T. */
+    inline bool getValue(char*                 value) const { return ConvertValue<T, char                >(value, value_, 0); } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
+    inline bool getValue(unsigned char*        value) const { return ConvertValue<T, unsigned char       >(value, value_, 0); } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
+    inline bool getValue(short*                value) const { return ConvertValue<T, short               >(value, value_, 0); } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
+    inline bool getValue(unsigned short*       value) const { return ConvertValue<T, unsigned short      >(value, value_, 0); } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
+    inline bool getValue(int*                  value) const { return ConvertValue<T, int                 >(value, value_, 0); } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
+    inline bool getValue(unsigned int*         value) const { return ConvertValue<T, unsigned int        >(value, value_, 0); } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
+    inline bool getValue(long*                 value) const { return ConvertValue<T, long                >(value, value_, 0); } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
+    inline bool getValue(unsigned long*        value) const { return ConvertValue<T, unsigned long       >(value, value_, 0); } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
+    inline bool getValue(long long*            value) const { return ConvertValue<T, long long           >(value, value_, 0); } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
+    inline bool getValue(unsigned long long*   value) const { return ConvertValue<T, unsigned long long  >(value, value_, 0); } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
+    inline bool getValue(float*                value) const { return ConvertValue<T, float               >(value, value_, 0); } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
+    inline bool getValue(double*               value) const { return ConvertValue<T, double              >(value, value_, 0); } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
+    inline bool getValue(long double*          value) const { return ConvertValue<T, long double         >(value, value_, 0); } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
+    inline bool getValue(bool*                 value) const { return ConvertValue<T, bool                >(value, value_, 0); } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
+    inline bool getValue(void**                value) const { return ConvertValue<T, void*               >(value, value_, 0); } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
+    inline bool getValue(std::string*          value) const { return ConvertValue<T, std::string         >(value, value_, zeroise<std::string>         ()); } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
+    inline bool getValue(orxonox::Vector2*     value) const { return ConvertValue<T, orxonox::Vector2    >(value, value_, zeroise<orxonox::Vector2>    ()); } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
+    inline bool getValue(orxonox::Vector3*     value) const { return ConvertValue<T, orxonox::Vector3    >(value, value_, zeroise<orxonox::Vector3>    ()); } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
+    inline bool getValue(orxonox::Vector4*     value) const { return ConvertValue<T, orxonox::Vector4    >(value, value_, zeroise<orxonox::Vector4>    ()); } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
+    inline bool getValue(orxonox::ColourValue* value) const { return ConvertValue<T, orxonox::ColourValue>(value, value_, zeroise<orxonox::ColourValue>()); } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
+    inline bool getValue(orxonox::Quaternion*  value) const { return ConvertValue<T, orxonox::Quaternion >(value, value_, zeroise<orxonox::Quaternion> ()); } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
+    inline bool getValue(orxonox::Radian*      value) const { return ConvertValue<T, orxonox::Radian     >(value, value_, zeroise<orxonox::Radian>     ()); } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
+    inline bool getValue(orxonox::Degree*      value) const { return ConvertValue<T, orxonox::Degree     >(value, value_, zeroise<orxonox::Degree>     ()); } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
+    inline bool setValue(const char& value)                 { return !(bHasDefaultValue_ = !ConvertValue<char                , T>(&value_, value, zeroise<T>())); } /** @brief Assigns the value by converting it to T. */
+    inline bool setValue(const unsigned char& value)        { return !(bHasDefaultValue_ = !ConvertValue<unsigned char       , T>(&value_, value, zeroise<T>())); } /** @brief Assigns the value by converting it to T. */
+    inline bool setValue(const short& value)                { return !(bHasDefaultValue_ = !ConvertValue<short               , T>(&value_, value, zeroise<T>())); } /** @brief Assigns the value by converting it to T. */
+    inline bool setValue(const unsigned short& value)       { return !(bHasDefaultValue_ = !ConvertValue<unsigned short      , T>(&value_, value, zeroise<T>())); } /** @brief Assigns the value by converting it to T. */
+    inline bool setValue(const int& value)                  { return !(bHasDefaultValue_ = !ConvertValue<int                 , T>(&value_, value, zeroise<T>())); } /** @brief Assigns the value by converting it to T. */
+    inline bool setValue(const unsigned int& value)         { return !(bHasDefaultValue_ = !ConvertValue<unsigned int        , T>(&value_, value, zeroise<T>())); } /** @brief Assigns the value by converting it to T. */
+    inline bool setValue(const long& value)                 { return !(bHasDefaultValue_ = !ConvertValue<long                , T>(&value_, value, zeroise<T>())); } /** @brief Assigns the value by converting it to T. */
+    inline bool setValue(const unsigned long& value)        { return !(bHasDefaultValue_ = !ConvertValue<unsigned long       , T>(&value_, value, zeroise<T>())); } /** @brief Assigns the value by converting it to T. */
+    inline bool setValue(const long long& value)            { return !(bHasDefaultValue_ = !ConvertValue<long long           , T>(&value_, value, zeroise<T>())); } /** @brief Assigns the value by converting it to T. */
+    inline bool setValue(const unsigned long long& value)   { return !(bHasDefaultValue_ = !ConvertValue<unsigned long long  , T>(&value_, value, zeroise<T>())); } /** @brief Assigns the value by converting it to T. */
+    inline bool setValue(const float& value)                { return !(bHasDefaultValue_ = !ConvertValue<float               , T>(&value_, value, zeroise<T>())); } /** @brief Assigns the value by converting it to T. */
+    inline bool setValue(const double& value)               { return !(bHasDefaultValue_ = !ConvertValue<double              , T>(&value_, value, zeroise<T>())); } /** @brief Assigns the value by converting it to T. */
+    inline bool setValue(const long double& value)          { return !(bHasDefaultValue_ = !ConvertValue<long double         , T>(&value_, value, zeroise<T>())); } /** @brief Assigns the value by converting it to T. */
+    inline bool setValue(const bool& value)                 { return !(bHasDefaultValue_ = !ConvertValue<bool                , T>(&value_, value, zeroise<T>())); } /** @brief Assigns the value by converting it to T. */
+    inline bool setValue(      void* const& value)          { return !(bHasDefaultValue_ = !ConvertValue<void*               , T>(&value_, value, zeroise<T>())); } /** @brief Assigns the value by converting it to T. */
+    inline bool setValue(const std::string& value)          { return !(bHasDefaultValue_ = !ConvertValue<std::string         , T>(&value_, value, zeroise<T>())); } /** @brief Assigns the value by converting it to T. */
+    inline bool setValue(const orxonox::Vector2& value)     { return !(bHasDefaultValue_ = !ConvertValue<orxonox::Vector2    , T>(&value_, value, zeroise<T>())); } /** @brief Assigns the value by converting it to T. */
+    inline bool setValue(const orxonox::Vector3& value)     { return !(bHasDefaultValue_ = !ConvertValue<orxonox::Vector3    , T>(&value_, value, zeroise<T>())); } /** @brief Assigns the value by converting it to T. */
+    inline bool setValue(const orxonox::Vector4& value)     { return !(bHasDefaultValue_ = !ConvertValue<orxonox::Vector4    , T>(&value_, value, zeroise<T>())); } /** @brief Assigns the value by converting it to T. */
+    inline bool setValue(const orxonox::ColourValue& value) { return !(bHasDefaultValue_ = !ConvertValue<orxonox::ColourValue, T>(&value_, value, zeroise<T>())); } /** @brief Assigns the value by converting it to T. */
+    inline bool setValue(const orxonox::Quaternion& value)  { return !(bHasDefaultValue_ = !ConvertValue<orxonox::Quaternion , T>(&value_, value, zeroise<T>())); } /** @brief Assigns the value by converting it to T. */
+    inline bool setValue(const orxonox::Radian& value)      { return !(bHasDefaultValue_ = !ConvertValue<orxonox::Radian     , T>(&value_, value, zeroise<T>())); } /** @brief Assigns the value by converting it to T. */
+    inline bool setValue(const orxonox::Degree& value)      { return !(bHasDefaultValue_ = !ConvertValue<orxonox::Degree     , T>(&value_, value, zeroise<T>())); } /** @brief Assigns the value by converting it to T. */
     inline operator char()                 const { return getConvertedValue<T, char>                (this->value_, 0); }     /** @brief Returns the current value, converted to the requested type. */
 …
     inline operator double()               const { return getConvertedValue<T, double>              (this->value_, 0); }     /** @brief Returns the current value, converted to the requested type. */
     inline operator long double()          const { return getConvertedValue<T, long double>         (this->value_, 0); }     /** @brief Returns the current value, converted to the requested type. */
     inline operator bool()                 const { return getConvertedValue<T, bool>                (this->value_, false); } /** @brief Returns the current value, converted to the requested type. */
+    inline operator bool()                 const { return getConvertedValue<T, bool>                (this->value_, 0); }     /** @brief Returns the current value, converted to the requested type. */
     inline operator void*()                const { return getConvertedValue<T, void*>               (this->value_, 0); }     /** @brief Returns the current value, converted to the requested type. */
     inline operator std::string()          const { return getConvertedValue<T, std::string>         (this->value_); }        /** @brief Returns the current value, converted to the requested type. */
     inline operator orxonox::Vector2()     const { return getConvertedValue<T, orxonox::Vector2>    (this->value_); }        /** @brief Returns the current value, converted to the requested type. */
     inline operator orxonox::Vector3()     const { return getConvertedValue<T, orxonox::Vector3>    (this->value_); }        /** @brief Returns the current value, converted to the requested type. */
     inline operator orxonox::Vector4()     const { return getConvertedValue<T, orxonox::Vector4>    (this->value_); }        /** @brief Returns the current value, converted to the requested type. */
     inline operator orxonox::ColourValue() const { return getConvertedValue<T, orxonox::ColourValue>(this->value_); }        /** @brief Returns the current value, converted to the requested type. */
     inline operator orxonox::Quaternion()  const { return getConvertedValue<T, orxonox::Quaternion> (this->value_); }        /** @brief Returns the current value, converted to the requested type. */
     inline operator orxonox::Radian()      const { return getConvertedValue<T, orxonox::Radian>     (this->value_); }        /** @brief Returns the current value, converted to the requested type. */
     inline operator orxonox::Degree()      const { return getConvertedValue<T, orxonox::Degree>     (this->value_); }        /** @brief Returns the current value, converted to the requested type. */
+    inline operator std::string()          const { return getConvertedValue<T, std::string>         (this->value_, zeroise<std::string         >()); } /** @brief Returns the current value, converted to the requested type. */
+    inline operator orxonox::Vector2()     const { return getConvertedValue<T, orxonox::Vector2>    (this->value_, zeroise<orxonox::Vector2    >()); } /** @brief Returns the current value, converted to the requested type. */
+    inline operator orxonox::Vector3()     const { return getConvertedValue<T, orxonox::Vector3>    (this->value_, zeroise<orxonox::Vector3    >()); } /** @brief Returns the current value, converted to the requested type. */
+    inline operator orxonox::Vector4()     const { return getConvertedValue<T, orxonox::Vector4>    (this->value_, zeroise<orxonox::Vector4    >()); } /** @brief Returns the current value, converted to the requested type. */
+    inline operator orxonox::ColourValue() const { return getConvertedValue<T, orxonox::ColourValue>(this->value_, zeroise<orxonox::ColourValue>()); } /** @brief Returns the current value, converted to the requested type. */
+    inline operator orxonox::Quaternion()  const { return getConvertedValue<T, orxonox::Quaternion> (this->value_, zeroise<orxonox::Quaternion >()); } /** @brief Returns the current value, converted to the requested type. */
+    inline operator orxonox::Radian()      const { return getConvertedValue<T, orxonox::Radian>     (this->value_, zeroise<orxonox::Radian     >()); } /** @brief Returns the current value, converted to the requested type. */
+    inline operator orxonox::Degree()      const { return getConvertedValue<T, orxonox::Degree>     (this->value_, zeroise<orxonox::Degree     >()); } /** @brief Returns the current value, converted to the requested type. */
     /** @brief Puts the current value on the stream */

code/trunk/src/util/OutputHandler.cc

-                      r1791
+                      r2087
 #include "OutputHandler.h"
+#include <time.h>
 namespace orxonox
 …
         this->logfilename_ = logfilename;
         this->logfile_.open(this->logfilename_.c_str(), std::fstream::out);
+        this->logfile_ << "Started log at yyyy/mm/dd hh:mm:ss" << std::endl; // Todo: Get date and time
+        time_t rawtime;
+        struct tm* timeinfo;
+        time(&rawtime);
+        timeinfo = localtime(&rawtime);
+        this->logfile_ << "Started log at " << asctime(timeinfo) << std::endl;
         this->logfile_.flush();
+    }

code/trunk/src/util/String.cc

-                      r1894
+                      r2087
 #include <iostream>
+/**
+    @brief Blank string as variable so you can use const std::string& even if you have to return "".
+*/
+std::string blankString = "";
+#include "Convert.h"
+#include "Math.h"
+std::string BLANKSTRING("");
+std::string getUniqueNumberString()
+{
+    return convertToString(getUniqueNumber());
+}
 /**

code/trunk/src/util/String.h

-                      r1889
+                      r2087
 #include <sstream>
+extern _UtilExport std::string blankString;
+extern _UtilExport std::string BLANKSTRING;
+_UtilExport std::string getUniqueNumberString();
 _UtilExport void        strip(std::string* str);

code/trunk/updateMedia.sh

r1506	r2087
1	1	#!/bin/bash
2	2	dir=${pwd}
3		cd ../Media
	3	cd ../media
4	4	svn up
5	5	cd $dir

code/trunk/visual_studio/vc8/audio.vcproj

Property svn:eol-style set to native

code/trunk/visual_studio/vc8/audio.vsprops

Property svn:mergeinfo changed
/code/branches/objecthierarchy/visual_studio/vc8/audio.vsprops (added) merged: 2037,2040,2085
Property svn:eol-style set to native

code/trunk/visual_studio/vc8/base.vsprops

Property svn:mergeinfo changed

/code/branches/objecthierarchy/visual_studio/vc8/base.vsprops (added)	merged: 1959,2037,2040,2085
/code/branches/script_trigger/visual_studio/vc8/base.vsprops (added)	merged: 1295-1953,1955
/code/trunk/visual_studio/vc8/base.vsprops (added)	merged: 2-1837

Property svn:eol-style set to native

code/trunk/visual_studio/vc8/ceguilua.vcproj

Property svn:eol-style set to native

code/trunk/visual_studio/vc8/ceguilua.vsprops

Property svn:mergeinfo changed
/code/branches/ceguilua/visual_studio/ceguilua_properties.vsprops reverse-merged: 1804
/code/branches/objecthierarchy/visual_studio/vc8/ceguilua.vsprops (added) merged: 2037,2040,2085
Property svn:eol-style set to native

code/trunk/visual_studio/vc8/core.vcproj

Property svn:eol-style set to native

-                      r1896
+                      r2087
                         </File>
                         <File
+                                RelativePath="..\..\src\core\Event.cc"
+                                >
+                        </File>
+                        <File
                                 RelativePath="..\..\src\core\GameState.cc"
+                                >
 …
                         </File>
                         <File
+                                RelativePath="..\..\src\core\LuaBind.cc"
+                                >
+                        </File>
+                        <File
                                 RelativePath="..\..\src\core\OrxonoxClass.cc"
+                                >
 …
                         </File>
                         <File
+                                RelativePath="..\..\src\core\Script.cc"
+                                RelativePath="..\..\src\core\Template.cc"
+                                >
+                        </File>
+                        <File
+                                RelativePath="..\..\src\core\XMLNameListener.cc"
+                                >
                         </File>
 …
                         </File>
                         <File
+                                RelativePath="..\..\src\core\Event.h"
+                                >
+                        </File>
+                        <File
+                                RelativePath="..\..\src\core\EventIncludes.h"
+                                >
+                        </File>
+                        <File
                                 RelativePath="..\..\src\core\GameState.h"
+                                >
 …
                         </File>
                         <File
+                                RelativePath="..\..\src\core\LuaBind.h"
+                                >
+                        </File>
+                        <File
                                 RelativePath="..\..\src\core\OrxonoxClass.h"
+                                >
 …
                         </File>
                         <File
-                                RelativePath="..\..\src\core\Script.h"
+                                >
-                        </File>
-                        <File
                                 RelativePath="..\..\src\core\Super.h"
+                                >
                         </File>
                         <File
+                                RelativePath="..\..\src\core\Template.h"
+                                >
+                        </File>
+                        <File
                                 RelativePath="..\..\src\core\XMLIncludes.h"
+                                >
                         </File>
+                        <File
+                                RelativePath="..\..\src\core\XMLNameListener.h"
+                                >
+                        </File>
                         <Filter
                                 Name="input"
 …
                                 </File>
                                 <File
-                                        RelativePath="..\..\src\core\Level.h"
+                                        >
-                                </File>
-                                <File
                                         RelativePath="..\..\src\core\Loader.h"
+                                        >
 …
                                 <File
                                         RelativePath="..\..\src\core\NamespaceNode.h"
+                                        >
+                                </File>
+                                <File
+                                        RelativePath="..\..\src\core\XMLFile.h"
+                                        >
                                 </File>

code/trunk/visual_studio/vc8/core.vsprops

Property svn:mergeinfo changed
/code/branches/objecthierarchy/visual_studio/vc8/core.vsprops (added) merged: 2037,2040,2085
Property svn:eol-style set to native

code/trunk/visual_studio/vc8/cpptcl.vcproj

Property svn:eol-style set to native

code/trunk/visual_studio/vc8/cpptcl.vsprops

Property svn:mergeinfo changed
/code/branches/objecthierarchy/visual_studio/vc8/cpptcl.vsprops (added) merged: 2037,2040,2085
Property svn:eol-style set to native

code/trunk/visual_studio/vc8/debug.vsprops

Property svn:mergeinfo changed
/code/branches/objecthierarchy/visual_studio/vc8/debug.vsprops (added) merged: 2037,2040,2085
Property svn:eol-style set to native

code/trunk/visual_studio/vc8/directories.vsprops

Property svn:mergeinfo changed
/code/branches/objecthierarchy/visual_studio/vc8/directories.vsprops (added) merged: 2017-2018,2037,2040,2085
Property svn:eol-style set to native

code/trunk/visual_studio/vc8/lua.vcproj

Property svn:eol-style set to native

code/trunk/visual_studio/vc8/lua.vsprops

Property svn:mergeinfo changed
/code/branches/ceguilua/visual_studio/lua_properties.vsprops reverse-merged: 1804
/code/branches/objecthierarchy/visual_studio/vc8/lua.vsprops (added) merged: 2037,2040,2085
Property svn:eol-style set to native

code/trunk/visual_studio/vc8/lua_static.vcproj

Property svn:eol-style set to native

code/trunk/visual_studio/vc8/lua_static.vsprops

Property svn:eol-style set to native

code/trunk/visual_studio/vc8/network.vcproj

Property svn:eol-style set to native

-                      r1909
+                      r2087
                 <Configuration
                         Name="Debug|Win32"
                         ConfigurationType="4"
+                        ConfigurationType="2"
                         InheritedPropertySheets=".\debug.vsprops;.\network.vsprops"
                         CharacterSet="1"
 …
                         />
                         <Tool
                                 Name="VCLibrarianTool"
+                                Name="VCLinkerTool"
                         />
                         <Tool
 …
                         />
                         <Tool
+                                Name="VCManifestTool"
+                        />
+                        <Tool
                                 Name="VCXDCMakeTool"
                         />
 …
                         <Tool
                                 Name="VCFxCopTool"
+                        />
+                        <Tool
+                                Name="VCAppVerifierTool"
+                        />
+                        <Tool
+                                Name="VCWebDeploymentTool"
                         />
                         <Tool
 …
                 <Configuration
                         Name="Release|Win32"
                         ConfigurationType="4"
+                        ConfigurationType="2"
                         InheritedPropertySheets=".\release.vsprops;.\network.vsprops"
                         CharacterSet="1"
 …
                         />
                         <Tool
                                 Name="VCLibrarianTool"
+                                Name="VCLinkerTool"
                         />
                         <Tool
 …
                         />
                         <Tool
+                                Name="VCManifestTool"
+                        />
+                        <Tool
                                 Name="VCXDCMakeTool"
                         />
 …
                         <Tool
                                 Name="VCFxCopTool"
+                        />
+                        <Tool
+                                Name="VCAppVerifierTool"
+                        />
+                        <Tool
+                                Name="VCWebDeploymentTool"
                         />
                         <Tool
 …
+                        >
                         <File
+                                RelativePath="..\..\src\network\ChatListener.cc"
+                                >
+                        </File>
+                        <File
                                 RelativePath="..\..\src\network\Client.cc"
+                                >
 …
                         <File
                                 RelativePath="..\..\src\network\ClientConnection.cc"
+                                >
+                        </File>
+                        <File
+                                RelativePath="..\..\src\network\ClientConnectionListener.cc"
+                                >
                         </File>
 …
+                        >
                         <File
+                                RelativePath="..\..\src\network\ChatListener.h"
+                                >
+                        </File>
+                        <File
                                 RelativePath="..\..\src\network\Client.h"
+                                >
 …
                         <File
                                 RelativePath="..\..\src\network\ClientConnection.h"
+                                >
+                        </File>
+                        <File
+                                RelativePath="..\..\src\network\ClientConnectionListener.h"
+                                >
                         </File>

code/trunk/visual_studio/vc8/network.vsprops

Property svn:mergeinfo changed
/code/branches/objecthierarchy/visual_studio/vc8/network.vsprops (added) merged: 1918,2037,2040,2085
Property svn:eol-style set to native

r1842	r2087
9	9	Name="VCCLCompilerTool"
10	10	AdditionalOptions="/MP2"
11		PreprocessorDefinitions="~~ORXONOX_NO_EXPORTS;NETWORK_STATIC~~_BUILD"
	11	PreprocessorDefinitions="NETWORK_SHARED_BUILD"
12	12	/>
13	13	<Tool

code/trunk/visual_studio/vc8/ois.vcproj

Property svn:eol-style set to native

code/trunk/visual_studio/vc8/ois.vsprops

Property svn:eol-style set to native

code/trunk/visual_studio/vc8/orxonox.vcproj

Property svn:eol-style set to native

-                      r1896
+                      r2087
                         <Tool
                                 Name="VCCLCompilerTool"
-                                AdditionalOptions="/Zm200"
                         />
                         <Tool
 …
                         <Tool
                                 Name="VCCLCompilerTool"
-                                AdditionalOptions="/Zm200"
                         />
                         <Tool
 …
+                        >
                         <File
+                                RelativePath="..\..\src\orxonox\CameraManager.cc"
+                                >
+                        </File>
+                        <File
                                 RelativePath="..\..\src\orxonox\GraphicsEngine.cc"
+                                >
+                        </File>
+                        <File
+                                RelativePath="..\..\src\orxonox\LevelManager.cc"
+                                >
                         </File>
 …
+                                >
                         </File>
-                        <File
-                                RelativePath="..\..\src\orxonox\SignalHandler.cc"
+                                >
-                        </File>
                         <Filter
                                 Name="objects"
+                                >
                                 <File
+                                        RelativePath="..\..\src\orxonox\objects\Ambient.cc"
+                                        >
+                                </File>
+                                <File
+                                        RelativePath="..\..\src\orxonox\objects\Backlight.cc"
+                                        >
+                                </File>
+                                <File
+                                        RelativePath="..\..\src\orxonox\objects\BillboardProjectile.cc"
+                                        >
+                                </File>
+                                <File
+                                        RelativePath="..\..\src\orxonox\objects\Camera.cc"
+                                        >
+                                </File>
+                                <File
+                                        RelativePath="..\..\src\orxonox\objects\CameraHandler.cc"
+                                        >
+                                </File>
+                                <File
+                                        RelativePath="..\..\src\orxonox\objects\Model.cc"
+                                        >
+                                </File>
+                                <File
+                                        RelativePath="..\..\src\orxonox\objects\NPC.cc"
+                                        >
+                                </File>
+                                <File
+                                        RelativePath="..\..\src\orxonox\objects\ParticleProjectile.cc"
+                                        >
+                                </File>
+                                <File
+                                        RelativePath="..\..\src\orxonox\objects\ParticleSpawner.cc"
+                                        >
+                                </File>
+                                <File
+                                        RelativePath="..\..\src\orxonox\objects\Projectile.cc"
+                                        RelativePath="..\..\src\orxonox\objects\EventDispatcher.cc"
+                                        >
+                                </File>
+                                <File
+                                        RelativePath="..\..\src\orxonox\objects\EventListener.cc"
+                                        >
+                                </File>
+                                <File
+                                        RelativePath="..\..\src\orxonox\objects\EventTarget.cc"
+                                        >
                                 </File>
 …
                                         RelativePath="..\..\src\orxonox\objects\Radar.cc"
+                                        >
-                                        <FileConfiguration
-                                                Name="Debug|Win32"
+                                                >
-                                                <Tool
-                                                        Name="VCCLCompilerTool"
-                                                        ObjectFile="$(IntDir)\$(InputName)1.obj"
-                                                        XMLDocumentationFileName="$(IntDir)\$(InputName)1.xdc"
-                                                />
-                                        </FileConfiguration>
-                                        <FileConfiguration
-                                                Name="Release|Win32"
+                                                >
-                                                <Tool
-                                                        Name="VCCLCompilerTool"
-                                                        ObjectFile="$(IntDir)\$(InputName)1.obj"
-                                                        XMLDocumentationFileName="$(IntDir)\$(InputName)1.xdc"
-                                                />
-                                        </FileConfiguration>
                                 </File>
                                 <File
                                         RelativePath="..\..\src\orxonox\objects\RadarListener.cc"
+                                        >
-                                        <FileConfiguration
-                                                Name="Debug|Win32"
+                                                >
-                                                <Tool
-                                                        Name="VCCLCompilerTool"
-                                                        ObjectFile="$(IntDir)\$(InputName)1.obj"
-                                                        XMLDocumentationFileName="$(IntDir)\$(InputName)1.xdc"
-                                                />
-                                        </FileConfiguration>
-                                        <FileConfiguration
-                                                Name="Release|Win32"
+                                                >
-                                                <Tool
-                                                        Name="VCCLCompilerTool"
-                                                        ObjectFile="$(IntDir)\$(InputName)1.obj"
-                                                        XMLDocumentationFileName="$(IntDir)\$(InputName)1.xdc"
-                                                />
-                                        </FileConfiguration>
                                 </File>
                                 <File
 …
                                 </File>
                                 <File
+                                        RelativePath="..\..\src\orxonox\objects\RotatingProjectile.cc"
+                                        >
+                                </File>
+                                <File
+                                        RelativePath="..\..\src\orxonox\objects\Skybox.cc"
+                                        >
+                                </File>
+                                <File
+                                        RelativePath="..\..\src\orxonox\objects\SpaceShip.cc"
+                                        >
+                                </File>
+                                <File
+                                        RelativePath="..\..\src\orxonox\objects\SpaceShipAI.cc"
+                                        RelativePath="..\..\src\orxonox\objects\Scene.cc"
+                                        >
+                                </File>
+                                <File
+                                        RelativePath="..\..\src\orxonox\objects\Script.cc"
+                                        >
+                                </File>
+                                <File
+                                        RelativePath="..\..\src\orxonox\objects\Test.cc"
+                                        >
                                 </File>
 …
+                                        >
                                 </File>
+                                <File
+                                        RelativePath="..\..\src\orxonox\objects\WorldEntity.cc"
+                                        >
+                                </File>
+                                <Filter
+                                        Name="worldentities"
+                                        >
+                                        <File
+                                                RelativePath="..\..\src\orxonox\objects\worldentities\Backlight.cc"
+                                                >
+                                                <FileConfiguration
+                                                        Name="Debug|Win32"
+                                                        ExcludedFromBuild="true"
+                                                        >
+                                                        <Tool
+                                                                Name="VCCLCompilerTool"
+                                                        />
+                                                </FileConfiguration>
+                                                <FileConfiguration
+                                                        Name="Release|Win32"
+                                                        ExcludedFromBuild="true"
+                                                        >
+                                                        <Tool
+                                                                Name="VCCLCompilerTool"
+                                                        />
+                                                </FileConfiguration>
+                                        </File>
+                                        <File
+                                                RelativePath="..\..\src\orxonox\objects\worldentities\Billboard.cc"
+                                                >
+                                        </File>
+                                        <File
+                                                RelativePath="..\..\src\orxonox\objects\worldentities\BlinkingBillboard.cc"
+                                                >
+                                        </File>
+                                        <File
+                                                RelativePath="..\..\src\orxonox\objects\worldentities\Camera.cc"
+                                                >
+                                        </File>
+                                        <File
+                                                RelativePath="..\..\src\orxonox\objects\worldentities\CameraPosition.cc"
+                                                >
+                                        </File>
+                                        <File
+                                                RelativePath="..\..\src\orxonox\objects\worldentities\ControllableEntity.cc"
+                                                >
+                                        </File>
+                                        <File
+                                                RelativePath="..\..\src\orxonox\objects\worldentities\Light.cc"
+                                                >
+                                        </File>
+                                        <File
+                                                RelativePath="..\..\src\orxonox\objects\worldentities\Model.cc"
+                                                >
+                                        </File>
+                                        <File
+                                                RelativePath="..\..\src\orxonox\objects\worldentities\MovableEntity.cc"
+                                                >
+                                        </File>
+                                        <File
+                                                RelativePath="..\..\src\orxonox\objects\worldentities\ParticleEmitter.cc"
+                                                >
+                                        </File>
+                                        <File
+                                                RelativePath="..\..\src\orxonox\objects\worldentities\ParticleSpawner.cc"
+                                                >
+                                        </File>
+                                        <File
+                                                RelativePath="..\..\src\orxonox\objects\worldentities\PositionableEntity.cc"
+                                                >
+                                        </File>
+                                        <File
+                                                RelativePath="..\..\src\orxonox\objects\worldentities\SpawnPoint.cc"
+                                                >
+                                        </File>
+                                        <File
+                                                RelativePath="..\..\src\orxonox\objects\worldentities\WorldEntity.cc"
+                                                >
+                                        </File>
+                                        <Filter
+                                                Name="pawns"
+                                                >
+                                                <File
+                                                        RelativePath="..\..\src\orxonox\objects\worldentities\pawns\Pawn.cc"
+                                                        >
+                                                </File>
+                                                <File
+                                                        RelativePath="..\..\src\orxonox\objects\worldentities\pawns\SpaceShip.cc"
+                                                        >
+                                                </File>
+                                                <File
+                                                        RelativePath="..\..\src\orxonox\objects\worldentities\pawns\Spectator.cc"
+                                                        >
+                                                </File>
+                                        </Filter>
+                                        <Filter
+                                                Name="triggers"
+                                                >
+                                                <File
+                                                        RelativePath="..\..\src\orxonox\objects\worldentities\triggers\DistanceTrigger.cc"
+                                                        >
+                                                </File>
+                                                <File
+                                                        RelativePath="..\..\src\orxonox\objects\worldentities\triggers\EventTrigger.cc"
+                                                        >
+                                                </File>
+                                                <File
+                                                        RelativePath="..\..\src\orxonox\objects\worldentities\triggers\Trigger.cc"
+                                                        >
+                                                </File>
+                                        </Filter>
+                                </Filter>
+                                <Filter
+                                        Name="gametypes"
+                                        >
+                                        <File
+                                                RelativePath="..\..\src\orxonox\objects\gametypes\Gametype.cc"
+                                                >
+                                        </File>
+                                </Filter>
+                                <Filter
+                                        Name="infos"
+                                        >
+                                        <File
+                                                RelativePath="..\..\src\orxonox\objects\infos\HumanPlayer.cc"
+                                                >
+                                        </File>
+                                        <File
+                                                RelativePath="..\..\src\orxonox\objects\infos\Info.cc"
+                                                >
+                                        </File>
+                                        <File
+                                                RelativePath="..\..\src\orxonox\objects\infos\Level.cc"
+                                                >
+                                        </File>
+                                        <File
+                                                RelativePath="..\..\src\orxonox\objects\infos\PlayerInfo.cc"
+                                                >
+                                        </File>
+                                </Filter>
+                                <Filter
+                                        Name="controllers"
+                                        >
+                                        <File
+                                                RelativePath="..\..\src\orxonox\objects\controllers\Controller.cc"
+                                                >
+                                        </File>
+                                        <File
+                                                RelativePath="..\..\src\orxonox\objects\controllers\HumanController.cc"
+                                                >
+                                        </File>
+                                </Filter>
                         </Filter>
                         <Filter
 …
                                 <File
                                         RelativePath="..\..\src\orxonox\tools\BillboardSet.cc"
+                                        >
-                                </File>
-                                <File
-                                        RelativePath="..\..\src\orxonox\tools\Light.cc"
+                                        >
                                 </File>
 …
+                                        >
                                         <File
+                                                RelativePath="..\..\src\orxonox\overlays\hud\ChatOverlay.cc"
+                                                >
+                                        </File>
+                                        <File
                                                 RelativePath="..\..\src\orxonox\overlays\hud\HUDBar.cc"
+                                                >
 …
                                         RelativePath="..\..\src\orxonox\gui\OgreCEGUIRenderer.cpp"
+                                        >
-                                        <FileConfiguration
-                                                Name="Debug|Win32"
+                                                >
-                                                <Tool
-                                                        Name="VCCLCompilerTool"
-                                                        UsePrecompiledHeader="0"
-                                                />
-                                        </FileConfiguration>
-                                        <FileConfiguration
-                                                Name="Release|Win32"
+                                                >
-                                                <Tool
-                                                        Name="VCCLCompilerTool"
-                                                        UsePrecompiledHeader="0"
-                                                />
-                                        </FileConfiguration>
                                 </File>
                                 <File
                                         RelativePath="..\..\src\orxonox\gui\OgreCEGUIResourceProvider.cpp"
+                                        >
-                                        <FileConfiguration
-                                                Name="Debug|Win32"
+                                                >
-                                                <Tool
-                                                        Name="VCCLCompilerTool"
-                                                        UsePrecompiledHeader="0"
-                                                />
-                                        </FileConfiguration>
-                                        <FileConfiguration
-                                                Name="Release|Win32"
+                                                >
-                                                <Tool
-                                                        Name="VCCLCompilerTool"
-                                                        UsePrecompiledHeader="0"
-                                                />
-                                        </FileConfiguration>
                                 </File>
                                 <File
                                         RelativePath="..\..\src\orxonox\gui\OgreCEGUITexture.cpp"
+                                        >
-                                        <FileConfiguration
-                                                Name="Debug|Win32"
+                                                >
-                                                <Tool
-                                                        Name="VCCLCompilerTool"
-                                                        UsePrecompiledHeader="0"
-                                                />
-                                        </FileConfiguration>
-                                        <FileConfiguration
-                                                Name="Release|Win32"
+                                                >
-                                                <Tool
-                                                        Name="VCCLCompilerTool"
-                                                        UsePrecompiledHeader="0"
-                                                />
-                                        </FileConfiguration>
                                 </File>
                         </Filter>
 …
+                        >
                         <File
+                                RelativePath="..\..\src\orxonox\CameraManager.h"
+                                >
+                        </File>
+                        <File
                                 RelativePath="..\..\src\orxonox\GraphicsEngine.h"
+                                >
                         </File>
                         <File
+                                RelativePath="..\..\src\orxonox\LevelManager.h"
+                                >
+                        </File>
+                        <File
                                 RelativePath="..\..\src\orxonox\OrxonoxPrereqs.h"
+                                >
 …
+                                >
                         </File>
-                        <File
-                                RelativePath="..\..\src\orxonox\SignalHandler.h"
+                                >
-                        </File>
                         <Filter
                                 Name="objects"
+                                >
                                 <File
+                                        RelativePath="..\..\src\orxonox\objects\Ambient.h"
+                                        >
+                                </File>
+                                <File
+                                        RelativePath="..\..\src\orxonox\objects\Backlight.h"
+                                        >
+                                </File>
+                                <File
+                                        RelativePath="..\..\src\orxonox\objects\BillboardProjectile.h"
+                                        >
+                                </File>
+                                <File
+                                        RelativePath="..\..\src\orxonox\objects\Camera.h"
+                                        >
+                                </File>
+                                <File
+                                        RelativePath="..\..\src\orxonox\objects\CameraHandler.h"
+                                        >
+                                </File>
+                                <File
+                                        RelativePath="..\..\src\orxonox\objects\Model.h"
+                                        >
+                                </File>
+                                <File
+                                        RelativePath="..\..\src\orxonox\objects\NPC.h"
+                                        >
+                                </File>
+                                <File
+                                        RelativePath="..\..\src\orxonox\objects\ParticleProjectile.h"
+                                        >
+                                </File>
+                                <File
+                                        RelativePath="..\..\src\orxonox\objects\ParticleSpawner.h"
+                                        >
+                                </File>
+                                <File
+                                        RelativePath="..\..\src\orxonox\objects\Projectile.h"
+                                        RelativePath="..\..\src\orxonox\objects\EventDispatcher.h"
+                                        >
+                                </File>
+                                <File
+                                        RelativePath="..\..\src\orxonox\objects\EventListener.h"
+                                        >
+                                </File>
+                                <File
+                                        RelativePath="..\..\src\orxonox\objects\EventTarget.h"
+                                        >
                                 </File>
 …
                                 </File>
                                 <File
+                                        RelativePath="..\..\src\orxonox\objects\RotatingProjectile.h"
+                                        >
+                                </File>
+                                <File
+                                        RelativePath="..\..\src\orxonox\objects\Skybox.h"
+                                        >
+                                </File>
+                                <File
+                                        RelativePath="..\..\src\orxonox\objects\SpaceShip.h"
+                                        >
+                                </File>
+                                <File
+                                        RelativePath="..\..\src\orxonox\objects\SpaceShipAI.h"
+                                        RelativePath="..\..\src\orxonox\objects\Scene.h"
+                                        >
+                                </File>
+                                <File
+                                        RelativePath="..\..\src\orxonox\objects\Script.h"
+                                        >
+                                </File>
+                                <File
+                                        RelativePath="..\..\src\orxonox\objects\Test.h"
+                                        >
                                 </File>
 …
+                                        >
                                 </File>
+                                <File
+                                        RelativePath="..\..\src\orxonox\objects\WorldEntity.h"
+                                        >
+                                </File>
+                                <Filter
+                                        Name="worldentities"
+                                        >
+                                        <File
+                                                RelativePath="..\..\src\orxonox\objects\worldentities\Backlight.h"
+                                                >
+                                        </File>
+                                        <File
+                                                RelativePath="..\..\src\orxonox\objects\worldentities\Billboard.h"
+                                                >
+                                        </File>
+                                        <File
+                                                RelativePath="..\..\src\orxonox\objects\worldentities\BlinkingBillboard.h"
+                                                >
+                                        </File>
+                                        <File
+                                                RelativePath="..\..\src\orxonox\objects\worldentities\Camera.h"
+                                                >
+                                        </File>
+                                        <File
+                                                RelativePath="..\..\src\orxonox\objects\worldentities\CameraPosition.h"
+                                                >
+                                        </File>
+                                        <File
+                                                RelativePath="..\..\src\orxonox\objects\worldentities\ControllableEntity.h"
+                                                >
+                                        </File>
+                                        <File
+                                                RelativePath="..\..\src\orxonox\objects\worldentities\Light.h"
+                                                >
+                                        </File>
+                                        <File
+                                                RelativePath="..\..\src\orxonox\objects\worldentities\Model.h"
+                                                >
+                                        </File>
+                                        <File
+                                                RelativePath="..\..\src\orxonox\objects\worldentities\MovableEntity.h"
+                                                >
+                                        </File>
+                                        <File
+                                                RelativePath="..\..\src\orxonox\objects\worldentities\ParticleEmitter.h"
+                                                >
+                                        </File>
+                                        <File
+                                                RelativePath="..\..\src\orxonox\objects\worldentities\ParticleSpawner.h"
+                                                >
+                                        </File>
+                                        <File
+                                                RelativePath="..\..\src\orxonox\objects\worldentities\PositionableEntity.h"
+                                                >
+                                        </File>
+                                        <File
+                                                RelativePath="..\..\src\orxonox\objects\worldentities\SpawnPoint.h"
+                                                >
+                                        </File>
+                                        <File
+                                                RelativePath="..\..\src\orxonox\objects\worldentities\WorldEntity.h"
+                                                >
+                                        </File>
+                                        <Filter
+                                                Name="pawns"
+                                                >
+                                                <File
+                                                        RelativePath="..\..\src\orxonox\objects\worldentities\pawns\Pawn.h"
+                                                        >
+                                                </File>
+                                                <File
+                                                        RelativePath="..\..\src\orxonox\objects\worldentities\pawns\SpaceShip.h"
+                                                        >
+                                                </File>
+                                                <File
+                                                        RelativePath="..\..\src\orxonox\objects\worldentities\pawns\Spectator.h"
+                                                        >
+                                                </File>
+                                        </Filter>
+                                        <Filter
+                                                Name="triggers"
+                                                >
+                                                <File
+                                                        RelativePath="..\..\src\orxonox\objects\worldentities\triggers\DistanceTrigger.h"
+                                                        >
+                                                </File>
+                                                <File
+                                                        RelativePath="..\..\src\orxonox\objects\worldentities\triggers\EventTrigger.h"
+                                                        >
+                                                </File>
+                                                <File
+                                                        RelativePath="..\..\src\orxonox\objects\worldentities\triggers\Trigger.h"
+                                                        >
+                                                </File>
+                                        </Filter>
+                                </Filter>
+                                <Filter
+                                        Name="gametypes"
+                                        >
+                                        <File
+                                                RelativePath="..\..\src\orxonox\objects\gametypes\Gametype.h"
+                                                >
+                                        </File>
+                                </Filter>
+                                <Filter
+                                        Name="infos"
+                                        >
+                                        <File
+                                                RelativePath="..\..\src\orxonox\objects\infos\Info.h"
+                                                >
+                                        </File>
+                                        <File
+                                                RelativePath="..\..\src\orxonox\objects\infos\Level.h"
+                                                >
+                                        </File>
+                                        <File
+                                                RelativePath="..\..\src\orxonox\objects\infos\PlayerInfo.h"
+                                                >
+                                        </File>
+                                </Filter>
+                                <Filter
+                                        Name="controllers"
+                                        >
+                                        <File
+                                                RelativePath="..\..\src\orxonox\objects\controllers\Controller.h"
+                                                >
+                                        </File>
+                                        <File
+                                                RelativePath="..\..\src\orxonox\objects\controllers\HumanController.h"
+                                                >
+                                        </File>
+                                </Filter>
                         </Filter>
                         <Filter
 …
                                 </File>
                                 <File
-                                        RelativePath="..\..\src\orxonox\tools\Light.h"
+                                        >
-                                </File>
-                                <File
                                         RelativePath="..\..\src\orxonox\tools\Mesh.h"
+                                        >
 …
                                         Name="hud"
+                                        >
+                                        <File
+                                                RelativePath="..\..\src\orxonox\overlays\hud\ChatOverlay.h"
+                                                >
+                                        </File>
                                         <File
                                                 RelativePath="..\..\src\orxonox\overlays\hud\HUDBar.h"

code/trunk/visual_studio/vc8/orxonox.vcproj.user

Property svn:eol-style set to native

code/trunk/visual_studio/vc8/orxonox.vsprops

Property svn:mergeinfo changed
/code/branches/objecthierarchy/visual_studio/vc8/orxonox.vsprops (added) merged: 1918,2013,2037,2040,2085
Property svn:eol-style set to native

-                      r1897
+                      r2087
         <Tool
                 Name="VCCLCompilerTool"
                 AdditionalOptions="/MP2"
                 PreprocessorDefinitions="ORXONOX_NO_EXPORTS;NETWORK_STATIC_BUILD;LUA_BUILD_AS_DLL"
+                AdditionalOptions="/MP2 /Zm200"
+                PreprocessorDefinitions="ORXONOX_NO_EXPORTS;ORXONOX_ENABLE_PCH;LUA_BUILD_AS_DLL"
                 UsePrecompiledHeader="2"
                 PrecompiledHeaderThrough="OrxonoxStableHeaders.h"
 …
                 Name="VCPostBuildEventTool"
                 Description="Copying files from init folder..."
                 CommandLine="for %%a in ($(RootDir)\init\$(SolutionName)\$(ConfigurationName)\*) do replace %%a $(OutDir). /A &gt;nul&#x0D;&#x0A;for %%a in ($(RootDir)\init\common\*) do replace %%a $(OutDir). /A &gt;nul"
+                CommandLine="for %%a in ($(RootDir)\init\$(SolutionName)\$(ConfigurationName)\*) do replace %%a $(OutDir). /A &gt;nul&#x0D;&#x0A;for %%a in ($(RootDir)\init\common\*) do replace %%a $(OutDir). /A &gt;nul&#x0D;&#x0A;"
         />
 </VisualStudioPropertySheet>

code/trunk/visual_studio/vc8/orxonox_vc8.sln

Property svn:mergeinfo changed
/code/branches/objecthierarchy/visual_studio/vc8/orxonox_vc8.sln (added) merged: 2037,2040,2085
Property svn:eol-style set to native

code/trunk/visual_studio/vc8/release.vsprops

Property svn:mergeinfo changed
/code/branches/objecthierarchy/visual_studio/vc8/release.vsprops (added) merged: 2037,2040,2085
Property svn:eol-style set to native

code/trunk/visual_studio/vc8/tinyxml.vcproj

Property svn:mergeinfo changed
/code/branches/objecthierarchy/visual_studio/vc8/tinyxml.vcproj (added) merged: 2037,2040,2085
Property svn:eol-style set to native

code/trunk/visual_studio/vc8/tinyxml.vsprops

Property svn:mergeinfo changed
/code/branches/objecthierarchy/visual_studio/vc8/tinyxml.vsprops (added) merged: 2037,2040,2085
Property svn:eol-style set to native

code/trunk/visual_studio/vc8/tolua.vcproj

Property svn:eol-style set to native

code/trunk/visual_studio/vc8/tolua.vsprops

Property svn:mergeinfo changed
/code/branches/objecthierarchy/visual_studio/vc8/tolua.vsprops (added) merged: 2037,2040,2085
Property svn:eol-style set to native

code/trunk/visual_studio/vc8/tolua_static.vcproj

Property svn:eol-style set to native

code/trunk/visual_studio/vc8/tolua_static.vsprops

Property svn:eol-style set to native

code/trunk/visual_studio/vc8/toluagen.vcproj

Property svn:mergeinfo changed
/code/branches/gui/visual_studio/vc8/tolua_gen.vcproj reverse-merged: 1638
/code/branches/objecthierarchy/visual_studio/vc8/toluagen.vcproj (added) merged: 2037,2040,2085
Property svn:eol-style set to native

code/trunk/visual_studio/vc8/toluagen.vsprops

Property svn:mergeinfo changed
/code/branches/gui/visual_studio/tolua_gen_properties.vsprops reverse-merged: 1638
/code/branches/objecthierarchy/visual_studio/vc8/toluagen.vsprops (added) merged: 2037,2040,2085
Property svn:eol-style set to native

code/trunk/visual_studio/vc8/toluagen_orxonox.vcproj

Property svn:mergeinfo changed
/code/branches/objecthierarchy/visual_studio/vc8/toluagen_orxonox.vcproj (added) merged: 2037,2040,2085
Property svn:eol-style set to native

code/trunk/visual_studio/vc8/toluagen_orxonox.vsprops

Property svn:mergeinfo changed
/code/branches/objecthierarchy/visual_studio/vc8/toluagen_orxonox.vsprops (added) merged: 2037,2040,2085
Property svn:eol-style set to native

code/trunk/visual_studio/vc8/util.vcproj

Property svn:eol-style set to native

-                      r1841
+                      r2087
                         </File>
                         <File
+                                RelativePath="..\..\src\util\SignalHandler.cc"
+                                >
+                        </File>
+                        <File
                                 RelativePath="..\..\src\util\String.cc"
+                                >
 …
                         </File>
                         <File
+                                RelativePath="..\..\src\util\MathConvert.h"
+                                >
+                        </File>
+                        <File
                                 RelativePath="..\..\src\util\MultiType.h"
+                                >
 …
                         <File
                                 RelativePath="..\..\src\util\OutputHandler.h"
+                                >
+                        </File>
+                        <File
+                                RelativePath="..\..\src\util\SignalHandler.h"
+                                >
                         </File>

code/trunk/visual_studio/vc8/util.vsprops

Property svn:mergeinfo changed
/code/branches/objecthierarchy/visual_studio/vc8/util.vsprops (added) merged: 2037,2040,2085
Property svn:eol-style set to native

/code/branches/ceguilua/visual_studio/ceguilua_properties.vsprops		reverse-merged: 1804
/code/branches/objecthierarchy/visual_studio/vc8/ceguilua.vsprops (added)	merged: 2037,2040,2085

/code/branches/ceguilua/visual_studio/lua_properties.vsprops		reverse-merged: 1804
/code/branches/objecthierarchy/visual_studio/vc8/lua.vsprops (added)	merged: 2037,2040,2085

/code/branches/gui/visual_studio/vc8/tolua_gen.vcproj		reverse-merged: 1638
/code/branches/objecthierarchy/visual_studio/vc8/toluagen.vcproj (added)	merged: 2037,2040,2085

/code/branches/gui/visual_studio/tolua_gen_properties.vsprops		reverse-merged: 1638
/code/branches/objecthierarchy/visual_studio/vc8/toluagen.vsprops (added)	merged: 2037,2040,2085

Context Navigation

Legend: