Changeset 1989 for code

Timestamp:

Oct 21, 2008, 4:56:41 PM (16 years ago)

Author:

landauf

Message:

• added ControllableEntity, the baseclass of all players, vehicles and ships.
• moved Template to core
• some changes in Camera
• added 6 constants to WorldEntity to identify relative directions
• changed vom Radian to Degree as default angle unit

Location:

code/branches/objecthierarchy/src

Files:

• core/BaseObject.cc (modified) (3 diffs)
• core/BaseObject.h (modified) (2 diffs)
• core/CMakeLists.txt (modified) (1 diff)
• core/CorePrereqs.h (modified) (1 diff)
• core/Template.cc (moved) (moved from code/branches/objecthierarchy/src/orxonox/objects/Template.cc) (2 diffs, 1 prop)
• core/Template.h (moved) (moved from code/branches/objecthierarchy/src/orxonox/objects/Template.h) (2 diffs, 1 prop)
• core/XMLPort.h (modified) (2 diffs)
• network/Synchronisable.cc (modified) (2 diffs)
• network/Synchronisable.h (modified) (1 diff)
• orxonox/CMakeLists.txt (modified) (1 diff)
• orxonox/OrxonoxPrereqs.h (modified) (1 diff)
• orxonox/gamestates/GSStandalone.cc (modified) (2 diffs)
• orxonox/objects/Camera.cc (modified) (3 diffs)
• orxonox/objects/Camera.h (modified) (2 diffs)
• orxonox/objects/gametypes/Gametype.cc (modified) (1 diff)
• orxonox/objects/gametypes/Gametype.h (modified) (2 diffs)
• orxonox/objects/infos/PlayerInfo.cc (modified) (4 diffs)
• orxonox/objects/infos/PlayerInfo.h (modified) (3 diffs)
• orxonox/objects/worldentities/ControllableEntity.cc (added)
• orxonox/objects/worldentities/ControllableEntity.h (added)
• orxonox/objects/worldentities/MovableEntity.cc (modified) (5 diffs)
• orxonox/objects/worldentities/MovableEntity.h (modified) (3 diffs)
• orxonox/objects/worldentities/PositionableEntity.h (modified) (1 diff)
• orxonox/objects/worldentities/WorldEntity.cc (modified) (2 diffs)
• orxonox/objects/worldentities/WorldEntity.h (modified) (4 diffs)

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

@@ -37 +37 @@
 #include "XMLPort.h"
 #include "Level.h"
+#include "Template.h"
 
 namespace orxonox
@@ -76 +77 @@
         XMLPortParam(BaseObject, "visible", setVisible, isVisible, xmlelement, mode);
         XMLPortParam(BaseObject, "active", setActive, isActive, xmlelement, mode);
+
+        XMLPortObjectTemplate(BaseObject, Template, "templates", addTemplate, getTemplate, xmlelement, mode, const std::string&);
     }
 
@@ -86 +89 @@
         return this->level_->getFile();
     }
