Index: code/branches/physics/src/orxonox/objects/worldentities/MobileEntity.cc
===================================================================
--- code/branches/physics/src/orxonox/objects/worldentities/MobileEntity.cc	(revision 2425)
+++ code/branches/physics/src/orxonox/objects/worldentities/MobileEntity.cc	(revision 2426)
@@ -30,4 +30,5 @@
 #include "MobileEntity.h"
 
+#include <OgreSceneNode.h>
 #include "BulletDynamics/Dynamics/btRigidBody.h"
 
@@ -117,17 +118,4 @@
     }
 
-    void MobileEntity::translate(const Vector3& distance, Ogre::Node::TransformSpace relativeTo)
-    {
-        if (this->isDynamic())
-        {
-            OrxAssert(relativeTo == Ogre::Node::TS_LOCAL, "Cannot translate physical object relative \
-                                                          to any other space than TS_LOCAL.");
-            this->physicalBody_->translate(btVector3(distance.x, distance.y, distance.z));
-        }
-
-        this->node_->translate(distance, relativeTo);
-        positionChanged(false);
-    }
-
     void MobileEntity::setOrientation(const Quaternion& orientation)
     {
@@ -140,89 +128,4 @@
 
         this->node_->setOrientation(orientation);
-        orientationChanged(false);
-    }
-
-    void MobileEntity::rotate(const Quaternion& rotation, Ogre::Node::TransformSpace relativeTo)
-    {
-        if (this->isDynamic())
-        {
-            OrxAssert(relativeTo == Ogre::Node::TS_LOCAL, "Cannot rotate physical object relative \
-                                                          to any other space than TS_LOCAL.");
-            btTransform transf = this->physicalBody_->getWorldTransform();
-            this->physicalBody_->setWorldTransform(transf * btTransform(btQuaternion(rotation.x, rotation.y, rotation.z, rotation.w)));
-        }
-
-        this->node_->rotate(rotation, relativeTo);
-        orientationChanged(false);
-    }
-
-    void MobileEntity::yaw(const Degree& angle, Ogre::Node::TransformSpace relativeTo)
-    {
-        if (this->isDynamic())
-        {
-            OrxAssert(relativeTo == Ogre::Node::TS_LOCAL, "Cannot yaw physical object relative \
-                                                          to any other space than TS_LOCAL.");
-            btTransform transf = this->physicalBody_->getWorldTransform();
-            btTransform rotation(btQuaternion(angle.valueRadians(), 0.0f, 0.0f));
-            this->physicalBody_->setWorldTransform(transf * rotation);
-        }
-
-        this->node_->yaw(angle, relativeTo);
-        orientationChanged(false);
-    }
-
-    void MobileEntity::pitch(const Degree& angle, Ogre::Node::TransformSpace relativeTo)
-    {
-        if (this->isDynamic())
-        {
-            OrxAssert(relativeTo == Ogre::Node::TS_LOCAL, "Cannot pitch physical object relative \
-                                                          to any other space than TS_LOCAL.");
-            btTransform transf = this->physicalBody_->getWorldTransform();
-            btTransform rotation(btQuaternion(0.0f, angle.valueRadians(), 0.0f));
-            this->physicalBody_->setWorldTransform(transf * rotation);
-        }
-
-        this->node_->pitch(angle, relativeTo);
-        orientationChanged(false);
-    }
-
-    void MobileEntity::roll(const Degree& angle, Ogre::Node::TransformSpace relativeTo)
-    {
-        if (this->isDynamic())
-        {
-            OrxAssert(relativeTo == Ogre::Node::TS_LOCAL, "Cannot roll physical object relative \
-                                                          to any other space than TS_LOCAL.");
-            btTransform transf = this->physicalBody_->getWorldTransform();
-            btTransform rotation(btQuaternion(angle.valueRadians(), 0.0f, 0.0f));
-            this->physicalBody_->setWorldTransform(transf * rotation);
-        }
-
-        this->node_->roll(angle, relativeTo);
-        orientationChanged(false);
-    }
-
-    void MobileEntity::lookAt(const Vector3& target, Ogre::Node::TransformSpace relativeTo, const Vector3& localDirectionVector)
-    {
-        if (this->isDynamic())
-        {
-            ThrowException(NotImplemented, "ControllableEntity::lookAt() is not yet supported for physical objects.");
-            OrxAssert(relativeTo == Ogre::Node::TS_LOCAL, "Cannot align physical object relative \
-                                                          to any other space than TS_LOCAL.");
-        }
-
-        this->node_->lookAt(target, relativeTo, localDirectionVector);
-        orientationChanged(false);
-    }
-
-    void MobileEntity::setDirection(const Vector3& direction, Ogre::Node::TransformSpace relativeTo, const Vector3& localDirectionVector)
-    {
-        if (this->isDynamic())
-        {
-            ThrowException(NotImplemented, "ControllableEntity::setDirection() is not yet supported for physical objects.");
-            OrxAssert(relativeTo == Ogre::Node::TS_LOCAL, "Cannot align physical object relative \
-                                                          to any other space than TS_LOCAL.");
-        }
-
-        this->node_->setDirection(direction, relativeTo, localDirectionVector);
         orientationChanged(false);
     }
