Index: code/branches/presentation/src/orxonox/objects/Scene.cc
===================================================================
--- code/branches/presentation/src/orxonox/objects/Scene.cc	(revision 2534)
+++ code/branches/presentation/src/orxonox/objects/Scene.cc	(revision 2535)
@@ -208,5 +208,5 @@
                 it != this->physicalObjects_.end(); ++it)
             {
-                this->physicalWorld_->removeRigidBody((*it)->getPhysicalBody());
+                this->physicalWorld_->removeRigidBody((*it)->physicalBody_);
                 this->physicalObjectQueue_.insert(*it);
             }
@@ -243,5 +243,5 @@
                     it != this->physicalObjectQueue_.end(); ++it)
                 {
-                    this->physicalWorld_->addRigidBody((*it)->getPhysicalBody());
+                    this->physicalWorld_->addRigidBody((*it)->physicalBody_);
                     this->physicalObjects_.insert(*it);
                 }
@@ -330,5 +330,5 @@
 
         if (this->hasPhysics())
-            this->physicalWorld_->removeRigidBody(object->getPhysicalBody());
+            this->physicalWorld_->removeRigidBody(object->physicalBody_);
     }
 
Index: code/branches/presentation/src/orxonox/objects/collisionshapes/ConeCollisionShape.cc
===================================================================
--- code/branches/presentation/src/orxonox/objects/collisionshapes/ConeCollisionShape.cc	(revision 2534)
+++ code/branches/presentation/src/orxonox/objects/collisionshapes/ConeCollisionShape.cc	(revision 2535)
@@ -73,5 +73,5 @@
     btCollisionShape* ConeCollisionShape::createNewShape() const
     {
-        return  new btConeShape(this->radius_, this->height_);
+        return new btConeShape(this->radius_, this->height_);
     }
 }
Index: code/branches/presentation/src/orxonox/objects/worldentities/WorldEntity.cc
===================================================================
--- code/branches/presentation/src/orxonox/objects/worldentities/WorldEntity.cc	(revision 2534)
+++ code/branches/presentation/src/orxonox/objects/worldentities/WorldEntity.cc	(revision 2535)
@@ -42,5 +42,4 @@
 
 #include "objects/Scene.h"
-#include "objects/collisionshapes/CompoundCollisionShape.h"
 
 namespace orxonox
@@ -53,5 +52,6 @@
     const Vector3 WorldEntity::UP    = Vector3::UNIT_Y;
 
-    WorldEntity::WorldEntity(BaseObject* creator) : BaseObject(creator), Synchronisable(creator)
+    WorldEntity::WorldEntity(BaseObject* creator) : BaseObject(creator), Synchronisable(creator), collisionShape_(0)
+
     {
         RegisterObject(WorldEntity);
@@ -68,18 +68,18 @@
         this->node_->setOrientation(Quaternion::IDENTITY);
 
+
         // Default behaviour does not include physics
-        this->physicalBody_ = 0;
-        this->bPhysicsActive_ = false;
-        this->bPhysicsActiveSynchronised_ = false;
-        this->bPhysicsActiveBeforeAttaching_ = false;
-        this->collisionShape_ = new CompoundCollisionShape(this);
         // Note: CompoundCollisionShape is a Synchronisable, but must not be synchronised.
         //       All objects will get attached on the client anyway, so we don't need synchronisation.
-        this->collisionShape_->setWorldEntityParent(this);
-        this->collisionType_ = None;
+        this->collisionShape_.setWorldEntityParent(this);
+        this->physicalBody_   = 0;
+        this->bPhysicsActive_ = false;
+        this->bPhysicsActiveSynchronised_    = false;
+        this->bPhysicsActiveBeforeAttaching_ = false;
+        this->collisionType_             = None;
         this->collisionTypeSynchronised_ = None;
         this->mass_           = 0;
         this->childrenMass_   = 0;
-        // Use bullet default values
+        // Using bullet default values
         this->restitution_    = 0;
         this->angularFactor_  = 1;
@@ -96,14 +96,10 @@
         if (this->isInitialized())
         {
-            this->node_->detachAllObjects();
+            if (this->parent_)
+                this->detachFromParent();
 
             for (std::set<WorldEntity*>::const_iterator it = this->children_.begin(); it != this->children_.end(); )
                 delete (*(it++));
 
-            if (this->parent_)
-                this->detachFromParent();
-
-            this->node_->removeAllChildren();
-
             if (this->physicalBody_)
             {
@@ -111,8 +107,10 @@
                 delete this->physicalBody_;
             }
-            delete this->collisionShape_;
-
-            if (this->getScene()->getSceneManager())
-                this->getScene()->getSceneManager()->destroySceneNode(this->node_->getName());
+
+            this->node_->detachAllObjects();
+            this->node_->removeAllChildren();
+
+            OrxAssert(this->getScene()->getSceneManager(), "No SceneManager defined in a WorldEntity.");
+            this->getScene()->getSceneManager()->destroySceneNode(this->node_->getName());
         }
     }