+
+    /**
+        @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;
+    }
 }

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

@@ -87 +87 @@
             const std::string& getLevelfile() 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_; }
@@ -102 +108 @@
 
         private:
+            Template* getTemplate(unsigned int index) const;
+
             bool bInitialized_;                         //!< True if the object was initialized (passed the object registration)
             const Level* level_;                        //!< The level that loaded this object
             std::string loaderIndentation_;             //!< Indentation of the debug output in the Loader
             Namespace* namespace_;
+            std::set<Template*> templates_;
     };
 

code/branches/objecthierarchy/src/core/CMakeLists.txt

@@ -31 +31 @@
   Namespace.cc
   NamespaceNode.cc
+  Template.cc
   XMLPort.cc
 

code/branches/objecthierarchy/src/core/CorePrereqs.h

@@ -153 +153 @@
   struct TclInterpreterBundle;
   class TclThreadManager;
+  class Template;
   class Tickable;
   template <class T, class O>

code/branches/objecthierarchy/src/core/Template.cc

@@ -49 +49 @@
     Template::~Template()
     {
+        Template::getTemplateMap().erase(this->getName());
     }
 
@@ -59 +60 @@
 
         this->setXMLElement(*xmlelement.FirstChildElement(false));
+    }
+
+    void Template::changedName()
+    {
+        if (this->getName() != "")
+        {
+            std::map<std::string, Template*>::iterator it;
+            it = Template::getTemplateMap().find(this->getOldName());
+            if (it != Template::getTemplateMap().end())
+                Template::getTemplateMap().erase(it);
+
+            it = Template::getTemplateMap().find(this->getName());
+            if (it != Template::getTemplateMap().end())
+                COUT(2) << "Warning: Template with name \"" << this->getName() << "\" already exists." << std::endl;
+            else
+                Template::getTemplateMap()[this->getName()] = this;
+        }
     }
 

code/branches/objecthierarchy/src/core/Template.h

@@ -32 +32 @@
 #include <map>
 
-#include "OrxonoxPrereqs.h"
-#include "core/BaseObject.h"
+#include "CorePrereqs.h"
+
+#include "BaseObject.h"
 #include "tinyxml/ticpp.h"
 
 namespace orxonox
 {
-    class _OrxonoxExport Template : public BaseObject
+    class _CoreExport Template : public BaseObject
     {
         public:
@@ -45 +46 @@
 
             virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
+            virtual void changedName();
 
             inline void setLink(const std::string& link)

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

@@ -219 +219 @@
 */
 #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)