Index: code/branches/physics/src/orxonox/objects/worldentities/MobileEntity.h
===================================================================
--- code/branches/physics/src/orxonox/objects/worldentities/MobileEntity.h	(revision 2425)
+++ code/branches/physics/src/orxonox/objects/worldentities/MobileEntity.h	(revision 2426)
@@ -48,22 +48,8 @@
 
             using WorldEntity::setPosition;
-            using WorldEntity::translate;
             using WorldEntity::setOrientation;
-            using WorldEntity::rotate;
-            using WorldEntity::yaw;
-            using WorldEntity::pitch;
-            using WorldEntity::roll;
-            using WorldEntity::lookAt;
-            using WorldEntity::setDirection;
 
             void setPosition(const Vector3& position);
-            void translate(const Vector3& distance, Ogre::Node::TransformSpace relativeTo = Ogre::Node::TS_LOCAL);
             void setOrientation(const Quaternion& orientation);
-            void rotate(const Quaternion& rotation, 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);
 
             void setVelocity(const Vector3& velocity);
Index: code/branches/physics/src/orxonox/objects/worldentities/StaticEntity.cc
===================================================================
--- code/branches/physics/src/orxonox/objects/worldentities/StaticEntity.cc	(revision 2425)
+++ code/branches/physics/src/orxonox/objects/worldentities/StaticEntity.cc	(revision 2426)
@@ -31,4 +31,5 @@
 #include "StaticEntity.h"
 
+#include <OgreSceneNode.h>
 #include "BulletDynamics/Dynamics/btRigidBody.h"
 
@@ -72,18 +73,4 @@
     }
 
