Changeset 2303 for code/branches/physics

Timestamp:

Dec 1, 2008, 11:09:43 PM (16 years ago)

Author:

rgrieder

Message:

• Added support for attaching physical WorldEntities to each other. Currently you can only add static objects to kinematic/dynamic/static other objects. Future plans involve attaching kinematic objects to static/kinematic ones. All other combinations don't make sense at all.
• Added CollisionShape, SphereCollisionShape and CompoundCollisionShape

Usage for collision shapes (example):

<LinearEntity collisionType="kinematic">

<attached>

<Model position="0,0,0" scale=10 mesh="ast1.mesh" />
<StaticEntity position="0,10,0" collisionType="static"> # Everything else than "static" fails!

<collisionShapes>

<SphereCollisionShape radius=40 position="10,10,-10"/>
<CompoundCollisionShape position="4,4,4"> # You can also make compound shapes directly

<SphereCollisionShape radius=10/>

</CompoundCollisionShape>

</collisionShapes>

</StaticEntity>

</attached>

</LinearEntity>

Location:

code/branches/physics

Files:

• src/core/XMLPort.h (modified) (3 diffs)
• src/orxonox/CMakeLists.txt (modified) (1 diff)
• src/orxonox/OrxonoxPrereqs.h (modified) (2 diffs)
• src/orxonox/objects/Scene.cc (modified) (3 diffs)
• src/orxonox/objects/Scene.h (modified) (2 diffs)
• src/orxonox/objects/worldentities/MovableEntity.cc (modified) (2 diffs)
• src/orxonox/objects/worldentities/StaticEntity.cc (modified) (1 diff)
• src/orxonox/objects/worldentities/WorldEntity.cc (modified) (12 diffs)
• src/orxonox/objects/worldentities/WorldEntity.h (modified) (4 diffs)
• src/orxonox/objects/worldentities/collisionshapes (added)
• src/orxonox/objects/worldentities/collisionshapes/CollisionShape.cc (added)
• src/orxonox/objects/worldentities/collisionshapes/CollisionShape.h (added)
• src/orxonox/objects/worldentities/collisionshapes/CompoundCollisionShape.cc (added)
• src/orxonox/objects/worldentities/collisionshapes/CompoundCollisionShape.h (added)
• src/orxonox/objects/worldentities/collisionshapes/SphereCollisionShape.cc (added)
• src/orxonox/objects/worldentities/collisionshapes/SphereCollisionShape.h (added)
• src/orxonox/objects/worldentities/pawns/SpaceShip.cc (modified) (1 diff)
• visual_studio/vc8/orxonox.vcproj (modified) (3 diffs)

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

@@ -196 +196 @@
     @param xmlelement The XMLElement (recieved through the XMLPort function)
     @param mode The mode (load/save) (received through the XMLPort function)
-    @param bApplyLoaderMask If this is true, an added sub-object only gets loaded if it's class is included in the Loaders ClassTreeMask (this is usually false)
-    @param bLoadBefore If this is true, the sub-cobject gets loaded (through XMLPort) BEFORE it gets added to the main class (this is usually true)
+    @param bApplyLoaderMask If this is true, an added sub-object gets loaded only if it's class is included in the Loaders ClassTreeMask (this is usually false)
+    @param bLoadBefore If this is true, the sub-object gets loaded (through XMLPort) BEFORE it gets added to the main class (this is usually true)
 
     bApplyLoaderMask is usually false for the following reason:
@@ -204 +204 @@
     Of course, if there are "standalone" weapons in the level, they wont be loaded.
 
-    If bLoadBefore, an added object already has all attributes set (like it's name). This is most
+    If bLoadBefore is true, an added object already has all attributes set (like it's name). This is most
     likely the best option, so this is usually true.
 
@@ -243 +243 @@
     Note that "weapons" is the subsection. This allows you to add more types of sub-objects. In our example,
     you could add pilots, blinking lights or other stuff. If you don't want a subsection, just use "" (an
-    empty string). The you can add sub-objects directly into the mainclass.
+    empty string). Then you can add sub-objects directly into the mainclass.
 */
 #define XMLPortObjectExtended(classname, objectclass, sectionname, loadfunction, savefunction, xmlelement, mode, bApplyLoaderMask, bLoadBefore) \

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

