Changeset 1592

Timestamp:

Jun 12, 2008, 4:32:10 AM (16 years ago)

Author:

landauf

Message:

• Some small changes in XMLPortParam: It's now possible to add functions of another class. an example is setPosition and getPosition that are directly referred to Ogre::Node. Use XMLPortParamExtern if you need this. It takes the object to call the functions on as an additional argument (in our example: this→node_).
• Removed loadParams functions and reduced the usage of XMLPortParamLoadOnly in several classes

Location:

code/branches/core3/src

Files:

• audio/AudioManager.h (modified) (1 diff)
• core/BaseObject.cc (modified) (1 diff)
• core/BaseObject.h (modified) (1 diff)
• core/Functor.h (modified) (1 diff)
• core/Identifier.cc (modified) (2 diffs)
• core/Identifier.h (modified) (4 diffs)
• core/XMLPort.h (modified) (6 diffs)
• orxonox/objects/Ambient.cc (modified) (2 diffs)
• orxonox/objects/Ambient.h (modified) (1 diff)
• orxonox/objects/Model.cc (modified) (1 diff)
• orxonox/objects/Model.h (modified) (1 diff)
• orxonox/objects/NPC.cc (modified) (1 diff)
• orxonox/objects/NPC.h (modified) (1 diff)
• orxonox/objects/Projectile.cc (modified) (1 diff)
• orxonox/objects/Skybox.cc (modified) (2 diffs)
• orxonox/objects/Skybox.h (modified) (1 diff)
• orxonox/objects/SpaceShip.cc (modified) (1 diff)
• orxonox/objects/WorldEntity.cc (modified) (3 diffs)
• orxonox/objects/WorldEntity.h (modified) (5 diffs)

code/branches/core3/src/audio/AudioManager.h

@@ -58 +58 @@
                 void setOri(std::vector<float> at, std::vector<float> up);
 
-                // Parses given xml string
-                void loadParams();
-
                 // Update
                 void tick(float dt);

code/branches/core3/src/core/BaseObject.cc