-    void StaticEntity::translate(const Vector3& distance, Ogre::Node::TransformSpace relativeTo)
-    {
-        if (this->addedToPhysicalWorld())
-            ThrowException(PhysicsViolation, "Cannot change position or orientation of a StaticEntity with physics at run time.");
-        if (this->isStatic())
-        {
-            OrxAssert(relativeTo == Ogre::Node::TS_LOCAL, "Cannot translate physical object relative \
-                                                          to any other space than TS_LOCAL.");
-            this->physicalBody_->translate(btVector3(distance.x, distance.y, distance.z));
-        }
-
-        this->node_->translate(distance, relativeTo);
-    }
-
     void StaticEntity::setOrientation(const Quaternion& orientation)
     {
@@ -98,95 +85,4 @@
 
         this->node_->setOrientation(orientation);
-    }
-
-    void StaticEntity::rotate(const Quaternion& rotation, Ogre::Node::TransformSpace relativeTo)
-    {
-        if (this->addedToPhysicalWorld())
-            ThrowException(PhysicsViolation, "Cannot change position or orientation of a StaticEntity with physics at run time.");
-        if (this->isStatic())
-        {
-            OrxAssert(relativeTo == Ogre::Node::TS_LOCAL, "Cannot rotate physical object relative \
-                                                          to any other space than TS_LOCAL.");
-            btTransform transf = this->physicalBody_->getWorldTransform();
-            this->physicalBody_->setWorldTransform(transf * btTransform(btQuaternion(rotation.x, rotation.y, rotation.z, rotation.w)));
-        }
-
-        this->node_->rotate(rotation, relativeTo);
-    }
-
-    void StaticEntity::yaw(const Degree& angle, Ogre::Node::TransformSpace relativeTo)
-    {
-        if (this->addedToPhysicalWorld())
-            ThrowException(PhysicsViolation, "Cannot change position or orientation of a StaticEntity with physics at run time.");
-        if (this->isStatic())
-        {
-            OrxAssert(relativeTo == Ogre::Node::TS_LOCAL, "Cannot yaw physical object relative \
-                                                          to any other space than TS_LOCAL.");
-            btTransform transf = this->physicalBody_->getWorldTransform();
-            btTransform rotation(btQuaternion(angle.valueRadians(), 0.0f, 0.0f));
-            this->physicalBody_->setWorldTransform(transf * rotation);
-        }
-
-        this->node_->yaw(angle, relativeTo);
-    }
-
-    void StaticEntity::pitch(const Degree& angle, Ogre::Node::TransformSpace relativeTo)
-    {
-        if (this->addedToPhysicalWorld())
-            ThrowException(PhysicsViolation, "Cannot change position or orientation of a StaticEntity with physics at run time.");
-        if (this->isStatic())
-        {
-            OrxAssert(relativeTo == Ogre::Node::TS_LOCAL, "Cannot pitch physical object relative \
-                                                          to any other space than TS_LOCAL.");
-            btTransform transf = this->physicalBody_->getWorldTransform();
-            btTransform rotation(btQuaternion(0.0f, angle.valueRadians(), 0.0f));
-            this->physicalBody_->setWorldTransform(transf * rotation);
-        }
-
-        this->node_->pitch(angle, relativeTo);
-    }
-
-    void StaticEntity::roll(const Degree& angle, Ogre::Node::TransformSpace relativeTo)
-    {
-        if (this->addedToPhysicalWorld())
-            ThrowException(PhysicsViolation, "Cannot change position or orientation of a StaticEntity with physics at run time.");
-        if (this->isStatic())
-        {
-            OrxAssert(relativeTo == Ogre::Node::TS_LOCAL, "Cannot roll physical object relative \
-                                                          to any other space than TS_LOCAL.");
-            btTransform transf = this->physicalBody_->getWorldTransform();
-            btTransform rotation(btQuaternion(angle.valueRadians(), 0.0f, 0.0f));
-            this->physicalBody_->setWorldTransform(transf * rotation);
-        }
-
-        this->node_->roll(angle, relativeTo);
-    }
-
-    void StaticEntity::lookAt(const Vector3& target, Ogre::Node::TransformSpace relativeTo, const Vector3& localDirectionVector)
-    {
-        if (this->addedToPhysicalWorld())
-            ThrowException(PhysicsViolation, "Cannot change position or orientation of a StaticEntity with physics at run time.");
-        if (this->isStatic())
-        {
-            ThrowException(NotImplemented, "ControllableEntity::lookAt() is not yet supported for physical objects.");
-            OrxAssert(relativeTo == Ogre::Node::TS_LOCAL, "Cannot align physical object relative \
-                                                          to any other space than TS_LOCAL.");
-        }
-
-        this->node_->lookAt(target, relativeTo, localDirectionVector);
-    }
-
-    void StaticEntity::setDirection(const Vector3& direction, Ogre::Node::TransformSpace relativeTo, const Vector3& localDirectionVector)
-    {
-        if (this->addedToPhysicalWorld())
-            ThrowException(PhysicsViolation, "Cannot change position or orientation of a StaticEntity with physics at run time.");
-        if (this->isStatic())
-        {
-            ThrowException(NotImplemented, "ControllableEntity::setDirection() is not yet supported for physical objects.");
-            OrxAssert(relativeTo == Ogre::Node::TS_LOCAL, "Cannot align physical object relative \
-                                                          to any other space than TS_LOCAL.");
-        }
-
-        this->node_->setDirection(direction, relativeTo, localDirectionVector);
     }
 