@@ -71 +71 @@
 #  objects/worldentities/Backlight.cc
 
+  objects/worldentities/collisionshapes/CollisionShape.cc
+  objects/worldentities/collisionshapes/CompoundCollisionShape.cc
+  objects/worldentities/collisionshapes/SphereCollisionShape.cc
+  
   objects/quest/AddQuest.cc
   objects/quest/AddQuestHint.cc

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

@@ -151 +151 @@
     class Scores;
 
+    // collision
+    class CollisionShape;
+    class SphereCollisionShape;
+
     // tools
     class BillboardSet;
@@ -209 +213 @@
 class btCollisionObject;
 class btGhostObject;
+
 class btCollisionShape;
 class btSphereShape;
-
-
+class btCompoundShape;
+
+class btDiscreteDynamicsWorld;
+
+// lua
 struct lua_State;
 

code/branches/physics/src/orxonox/objects/Scene.cc

@@ -35 +35 @@
 #include <OgreLight.h>
 
+#include "BulletCollision/BroadphaseCollision/btAxisSweep3.h"
+#include "BulletCollision/CollisionDispatch/btDefaultCollisionConfiguration.h"
+#include "BulletDynamics/ConstraintSolver/btSequentialImpulseConstraintSolver.h"
+#include "BulletDynamics/Dynamics/btDiscreteDynamicsWorld.h"
+
 #include "core/CoreIncludes.h"
 #include "core/Core.h"
 #include "core/XMLPort.h"
-
-#include "BulletCollision/BroadphaseCollision/btAxisSweep3.h"
-#include "BulletDynamics/ConstraintSolver/btSequentialImpulseConstraintSolver.h"
-#include "BulletCollision/CollisionDispatch/btDefaultCollisionConfiguration.h"
+#include "objects/worldentities/WorldEntity.h"
 
 namespace orxonox
@@ -123 +125 @@
 
         XMLPortObjectExtended(Scene, BaseObject, "", addObject, getObject, xmlelement, mode, true, false);
+
+        // finally add all rigid bodies to the physics engine
+        if (hasPhysics())
+        {
+            for (std::list<BaseObject*>::const_iterator it = this->objects_.begin(); it != this->objects_.end(); ++it)
+            {
+                WorldEntity* temp = dynamic_cast<WorldEntity*>(*it);
+                if (temp)
+                {
+                    if (temp->getCollisionType() != WorldEntity::None)
+                        this->physicalWorld_->addRigidBody(temp->getPhysicalBody());
+                }
+            }
+        }
     }
 
@@ -157 +173 @@
     {
         if (physicalWorld_)
-            physicalWorld_->stepSimulation(dt,10);
+            physicalWorld_->stepSimulation(dt,(int)(dt/0.0166666f));
     }
 

code/branches/physics/src/orxonox/objects/Scene.h

@@ -37 +37 @@
 #include "objects/Tickable.h"
 
