Changeset 2298 for code/branches/physics/src/orxonox/objects/worldentities

Timestamp:

Nov 29, 2008, 12:45:19 AM (16 years ago)

Author:

rgrieder

Message:

Clarified use of different physical bodies. The "collisionType" XML attribute of WE specifies the following:
"none": There is not physical body at all. Physics disabled.
"static": It is a StaticEntity with physics. Any other derived class of WE issues an exception by choosing this collision type.
"kinematic" or "dynamic": MovableEntity with physics. StaticEntity issues an exception when choosing one of these two.

Added two new Exceptions: ParseError and PhysicsViolation.

Location:

code/branches/physics/src/orxonox/objects/worldentities

Files:

• MovableEntity.cc (modified) (1 diff)
• MovableEntity.h (modified) (1 diff)
• StaticEntity.cc (modified) (1 diff)
• StaticEntity.h (modified) (1 diff)
• WorldEntity.cc (modified) (11 diffs)
• WorldEntity.h (modified) (4 diffs)
• pawns/SpaceShip.cc (modified) (1 diff)

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

@@ -301 +301 @@
             this->node_->setDirection(direction, relativeTo, localDirectionVector);
         }
+    }
+
+    bool MovableEntity::isCollisionTypeLegal(WorldEntity::CollisionType type)
+    {
+        if (type == WorldEntity::Static)
+        {
+            ThrowException(PhysicsViolation, "Cannot tell a MovableEntity to have static collision type");
+            return false;
+        }
+        else
+            return true;
     }
 

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

@@ -74 +74 @@
             virtual void positionChanged() { }
             virtual void orientationChanged() { }
+            virtual bool isCollisionTypeLegal(WorldEntity::CollisionType type);
 
             // Bullet btMotionState related

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

@@ -60 +60 @@
     }
 
-    void StaticEntity::setCollisionType(CollisionType type)
+    bool StaticEntity::isCollisionTypeLegal(WorldEntity::CollisionType type)
     {
-        if (!this->physicalBody_)
-            return;
-        if (type != Static)
-            ThrowException(Argument, "Cannot tell a StaticEntity to be kinematic or dynamic");
-
-        this->physicalBody_->setCollisionFlags(this->physicalBody_->getCollisionFlags() & !btCollisionObject::CF_KINEMATIC_OBJECT | btCollisionObject::CF_STATIC_OBJECT);
+        if (type == WorldEntity::Static)
+        {
+            ThrowException(PhysicsViolation, "Cannot tell a MovableEntity to have static collision type");
+            return false;
+        }
+        else
+            return true;
     }
 

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

@@ -74 +74 @@
         private:
 
-            void setCollisionType(CollisionType type);
+            bool isCollisionTypeLegal(CollisionType type);
 
             // Bullet btMotionState related

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

@@ -41 +41 @@
 
 #include "objects/Scene.h"
-
-#include "StaticEntity.h"
 
 namespace orxonox
@@ -70 +68 @@
         // Default behaviour does not include physics
         this->physicalBody_ = 0;
+        updateCollisionType();
 
         this->registerVariables();
@@ -81 +80 @@
             if (this->getScene()->getSceneManager())
                 this->getScene()->getSceneManager()->destroySceneNode(this->node_->getName());
-            
-            // Physics is not guaranteed, so check first
-            if (this->physicalBody_)
-            {
-                if (this->physicalBody_->isInWorld())
-                    this->getScene()->getPhysicalWorld()->removeRigidBody(this->physicalBody_);
-                if (this->physicalBody_->getCollisionShape())
-                    delete this->physicalBody_->getCollisionShape();
-                delete this->physicalBody_;
-            }
+
+            this->setCollisionType(None);
         }
     }
@@ -108 +99 @@
         XMLPortParam(WorldEntity, "scale", setScale, getScale, xmlelement, mode);
 
+        XMLPortParam(WorldEntity, "collisionType", setCollisionTypeStr, getCollisionTypeStr, xmlelement, mode);
         XMLPortParam(WorldEntity, "collisionRadius", setCollisionRadius, getCollisionRadius, xmlelement, mode);
-        XMLPortParam(WorldEntity, "collisionType", setCollisionTypeStr, getCollisionTypeStr, xmlelement, mode);
         XMLPortParam(WorldEntity, "mass", setMass, getMass, xmlelement, mode);
 
-        if (this->physicalBody_)
+        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, WorldEntity, "attached", attach, getAttachedObject, xmlelement, mode);
     }
 
@@ -200 +192 @@
     }
 