Index: code/branches/physics/src/orxonox/objects/worldentities/StaticEntity.h
===================================================================
--- code/branches/physics/src/orxonox/objects/worldentities/StaticEntity.h	(revision 2425)
+++ code/branches/physics/src/orxonox/objects/worldentities/StaticEntity.h	(revision 2426)
@@ -45,26 +45,13 @@
 
             using WorldEntity::setPosition;
-            using WorldEntity::translate;
             using WorldEntity::setOrientation;
-            using WorldEntity::rotate;
-            using WorldEntity::yaw;
-            using WorldEntity::pitch;
-            using WorldEntity::roll;
-            using WorldEntity::lookAt;
-            using WorldEntity::setDirection;
 
             void setPosition(const Vector3& position);
-            void translate(const Vector3& distance, Ogre::Node::TransformSpace relativeTo = Ogre::Node::TS_LOCAL);
             void setOrientation(const Quaternion& orientation);
-            void rotate(const Quaternion& rotation, 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);
 
         private:
             bool isCollisionTypeLegal(CollisionType type) const;
 
+            // network callbacks
             inline void positionChanged()
                 { this->setPosition(this->getPosition()); }
Index: code/branches/physics/src/orxonox/objects/worldentities/WorldEntity.cc
===================================================================
--- code/branches/physics/src/orxonox/objects/worldentities/WorldEntity.cc	(revision 2425)
+++ code/branches/physics/src/orxonox/objects/worldentities/WorldEntity.cc	(revision 2426)
@@ -32,4 +32,5 @@
 
 #include <cassert>
+#include <OgreSceneNode.h>
 #include <OgreSceneManager.h>
 #include "BulletDynamics/Dynamics/btRigidBody.h"
@@ -249,4 +250,19 @@
     }
 
+    void WorldEntity::attachOgreObject(Ogre::MovableObject* object)
+    {
+        this->node_->attachObject(object);
+    }
+
+    void WorldEntity::detachOgreObject(Ogre::MovableObject* object)
+    {
+        this->node_->detachObject(object);
+    }
+
+    Ogre::MovableObject* WorldEntity::detachOgreObject(const Ogre::String& name)
+    {
+        return this->node_->detachObject(name);
+    }
+
     void WorldEntity::attachCollisionShape(CollisionShape* shape)
     {
@@ -289,4 +305,109 @@
     }
 