-#include "BulletDynamics/Dynamics/btDiscreteDynamicsWorld.h"
-
 namespace orxonox
 {
@@ -70 +68 @@
                 { return this->bShadows_; }
 
-            inline const Vector3& getWorldAabbMax()
-            {
-                this->physicalWorld_->getBroadphase();
-            }
+            //inline const Vector3& getWorldAabbMax()
+            //{
+            //    this->physicalWorld_->getBroadphase();
+            //}
 
             inline bool hasPhysics()

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

@@ -30 +30 @@
 #include "MovableEntity.h"
 
+#include "BulletDynamics/Dynamics/btRigidBody.h"
+
 #include "util/Exception.h"
 #include "core/CoreIncludes.h"
@@ -61 +63 @@
     {
     }
-
-    //void MovableEntity::setPosition(const Vector3& position)
-    //{
-    //    //if (isDynamic() && bAddedToPhysicalWorld_)
-    //    //{
-    //    //    this->getScene()->getPhysicalWorld()->removeRigidBody(this->physicalBody_);
-    //    //    this->getScene()->getPhysicalWorld()->addRigidBody(this->physicalBody_);
-    //    //}
-    //    this->node_->setPosition(position);
-    //    positionChanged();
-    //}
-
-    //void MovableEntity::translate(const Vector3& distance, Ogre::Node::TransformSpace relativeTo)
-    //{
-    //    //if (isDynamic() && bAddedToPhysicalWorld_)
-    //    //{
-    //    //    this->getScene()->getPhysicalWorld()->removeRigidBody(this->physicalBody_);
-    //    //    this->getScene()->getPhysicalWorld()->addRigidBody(this->physicalBody_);
-    //    //}
-    //    this->node_->translate(distance, relativeTo); 
-    //    positionChanged();
-    //}
-
-    //void MovableEntity::setOrientation(const Quaternion& orientation)
-    //{
-    //    //if (isDynamic() && bAddedToPhysicalWorld_)
-    //    //{
-    //    //    this->getScene()->getPhysicalWorld()->removeRigidBody(this->physicalBody_);
-    //    //    this->getScene()->getPhysicalWorld()->addRigidBody(this->physicalBody_);
-    //    //}
-    //    this->node_->setOrientation(orientation);
-    //    orientationChanged();
-    //}
-
-    //void MovableEntity::rotate(const Quaternion& rotation, Ogre::Node::TransformSpace relativeTo)
-    //{
-    //    //if (isDynamic() && bAddedToPhysicalWorld_)
-    //    //{
-    //    //    this->getScene()->getPhysicalWorld()->removeRigidBody(this->physicalBody_);
-    //    //    this->getScene()->getPhysicalWorld()->addRigidBody(this->physicalBody_);
-    //    //}
-    //    this->node_->rotate(rotation, relativeTo);
-    //    orientationChanged();
-    //}
-
-    //void MovableEntity::yaw(const Degree& angle, Ogre::Node::TransformSpace relativeTo)
-    //{
-    //    //if (isDynamic() && bAddedToPhysicalWorld_)
-    //    //{
-    //    //    this->getScene()->getPhysicalWorld()->removeRigidBody(this->physicalBody_);
-    //    //    this->getScene()->getPhysicalWorld()->addRigidBody(this->physicalBody_);
-    //    //}
-    //    this->node_->yaw(angle, relativeTo);
-    //    orientationChanged();
-    //}
-
-    //void MovableEntity::pitch(const Degree& angle, Ogre::Node::TransformSpace relativeTo)
-    //{
-    //    //if (isDynamic() && bAddedToPhysicalWorld_)
-    //    //{
-    //    //    this->getScene()->getPhysicalWorld()->removeRigidBody(this->physicalBody_);
-    //    //    this->getScene()->getPhysicalWorld()->addRigidBody(this->physicalBody_);
-    //    //}
-    //    this->node_->pitch(angle, relativeTo);
-    //    orientationChanged();
-    //}
-
-    //void MovableEntity::roll(const Degree& angle, Ogre::Node::TransformSpace relativeTo)
-    //{
-    //    //if (isDynamic() && bAddedToPhysicalWorld_)
-    //    //{
-    //    //    this->getScene()->getPhysicalWorld()->removeRigidBody(this->physicalBody_);
-    //    //    this->getScene()->getPhysicalWorld()->addRigidBody(this->physicalBody_);
-    //    //}
-    //    this->node_->roll(angle, relativeTo);
-    //    orientationChanged();
-    //}
-
-    //void MovableEntity::lookAt(const Vector3& target, Ogre::Node::TransformSpace relativeTo, const Vector3& localDirectionVector)
-    //{
-    //    //if (isDynamic() && bAddedToPhysicalWorld_)
-    //    //{
-    //    //    this->getScene()->getPhysicalWorld()->removeRigidBody(this->physicalBody_);
-    //    //    this->getScene()->getPhysicalWorld()->addRigidBody(this->physicalBody_);
-    //    //}
-    //    this->node_->lookAt(target, relativeTo, localDirectionVector); 
-    //    orientationChanged();
-    //}
-
-    //void MovableEntity::setDirection(const Vector3& direction, Ogre::Node::TransformSpace relativeTo, const Vector3& localDirectionVector)
-    //{
-    //    //if (isDynamic() && bAddedToPhysicalWorld_)
-    //    //{
-    //    //    this->getScene()->getPhysicalWorld()->removeRigidBody(this->physicalBody_);
-    //    //    this->getScene()->getPhysicalWorld()->addRigidBody(this->physicalBody_);
-    //    //}
-    //    this->node_->setDirection(direction, relativeTo, localDirectionVector); 
-    //    orientationChanged();
-    //}
 
     void MovableEntity::setPosition(const Vector3& position)

code/branches/physics/src/orxonox/objects/worldentities/StaticEntity.cc

@@ -62 +62 @@
     bool StaticEntity::isCollisionTypeLegal(WorldEntity::CollisionType type) const
     {
-        if (type == WorldEntity::Static)
+        if (type == WorldEntity::Kinematic || type == WorldEntity::Dynamic)
         {
-            ThrowException(PhysicsViolation, "Cannot tell a MovableEntity to have static collision type");
+            ThrowException(PhysicsViolation, "Cannot tell a StaticEntity to have kinematic or dynamic collision type");
             return false;
         }

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

@@ -33 +33 @@
 #include <OgreSceneManager.h>
 
-#include "BulletCollision/CollisionShapes/btSphereShape.h"
+#include "BulletCollision/CollisionShapes/btCollisionShape.h"
+#include "BulletDynamics/Dynamics/btDiscreteDynamicsWorld.h"
+#include "BulletDynamics/Dynamics/btRigidBody.h"
 
 #include "util/Exception.h"
@@ -41 +43 @@
 
 #include "objects/Scene.h"
+#include "objects/worldentities/collisionshapes/CollisionShape.h"
+#include "objects/worldentities/collisionshapes/CompoundCollisionShape.h"
 
 namespace orxonox
@@ -68 +72 @@
         // Default behaviour does not include physics
         this->physicalBody_ = 0;
+        this->collisionShape_ = 0;
+        this->mass_ = 0;
         updateCollisionType();
 
@@ -100 +106 @@
 
         XMLPortParam(WorldEntity, "collisionType", setCollisionTypeStr, getCollisionTypeStr, xmlelement, mode);
-        XMLPortParam(WorldEntity, "collisionRadius", setCollisionRadius, getCollisionRadius, xmlelement, mode);
+        //XMLPortParam(WorldEntity, "collisionRadius", setCollisionRadius, getCollisionRadius, xmlelement, mode);
         XMLPortParam(WorldEntity, "mass", setMass, getMass, xmlelement, mode);
 
         XMLPortObject(WorldEntity, WorldEntity, "attached", attach, getAttachedObject, xmlelement, mode);
-
-        // Add the physical after loading because we cannot change its attributes without removing.
-        if (getCollisionType() != None)
-            this->getScene()->getPhysicalWorld()->addRigidBody(this->physicalBody_);
+        XMLPortObject(WorldEntity, CollisionShape, "collisionShapes", attachCollisionShape, getAttachedCollisionShape, xmlelement, mode);
     }
 
@@ -131 +134 @@
     void WorldEntity::attach(WorldEntity* object)
     {
+        // check first whether attaching is even allowed
+        if (object->hasPhysics())
+        {
+            if (!this->hasPhysics())
+                ThrowException(PhysicsViolation, "Cannot attach a physical object to a non physical one.");
+            else if (object->isDynamic())
+                ThrowException(PhysicsViolation, "Cannot attach a dynamic object to a WorldEntity.");
+            else if (object->isKinematic() && this->isDynamic())
+                ThrowException(PhysicsViolation, "Cannot attach a kinematic object to a dynamic one.");
+            else if (object->isKinematic())
+                ThrowException(NotImplemented, "Cannot attach a kinematic object to a static or kinematic one: Not yet implemented.");
+            else if (object->physicalBody_->isInWorld() || this->physicalBody_->isInWorld())
+                ThrowException(PhysicsViolation, "Cannot attach a physical object at runtime.");
+            else
+            {
+                // static to static/kinematic/dynamic --> merge shapes
+                this->attachCollisionShape(object->getCollisionShape());
+                // Remove the btRigidBody from the child object.
+                // That also implies that cannot add a physics WE to the child afterwards.
+                object->setCollisionType(None);
+            }
+        }
+
         if (object->getParent())
             object->detachFromParent();
@@ -144 +170 @@
         object->parent_ = this;
         object->parentID_ = this->getObjectID();
-
-        // Do the physical connection if required
-        //this->attachPhysicalObject(object);
-    }
-
-    //void WorldEntity::attachPhysicalObject(WorldEntity* object)
-    //{
-    //    StaticEntity* staticObject = dynamic_cast<StaticEntity*>(object);
-    //    if (staticObject != 0 && this->hasPhysics())
-    //    {
-    //       btCompoundShape* compoundShape = dynamic_cast<btCompoundShape*>(this->physicalBody_->getCollisionShape());
-    //       if (compoundShape == 0)
-    //       {
-    //            // create a compound shape and add both
-    //            compoundShape = new btCompoundShape();
-    //            compoundShape->addChildShape(this->physicalBody_->getCollisionShape());
-    //            compoundShape->addChildShape(staticObject->getCollisionShape());
-    //            this->physicalBody_->setCollisionShape();
-    //       }
-    //       else
-    //       {
-    //           compoundShape -> addChildShape(staticObject->getCollisionShape());
-    //       }
-    //    }
-    //}
+    }
 
     void WorldEntity::detach(WorldEntity* object)