@@ -66 +66 @@
 
     /**
-        @brief load general xml paramters
-    */
-    void BaseObject::loadParams(TiXmlElement* xmlElem)
-    {
-        if (xmlElem->Attribute("name"))
-        {
-            this->setName(xmlElem->Attribute("name"));
-        }
-    }
-
-    /**
         @brief XML loading and saving.
         @param xmlelement The XML-element

code/branches/core3/src/core/BaseObject.h

@@ -52 +52 @@
             BaseObject();
             virtual ~BaseObject();
-            virtual void loadParams(TiXmlElement* xmlElem);
             virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
 

code/branches/core3/src/core/Functor.h

@@ -80 +80 @@
     CreateTypeToStringTemplate(Degree);
 
-    template <> \
-    inline std::string typeToString<std::string>() { return "string"; } \
-    template <> \
-    inline std::string typeToString<std::string&>() { return "string"; } \
-    template <> \
-    inline std::string typeToString<const std::string>() { return "string"; } \
-    template <> \
+    template <>
+    inline std::string typeToString<std::string>() { return "string"; }
+    template <>
+    inline std::string typeToString<std::string&>() { return "string"; }
+    template <>
+    inline std::string typeToString<const std::string>() { return "string"; }
+    template <>
     inline std::string typeToString<const std::string&>() { return "string"; }
 

code/branches/core3/src/core/Identifier.cc

@@ -42 +42 @@
 #include "ObjectList.h"
 #include "OrxonoxClass.h"
+#include "XMLPort.h"
 
 namespace orxonox
@@ -206 +207 @@
 
     /**
+        @brief Tells the container to which Identifier it belongs to.
+    */
+    void Identifier::addXMLPortParamContainer(const std::string& paramname, XMLPortParamContainer* container)
+    {
+        container->setIdentifier(this);
+    }
+
+    /**
         @brief Returns true, if the Identifier is at least of the given type.
         @param identifier The identifier to compare with

code/branches/core3/src/core/Identifier.h

@@ -206 +206 @@
             ConfigValueContainer* getLowercaseConfigValueContainer(const std::string& varname);
 
-            virtual void addXMLPortParamContainer(const std::string& paramname, XMLPortParamContainer* container) = 0;
+            virtual void addXMLPortParamContainer(const std::string& paramname, XMLPortParamContainer* container);
             virtual XMLPortParamContainer* getXMLPortParamContainer(const std::string& paramname) = 0;
 
@@ -313 +313 @@
             ~ClassIdentifier() {}                                       // don't delete
 
-            std::map<std::string, XMLPortClassParamContainer<T>*> xmlportParamContainers_;              //!< All loadable parameters
+            std::map<std::string, XMLPortClassParamContainer<class O>*> xmlportParamContainers_;              //!< All loadable parameters
             std::map<std::string, XMLPortClassObjectContainer<T, class O>*> xmlportObjectContainers_;   //!< All attachable objects
 
@@ -427 +427 @@
     XMLPortParamContainer* ClassIdentifier<T>::getXMLPortParamContainer(const std::string& paramname)
     {
-        typename std::map<std::string, XMLPortClassParamContainer<T>*>::const_iterator it = xmlportParamContainers_.find(paramname);
+        typename std::map<std::string, XMLPortClassParamContainer<class O>*>::const_iterator it = xmlportParamContainers_.find(paramname);
         if (it != xmlportParamContainers_.end())
             return (XMLPortParamContainer*)((*it).second);
@@ -442 +442 @@
     void ClassIdentifier<T>::addXMLPortParamContainer(const std::string& paramname, XMLPortParamContainer* container)
     {
-        this->xmlportParamContainers_[paramname] = (XMLPortClassParamContainer<T>*)container;
+        Identifier::addXMLPortParamContainer(paramname, container);
+        this->xmlportParamContainers_[paramname] = (XMLPortClassParamContainer<class O>*)container;
     }
 

code/branches/core3/src/core/XMLPort.h

@@ -42 +42 @@
 
 #define XMLPortParam(classname, paramname, loadfunction, savefunction, xmlelement, mode) \
-    XMLPortParamGeneric(xmlcontainer##loadfunction##savefunction, classname, paramname, orxonox::createExecutor(orxonox::createFunctor(&classname::loadfunction), #loadfunction), orxonox::createExecutor(orxonox::createFunctor(&classname::savefunction), #savefunction), xmlelement, mode)
-#define XMLPortParam_Template(classname, paramname, loadtemplate, loadfunction, savetemplate, savefunction, xmlelement, mode) \
-    XMLPortParamGeneric(xmlcontainer##loadfunction##savefunction, classname, paramname, orxonox::createExecutor(orxonox::createFunctor loadtemplate (&classname::loadfunction), #loadfunction), orxonox::createExecutor(orxonox::createFunctor savetemplate (&classname::savefunction), #savefunction), xmlelement, mode)
+    XMLPortParamGeneric(xmlcontainer##loadfunction##savefunction, 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)
+#define XMLPortParamTemplate(classname, paramname, loadfunction, savefunction, xmlelement, mode, ...) \
+    XMLPortParamGeneric(xmlcontainer##loadfunction##savefunction, classname, this, paramname, orxonox::createExecutor(orxonox::createFunctor< __VA_ARGS__ >(&classname::loadfunction), std::string( #classname ) + "::" + #loadfunction), orxonox::createExecutor(orxonox::createFunctor(&classname::savefunction), std::string( #classname ) + "::" + #savefunction), xmlelement, mode)
 
 #define XMLPortParamLoadOnly(classname, paramname, loadfunction, xmlelement, mode) \
-    XMLPortParamGeneric(xmlcontainer##loadfunction##0, classname, paramname, orxonox::createExecutor(orxonox::createFunctor(&classname::loadfunction), #loadfunction), 0, xmlelement, mode)
-#define XMLPortParamLoadOnly_Template(classname, paramname, loadtemplate, loadfunction, xmlelement, mode) \
-    XMLPortParamGeneric(xmlcontainer##loadfunction##0, classname, paramname, orxonox::createExecutor(orxonox::createFunctor loadtemplate (&classname::loadfunction), #loadfunction), 0, xmlelement, mode)
-
-#define XMLPortParamGeneric(containername, classname, paramname, loadexecutor, saveexecutor, xmlelement, mode) \
+    XMLPortParamGeneric(xmlcontainer##loadfunction##0, classname, this, paramname, orxonox::createExecutor(orxonox::createFunctor(&classname::loadfunction), std::string( #classname ) + "::" + #loadfunction), 0, xmlelement, mode)
+#define XMLPortParamLoadOnlyTemplate(classname, paramname, loadfunction, xmlelement, mode, ...) \
+    XMLPortParamGeneric(xmlcontainer##loadfunction##0, classname, this, paramname, orxonox::createExecutor(orxonox::createFunctor< __VA_ARGS__ >(&classname::loadfunction), std::string( #classname ) + "::" + #loadfunction), 0, xmlelement, mode)
+
+#define XMLPortParamExtern(classname, object, paramname, loadfunction, savefunction, xmlelement, mode) \
+    XMLPortParamGeneric(xmlcontainer##loadfunction##savefunction, classname, object, paramname, orxonox::createExecutor(orxonox::createFunctor(&classname::loadfunction), std::string( #classname ) + "::" + #loadfunction), orxonox::createExecutor(orxonox::createFunctor(&classname::savefunction), std::string( #classname ) + "::" + #savefunction), xmlelement, mode);
+#define XMLPortParamExternTemplate(classname, object, paramname, loadfunction, savefunction, xmlelement, mode, ...) \
+    XMLPortParamGeneric(xmlcontainer##loadfunction##savefunction, classname, object, paramname, orxonox::createExecutor(orxonox::createFunctor< __VA_ARGS__ >(&classname::loadfunction), std::string( #classname ) + "::" + #loadfunction), orxonox::createExecutor(orxonox::createFunctor(&classname::savefunction), std::string( #classname ) + "::" + #savefunction), xmlelement, mode);
+
+#define XMLPortParamGeneric(containername, classname, object, paramname, loadexecutor, saveexecutor, xmlelement, mode) \
     orxonox::XMLPortClassParamContainer<classname>* containername = (orxonox::XMLPortClassParamContainer<classname>*)(this->getIdentifier()->getXMLPortParamContainer(paramname)); \
     if (!containername) \
@@ -58 +63 @@
         this->getIdentifier()->addXMLPortParamContainer(paramname, containername); \
     } \
-    containername->port(this, xmlelement, mode)
+    containername->port(object, xmlelement, mode)
 
 
 #define XMLPortObject(classname, objectclass, sectionname, loadfunction, savefunction, xmlelement, mode, bApplyLoaderMask, bLoadBefore) \
-    XMLPortObjectGeneric(xmlcontainer##loadfunction##savefunction, classname, objectclass, sectionname, orxonox::createExecutor(orxonox::createFunctor(&classname::loadfunction), #loadfunction), orxonox::createExecutor(orxonox::createFunctor(&classname::savefunction), #savefunction), xmlelement, mode, bApplyLoaderMask, bLoadBefore)
-#define XMLPortObject_Template(classname, objectclass, sectionname, loadtemplate, loadfunction, savetemplate, savefunction, xmlelement, mode, bApplyLoaderMask, bLoadBefore) \
-    XMLPortObjectGeneric(xmlcontainer##loadfunction##savefunction, classname, objectclass, sectionname, orxonox::createExecutor(orxonox::createFunctor loadtemplate (&classname::loadfunction), #loadfunction), orxonox::createExecutor(orxonox::createFunctor savetemplate (&classname::savefunction), #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)
+#define XMLPortObjectTemplate(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)
 
 #define XMLPortObjectGeneric(containername, classname, objectclass, sectionname, loadexecutor, saveexecutor, xmlelement, mode, bApplyLoaderMask, bLoadBefore) \
@@ -98 +103 @@
             inline const std::string& getName() const
                 { return this->paramname_; }
+            inline void setIdentifier(Identifier* identifier)
+                { this->identifier_ = identifier; }
 
             virtual XMLPortParamContainer& description(const std::string description) = 0;
@@ -112 +119 @@
             std::string paramname_;
             ParseResult parseResult_;
-
+            Identifier* identifier_;
     };
 
@@ -146 +153 @@
                         if ((attribute.size() > 0) || (this->loadexecutor_->allDefaultValuesSet()))
                         {
-                            COUT(5) << ((BaseObject*)object)->getLoaderIndentation() << "Loading parameter " << this->paramname_ << " in " << object->getIdentifier()->getName() << " (objectname " << ((BaseObject*)object)->getName() << ")." << std::endl << ((BaseObject*)object)->getLoaderIndentation();
+                            COUT(5) << ((BaseObject*)object)->getLoaderIndentation() << "Loading parameter " << this->paramname_ << " in " << this->identifier_->getName() << " (objectname " << ((BaseObject*)object)->getName() << ")." << std::endl << ((BaseObject*)object)->getLoaderIndentation();
                             if (this->loadexecutor_->parse(object, attribute, ","))
                                 this->parseResult_ = PR_finished;
@@ -156 +163 @@
                     {
                         COUT(1) << std::endl;
-                        COUT(1) << "An error occurred in XMLPort.h while loading attribute '" << this->paramname_ << "' of '" << object->getIdentifier()->getName() << "' (objectname: " << ((BaseObject*)object)->getName() << ") in " << ((BaseObject*)object)->getLevelfile() << ":" << std::endl;
+                        COUT(1) << "An error occurred in XMLPort.h while loading attribute '" << this->paramname_ << "' of '" << this->identifier_->getName() << "' (objectname: " << ((BaseObject*)object)->getName() << ") in " << ((BaseObject*)object)->getLevelfile() << ":" << std::endl;
                         COUT(1) << ex.what() << std::endl;
                     }

code/branches/core3/src/orxonox/objects/Ambient.cc

@@ -64 +64 @@
     }
 
-    bool Ambient::create(){
-      GraphicsEngine::getSingleton().getSceneManager()->setAmbientLight(ambientLight_);
-      return Synchronisable::create();
+    bool Ambient::create()
+    {
+        GraphicsEngine::getSingleton().getSceneManager()->setAmbientLight(ambientLight_);
+        return Synchronisable::create();
     }
 
-    void Ambient::registerAllVariables(){
-      registerVar(&ambientLight_, sizeof(ColourValue), network::DATA);
-
+    void Ambient::registerAllVariables()
+    {
+        registerVar(&ambientLight_, sizeof(ColourValue), network::DATA);
     }
 
-    void Ambient::loadParams(TiXmlElement* xmlElem)
+    void Ambient::setAmbientLight(const ColourValue& colour)
     {
-        if (xmlElem->Attribute("colourvalue"))
-        {
-        SubString colourvalues(xmlElem->Attribute("colourvalue"), ',');
-
-                float r, g, b;
-        convertValue<std::string, float>(&r, colourvalues[0]);
-        convertValue<std::string, float>(&g, colourvalues[1]);
-        convertValue<std::string, float>(&b, colourvalues[2]);
-
-                this->setAmbientLight(ColourValue(r, g, b));
-
-                COUT(4) << "Loader: Set ambient light: "<<r<<" " << g << " " << b  << std::endl << std::endl;
-        }
-   }
-
-   void Ambient::setAmbientLight(const ColourValue& colour)
-   {
-        GraphicsEngine::getSingleton().getSceneManager()->setAmbientLight(colour);
-      ambientLight_=colour;
-   }
+        GraphicsEngine::getSingleton().getSceneManager()->setAmbientLight(colour);
+        ambientLight_=colour;
+    }
 
     /**
@@ -107 +91 @@
         BaseObject::XMLPort(xmlelement, mode);
 
-        XMLPortParamLoadOnly(Ambient, "colourvalue", setAmbientLight, xmlelement, mode);
+        XMLPortParam(Ambient, "colourvalue", setAmbientLight, getAmbienetLight, xmlelement, mode);
         create();
     }

code/branches/core3/src/orxonox/objects/Ambient.h

@@ -44 +44 @@
             virtual ~Ambient();
 
-            void loadParams(TiXmlElement* xmlElem);
             virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
-            void setAmbientLight(const ColourValue& colour);
             virtual bool create();
             void registerAllVariables();
+
+            void setAmbientLight(const ColourValue& colour);
+            inline const ColourValue& getAmbienetLight() const
+                { return this->ambientLight_; }
 
             static void setAmbientLightTest(const ColourValue& colour)

code/branches/core3/src/orxonox/objects/Model.cc

@@ -68 +68 @@
         WorldEntity::XMLPort(xmlelement, mode);
 
-        XMLPortParamLoadOnly(Model, "mesh", setMesh, xmlelement, mode);
+        XMLPortParam(Model, "mesh", setMesh, getMesh, xmlelement, mode);
 
         Model::create();
-    }
-
-    void Model::setMesh(const std::string& meshname)
-    {
-        this->meshSrc_ = meshname;
     }
 

code/branches/core3/src/orxonox/objects/Model.h

@@ -45 +45 @@
             virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
             virtual void changedVisibility();
-            void setMesh(const std::string& meshname);
+            inline void setMesh(const std::string& meshname)
+                { this->meshSrc_ = meshname; }
+            inline const std::string& getMesh() const
+                { return this->meshSrc_; }
             virtual bool create();
 

code/branches/core3/src/orxonox/objects/NPC.cc

@@ -46 +46 @@
   NPC::~NPC()
   {
-  }
-
-  void NPC::loadParams(TiXmlElement* xmlElem)
-  {
-    Model::loadParams(xmlElem);
   }
 

code/branches/core3/src/orxonox/objects/NPC.h

@@ -48 +48 @@
       NPC();
       virtual ~NPC();
-      virtual void loadParams(TiXmlElement* xmlElem);
       void tick(float dt);
       void update();

code/branches/core3/src/orxonox/objects/Projectile.cc

@@ -92 +92 @@
             if ((*it) != this->owner_)
             {
-                radius = it->getScale().x * 3.0;
+                radius = it->getScale3D().x * 3.0;
 
                 if (this->getPosition().squaredDistance(it->getPosition()) <= (radius*radius))

code/branches/core3/src/orxonox/objects/Skybox.cc

@@ -59 +59 @@
     }
 
-    void Skybox::setSkyboxSrc(const std::string& src)
-    {
-        this->skyboxSrc_ = src;
-    }
-
     /**
         @brief XML loading and saving.
@@ -74 +69 @@
         BaseObject::XMLPort(xmlelement, mode);
 
-        XMLPortParamLoadOnly(Skybox, "src", setSkyboxSrc, xmlelement, mode);
+        XMLPortParam(Skybox, "src", setSkyboxSrc, getSkyboxSrc, xmlelement, mode);
         create();
     }

code/branches/core3/src/orxonox/objects/Skybox.h

@@ -49 +49 @@
             virtual bool create();
             void registerAllVariables();
-            void setSkyboxSrc(const std::string &src);
+
+            inline void setSkyboxSrc(const std::string &src)
+                { this->skyboxSrc_ = src; }
+            inline const std::string& getSkyboxSrc() const
+                { return this->skyboxSrc_; }
 
         private:

code/branches/core3/src/orxonox/objects/SpaceShip.cc

@@ -347 +347 @@
         Model::XMLPort(xmlelement, mode);
 
-        XMLPortParamLoadOnly(SpaceShip, "camera", setCamera, xmlelement, mode);
-        XMLPortParamLoadOnly(SpaceShip, "maxSpeed", setMaxSpeed, xmlelement, mode);
-        XMLPortParamLoadOnly(SpaceShip, "maxSideAndBackSpeed", setMaxSideAndBackSpeed, xmlelement, mode);
-        XMLPortParamLoadOnly(SpaceShip, "maxRotation", setMaxRotation, xmlelement, mode);
-        XMLPortParamLoadOnly(SpaceShip, "transAcc", setTransAcc, xmlelement, mode);
-        XMLPortParamLoadOnly(SpaceShip, "rotAcc", setRotAcc, xmlelement, mode);
-        XMLPortParamLoadOnly(SpaceShip, "transDamp", setTransDamp, xmlelement, mode);
-        XMLPortParamLoadOnly(SpaceShip, "rotDamp", setRotDamp, xmlelement, mode);
+        XMLPortParam(SpaceShip, "camera", setCamera, getCamera, xmlelement, mode);
+        XMLPortParam(SpaceShip, "maxSpeed", setMaxSpeed, getMaxSpeed, xmlelement, mode);
+        XMLPortParam(SpaceShip, "maxSideAndBackSpeed", setMaxSideAndBackSpeed, getMaxSideAndBackSpeed, xmlelement, mode);
+        XMLPortParam(SpaceShip, "maxRotation", setMaxRotation, getMaxRotation, xmlelement, mode);
+        XMLPortParam(SpaceShip, "transAcc", setTransAcc, getTransAcc, xmlelement, mode);
+        XMLPortParam(SpaceShip, "rotAcc", setRotAcc, getRotAcc, xmlelement, mode);
+        XMLPortParam(SpaceShip, "transDamp", setTransDamp, getTransDamp, xmlelement, mode);
+        XMLPortParam(SpaceShip, "rotDamp", setRotDamp, getRotDamp, xmlelement, mode);
 
         SpaceShip::create();

code/branches/core3/src/orxonox/objects/WorldEntity.cc

@@ -95 +95 @@
     }
 
-    void WorldEntity::loadParams(TiXmlElement* xmlElem)
-    {
-
-        BaseObject::loadParams(xmlElem);
-        create();
-    }
-
-
     void WorldEntity::setYawPitchRoll(const Degree& yaw, const Degree& pitch, const Degree& roll)
     {
@@ -120 +112 @@
         BaseObject::XMLPort(xmlelement, mode);
 
-        XMLPortParam(WorldEntity, "position", setPositionLoader2, getPosition, xmlelement, mode);
-        XMLPortParamLoadOnly(WorldEntity, "direction", setDirectionLoader, xmlelement, mode);
+        XMLPortParamExternTemplate(Ogre::Node, this->node_, "position", setPosition, getPosition, xmlelement, mode, Ogre::Node, const Vector3&);
+        XMLPortParamLoadOnly(WorldEntity, "direction", setDirectionSimple, xmlelement, mode);
         XMLPortParamLoadOnly(WorldEntity, "yawpitchroll", setYawPitchRoll, xmlelement, mode);
-        XMLPortParam(WorldEntity, "scale", setTotalScale, getScale, xmlelement, mode);
-        XMLPortParam(WorldEntity, "rotationAxis", setRotationAxisLoader, getRotationAxis, xmlelement, mode);
+        XMLPortParam(WorldEntity, "scale", setScale, getScale, xmlelement, mode);
+        XMLPortParamTemplate(WorldEntity, "rotationAxis", setRotationAxis, getRotationAxis, xmlelement, mode, WorldEntity, const Vector3&);
         XMLPortParam(WorldEntity, "rotationRate", setRotationRate, getRotationRate, xmlelement, mode);
 
@@ -157 +149 @@
       registerVar( (void*) &(this->getRotationAxis().z), sizeof(this->getRotationAxis().z), network::DATA, 0x3);
       // register scale of node
-      registerVar( (void*) &(this->getScale().x), sizeof(this->getScale().x), network::DATA, 0x3);
-      registerVar( (void*) &(this->getScale().y), sizeof(this->getScale().y), network::DATA, 0x3);
-      registerVar( (void*) &(this->getScale().z), sizeof(this->getScale().z), network::DATA, 0x3);
+      registerVar( (void*) &(this->getScale3D().x), sizeof(this->getScale3D().x), network::DATA, 0x3);
+      registerVar( (void*) &(this->getScale3D().y), sizeof(this->getScale3D().y), network::DATA, 0x3);
+      registerVar( (void*) &(this->getScale3D().z), sizeof(this->getScale3D().z), network::DATA, 0x3);
       //register staticity
       registerVar( (void*) &(this->bStatic_), sizeof(this->bStatic_), network::DATA, 0x3);

code/branches/core3/src/orxonox/objects/WorldEntity.h

@@ -51 +51 @@
 
             virtual void tick(float dt);
-            virtual void loadParams(TiXmlElement* xmlElem);
             virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
             virtual inline bool create(){ return Synchronisable::create(); }
@@ -66 +65 @@
             inline void setPosition(const Vector3& pos)
                 { this->node_->setPosition(pos); }
-            inline void setPositionLoader1(const Vector3& pos)
-                { this->node_->setPosition(pos); }
-            inline void setPositionLoader2(Real x, Real y, Real z)
-                { this->node_->setPosition(x, y, z); }
             inline void setPosition(Real x, Real y, Real z)
                 { this->node_->setPosition(x, y, z); }
@@ -105 +100 @@
             inline void rotate(const Vector3 &axis, const Radian &angle, Ogre::Node::TransformSpace relativeTo=Ogre::Node::TS_LOCAL)
               { this->node_->rotate(axis, angle, relativeTo); }
-            inline void setDirectionLoader(Real x, Real y, Real z)
+            inline void setDirectionSimple(Real x, Real y, Real z)
               { this->setDirection(x, y, z); }
             inline void setDirection(Real x, Real y, Real z, Ogre::Node::TransformSpace relativeTo=Ogre::Node::TS_LOCAL, const Vector3 &localDirectionVector=Vector3::NEGATIVE_UNIT_Z)
@@ -114 +109 @@
               { this->node_->lookAt(targetPoint, relativeTo, localDirectionVector); }
 
-            inline void setScale(const Vector3 &scale)
+            inline void setScale3D(const Vector3 &scale)
               { this->node_->setScale(scale); }
-            inline void setScale(Real x, Real y, Real z)
+            inline void setScale3D(Real x, Real y, Real z)
               { this->node_->setScale(x, y, z); }
-            inline void setScale(Real scale)
+            inline const Vector3& getScale3D(void) const
+              { return this->node_->getScale(); }
+            inline void setScale(float scale)
               { this->node_->setScale(scale, scale, scale); }
-            inline void setTotalScale(Real scale)
-              { this->node_->setScale(scale, scale, scale); }
-            inline const Vector3& getScale(void) const
-              { return this->node_->getScale(); }
-            inline void scale(const Vector3 &scale)
+            inline float getScale() const
+              { Vector3 scale = this->getScale3D(); return (scale.x == scale.y && scale.x == scale.z) ? scale.x : 1; }
+            inline void scale3D(const Vector3 &scale)
               { this->node_->scale(scale); }
-            inline void scale(Real x, Real y, Real z)
+            inline void scale3D(Real x, Real y, Real z)
               { this->node_->scale(x, y, z); }
             inline void scale(Real scale)
@@ -154 +149 @@
                 { return this->acceleration_; }
 
-            inline void setRotationAxisLoader(const Vector3& axis)
-                { this->rotationAxis_ = axis; rotationAxis_.normalise(); }
             inline void setRotationAxis(const Vector3& axis)
-                { this->rotationAxis_ = axis; rotationAxis_.normalise(); }
+                { this->rotationAxis_ = axis; this->rotationAxis_.normalise(); }
             inline void setRotationAxis(Real x, Real y, Real z)
                 { this->rotationAxis_.x = x; this->rotationAxis_.y = y; this->rotationAxis_.z = z; rotationAxis_.normalise(); }