+#ifndef _NDEBUG
+    const Vector3& WorldEntity::getPosition() const
+    {
+        return this->node_->getPosition();
+    }
+
+    const Quaternion& WorldEntity::getOrientation() const
+    {
+        return this->node_->getOrientation();
+    }
+
+    const Vector3& WorldEntity::getScale3D() const
+    {
+        return this->node_->getScale();
+    }
+#endif
+
+    const Vector3& WorldEntity::getWorldPosition() const
+    {
+        return this->node_->_getDerivedPosition();
+    }
+
+    const Quaternion& WorldEntity::getWorldOrientation() const
+    {
+        return this->node_->_getDerivedOrientation();
+    }
+
+    void WorldEntity::translate(const Vector3& distance, TransformSpace::Space relativeTo)
+    {
+        switch (relativeTo)
+        {
+        case TransformSpace::Local:
+            // position is relative to parent so transform downwards
+            this->setPosition(this->getPosition() + this->getOrientation() * distance);
+            break;
+        case TransformSpace::Parent:
+            this->setPosition(this->getPosition() + distance);
+            break;
+        case TransformSpace::World:
+            // position is relative to parent so transform upwards
+            if (this->node_->getParent())
+                setPosition(getPosition() + (node_->getParent()->_getDerivedOrientation().Inverse() * distance)
+                    / node_->getParent()->_getDerivedScale());
+            else
+                this->setPosition(this->getPosition() + distance);
+            break;
+        }
+    }
+
+    void WorldEntity::rotate(const Quaternion& rotation, TransformSpace::Space relativeTo)
+    {
+        switch(relativeTo)
+        {
+        case TransformSpace::Local:
+            this->setOrientation(this->getOrientation() * rotation);
+            break;
+        case TransformSpace::Parent:
+            // Rotations are normally relative to local axes, transform up
+            this->setOrientation(rotation * this->getOrientation());
+            break;
+        case TransformSpace::World:
+            // Rotations are normally relative to local axes, transform up
+            this->setOrientation(this->getOrientation() * this->getWorldOrientation().Inverse()
+                * rotation * this->getWorldOrientation());
+            break;
+        }
+    }
+
+    void WorldEntity::lookAt(const Vector3& target, TransformSpace::Space relativeTo, const Vector3& localDirectionVector)
+    {
+        Vector3 origin;
+        switch (relativeTo)
+        {
+        case TransformSpace::Local:
+            origin = Vector3::ZERO;
+            break;
+        case TransformSpace::Parent:
+            origin = this->getPosition();
+            break;
+        case TransformSpace::World:
+            origin = this->getWorldPosition();
+            break;
+        }
+        this->setDirection(target - origin, relativeTo, localDirectionVector);
+    }
+
+    void WorldEntity::setDirection(const Vector3& direction, TransformSpace::Space relativeTo, const Vector3& localDirectionVector)
+    {
+        Quaternion savedOrientation(this->getOrientation());
+        Ogre::Node::TransformSpace ogreRelativeTo;
+        switch (relativeTo)
+        {
+        case TransformSpace::Local:
+            ogreRelativeTo = Ogre::Node::TS_LOCAL; break;
+        case TransformSpace::Parent:
+            ogreRelativeTo = Ogre::Node::TS_PARENT; break;
+        case TransformSpace::World:
+            ogreRelativeTo = Ogre::Node::TS_WORLD; break;
+        }
+        this->node_->setDirection(direction, ogreRelativeTo, localDirectionVector);
+        Quaternion newOrientation(this->node_->getOrientation());
+        this->node_->setOrientation(savedOrientation);
+        this->setOrientation(newOrientation);
+    }
+
     void WorldEntity::setScale3D(const Vector3& scale)
     {
@@ -295,12 +416,4 @@
 
         this->node_->setScale(scale);
-    }
-
-    void WorldEntity::scale3D(const Vector3& scale)
-    {
-        if (this->hasPhysics())
-            ThrowException(NotImplemented, "Cannot set the scale of a physical object: Not yet implemented.");
-
-        this->node_->scale(scale);
     }
 
Index: code/branches/physics/src/orxonox/objects/worldentities/WorldEntity.h
===================================================================
--- code/branches/physics/src/orxonox/objects/worldentities/WorldEntity.h	(revision 2425)
+++ code/branches/physics/src/orxonox/objects/worldentities/WorldEntity.h	(revision 2426)
@@ -33,6 +33,9 @@
 #include "OrxonoxPrereqs.h"
 
-#define OGRE_FORCE_ANGLE_TYPES
+#ifdef _NDEBUG
 #include <OgreSceneNode.h>
+#else
+#include <OgrePrerequisites.h>
+#endif
 #include "LinearMath/btMotionState.h"
 
@@ -65,11 +68,9 @@
             inline void setPosition(float x, float y, float z)
                 { this->setPosition(Vector3(x, y, z)); }
-            inline const Vector3& getPosition() const
-                { return this->node_->getPosition(); }
-            inline const Vector3& getWorldPosition() const
-                { return this->node_->getWorldPosition(); }
-
-            virtual void translate(const Vector3& distance, Ogre::Node::TransformSpace relativeTo = Ogre::Node::TS_LOCAL) = 0;
-            inline void translate(float x, float y, float z, Ogre::Node::TransformSpace relativeTo = Ogre::Node::TS_LOCAL)
+            const Vector3& getPosition() const;
+            const Vector3& getWorldPosition() const;
+
+            void translate(const Vector3& distance, TransformSpace::Space relativeTo = TransformSpace::Parent);
+            inline void translate(float x, float y, float z, TransformSpace::Space relativeTo = TransformSpace::Parent)
                 { this->translate(Vector3(x, y, z), relativeTo); }
 
@@ -81,28 +82,21 @@
             inline void setOrientation(const Vector3& axis, const Degree& angle)
                 { this->setOrientation(Quaternion(angle, axis)); }