@@ -192 +194 @@
     }
 
-    float WorldEntity::getMass() const
-    {
-        if (!checkPhysics())
-            return 0.0f;
-
-        if (this->physicalBody_->getInvMass() == 0.0f)
-            return 0.0f;
-        else
-            return 1.0f/this->physicalBody_->getInvMass();
+    void WorldEntity::mergeCollisionShape(CollisionShape* shape)
+    {
+        if (!this->collisionShape_)
+            this->collisionShape_ = new CompoundCollisionShape(this);
+        assert(this->collisionShape_->isCompoundShape());
+
+        // merge with transform
+        CompoundCollisionShape* compoundShape = static_cast<CompoundCollisionShape*>(this->collisionShape_);
+        assert(compoundShape);
+        compoundShape->addChildShape(shape);
+    }
+
+    void WorldEntity::attachCollisionShape(CollisionShape* shape)
+    {
+        this->attachedShapes_.push_back(shape);
+
+        if (!this->collisionShape_ && shape->hasNoTransform())
+        {
+            // Simply add the shape as is.
+            shape->getCollisionShape()->setLocalScaling(shape->getTotalScaling());
+            this->collisionShape_ = shape;
+        }
+        else
+        {
+            if (this->collisionShape_ && !this->collisionShape_->isCompoundShape())
+            {
+                // We have to create a new compound shape and add the old one first.
+                CollisionShape* thisShape = this->collisionShape_;
+                this->collisionShape_ = 0;
+                this->mergeCollisionShape(thisShape);
+            }
+            this->mergeCollisionShape(shape);
+        }
+
+        if (this->physicalBody_)
+        {
+            if (this->physicalBody_->isInWorld())
+                COUT(2) << "Warning: Cannot attach a physical object at runtime.";
+            else
+                this->physicalBody_->setCollisionShape(this->collisionShape_->getCollisionShape());
+        }
+    }
+
+    CollisionShape* WorldEntity::getAttachedCollisionShape(unsigned int index) const
+    {
+        if (index < this->attachedShapes_.size())
+            return attachedShapes_[index];
+        else
+            return 0;
+    }
+
+    //BlinkingBillboard* WorldEntity::getAttachedAsdfObject(unsigned int index) const
+    //{
+    //    return 0;
+    //}
+
+    void WorldEntity::setScale3D(const Vector3& scale)
+    {
+        if (this->hasPhysics())
+            ThrowException(NotImplemented, "Cannot set the scale of a physical object: Not yet implemented.");
+
+        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);
     }
 
     void WorldEntity::setMass(float mass)
     {
-        if (!checkPhysics())
-            return;
+        this->mass_ = mass;
+        if (!hasPhysics())
+            COUT(2) << "Warning: Setting the mass of a WorldEntity with no physics has no effect." << std::endl;
         else if (this->physicalBody_->isInWorld())
-        {
-            CCOUT(2) << "Cannot set the physical mass at run time." << std::endl;
-            assert(false);
-        }
-        else
-        {
-            this->physicalBody_->setMassProps(mass, btVector3(0,0,0));
-            updateCollisionType();
+            COUT(2) << "Warning: Cannot set the physical mass at run time. Storing temporarily." << std::endl;
+        else
+        {
+            if (this->collisionType_ != Dynamic)
+                COUT(2) << "Warning: Cannot set the physical mass of a static or kinematic object. Storing temporarily." << std::endl;
+            else if (mass == 0.0f)
+                COUT(2) << "Warning: Cannot set physical mass of a dynamic object to zero. Storing temporarily." << std::endl;
+            else
+                this->physicalBody_->setMassProps(mass, btVector3(0,0,0));
         }
     }
@@ -221 +286 @@
     void WorldEntity::setCollisionType(CollisionType type)
     {
-        // Check first whether we have to create or destroy.
+        // If we are already attached to a parent, this would be a bad idea..
+        if (this->parent_)
+            ThrowException(PhysicsViolation, "Cannot set the collision type of a WorldEntity with a parent");
+        else if (this->physicalBody_ && this->physicalBody_->isInWorld())
+            ThrowException(PhysicsViolation, "Warning: Cannot set the collision type at run time.");
+
+        // Check for type legality. Could be StaticEntity or MovableEntity
+        if (!this->isCollisionTypeLegal(type))
+            return; // exception gets issued anyway
+
+        // Check whether we have to create or destroy.
         if (type != None && this->collisionType_ == None)
         {
-            // First, check whether our SceneNode is relative to the root space of the scene.
-            // TODO: Static and Kinematic objects don't always have to obey this rule.
-            if (this->node_->getParent() != this->getScene()->getRootSceneNode())
-                ThrowException(PhysicsViolation, "Cannot make WorldEntity physical that is not in the root space of the Scene.");
-
             // Create new rigid body
-            btRigidBody::btRigidBodyConstructionInfo bodyConstructionInfo(0, this, 0, btVector3(0,0,0));
+            btCollisionShape* temp = 0;
+            if (this->collisionShape_)
+                temp = this->collisionShape_->getCollisionShape();
+            btRigidBody::btRigidBodyConstructionInfo bodyConstructionInfo(0, this, temp, btVector3(0,0,0));
             this->physicalBody_ = new btRigidBody(bodyConstructionInfo);
             this->physicalBody_->setUserPointer(this);
-
-            // Adjust parameters according to the node
-            //btTransform nodeTransform;
-            //this->
         }
         else if (type == None && this->collisionType_ != None)
@@ -243 +312 @@
             if (this->physicalBody_->isInWorld())
                 this->getScene()->getPhysicalWorld()->removeRigidBody(this->physicalBody_);
-            if (this->physicalBody_->getCollisionShape())
-                delete this->physicalBody_->getCollisionShape();
             delete this->physicalBody_;
             this->physicalBody_ = 0;
@@ -250 +317 @@
             return;
         }
-
-        // Check for type legality. Could be StaticEntity or MovableEntity
-        if (!this->isCollisionTypeLegal(type))
-            return; // exception gets issued anyway
 
         // Change type
@@ -271 +334 @@
         }
 