@@ -184,4 +182,18 @@
     }
 
+    void WorldEntity::attachToNode(Ogre::SceneNode* node)
+    {
+        Ogre::Node* parent = this->node_->getParent();
+        if (parent)
+            parent->removeChild(this->node_);
+        node->addChild(this->node_);
+    }
+
+    void WorldEntity::detachFromNode(Ogre::SceneNode* node)
+    {
+        node->removeChild(this->node_);
+//        this->getScene()->getRootSceneNode()->addChild(this->node_);
+    }
+
     void WorldEntity::collisionTypeChanged()
     {
@@ -223,4 +235,122 @@
     }
 
+    void WorldEntity::attach(WorldEntity* object)
+    {
+        if (object == this)
+        {
+            COUT(2) << "Warning: Can't attach a WorldEntity to itself." << std::endl;
+            return;
+        }
+
+        if (!object->notifyBeingAttached(this))
+            return;
+
+        this->attachNode(object->node_);
+        this->children_.insert(object);
+
+        this->attachCollisionShape(&object->collisionShape_);
+        // mass
+        this->childrenMass_ += object->getMass();
+        recalculateMassProps();
+    }
+
+    bool WorldEntity::notifyBeingAttached(WorldEntity* newParent)
+    {
+        // check first whether attaching is even allowed
+        if (this->hasPhysics())
+        {
+            if (!newParent->hasPhysics())
+            {
+                COUT(2) << "Warning: Cannot attach a physical object to a non physical one." << std::endl;
+                return false;
+            }
+            else if (this->isDynamic())
+            {
+                COUT(2) << "Warning: Cannot attach a dynamic object to a WorldEntity." << std::endl;
+                return false;
+            }
+            else if (this->isKinematic() && newParent->isDynamic())
+            {
+                COUT(2) << "Warning: Cannot attach a kinematic object to a dynamic one." << std::endl;
+                return false;
+            }
+            else if (this->isKinematic())
+            {
+                COUT(2) << "Warning: Cannot attach a kinematic object to a static or kinematic one: Not yet implemented." << std::endl;
+                return false;
+            }
+        }
+
+        if (this->isPhysicsActive())
+            this->bPhysicsActiveBeforeAttaching_ = true;
+        this->deactivatePhysics();
+
+        if (this->parent_)
+            this->detachFromParent();
+
+        this->parent_ = newParent;
+        this->parentID_ = newParent->getObjectID();
+
+        // apply transform to collision shape
+        this->collisionShape_.setPosition(this->getPosition());
+        this->collisionShape_.setOrientation(this->getOrientation());
+        // TODO: Scale
+        
+        return true;
+    }
+
+    void WorldEntity::detach(WorldEntity* object)
+    {
+        if (this->children_.find(object) == this->children_.end())
+        {
+            CCOUT(2) << "Warning: Cannot detach an object that is not a child." << std::endl;
+            return;
+        }
+
+        // collision shapes
+        this->detachCollisionShape(&object->collisionShape_);
+
+        // mass
+        if (object->getMass() > 0.0f)
+        {
+            this->childrenMass_ -= object->getMass();
+            recalculateMassProps();
+        }
+
+        this->detachNode(object->node_);
+        this->children_.erase(object);
+
+        object->notifyDetached();
+    }
+
+    void WorldEntity::notifyDetached()
+    {
+        this->parent_ = 0;
+        this->parentID_ = OBJECTID_UNKNOWN;
+
+        // reset orientation of the collisionShape (cannot be set within a WE usually)
+        this->collisionShape_.setPosition(Vector3::ZERO);
+        this->collisionShape_.setOrientation(Quaternion::IDENTITY);
+        // TODO: Scale
+
+        if (this->bPhysicsActiveBeforeAttaching_)
+        {
+            this->activatePhysics();
+            this->bPhysicsActiveBeforeAttaching_ = false;
+        }
+    }
+
+    WorldEntity* WorldEntity::getAttachedObject(unsigned int index)
+    {
+        unsigned int i = 0;
+        for (std::set<WorldEntity*>::const_iterator it = this->children_.begin(); it != this->children_.end(); ++it)
+        {
+            if (i == index)
+                return (*it);
+            ++i;
+        }
+        return 0;
+    }
+
     void WorldEntity::attachNode(Ogre::SceneNode* node)
     {
@@ -237,136 +367,4 @@
     }
 