+    XMLPortObjectGeneric(xmlcontainer##loadfunction##savefunction, classname, objectclass, sectionname, 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, bApplyLoaderMask, bLoadBefore)
 
 // -------------
@@ -233 +233 @@
 */
 #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)
+    XMLPortObjectGeneric(xmlcontainer##loadfunction##savefunction, classname, objectclass, sectionname, 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, false, true)
 
 // --------------------

code/branches/objecthierarchy/src/network/Synchronisable.cc

@@ -81 +81 @@
       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;
@@ -418 +419 @@
    */
   void Synchronisable::setObjectMode(int mode){
-    assert(mode==0x1 || mode==0x2 || mode==0x3);
+    assert(mode==0x0 || mode==0x1 || mode==0x2 || mode==0x3);
     objectMode_=mode;
   }

code/branches/objecthierarchy/src/network/Synchronisable.h

@@ -48 +48 @@
 namespace network
 {
+  static const unsigned int OBJECTID_UNKNOWN = (unsigned int)-1;
+
   namespace direction{
     enum syncdirection{

code/branches/objecthierarchy/src/orxonox/CMakeLists.txt

@@ -43 +43 @@
   tools/WindowEventListener.cc
 
-  objects/Template.cc
-
   objects/worldentities/WorldEntity.cc
   objects/worldentities/PositionableEntity.cc
   objects/worldentities/MovableEntity.cc
+  objects/worldentities/ControllableEntity.cc
 #  objects/Backlight.cc
   objects/Camera.cc

code/branches/objecthierarchy/src/orxonox/OrxonoxPrereqs.h

@@ -81 +81 @@
 
     // objects
-    class Template;
-
     class WorldEntity;
     class PositionableEntity;

code/branches/objecthierarchy/src/orxonox/gamestates/GSStandalone.cc

@@ -49 +49 @@
         GSLevel::enter();
 
+        Core::setIsStandalone(true);
         this->loadLevel();
 
@@ -58 +59 @@
         // level is loaded: we can start capturing the input
         InputManager::getInstance().requestEnterState("game");
-
-        Core::setIsStandalone(true);
     }
 

code/branches/objecthierarchy/src/orxonox/objects/Camera.cc

@@ -47 +47 @@
 namespace orxonox
 {
+  Camera::Camera()
+  {
+    RegisterObject(Camera);
 
-  Camera::Camera(Ogre::SceneNode* node)
-  {
     this->bHasFocus_ = false;
-    this->cameraNode_ = GraphicsEngine::getInstance().getLevelSceneManager()->getRootSceneNode()->createChildSceneNode(node->getName() + "Camera");
-    if( node != NULL )
-      this->setPositionNode(node);
+    this->bDrag_ = false;
+    this->cameraNode_ = GraphicsEngine::getInstance().getLevelSceneManager()->getRootSceneNode()->createChildSceneNode();
+    this->setObjectMode(0x0);
   }
 
   Camera::~Camera()
   {
-    CameraHandler::getInstance()->releaseFocus(this);
-    GraphicsEngine::getInstance().getLevelSceneManager()->getRootSceneNode()->removeAndDestroyChild(cameraNode_->getName());
-  }
-
-  void Camera::setPositionNode(Ogre::SceneNode* node)
-  {
-    this->positionNode_ = node;
-    // set camera to node values according to camera mode
-  }
-
-  void Camera::setTargetNode(Ogre::SceneNode* obj)
-  {
-    this->targetNode_ = obj;
+    if (this->isInitialized())
+    {
+      CameraHandler::getInstance()->releaseFocus(this);
+      GraphicsEngine::getInstance().getLevelSceneManager()->getRootSceneNode()->removeAndDestroyChild(this->cameraNode_->getName());
+    }
   }
 
   void Camera::tick(float dt)
   {
-    if (this->positionNode_ != NULL)
-    {
       // this stuff here may need some adjustments
-      Vector3 offset = this->positionNode_->getWorldPosition() - this->cameraNode_->getWorldPosition();
-      float coeff = 15.0f * dt;
-      if (coeff > 1.0f)
-        coeff = 1.0f;
+      float coeff = (this->bDrag_) ? min(1.0f, 15.0f * dt) : (1.0f);
 
+      Vector3 offset = this->getNode()->getWorldPosition() - this->cameraNode_->getWorldPosition();
       this->cameraNode_->translate(coeff * offset);
 
-      this->cameraNode_->setOrientation(Quaternion::Slerp(1-coeff, this->positionNode_->getWorldOrientation(), this->cameraNode_->getWorldOrientation(), false));
-    }
+      this->cameraNode_->setOrientation(Quaternion::Slerp(coeff, this->cameraNode_->getWorldOrientation(), this->getWorldOrientation(), false));
   }
 
@@ -95 +83 @@
   void Camera::update()
   {
-    if(this->positionNode_ != NULL)
-    {
-      this->cameraNode_->setPosition(this->positionNode_->getWorldPosition());
-      this->cameraNode_->setOrientation(this->positionNode_->getWorldOrientation());
-    }
+      this->cameraNode_->setPosition(this->getWorldPosition());
+      this->cameraNode_->setOrientation(this->getWorldOrientation());
   }
 
@@ -119 +104 @@
     this->cameraNode_->attachObject(this->cam_);
   }
+
+  void Camera::requestFocus()
+  {
+    CameraHandler::getInstance()->requestFocus(this);
+  }
 }

code/branches/objecthierarchy/src/orxonox/objects/Camera.h

@@ -35 +35 @@
 
 #include "OrxonoxPrereqs.h"
+#include "objects/worldentities/PositionableEntity.h"
 
 namespace orxonox
 {
-    class _OrxonoxExport Camera
+    class _OrxonoxExport Camera : public PositionableEntity
     {
       friend class CameraHandler;
       public:
-        Camera(Ogre::SceneNode* node = NULL);
+        Camera();
         virtual ~Camera();
-
-        void setPositionNode(Ogre::SceneNode* node);
-        inline Ogre::SceneNode* getCameraNode() { return this->positionNode_; }
-        // maybe also BaseObject
-        void setTargetNode(Ogre::SceneNode* obj);
-
-        Ogre::Camera* cam_;
 
         void tick(float dt);
         void update();
-        inline bool hasFocus() { return this->bHasFocus_; }
+
+        void requestFocus();
+        inline bool hasFocus()
+            { return this->bHasFocus_; }
+
+        inline void setDrag(bool bDrag)
+            { this->bDrag_ = bDrag; }
+        inline bool getDrag() const
+            { return this->bDrag_; }
 
       private:
@@ -60 +62 @@
         void setFocus(Ogre::Camera* ogreCam);
 
-      private:
-        Ogre::SceneNode* targetNode_;
-        Ogre::SceneNode* positionNode_;
+        Ogre::Camera* cam_;
         Ogre::SceneNode* cameraNode_;
         Ogre::Vector3 oldPos;
         bool bHasFocus_;
+        bool bDrag_;
     };
 }

code/branches/objecthierarchy/src/orxonox/objects/gametypes/Gametype.cc

@@ -122 +122 @@
         this->players_.insert(player);
         this->playerJoined(player);
+
+        ControllableEntity* newpawn = this->defaultPawn_.fabricate();
+        player->startControl(newpawn);
     }
 
     void Gametype::removePlayer(PlayerInfo* player)
     {
+        player->stopControl();
         this->players_.erase(player);
         this->playerLeft(player);

code/branches/objecthierarchy/src/orxonox/objects/gametypes/Gametype.h

@@ -35 +35 @@
 
 #include "core/BaseObject.h"
+#include "core/Identifier.h"
 #include "network/ClientConnectionListener.h"
+#include "objects/worldentities/ControllableEntity.h"
 
 namespace orxonox
@@ -71 +73 @@
             std::set<PlayerInfo*> players_;
             std::map<unsigned int, PlayerInfo*> clients_;
+            SubclassIdentifier<ControllableEntity> defaultPawn_;
     };
 }

code/branches/objecthierarchy/src/orxonox/objects/infos/PlayerInfo.cc

@@ -41 +41 @@
 #include "GraphicsEngine.h"
 #include "objects/gametypes/Gametype.h"
+#include "objects/worldentities/ControllableEntity.h"
 
 namespace orxonox
@@ -56 +57 @@
         this->bHumanPlayer_ = false;
         this->bFinishedSetup_ = false;
+
+        this->pawn_ = 0;
+        this->pawnID_ = network::OBJECTID_UNKNOWN;
 
         this->setConfigValues();
@@ -103 +107 @@
         REGISTERDATA(ping_,           network::direction::toclient);
         REGISTERDATA(bHumanPlayer_,   network::direction::toclient);
+        REGISTERDATA(pawnID_,         network::direction::toclient, new network::NetworkCallback<PlayerInfo>(this, &PlayerInfo::updatePawn));
         REGISTERDATA(bFinishedSetup_, network::direction::bidirectional, new network::NetworkCallback<PlayerInfo>(this, &PlayerInfo::finishedSetup));
     }
@@ -160 +165 @@
         }
     }