+        // update our variable for faster checks
+        updateCollisionType();
+
         // Mass non zero is a bad idea for kinematic and static objects
-        if ((type == Kinematic || type == Static) && getMass() != 0.0f)
+        if ((type == Kinematic || type == Static) && this->mass_ != 0.0f)
             this->setMass(0.0f);
         // Mass zero is not such a good idea for dynamic objects
-        else if (type == Dynamic && getMass() == 0.0f)
+        else if (type == Dynamic && this->mass_ == 0.0f)
             this->setMass(1.0f);
-
-        // finally update our variable for faster checks
-        updateCollisionType();
+        else if (hasPhysics())
+            this->physicalBody_->setMassProps(this->mass_, btVector3(0,0,0));
     }
 
@@ -329 +394 @@
     }
 
-    void WorldEntity::setCollisionRadius(float radius)
-    {
-        if (!checkPhysics())
-            return;
-
-        // destroy old one first
-        btCollisionShape* oldShape = this->physicalBody_->getCollisionShape();
-        if (oldShape)
-            delete oldShape;
-
-        this->physicalBody_->setCollisionShape(new btSphereShape(btScalar(radius)));
-    }
-
-    float WorldEntity::getCollisionRadius() const
-    {
-        if (checkPhysics())
-        {
-            btSphereShape* sphere = dynamic_cast<btSphereShape*>(this->physicalBody_->getCollisionShape());
-            if (sphere)
-                return (float)sphere->getRadius();
-        }
-        return 0.0f;
-    }
+    //void WorldEntity::setCollisionRadius(float radius)
+    //{
+    //    if (!checkPhysics())
+    //        return;
+
+    //    // destroy old one first
+    //    btCollisionShape* oldShape = this->physicalBody_->getCollisionShape();
+    //    if (oldShape)
+    //        delete oldShape;
+
+    //    //if (this->getName() == "blubb")
+    //    //{
+    //    //    btCompoundShape* cShape = new btCompoundShape();
+    //    //    cShape->setLocalScaling(btVector3(1,1,1));
+    //    //    btTransform offset(btQuaternion(0, 0, 0), btVector3(0, 0, 0));
+    //    //    offset.setBasis(btMatrix3x3(3, 0, 0, 0, 3, 0, 0, 0, 3));
+    //    //    btSphereShape* sphere = new btSphereShape(radius);
+    //    //    sphere->setLocalScaling(btVector3(1,1,3));
+    //    //    cShape->addChildShape(offset, sphere);
+    //    //    this->physicalBody_->setCollisionShape(cShape);
+    //    //}
+    //    //else
+    //    this->physicalBody_->setCollisionShape(new btSphereShape(btScalar(radius)));
+    //}
+
+    //float WorldEntity::getCollisionRadius() const
+    //{
+    //    if (checkPhysics())
+    //    {
+    //        btSphereShape* sphere = dynamic_cast<btSphereShape*>(this->physicalBody_->getCollisionShape());
+    //        if (sphere)
+    //            return (float)sphere->getRadius();
+    //    }
+    //    return 0.0f;
+    //}
 
     bool WorldEntity::checkPhysics() const

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