-    void WorldEntity::attachToNode(Ogre::SceneNode* node)
-    {
-        Ogre::Node* parent = this->node_->getParent();
-        if (parent)
-            parent->removeChild(this->node_);
-        node->addChild(this->node_);
-    }
-
-    void WorldEntity::detachFromNode(Ogre::SceneNode* node)
-    {
-        node->removeChild(this->node_);
-//        this->getScene()->getRootSceneNode()->addChild(this->node_);
-    }
-
-    void WorldEntity::attach(WorldEntity* object)
-    {
-        if (object == this)
-        {
-            COUT(2) << "Warning: Can't attach a WorldEntity to itself." << std::endl;
-            return;
-        }
-
-        if (!object->notifyBeingAttached(this))
-            return;
-
-        this->attachNode(object->node_);
-        this->children_.insert(object);
-
-        this->attachCollisionShape(object->getCollisionShape());
-        // mass
-        this->childrenMass_ += object->getMass();
-        recalculateMassProps();
-    }
-
-    bool WorldEntity::notifyBeingAttached(WorldEntity* newParent)
-    {
-        // check first whether attaching is even allowed
-        if (this->hasPhysics())
-        {
-            if (!newParent->hasPhysics())
-            {
-                COUT(2) << "Warning: Cannot attach a physical object to a non physical one." << std::endl;
-                return false;
-            }
-            else if (this->isDynamic())
-            {
-                COUT(2) << "Warning: Cannot attach a dynamic object to a WorldEntity." << std::endl;
-                return false;
-            }
-            else if (this->isKinematic() && newParent->isDynamic())
-            {
-                COUT(2) << "Warning: Cannot attach a kinematic object to a dynamic one." << std::endl;
-                return false;
-            }
-            else if (this->isKinematic())
-            {
-                COUT(2) << "Warning: Cannot attach a kinematic object to a static or kinematic one: Not yet implemented." << std::endl;
-                return false;
-            }
-        }
-
-        if (this->isPhysicsActive())
-            this->bPhysicsActiveBeforeAttaching_ = true;
-        this->deactivatePhysics();
-
-        if (this->parent_)
-            this->detachFromParent();
-
-        this->parent_ = newParent;
-        this->parentID_ = newParent->getObjectID();
-
-        // apply transform to collision shape
-        this->collisionShape_->setPosition(this->getPosition());
-        this->collisionShape_->setOrientation(this->getOrientation());
-        // TODO: Scale
-        
-        return true;
-    }
-
-    void WorldEntity::detach(WorldEntity* object)
-    {
-        if (this->children_.find(object) == this->children_.end())
-        {
-            CCOUT(2) << "Warning: Cannot detach an object that is not a child." << std::endl;
-            return;
-        }
-
-        // collision shapes
-        this->detachCollisionShape(object->getCollisionShape());
-
-        // mass
-        if (object->getMass() > 0.0f)
-        {
-            this->childrenMass_ -= object->getMass();
-            recalculateMassProps();
-        }
-
-        this->detachNode(object->node_);
-        this->children_.erase(object);
-
-        object->notifyDetached();
-    }
-
-    void WorldEntity::notifyDetached()
-    {
-        this->parent_ = 0;
-        this->parentID_ = OBJECTID_UNKNOWN;
-
-        // reset orientation of the collisionShape (cannot be set within a WE usually)
-        this->collisionShape_->setPosition(Vector3::ZERO);
-        this->collisionShape_->setOrientation(Quaternion::IDENTITY);
-        // TODO: Scale
-
-        if (this->bPhysicsActiveBeforeAttaching_)
-        {
-            this->activatePhysics();
-            this->bPhysicsActiveBeforeAttaching_ = false;
-        }
-    }
-
-    WorldEntity* WorldEntity::getAttachedObject(unsigned int index) const
-    {
-        unsigned int i = 0;
-        for (std::set<WorldEntity*>::const_iterator it = this->children_.begin(); it != this->children_.end(); ++it)
-        {
-            if (i == index)
-                return (*it);
-            ++i;
-        }
-        return 0;
-    }
-
     void WorldEntity::attachOgreObject(Ogre::MovableObject* object)
     {
@@ -386,5 +384,5 @@
     void WorldEntity::attachCollisionShape(CollisionShape* shape)
     {
-        this->collisionShape_->attach(shape);
+        this->collisionShape_.attach(shape);
         // Note: this->collisionShape_ already notifies us of any changes.
     }
@@ -392,5 +390,5 @@
     void WorldEntity::detachCollisionShape(CollisionShape* shape)
     {
-        this->collisionShape_->detach(shape);
+        this->collisionShape_.detach(shape);
         // Note: this->collisionShape_ already notifies us of any changes.
     }
@@ -398,30 +396,8 @@
     CollisionShape* WorldEntity::getAttachedCollisionShape(unsigned int index) const
     {
-        return this->collisionShape_->getAttachedShape(index);
-    }
-
-    void WorldEntity::activatePhysics()
-    {
-        if (this->isActive() && this->hasPhysics() && !this->isPhysicsActive() && !this->parent_)
-        {
-            this->getScene()->addPhysicalObject(this);
-            this->bPhysicsActive_ = true;
-        }
-    }
-
-    void WorldEntity::deactivatePhysics()
-    {
-        if (this->isPhysicsActive())
-        {
-            this->getScene()->removePhysicalObject(this);
-            this->bPhysicsActive_ = false;
-        }
-    }
-
-    bool WorldEntity::addedToPhysicalWorld() const
-    {
-        return this->physicalBody_ && this->physicalBody_->isInWorld();
-    }
-
+        return this->collisionShape_.getAttachedShape(index);
+    }
+
+    // Note: These functions are placed in WorldEntity.h as inline functions for the release build.
 #ifndef _NDEBUG
     const Vector3& WorldEntity::getPosition() const