-    void WorldEntity::createPhysicalBody()
-    {
-        // Note: The motion state will be configured in a derived class.
-        btRigidBody::btRigidBodyConstructionInfo bodyConstructionInfo(0, this, 0, btVector3(0,0,0));
-        this->physicalBody_ = new btRigidBody(bodyConstructionInfo);
-    }
-
     float WorldEntity::getMass()
     {
-        if (!this->physicalBody_)
+        if (!checkPhysics())
             return 0.0f;
 
@@ -217 +202 @@
     void WorldEntity::setMass(float mass)
     {
-        if (!this->physicalBody_)
-            this->createPhysicalBody();
-
-        this->physicalBody_->setMassProps(mass, btVector3(0,0,0));
-    }
-
-    void WorldEntity::setCollisionType(WorldEntity::CollisionType type)
-    {
-        if (!this->physicalBody_)
-            this->createPhysicalBody();
-
+        if (!checkPhysics())
+            return;
+        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();
+        }
+    }
+
+    void WorldEntity::setCollisionType(CollisionType type)
+    {
+        // Check first whether we have to create or destroy.
+        if (type != None && this->collisionType_ == None)
+        {
+            // Create new rigid body
+            btRigidBody::btRigidBodyConstructionInfo bodyConstructionInfo(0, this, 0, 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)
+        {
+            // Destroy rigid body
+            if (this->physicalBody_->isInWorld())
+                this->getScene()->getPhysicalWorld()->removeRigidBody(this->physicalBody_);
+            if (this->physicalBody_->getCollisionShape())
+                delete this->physicalBody_->getCollisionShape();
+            delete this->physicalBody_;
+            this->physicalBody_ = 0;
+            this->collisionType_ = None;
+            return;
+        }
+
+        // Check for type legality. Could be StaticEntity or MovableEntity
+        if (!this->isCollisionTypeLegal(type))
+            return; // exception gets issued anyway
+
+        // Change type
         switch (type)
         {
@@ -239 +259 @@
             this->physicalBody_->setCollisionFlags(this->physicalBody_->getCollisionFlags() & !btCollisionObject::CF_KINEMATIC_OBJECT | btCollisionObject::CF_STATIC_OBJECT);
             break;
-        }
-    }
-
-    WorldEntity::CollisionType WorldEntity::getCollisionType()
+        case None:
+            return; // this->collisionType_ was None too
+        }
+
+        // Mass non zero is a bad idea for kinematic and static objects
+        if ((type == Kinematic || type == Static) && getMass() != 0.0f)
+            this->setMass(0.0f);
+        // Mass zero is not such a good idea for dynamic objects
+        else if (type == Dynamic && getMass() == 0.0f)
+            this->setMass(1.0f);
+
+        // finally update our variable for faster checks
+        updateCollisionType();
+    }
+
+    void WorldEntity::updateCollisionType()
     {
         if (!this->physicalBody_)
-            ThrowException(Argument, "Cannot retrieve collision type of a non physical object.");
-
-        int flags = this->physicalBody_->getCollisionFlags();
-        if (flags & btCollisionObject::CF_STATIC_OBJECT)
-            return Static;
-        else if (flags & btCollisionObject::CF_KINEMATIC_OBJECT)
-            return Kinematic;
-        else
-            return Dynamic;
-    }
-
-    void WorldEntity::setCollisionTypeStr(const std::string& type)
-    {
-        std::string lower = getLowercase(type);
-        if (lower == "dynamic")
-            setCollisionType(Dynamic);
-        else if (lower == "static")
-            setCollisionType(Static);
-        else if (lower == "kinematic")
-            setCollisionType(Kinematic);
-        else
-            ThrowException(Argument, std::string("Trying to set an unknown collision type: '") + type + "'.");
+            this->collisionType_ = None;
+        else if (this->physicalBody_->isKinematicObject())
+            this->collisionType_ = Kinematic;
+        else if (this->physicalBody_->isStaticObject())
+            this->collisionType_ = Static;
+        else
+            this->collisionType_ = Dynamic;
+    }
+
+    void WorldEntity::setCollisionTypeStr(const std::string& typeStr)
+    {
+        std::string typeStrLower = getLowercase(typeStr);
+        CollisionType type;
+        if (typeStrLower == "dynamic")
+            type = Dynamic;
+        else if (typeStrLower == "static")
+            type = Static;
+        else if (typeStrLower == "kinematic")
+            type = Kinematic;
+        else if (typeStrLower == "none")
+            type = None;
+        else
+            ThrowException(ParseError, std::string("Attempting to set an unknown collision type: '") + typeStr + "'.");
+        this->setCollisionType(type);
     }
 