@@ -36 +36 @@
 
 #include "LinearMath/btMotionState.h"
-#include "BulletDynamics/Dynamics/btRigidBody.h"
 
 #include "network/Synchronisable.h"
@@ -108 +107 @@
                 { this->setDirection(Vector3(x, y, z), relativeTo, localDirectionVector); }
 
-            inline void setScale3D(const Vector3& scale)
-                { this->node_->setScale(scale); }
+            void setScale3D(const Vector3& scale);
             inline void setScale3D(float x, float y, float z)
-                { this->node_->setScale(x, y, z); }
+                { this->setScale3D(Vector3(x, y, z)); }
             inline const Vector3& getScale3D(void) const
                 { return this->node_->getScale(); }
 
-            inline void setScale(float scale)
-                { this->node_->setScale(scale, scale, scale); }
+            void setScale(float scale)
+                { this->setScale3D(scale, scale, 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); }
+            void scale3D(const Vector3& scale);
             inline void scale3D(float x, float y, float z)
-                { this->node_->scale(x, y, z); }
+                { this->scale3D(Vector3(x, y, z)); }
             inline void scale(float scale)
-                { this->node_->scale(scale, scale, scale); }
+                { this->scale3D(scale, scale, scale); }
 
             void attach(WorldEntity* object);