@@ -451,5 +427,32 @@
     }
 
-    void WorldEntity::translate(const Vector3& distance, TransformSpace::Space relativeTo)
+    const Vector3& WorldEntity::getWorldScale3D() const
+    {
+        return this->node_->_getDerivedScale();
+    }
+
+    float WorldEntity::getWorldScale() const
+    {
+        Vector3 scale = this->getWorldScale3D();
+        return (scale.x == scale.y && scale.x == scale.z) ? scale.x : 1;
+    }
+
+    void WorldEntity::setScale3D(const Vector3& scale)
+    {
+/*
+HACK HACK HACK
+        if (bScalePhysics && this->hasPhysics() && scale != Vector3::UNIT_SCALE)
+        {
+            CCOUT(2) << "Warning: Cannot set the scale of a physical object: Not yet implemented. Ignoring scaling." << std::endl;
+            return;
+        }
+HACK HACK HACK
+*/
+        this->node_->setScale(scale);
+
+        this->changedScale();
+    }
+
+    void WorldEntity::translate(const Vector3& distance, TransformSpace::Enum relativeTo)
     {
         switch (relativeTo)
@@ -474,4 +477,5 @@
 
     void WorldEntity::rotate(const Quaternion& rotation, TransformSpace::Space relativeTo)
+    void WorldEntity::rotate(const Quaternion& rotation, TransformSpace::Enum relativeTo)
     {
         switch(relativeTo)
@@ -493,4 +497,5 @@
 
     void WorldEntity::lookAt(const Vector3& target, TransformSpace::Space relativeTo, const Vector3& localDirectionVector)
+    void WorldEntity::lookAt(const Vector3& target, TransformSpace::Enum relativeTo, const Vector3& localDirectionVector)
     {
         Vector3 origin;
@@ -511,4 +516,5 @@
 
     void WorldEntity::setDirection(const Vector3& direction, TransformSpace::Space relativeTo, const Vector3& localDirectionVector)
+    void WorldEntity::setDirection(const Vector3& direction, TransformSpace::Enum relativeTo, const Vector3& localDirectionVector)
     {
         Quaternion savedOrientation(this->getOrientation());
@@ -529,31 +535,32 @@
     }
 
-    void WorldEntity::setScale3D(const Vector3& scale)
-    {
-/*
-        if (this->hasPhysics() && scale != Vector3::UNIT_SCALE)
-        {
-            CCOUT(2) << "Warning: Cannot set the scale of a physical object: Not yet implemented." << std::endl;
-            return;
-        }
-*/
-        this->node_->setScale(scale);
-
-        this->changedScale();
-    }
-
-    const Vector3& WorldEntity::getWorldScale3D() const
-    {
-        return this->node_->_getDerivedScale();
-    }
-
-    float WorldEntity::getWorldScale() const
-    {
-        Vector3 scale = this->getWorldScale3D();
-        return (scale.x == scale.y && scale.x == scale.z) ? scale.x : 1;
+    void WorldEntity::activatePhysics()
+    {
+        if (this->isActive() && this->hasPhysics() && !this->isPhysicsActive() && !this->parent_)
+        {
+            this->getScene()->addPhysicalObject(this);
+            this->bPhysicsActive_ = true;
+        }
+    }
+
+    void WorldEntity::deactivatePhysics()
+    {
+        if (this->isPhysicsActive())
+        {
+            this->getScene()->removePhysicalObject(this);
+            this->bPhysicsActive_ = false;
+        }
+    }
+
+    bool WorldEntity::addedToPhysicalWorld() const
+    {
+        return this->physicalBody_ && this->physicalBody_->isInWorld();
     }
 
     void WorldEntity::setCollisionType(CollisionType type)
     {
+        if (this->collisionType_ == type)
+            return;
+
         // If we are already attached to a parent, this would be a bad idea..
         if (this->parent_)
@@ -562,11 +569,6 @@
             return;
         }
-        else if (this->addedToPhysicalWorld())
-        {
-            CCOUT(2) << "Warning: Cannot set the collision type at run time." << std::endl;
-            return;
-        }
-
-        // Check for type legality. Could be StaticEntity or MobileEntity
+
+        // Check for type legality. Could be StaticEntity or MobileEntity.
         if (!this->isCollisionTypeLegal(type))
             return;
@@ -576,4 +578,11 @@
             return;
         }
+
+        if (this->isPhysicsActive())
+            this->deactivatePhysics();
+
+        bool bReactivatePhysics = true;
+        if (this->hasPhysics() && !this->isPhysicsActive())
+            bReactivatePhysics = false;
 
         // Check whether we have to create or destroy.
@@ -581,4 +590,5 @@
         {
 /*
+HACK HACK HACK
             // Check whether there was some scaling applied.
             if (!this->node_->getScale().positionEquals(Vector3(1, 1, 1), 0.001))
@@ -587,7 +597,8 @@
                 return;
             }
+HACK HACK HACK
 */
             // Create new rigid body
-            btRigidBody::btRigidBodyConstructionInfo bodyConstructionInfo(0, this, this->collisionShape_->getCollisionShape());
+            btRigidBody::btRigidBodyConstructionInfo bodyConstructionInfo(0, this, this->collisionShape_.getCollisionShape());
             this->physicalBody_ = new btRigidBody(bodyConstructionInfo);
             this->physicalBody_->setUserPointer(this);
@@ -619,8 +630,9 @@
             break;
         case None:
-            return; // this->collisionType_ was None too
-        }
-
-        // Only sets this->collisionShape_
+            assert(false); // Doesn't happen
+            return;
+        }
+
+        // Only sets this->collisionType_
         // However the assertion is to ensure that the internal bullet setting is right
         updateCollisionType();
@@ -629,7 +641,8 @@
         // update mass and inertia tensor
         recalculateMassProps();
-        resetPhysicsProps();
+        internalSetPhysicsProps();
         collisionCallbackActivityChanged();
-        activatePhysics();
+        if (bReactivatePhysics)
+            activatePhysics();
     }
 
@@ -682,5 +695,5 @@
     }
 