+
+    void PlayerInfo::startControl(ControllableEntity* pawn)
+    {
+        pawn->setPlayer(this);
+        this->pawn_ = pawn;
+        this->pawnID_ = pawn->getObjectID();
+    }
+
+    void PlayerInfo::stopControl()
+    {
+        this->pawn_->removePlayer();
+        this->pawn_ = 0;
+        this->pawnID_ = network::OBJECTID_UNKNOWN;
+    }
+
+    void PlayerInfo::updatePawn()
+    {
+        this->pawn_ = dynamic_cast<ControllableEntity*>(network::Synchronisable::getSynchronisable(this->pawnID_));
+        if (this->pawn_ && (this->pawn_->getPlayer() != this))
+            this->pawn_->setPlayer(this);
+    }
 }

code/branches/objecthierarchy/src/orxonox/objects/infos/PlayerInfo.h

@@ -52 +52 @@
                 { return this->clientID_; }
 
-            inline void setHumanPlayer(bool bHumanPlayer)
-                { this->bHumanPlayer_ = bHumanPlayer; }
             inline bool isHumanPlayer() const
                 { return this->bHumanPlayer_; }
+
+            inline bool isLocalPlayer() const
+                { return this->bLocalPlayer_; }
+
+            void startControl(ControllableEntity* pawn);
+            void stopControl();
+
+            inline ControllableEntity* getPawn() const
+                { return this->pawn_; }
 
         private:
@@ -62 +69 @@
             void checkNick();
             void clientChangedName();
+            void updatePawn();
 
             unsigned int clientID_;
@@ -71 +79 @@
             std::string playerName_;
             std::string nick_;
+
+            ControllableEntity* pawn_;
+            unsigned int pawnID_;
     };
 }

code/branches/objecthierarchy/src/orxonox/objects/worldentities/MovableEntity.cc

@@ -44 +44 @@
         RegisterObject(MovableEntity);
 
+        this->velocity_ = Vector3::ZERO;
+        this->acceleration_ = Vector3::ZERO;
+        this->rotationAxis_ = Vector3::ZERO;
+        this->rotationRate_ = 0;
+        this->momentum_ = 0;
+
+        this->overwrite_position_ = Vector3::ZERO;
+        this->overwrite_orientation_ = Quaternion::IDENTITY;
+
         this->registerVariables();
     }
@@ -57 +66 @@
         XMLPortParamTemplate(MovableEntity, "velocity", setVelocity, getVelocity, xmlelement, mode, const Vector3&);
         XMLPortParamTemplate(MovableEntity, "rotationaxis", setRotationAxis, getRotationAxis, xmlelement, mode, const Vector3&);
-        XMLPortParamTemplate(MovableEntity, "rotationrate", setRotationRate, getRotationRate, xmlelement, mode, const Radian&);
+        XMLPortParamTemplate(MovableEntity, "rotationrate", setRotationRate, getRotationRate, xmlelement, mode, const Degree&);
     }
 
@@ -139 +148 @@
     }
 
-    void MovableEntity::yaw(const Radian& angle, Ogre::Node::TransformSpace relativeTo)
+    void MovableEntity::yaw(const Degree& angle, Ogre::Node::TransformSpace relativeTo)
     {
         this->node_->yaw(angle, relativeTo);
@@ -145 +154 @@
     }
 
-    void MovableEntity::pitch(const Radian& angle, Ogre::Node::TransformSpace relativeTo)
+    void MovableEntity::pitch(const Degree& angle, Ogre::Node::TransformSpace relativeTo)
     {
         this->node_->pitch(angle, relativeTo);
@@ -151 +160 @@
     }
 