+//            void attachAsdf(BlinkingBillboard* object);
             void detach(WorldEntity* object);
             WorldEntity* getAttachedObject(unsigned int index) const;
+//            BlinkingBillboard* getAttachedAsdfObject(unsigned int index) const;
             inline const std::set<WorldEntity*>& getAttachedObjects() const
                 { return this->children_; }
@@ -195 +194 @@
 
             void setMass(float mass);
-            float getMass() const;
-
-            void setCollisionRadius(float radius);
-            float getCollisionRadius() const;
+            inline float getMass() const
+                { return this->mass_; }
+
+            void attachCollisionShape(CollisionShape* shape);
+            CollisionShape* getAttachedCollisionShape(unsigned int index) const;
+
+            CollisionShape* getCollisionShape() { return this->collisionShape_; }
+            btRigidBody* getPhysicalBody() { return this->physicalBody_; }
 
         protected:
@@ -211 +214 @@
 
         private:
-            CollisionType collisionType_;
-
+            void mergeCollisionShape(CollisionShape* shape);
+
+            CollisionType                collisionType_;
+            std::vector<CollisionShape*> attachedShapes_;
+            CollisionShape*              collisionShape_;
+            btScalar                     mass_;
     };
 }

code/branches/physics/src/orxonox/objects/worldentities/pawns/SpaceShip.cc