-    void WorldEntity::notifyChildMassChanged() // Called by a child WE
+    void WorldEntity::notifyChildMassChanged()
     {
         // Note: CollisionShape changes of a child get handled over the internal CompoundCollisionShape already
@@ -695,5 +708,5 @@
     }
 
-    void WorldEntity::notifyCollisionShapeChanged() // called by this->collisionShape_
+    void WorldEntity::notifyCollisionShapeChanged()
     {
         if (hasPhysics())
@@ -703,9 +716,9 @@
             {
                 this->deactivatePhysics();
-                this->physicalBody_->setCollisionShape(this->collisionShape_->getCollisionShape());
+                this->physicalBody_->setCollisionShape(this->collisionShape_.getCollisionShape());
                 this->activatePhysics();
             }
             else
-                this->physicalBody_->setCollisionShape(this->collisionShape_->getCollisionShape());
+                this->physicalBody_->setCollisionShape(this->collisionShape_.getCollisionShape());
         }
         recalculateMassProps();
@@ -716,5 +729,5 @@
         // Store local inertia for faster access. Evaluates to (0,0,0) if there is no collision shape.
         float totalMass = this->mass_ + this->childrenMass_;
-        this->collisionShape_->calculateLocalInertia(totalMass, this->localInertia_);
+        this->collisionShape_.calculateLocalInertia(totalMass, this->localInertia_);
         if (this->hasPhysics())
         {
@@ -729,5 +742,5 @@
                 CCOUT(4) << "Warning: Setting the internal physical mass to 1.0 because mass_ is 0.0." << std::endl;
                 btVector3 inertia(0, 0, 0);
-                this->collisionShape_->calculateLocalInertia(1.0f, inertia);
+                this->collisionShape_.calculateLocalInertia(1.0f, inertia);
                 this->physicalBody_->setMassProps(1.0f, inertia);
             }