-    void MovableEntity::roll(const Radian& angle, Ogre::Node::TransformSpace relativeTo)
+    void MovableEntity::roll(const Degree& angle, Ogre::Node::TransformSpace relativeTo)
     {
         this->node_->roll(angle, relativeTo);

code/branches/objecthierarchy/src/orxonox/objects/worldentities/MovableEntity.h

@@ -59 +59 @@
             void setOrientation(const Quaternion& orientation);
             void rotate(const Quaternion& rotation, Ogre::Node::TransformSpace relativeTo = Ogre::Node::TS_LOCAL);
-            void yaw(const Radian& angle, Ogre::Node::TransformSpace relativeTo = Ogre::Node::TS_LOCAL);
-            void pitch(const Radian& angle, Ogre::Node::TransformSpace relativeTo = Ogre::Node::TS_LOCAL);
-            void roll(const Radian& angle, Ogre::Node::TransformSpace relativeTo = Ogre::Node::TS_LOCAL);
+            void yaw(const Degree& angle, Ogre::Node::TransformSpace relativeTo = Ogre::Node::TS_LOCAL);
+            void pitch(const Degree& angle, Ogre::Node::TransformSpace relativeTo = Ogre::Node::TS_LOCAL);
+            void roll(const Degree& angle, Ogre::Node::TransformSpace relativeTo = Ogre::Node::TS_LOCAL);
             void lookAt(const Vector3& target, Ogre::Node::TransformSpace relativeTo = Ogre::Node::TS_LOCAL, const Vector3& localDirectionVector = Vector3::NEGATIVE_UNIT_Z);
             void setDirection(const Vector3& direction, Ogre::Node::TransformSpace relativeTo = Ogre::Node::TS_LOCAL, const Vector3& localDirectionVector = Vector3::NEGATIVE_UNIT_Z);
@@ -86 +86 @@
                 { return this->rotationAxis_; }
 
+            inline void setRotationRate(const Degree& angle)
+                { this->rotationRate_ = angle; }
             inline void setRotationRate(const Radian& angle)
                 { this->rotationRate_ = angle; }
-            inline void setRotationRate(const Degree& angle)
-                { this->rotationRate_ = angle; }
-            inline const Radian& getRotationRate() const
+            inline const Degree& getRotationRate() const
                 { return this->rotationRate_; }
 
+            inline void setMomentum(const Degree& angle)
+                { this->momentum_ = angle; }
             inline void setMomentum(const Radian& angle)
                 { this->momentum_ = angle; }
-            inline void setMomentum(const Degree& angle)
-                { this->momentum_ = angle; }
-            inline const Radian& getMomentum() const
+            inline const Degree& getMomentum() const
                 { return this->momentum_; }
 
@@ -111 +111 @@
             Vector3 acceleration_;
             Vector3 rotationAxis_;
-            Radian rotationRate_;
-            Radian momentum_;
+            Degree rotationRate_;
+            Degree momentum_;
 
             Vector3 overwrite_position_;

code/branches/objecthierarchy/src/orxonox/objects/worldentities/PositionableEntity.h

@@ -58 +58 @@
             inline void rotate(const Quaternion& rotation, Ogre::Node::TransformSpace relativeTo = Ogre::Node::TS_LOCAL)
                 { this->node_->rotate(rotation, relativeTo); }
-            inline void yaw(const Radian& angle, Ogre::Node::TransformSpace relativeTo = Ogre::Node::TS_LOCAL)
+            inline void yaw(const Degree& angle, Ogre::Node::TransformSpace relativeTo = Ogre::Node::TS_LOCAL)
                 { this->node_->yaw(angle, relativeTo); }
-            inline void pitch(const Radian& angle, Ogre::Node::TransformSpace relativeTo = Ogre::Node::TS_LOCAL)
+            inline void pitch(const Degree& angle, Ogre::Node::TransformSpace relativeTo = Ogre::Node::TS_LOCAL)
                 { this->node_->pitch(angle, relativeTo); }
-            inline void roll(const Radian& angle, Ogre::Node::TransformSpace relativeTo = Ogre::Node::TS_LOCAL)
+            inline void roll(const Degree& angle, Ogre::Node::TransformSpace relativeTo = Ogre::Node::TS_LOCAL)
                 { this->node_->roll(angle, relativeTo); }
             inline void lookAt(const Vector3& target, Ogre::Node::TransformSpace relativeTo = Ogre::Node::TS_LOCAL, const Vector3& localDirectionVector = Vector3::NEGATIVE_UNIT_Z)

code/branches/objecthierarchy/src/orxonox/objects/worldentities/WorldEntity.cc

@@ -39 +39 @@
 namespace orxonox
 {
+    const Vector3 WorldEntity::FRONT = Vector3::NEGATIVE_UNIT_Z;
+    const Vector3 WorldEntity::BACK  = Vector3::UNIT_Z;
+    const Vector3 WorldEntity::LEFT  = Vector3::NEGATIVE_UNIT_X;
+    const Vector3 WorldEntity::RIGHT = Vector3::UNIT_X;
+    const Vector3 WorldEntity::DOWN  = Vector3::NEGATIVE_UNIT_Y;
+    const Vector3 WorldEntity::UP    = Vector3::UNIT_Y;
+
     WorldEntity::WorldEntity()
     {
@@ -46 +53 @@
         this->parent_ = 0;
         this->parentID_ = (unsigned int)-1;
+
+        this->node_->setPosition(Vector3::ZERO);
+        this->node_->setOrientation(Quaternion::IDENTITY);
 
         this->registerVariables();

code/branches/objecthierarchy/src/orxonox/objects/worldentities/WorldEntity.h

@@ -54 +54 @@
                 { return this->node_; }
 
+            static const Vector3 FRONT;
+            static const Vector3 BACK;
+            static const Vector3 LEFT;
+            static const Vector3 RIGHT;
+            static const Vector3 DOWN;
+            static const Vector3 UP;
+
             virtual void setPosition(const Vector3& position) = 0;
             inline void setPosition(float x, float y, float z)
@@ -71 +78 @@
             inline void setOrientation(const Vector3& axis, const Radian& angle)
                 { this->setOrientation(Quaternion(angle, axis)); }
+            inline void setOrientation(const Vector3& axis, const Degree& angle)
+                { this->setOrientation(Quaternion(angle, axis)); }
             inline const Quaternion& getOrientation() const
                 { return this->node_->getOrientation(); }
@@ -77 +86 @@
 
             virtual void rotate(const Quaternion& rotation, Ogre::Node::TransformSpace relativeTo = Ogre::Node::TS_LOCAL) = 0;
+            inline void rotate(const Vector3& axis, const Degree& angle, Ogre::Node::TransformSpace relativeTo = Ogre::Node::TS_LOCAL)
+                { this->rotate(Quaternion(angle, axis), relativeTo); }
             inline void rotate(const Vector3& axis, const Radian& angle, Ogre::Node::TransformSpace relativeTo = Ogre::Node::TS_LOCAL)
                 { this->rotate(Quaternion(angle, axis), relativeTo); }
 
-            virtual void yaw(const Radian& angle, Ogre::Node::TransformSpace relativeTo = Ogre::Node::TS_LOCAL) = 0;
-            virtual void pitch(const Radian& angle, Ogre::Node::TransformSpace relativeTo = Ogre::Node::TS_LOCAL) = 0;
-            virtual void roll(const Radian& angle, Ogre::Node::TransformSpace relativeTo = Ogre::Node::TS_LOCAL) = 0;
+            virtual void yaw(const Degree& angle, Ogre::Node::TransformSpace relativeTo = Ogre::Node::TS_LOCAL) = 0;
+            inline void yaw(const Radian& angle, Ogre::Node::TransformSpace relativeTo = Ogre::Node::TS_LOCAL)
+                { this->yaw(Degree(angle), relativeTo); }
+            virtual void pitch(const Degree& angle, Ogre::Node::TransformSpace relativeTo = Ogre::Node::TS_LOCAL) = 0;
+            inline void pitch(const Radian& angle, Ogre::Node::TransformSpace relativeTo = Ogre::Node::TS_LOCAL)
+                { this->pitch(Degree(angle), relativeTo); }
+            virtual void roll(const Degree& angle, Ogre::Node::TransformSpace relativeTo = Ogre::Node::TS_LOCAL) = 0;
+            inline void roll(const Radian& angle, Ogre::Node::TransformSpace relativeTo = Ogre::Node::TS_LOCAL)
+                { this->roll(Degree(angle), relativeTo); }
 
             virtual void lookAt(const Vector3& target, Ogre::Node::TransformSpace relativeTo = Ogre::Node::TS_LOCAL, const Vector3& localDirectionVector = Vector3::NEGATIVE_UNIT_Z) = 0;
@@ -131 +148 @@
             inline void setDirection_xmlport(const Vector3& direction)
                 { this->setDirection(direction); }
-            inline void yaw_xmlport(const Radian& angle)
+            inline void yaw_xmlport(const Degree& angle)
                 { this->yaw(angle); }
-            inline void pitch_xmlport(const Radian& angle)
+            inline void pitch_xmlport(const Degree& angle)
                 { this->pitch(angle); }
-            inline void roll_xmlport(const Radian& angle)
+            inline void roll_xmlport(const Degree& angle)
                 { this->roll(angle); }