-            inline const Quaternion& getOrientation() const
-                { return this->node_->getOrientation(); }
-            inline const Quaternion& getWorldOrientation() const
-                { return this->node_->getWorldOrientation(); }
-
-            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)
+            const Quaternion& getOrientation() const;
+            const Quaternion& getWorldOrientation() const;
+
+            void rotate(const Quaternion& rotation, TransformSpace::Space relativeTo = TransformSpace::Local);
+            inline void rotate(const Vector3& axis, const Degree& angle, TransformSpace::Space relativeTo = TransformSpace::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 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;
-            virtual void setDirection(const Vector3& direction, Ogre::Node::TransformSpace relativeTo = Ogre::Node::TS_LOCAL, const Vector3& localDirectionVector = Vector3::NEGATIVE_UNIT_Z) = 0;
-            inline void setDirection(float x, float y, float z, Ogre::Node::TransformSpace relativeTo = Ogre::Node::TS_LOCAL, const Vector3& localDirectionVector = Vector3::NEGATIVE_UNIT_Z)
+
+            inline void yaw(const Degree& angle, TransformSpace::Space relativeTo = TransformSpace::Local)
+                { this->rotate(Quaternion(angle, Vector3::UNIT_Y), relativeTo); }
+            inline void pitch(const Degree& angle, TransformSpace::Space relativeTo = TransformSpace::Local)
+                { this->rotate(Quaternion(angle, Vector3::UNIT_X), relativeTo); }
+            inline void roll(const Degree& angle, TransformSpace::Space relativeTo = TransformSpace::Local)
+                { this->rotate(Quaternion(angle, Vector3::UNIT_Z), relativeTo); }
+
+            void lookAt(const Vector3& target, TransformSpace::Space relativeTo = TransformSpace::Parent, const Vector3& localDirectionVector = Vector3::NEGATIVE_UNIT_Z);
+            void setDirection(const Vector3& direction, TransformSpace::Space relativeTo = TransformSpace::Local, const Vector3& localDirectionVector = Vector3::NEGATIVE_UNIT_Z);
+            inline void setDirection(float x, float y, float z, TransformSpace::Space relativeTo = TransformSpace::Local, const Vector3& localDirectionVector = Vector3::NEGATIVE_UNIT_Z)
                 { this->setDirection(Vector3(x, y, z), relativeTo, localDirectionVector); }
 
@@ -110,6 +104,5 @@
             inline void setScale3D(float x, float y, float z)
                 { this->setScale3D(Vector3(x, y, z)); }
-            inline const Vector3& getScale3D(void) const
-                { return this->node_->getScale(); }
+            const Vector3& getScale3D(void) const;
 
             void setScale(float scale)
@@ -118,5 +111,6 @@
                 { Vector3 scale = this->getScale3D(); return (scale.x == scale.y && scale.x == scale.z) ? scale.x : 1; }
 
-            virtual void scale3D(const Vector3& scale);
+            inline void scale3D(const Vector3& scale)
+                { this->setScale3D(this->getScale3D() * scale); }
             inline void scale3D(float x, float y, float z)
                 { this->scale3D(Vector3(x, y, z)); }
@@ -130,10 +124,7 @@
                 { return this->children_; }
 
-            inline void attachOgreObject(Ogre::MovableObject* object)
-                { this->node_->attachObject(object); }
-            inline void detachOgreObject(Ogre::MovableObject* object)
-                { this->node_->detachObject(object); }
-            inline Ogre::MovableObject* detachOgreObject(const Ogre::String& name)
-                { return this->node_->detachObject(name); }
+            void attachOgreObject(Ogre::MovableObject* object);
+            void detachOgreObject(Ogre::MovableObject* object);
+            Ogre::MovableObject* detachOgreObject(const Ogre::String& name);
 
             inline void attachToParent(WorldEntity* parent)
@@ -241,4 +232,14 @@
             btScalar                     childrenMass_;
     };
+
+    // Inline heavily used functions for release builds. In debug, we better avoid including OgreSceneNode here.
+#ifdef _NDEBUG
+    inline const Vector3& WorldEntity::getPosition() const
+        { return this->node_->getPosition(); }
+    inline const Quaternion& WorldEntity::getOrientation() const
+        { return this->node_->getrOrientation(); }
+    inline const Vector3& WorldEntity::getScale3D(void) const
+        { return this->node_->getScale(); }
+#endif
 }
 