@@ -739,5 +752,5 @@
     }
 
-    void WorldEntity::resetPhysicsProps()
+    void WorldEntity::internalSetPhysicsProps()
     {
         if (this->hasPhysics())
Index: code/branches/presentation/src/orxonox/objects/worldentities/WorldEntity.h
===================================================================
--- code/branches/presentation/src/orxonox/objects/worldentities/WorldEntity.h	(revision 2534)
+++ code/branches/presentation/src/orxonox/objects/worldentities/WorldEntity.h	(revision 2535)
@@ -40,7 +40,8 @@
 #include "LinearMath/btMotionState.h"
 
+#include "util/Math.h"
+#include "core/BaseObject.h"
 #include "network/synchronisable/Synchronisable.h"
-#include "core/BaseObject.h"
-#include "util/Math.h"
+#include "objects/collisionshapes/CompoundCollisionShape.h"
 
 namespace orxonox
@@ -48,4 +49,6 @@
     class _OrxonoxExport WorldEntity : public BaseObject, public Synchronisable, public btMotionState
     {
+        friend class Scene;
+
         public:
             WorldEntity(BaseObject* creator);
@@ -71,6 +74,6 @@
             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)
+            void translate(const Vector3& distance, TransformSpace::Enum relativeTo = TransformSpace::Parent);
+            inline void translate(float x, float y, float z, TransformSpace::Enum relativeTo = TransformSpace::Parent)
                 { this->translate(Vector3(x, y, z), relativeTo); }
 
@@ -88,18 +91,18 @@
             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)
+            void rotate(const Quaternion& rotation, TransformSpace::Enum relativeTo = TransformSpace::Local);
+            inline void rotate(const Vector3& axis, const Degree& angle, TransformSpace::Enum relativeTo = TransformSpace::Local)
                 { this->rotate(Quaternion(angle, axis), relativeTo); }
 
-            inline void yaw(const Degree& angle, TransformSpace::Space relativeTo = TransformSpace::Local)
+            inline void yaw(const Degree& angle, TransformSpace::Enum relativeTo = TransformSpace::Local)
                 { this->rotate(Quaternion(angle, Vector3::UNIT_Y), relativeTo); }
-            inline void pitch(const Degree& angle, TransformSpace::Space relativeTo = TransformSpace::Local)
+            inline void pitch(const Degree& angle, TransformSpace::Enum relativeTo = TransformSpace::Local)
                 { this->rotate(Quaternion(angle, Vector3::UNIT_X), relativeTo); }