@@ -273 +307 @@
         switch (this->getCollisionType())
         {
-        case Dynamic:
-            return "dynamic";
-        case Kinematic:
-            return "kinematic";
-        case Static:
-            return "static";
-        default:
-            ThrowException(Argument, "Encountered unknown collision Type.");
+            case Dynamic:
+                return "dynamic";
+            case Kinematic:
+                return "kinematic";
+            case Static:
+                return "static";
+            case None:
+                return "none";
+            default:
+                assert(false);
+                return "";
         }
     }
@@ -286 +323 @@
     void WorldEntity::setCollisionRadius(float radius)
     {
-        if (!this->physicalBody_)
-            createPhysicalBody();
+        if (!checkPhysics())
+            return;
 
         // destroy old one first
@@ -299 +336 @@
     float WorldEntity::getCollisionRadius()
     {
-        if (this->physicalBody_)
+        if (checkPhysics())
         {
             btSphereShape* sphere = dynamic_cast<btSphereShape*>(this->physicalBody_->getCollisionShape());
@@ -307 +344 @@
         return 0.0f;
     }
+
+    bool WorldEntity::checkPhysics()
+    {
+        if (!this->physicalBody_)
+        {
+            assert(this->getCollisionType() == None);
+            COUT(2) << "WorldEntity was not fitted with physics, cannot set phyiscal property." << std::endl;
+            return false;
+        }
+        else
+            return true;
+    }
 }

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

@@ -46 +46 @@
     class _OrxonoxExport WorldEntity : public BaseObject, public network::Synchronisable, public btMotionState
     {
-        public:
-            enum CollisionType
-            {
-                Dynamic,
-                Kinematic,
-                Static
-            };
-
         public:
             WorldEntity(BaseObject* creator);
@@ -135 +127 @@
                 { this->node_->scale(scale, scale, scale); }
 
-            bool hasPhysics()  { return this->physicalBody_; }
-            bool isKinematic() { return this->physicalBody_ && this->physicalBody_->isKinematicObject(); }
-            bool isDynamic()   { return this->physicalBody_ && !this->physicalBody_->isStaticOrKinematicObject(); }
-
             void attach(WorldEntity* object);
             void detach(WorldEntity* object);
@@ -159 +147 @@
                 { return this->parent_; }
 
-            void setCollisionRadius(float radius);
-            float getCollisionRadius();
-
-            void setCollisionTypeStr(const std::string& type);
-            std::string getCollisionTypeStr();
-
-            void setMass(float mass);
-            float getMass();
-
-            CollisionType getCollisionType();
-
         protected:
-            //virtual btCollisionShape* getCollisionShape() = 0;
-
-            void createPhysicalBody();
-            //virtual void attachPhysicalObject(WorldEntity* object);
-            virtual void setCollisionType(CollisionType type);
-
             Ogre::SceneNode* node_;
-            btRigidBody* physicalBody_;
 
         private:
@@ -197 +167 @@
             unsigned int parentID_;
             std::set<WorldEntity*> children_;
+
+            /////////////
+            // Physics //
+            /////////////
+
+        public:
+            enum CollisionType
+            {
+                Dynamic,
+                Kinematic,
+                Static,
+                None
+            };
+
+            bool hasPhysics()  { return getCollisionType() != None; }
+
+            CollisionType getCollisionType() { return this->collisionType_; }
+            void setCollisionType(CollisionType type);
+
+            void setCollisionTypeStr(const std::string& type);
+            std::string getCollisionTypeStr();
+
+            bool isStatic()    { return getCollisionType() == Static   ; }
+            bool isKinematic() { return getCollisionType() == Kinematic; }
+            bool isDynamic()   { return getCollisionType() == Dynamic  ; }
+
+            void setMass(float mass);
+            float getMass();
+
+            void setCollisionRadius(float radius);
+            float getCollisionRadius();
+
+        protected:
+            //virtual btCollisionShape* getCollisionShape() = 0;
+            //virtual void attachPhysicalObject(WorldEntity* object);
+
+            virtual bool isCollisionTypeLegal(CollisionType type) = 0;
+            bool checkPhysics();
+            void updateCollisionType();
+
+            btRigidBody*  physicalBody_;
+
+        private:
+            CollisionType collisionType_;
+
     };
 }

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

@@ -60 +60 @@
 
         this->setDestroyWhenPlayerLeft(true);
-
-        // create a phyisical body
-        OrxAssert(this->physicalBody_ == 0, " Check why there is already a physical body in the space ship.");
-        this->createPhysicalBody();
 
         this->setConfigValues();