@@ -29 +29 @@
 #include "OrxonoxStableHeaders.h"
 #include "SpaceShip.h"
+
+#include "BulletDynamics/Dynamics/btRigidBody.h"
 
 #include "util/Math.h"

code/branches/physics/visual_studio/vc8/orxonox.vcproj

@@ -348 +348 @@
                                                 </File>
                                         </Filter>
+                                        <Filter
+                                                Name="collisionShapes"
+                                                >
+                                                <File
+                                                        RelativePath="..\..\src\orxonox\objects\worldentities\collisionShapes\CollisionShape.cc"
+                                                        >
+                                                </File>
+                                                <File
+                                                        RelativePath="..\..\src\orxonox\objects\worldentities\collisionShapes\CompoundCollisionShape.cc"
+                                                        >
+                                                </File>
+                                                <File
+                                                        RelativePath="..\..\src\orxonox\objects\worldentities\collisionShapes\SphereCollisionShape.cc"
+                                                        >
+                                                </File>
+                                        </Filter>
                                 </Filter>
                                 <Filter
@@ -1252 +1268 @@
                                                 </File>
                                         </Filter>
+                                        <Filter
+                                                Name="collisionShapes"
+                                                >
+                                                <File
+                                                        RelativePath="..\..\src\orxonox\objects\worldentities\collisionShapes\CollisionShape.h"
+                                                        >
+                                                </File>
+                                                <File
+                                                        RelativePath="..\..\src\orxonox\objects\worldentities\collisionShapes\CompoundCollisionShape.h"
+                                                        >
+                                                </File>
+                                                <File
+                                                        RelativePath="..\..\src\orxonox\objects\worldentities\collisionShapes\SphereCollisionShape.h"
+                                                        >
+                                                </File>
+                                        </Filter>
                                 </Filter>
                                 <Filter
@@ -1419 +1451 @@
                                 <File
                                         RelativePath="..\..\src\orxonox\tools\BillboardSet.h"
+                                        >
+                                </File>
+                                <File
+                                        RelativePath="..\..\src\orxonox\tools\BulletConversions.h"
                                         >
                                 </File>