-            inline void roll(const Degree& angle, TransformSpace::Space relativeTo = TransformSpace::Local)
+            inline void roll(const Degree& angle, TransformSpace::Enum 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)
+            void lookAt(const Vector3& target, TransformSpace::Enum relativeTo = TransformSpace::Parent, const Vector3& localDirectionVector = Vector3::NEGATIVE_UNIT_Z);
+            void setDirection(const Vector3& direction, TransformSpace::Enum relativeTo = TransformSpace::Local, const Vector3& localDirectionVector = Vector3::NEGATIVE_UNIT_Z);
+            inline void setDirection(float x, float y, float z, TransformSpace::Enum relativeTo = TransformSpace::Local, const Vector3& localDirectionVector = Vector3::NEGATIVE_UNIT_Z)
                 { this->setDirection(Vector3(x, y, z), relativeTo, localDirectionVector); }
 
@@ -127,5 +130,5 @@
             void attach(WorldEntity* object);
             void detach(WorldEntity* object);
-            WorldEntity* getAttachedObject(unsigned int index) const;
+            WorldEntity* getAttachedObject(unsigned int index);
             inline const std::set<WorldEntity*>& getAttachedObjects() const
                 { return this->children_; }
@@ -216,25 +219,25 @@
 
             inline void setRestitution(float restitution)
-                { this->restitution_ = restitution; resetPhysicsProps(); }
+                { this->restitution_ = restitution; internalSetPhysicsProps(); }
             inline float getRestitution() const
                 { return this->restitution_; }
 
             inline void setAngularFactor(float angularFactor)
-                { this->angularFactor_ = angularFactor; resetPhysicsProps(); }
+                { this->angularFactor_ = angularFactor; internalSetPhysicsProps(); }
             inline float getAngularFactor() const
                 { return this->angularFactor_; }
 
             inline void setLinearDamping(float linearDamping)
-                { this->linearDamping_ = linearDamping; resetPhysicsProps(); }
+                { this->linearDamping_ = linearDamping; internalSetPhysicsProps(); }
             inline float getLinearDamping() const
                 { return this->linearDamping_; }
 
             inline void setAngularDamping(float angularDamping)
-                { this->angularDamping_ = angularDamping; resetPhysicsProps(); }
+                { this->angularDamping_ = angularDamping; internalSetPhysicsProps(); }
             inline float getAngularDamping() const
                 { return this->angularDamping_; }
 
             inline void setFriction(float friction)
-                { this->friction_ = friction; resetPhysicsProps(); }
+                { this->friction_ = friction; internalSetPhysicsProps(); }
             inline float getFriction() const
                 { return this->friction_; }
@@ -242,10 +245,5 @@
             void attachCollisionShape(CollisionShape* shape);
             void detachCollisionShape(CollisionShape* shape);
-            CollisionShape* getAttachedCollisionShape(unsigned int index) const;
-
-            inline CompoundCollisionShape* getCollisionShape() const
-                { return this->collisionShape_; }
-            inline btRigidBody* getPhysicalBody() const
-                { return this->physicalBody_; }
+            CollisionShape* getAttachedCollisionShape(unsigned int index);
 
             void notifyCollisionShapeChanged();
@@ -265,10 +263,10 @@
             virtual bool isCollisionTypeLegal(CollisionType type) const = 0;
 
-            btRigidBody*  physicalBody_;
+            btRigidBody* physicalBody_;
 
         private:
             void updateCollisionType();
             void recalculateMassProps();
-            void resetPhysicsProps();
+            void internalSetPhysicsProps();
 
             bool notifyBeingAttached(WorldEntity* newParent);
@@ -297,5 +295,5 @@
             bool                         bPhysicsActiveSynchronised_;
             bool                         bPhysicsActiveBeforeAttaching_;
-            CompoundCollisionShape*      collisionShape_;
+            CompoundCollisionShape       collisionShape_;
             btScalar                     mass_;
             btVector3                    localInertia_;
Index: code/branches/presentation/src/util/Math.h
===================================================================
--- code/branches/presentation/src/util/Math.h	(revision 2534)
+++ code/branches/presentation/src/util/Math.h	(revision 2535)
@@ -80,11 +80,11 @@
             Enumeration denoting the spaces which a transform can be relative to.
         */
-        enum Space
+        enum Enum
         {
-            /// Transform is relative to the local space
+            //! Transform is relative to the local space
             Local,
-            /// Transform is relative to the space of the parent node
+            //! Transform is relative to the space of the parent node
             Parent,
-            /// Transform is relative to world space
+            //! Transform is relative to world space
             World
         };
