Changeset 2192 for code/branches/physics/src/orxonox

Timestamp:

Nov 12, 2008, 1:44:09 PM (16 years ago)

Author:

rgrieder

Message:

Reverted all changes of attempt to update physics branch.

Location:

code/branches/physics

Files:

• . (modified) (1 prop)
• src/orxonox/CMakeLists.txt (modified) (3 diffs)
• src/orxonox/OrxonoxPrereqs.h (modified) (2 diffs)
• src/orxonox/OrxonoxStableHeaders.h (modified) (2 diffs)
• src/orxonox/gamestates/GSLevel.cc (modified) (1 diff)
• src/orxonox/objects/HelloBullet.cc (copied) (copied from code/branches/physics/src/orxonox/objects/HelloBullet.cc)
• src/orxonox/objects/HelloBullet.h (copied) (copied from code/branches/physics/src/orxonox/objects/HelloBullet.h)
• src/orxonox/objects/Scene.cc (modified) (2 diffs)
• src/orxonox/objects/Scene.h (modified) (3 diffs)
• src/orxonox/objects/weaponSystem/WeaponSystem.h (modified) (1 prop)
• src/orxonox/objects/worldentities/ControllableEntity.cc (modified) (1 diff)
• src/orxonox/objects/worldentities/ControllableEntity.h (modified) (1 diff)
• src/orxonox/objects/worldentities/LinearEntity.cc (copied) (copied from code/branches/physics/src/orxonox/objects/worldentities/LinearEntity.cc)
• src/orxonox/objects/worldentities/LinearEntity.h (copied) (copied from code/branches/physics/src/orxonox/objects/worldentities/LinearEntity.h)
• src/orxonox/objects/worldentities/Model.h (modified) (1 diff)
• src/orxonox/objects/worldentities/MovableEntity.cc (modified) (2 diffs)
• src/orxonox/objects/worldentities/MovableEntity.h (modified) (2 diffs)
• src/orxonox/objects/worldentities/PositionableEntity.cc (modified) (2 diffs)
• src/orxonox/objects/worldentities/PositionableEntity.h (modified) (2 diffs)
• src/orxonox/objects/worldentities/StaticEntity.cc (copied) (copied from code/branches/physics/src/orxonox/objects/worldentities/StaticEntity.cc)
• src/orxonox/objects/worldentities/StaticEntity.h (copied) (copied from code/branches/physics/src/orxonox/objects/worldentities/StaticEntity.h)
• src/orxonox/objects/worldentities/WorldEntity.cc (modified) (6 diffs)
• src/orxonox/objects/worldentities/WorldEntity.h (modified) (5 diffs)

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

@@ -46 +46 @@
   objects/EventDispatcher.cc
   objects/EventTarget.cc
+  objects/HelloBullet.cc
   objects/Radar.cc
   objects/RadarListener.cc
@@ -55 +56 @@
   objects/Scene.cc
   objects/worldentities/WorldEntity.cc
+  objects/worldentities/StaticEntity.cc
+  objects/worldentities/MovableEntity.cc
   objects/worldentities/PositionableEntity.cc
-  objects/worldentities/MovableEntity.cc
+  objects/worldentities/LinearEntity.cc
   objects/worldentities/ControllableEntity.cc
   objects/worldentities/Model.cc
@@ -144 +147 @@
   tinyxml_orxonox
   tolualib_orxonox
+#LibBulletSoftBody
+  LibBulletDynamics
+  LibBulletCollision
+  LibLinearMath
+#ogrebullet_collisions_orxonox
+#ogrebullet_dynamics_orxonox
   util
   core

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

@@ -103 +103 @@
 
     class WorldEntity;
+    class StaticEntity;
+    class MovableEntity;
     class PositionableEntity;
-    class MovableEntity;
     class ControllableEntity;
+    class LinearEntity;
     class Sublevel;
 
@@ -203 +205 @@
 }
 
+// Bullet Physics Engine
+
+class btRigidBody;
+class btCollisionObject;
+class btGhostObject;
+class btCollisionShape;
+class btSphereShape;
+
+
 struct lua_State;
 

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

@@ -48 +48 @@
 #include <CEGUI.h>
 #include "ois/OIS.h"
+//#include "btBulletCollisionCommon.h"
+//#include "btBulletDynamicsCommon.h"
 #include <boost/thread/recursive_mutex.hpp>
 //#include <boost/thread/mutex.hpp>
@@ -97 +99 @@
 #include "network/Synchronisable.h"
 
-#include "Settings.h"
+//#include "Settings.h"
 
 //#endif /* ifdef NDEBUG */

code/branches/physics/src/orxonox/gamestates/GSLevel.cc

@@ -51 +51 @@
 namespace orxonox
 {
-    SetCommandLineArgument(level, "sample2.oxw").shortcut("l");
+    SetCommandLineArgument(level, "physicstest2.oxw").shortcut("l");
 
     GSLevel::GSLevel()

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

@@ -70 +70 @@
         }
 
+        /////////////
+        // Physics //
+        /////////////
+
+        // create bullet world; bullet solver etc.
+
+        // int maxProxies = 1024;
+
+        btVector3 worldAabbMin(-10000,-10000,-10000);
+        btVector3 worldAabbMax(10000,10000,10000);
+        bt32BitAxisSweep3* broadphase = new bt32BitAxisSweep3(worldAabbMin,worldAabbMax);
+
+        this -> collisionConfiguration_ = new btDefaultCollisionConfiguration();
+        this -> dispatcher_ = new btCollisionDispatcher(collisionConfiguration_);
+
+        this -> solver_ = new btSequentialImpulseConstraintSolver;
+
+        this -> dynamicsWorld_ =  new btDiscreteDynamicsWorld(dispatcher_,broadphase,solver_,collisionConfiguration_);
+
+        dynamicsWorld_->setGravity(btVector3(0,-10,0));
+
+
         // test test test
         if (Core::showsGraphics() && this->sceneManager_)
@@ -91 +113 @@
             if (Ogre::Root::getSingletonPtr())
             {
-//                this->sceneManager_->destroySceneNode(this->rootSceneNode_->getName()); // TODO: remove getName() for newer versions of Ogre
                 Ogre::Root::getSingleton().destroySceneManager(this->sceneManager_);
             }

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

@@ -36 +36 @@
 #include "util/Math.h"
 
+#include "ogrebullet/Dynamics/OgreBulletDynamics.h"
+
 namespace orxonox
 {
@@ -51 +53 @@
             inline Ogre::SceneNode* getRootSceneNode() const
                 { return this->rootSceneNode_; }
+
+            inline btDiscreteDynamicsWorld* getPhysicalWorld() const
+                { return this->dynamicsWorld_; }
 
             void setSkybox(const std::string& skybox);
@@ -75 +80 @@
             Ogre::SceneManager*    sceneManager_;
             Ogre::SceneNode*       rootSceneNode_;
+
+            btDiscreteDynamicsWorld* dynamicsWorld_;
+            btSequentialImpulseConstraintSolver* solver_;
+            btDefaultCollisionConfiguration* collisionConfiguration_;
+            btCollisionDispatcher* dispatcher_; 
+            // Point auf Bullet btDynamics world && solver
+
             std::string            skybox_;
             ColourValue            ambientLight_;

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

@@ -44 +44 @@
     CreateFactory(ControllableEntity);
 
-    ControllableEntity::ControllableEntity(BaseObject* creator) : WorldEntity(creator)
+    ControllableEntity::ControllableEntity(BaseObject* creator) : MovableEntity(creator)
     {
         RegisterObject(ControllableEntity);

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

@@ -32 +32 @@
 #include "OrxonoxPrereqs.h"
 
-#include "WorldEntity.h"
+#include "MovableEntity.h"
 #include "objects/Tickable.h"
 
 namespace orxonox
 {
-    class _OrxonoxExport ControllableEntity : public WorldEntity, public Tickable
+    class _OrxonoxExport ControllableEntity : public MovableEntity, public Tickable
     {
         public:

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

@@ -70 +70 @@
 }
 
-#endif /* _PositionableEntity_H__ */
+#endif /* _Model_H__ */

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

@@ -32 +32 @@
 #include "core/CoreIncludes.h"
 #include "core/XMLPort.h"
-#include "core/Executor.h"
-#include "tools/Timer.h"
 
 namespace orxonox
 {
-    static const float MAX_RESYNCHRONIZE_TIME = 3.0f;
-
-    CreateFactory(MovableEntity);
-
     MovableEntity::MovableEntity(BaseObject* creator) : WorldEntity(creator)
     {
         RegisterObject(MovableEntity);
-
-        this->velocity_ = Vector3::ZERO;
-        this->acceleration_ = Vector3::ZERO;
-        this->rotationAxis_ = Vector3::ZERO;
-        this->rotationRate_ = 0;
-        this->momentum_ = 0;
-
-        this->overwrite_position_ = Vector3::ZERO;
-        this->overwrite_orientation_ = Quaternion::IDENTITY;
 
         this->registerVariables();
@@ -64 +49 @@
     {
         SUPER(MovableEntity, XMLPort, xmlelement, mode);
-
-        XMLPortParamTemplate(MovableEntity, "velocity", setVelocity, getVelocity, xmlelement, mode, const Vector3&);
-        XMLPortParamTemplate(MovableEntity, "rotationaxis", setRotationAxis, getRotationAxis, xmlelement, mode, const Vector3&);
-        XMLPortParamTemplate(MovableEntity, "rotationrate", setRotationRate, getRotationRate, xmlelement, mode, const Degree&);
-    }
-
-    void MovableEntity::tick(float dt)
-    {
-        if (this->isActive())
-        {
-            this->velocity_ += (dt * this->acceleration_);
-            this->node_->translate(dt * this->velocity_);
-
-            this->rotationRate_ += (dt * this->momentum_);
-            this->node_->rotate(this->rotationAxis_, this->rotationRate_  * dt);
-        }
     }
 
     void MovableEntity::registerVariables()
     {
-        REGISTERDATA(this->velocity_.x, network::direction::toclient);
-        REGISTERDATA(this->velocity_.y, network::direction::toclient);
-        REGISTERDATA(this->velocity_.z, network::direction::toclient);
-
-        REGISTERDATA(this->rotationAxis_.x, network::direction::toclient);
-        REGISTERDATA(this->rotationAxis_.y, network::direction::toclient);
-        REGISTERDATA(this->rotationAxis_.z, network::direction::toclient);
-
-        REGISTERDATA(this->rotationRate_, network::direction::toclient);
-
-        REGISTERDATA(this->overwrite_position_,    network::direction::toclient, new network::NetworkCallback<MovableEntity>(this, &MovableEntity::overwritePosition));
-        REGISTERDATA(this->overwrite_orientation_, network::direction::toclient, new network::NetworkCallback<MovableEntity>(this, &MovableEntity::overwriteOrientation));
-    }
-
-    void MovableEntity::overwritePosition()
-    {
-        this->node_->setPosition(this->overwrite_position_);
-    }
-
-    void MovableEntity::overwriteOrientation()
-    {
-        this->node_->setOrientation(this->overwrite_orientation_);
-    }
-
-    void MovableEntity::clientConnected(unsigned int clientID)
-    {
-        new Timer<MovableEntity>(rnd() * MAX_RESYNCHRONIZE_TIME, false, this, createExecutor(createFunctor(&MovableEntity::resynchronize)), true);
-    }
-
-    void MovableEntity::clientDisconnected(unsigned int clientID)
-    {
-    }
-
-    void MovableEntity::resynchronize()
-    {
-        this->overwrite_position_ = this->getPosition();
-        this->overwrite_orientation_ = this->getOrientation();
-    }
-
-    void MovableEntity::setPosition(const Vector3& position)
-    {
-        this->node_->setPosition(position);
-        this->overwrite_position_ = this->node_->getPosition();
-    }
-
-    void MovableEntity::translate(const Vector3& distance, Ogre::Node::TransformSpace relativeTo)
-    {
-        this->node_->translate(distance, relativeTo);
-        this->overwrite_position_ = this->node_->getPosition();
-    }
-
-    void MovableEntity::setOrientation(const Quaternion& orientation)
-    {
-        this->node_->setOrientation(orientation);
-        this->overwrite_orientation_ = this->node_->getOrientation();
-    }
-
-    void MovableEntity::rotate(const Quaternion& rotation, Ogre::Node::TransformSpace relativeTo)
-    {
-        this->node_->rotate(rotation, relativeTo);
-        this->overwrite_orientation_ = this->node_->getOrientation();
-    }
-
-    void MovableEntity::yaw(const Degree& angle, Ogre::Node::TransformSpace relativeTo)
-    {
-        this->node_->yaw(angle, relativeTo);
-        this->overwrite_orientation_ = this->node_->getOrientation();
-    }
-
-    void MovableEntity::pitch(const Degree& angle, Ogre::Node::TransformSpace relativeTo)
-    {
-        this->node_->pitch(angle, relativeTo);
-        this->overwrite_orientation_ = this->node_->getOrientation();
-    }
-
-    void MovableEntity::roll(const Degree& angle, Ogre::Node::TransformSpace relativeTo)
-    {
-        this->node_->roll(angle, relativeTo);
-        this->overwrite_orientation_ = this->node_->getOrientation();
-    }
-
-    void MovableEntity::lookAt(const Vector3& target, Ogre::Node::TransformSpace relativeTo, const Vector3& localDirectionVector)
-    {
-        this->node_->lookAt(target, relativeTo, localDirectionVector);
-        this->overwrite_orientation_ = this->node_->getOrientation();
-    }
-
-    void MovableEntity::setDirection(const Vector3& direction, Ogre::Node::TransformSpace relativeTo, const Vector3& localDirectionVector)
-    {
-        this->node_->setDirection(direction, relativeTo, localDirectionVector);
-        this->overwrite_orientation_ = this->node_->getOrientation();
     }
 }

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

@@ -38 +38 @@
 namespace orxonox
 {
-    class _OrxonoxExport MovableEntity : public WorldEntity, public Tickable, public network::ClientConnectionListener
+    class _OrxonoxExport MovableEntity : public WorldEntity
     {
         public:
@@ -45 +45 @@
 
             virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
-            virtual void tick(float dt);
             void registerVariables();
 
-            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;
+        private:
 
-            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 attachPhysicalObject(WorldEntity* object);
 
-            inline void setVelocity(const Vector3& velocity)
-                { this->velocity_ = velocity; }
-            inline void setVelocity(float x, float y, float z)
-                { this->velocity_.x = x; this->velocity_.y = y; this->velocity_.z = z; }
-            inline const Vector3& getVelocity() const
-                { return this->velocity_; }
+            //// Bullet btMotionState related
+            //void setWorldTransform(const btTransform& worldTrans)
+            //{
+            //    this->node_->setPosition(worldTrans.getOrigin().x(), worldTrans.getOrigin().y(), worldTrans.getOrigin().z());
+            //    this->node_->setOrientation(worldTrans.getRotation().w(), worldTrans.getRotation().x(), worldTrans.getRotation().y(), worldTrans.getRotation().z());
+            //    //this->velocity_.x = this->physicalBody_->
+            //}
 
-            inline void setAcceleration(const Vector3& acceleration)
-                { this->acceleration_ = acceleration; }
-            inline void setAcceleration(float x, float y, float z)
-                { this->acceleration_.x = x; this->acceleration_.y = y; this->acceleration_.z = z; }
-            inline const Vector3& getAcceleration() const
-                { return this->acceleration_; }
-
-            inline void setRotationAxis(const Vector3& axis)
-                { this->rotationAxis_ = axis; this->rotationAxis_.normalise(); }
-            inline void setRotationAxis(float x, float y, float z)
-                { this->rotationAxis_.x = x; this->rotationAxis_.y = y; this->rotationAxis_.z = z; rotationAxis_.normalise(); }
-            inline const Vector3& getRotationAxis() const
-                { return this->rotationAxis_; }
-
-            inline void setRotationRate(const Degree& angle)
-                { this->rotationRate_ = angle; }
-            inline void setRotationRate(const Radian& angle)
-                { this->rotationRate_ = angle; }
-            inline const Degree& getRotationRate() const
-                { return this->rotationRate_; }
-
-            inline void setMomentum(const Degree& angle)
-                { this->momentum_ = angle; }
-            inline void setMomentum(const Radian& angle)
-                { this->momentum_ = angle; }
-            inline const Degree& getMomentum() const
-                { return this->momentum_; }
-
-        private:
-            void clientConnected(unsigned int clientID);
-            void clientDisconnected(unsigned int clientID);
-            void resynchronize();
-
-            void overwritePosition();
-            void overwriteOrientation();
-
-            Vector3 velocity_;
-            Vector3 acceleration_;
-            Vector3 rotationAxis_;
-            Degree rotationRate_;
-            Degree momentum_;
-
-            Vector3 overwrite_position_;
-            Quaternion overwrite_orientation_;
+            //// Bullet btMotionState related
+            //void getWorldTransform(btTransform& worldTrans) const
+            //{
+            //    worldTrans.setOrigin(btVector3(node_->getPosition().x, node_->getPosition().y, node_->getPosition().z));
+            //    worldTrans.setRotation(btQuaternion(node_->getOrientation().w, node_->getOrientation().x, node_->getOrientation().y, node_->getOrientation().z));
+            //}
     };
 }

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

@@ -35 +35 @@
     CreateFactory(PositionableEntity);
 
-    PositionableEntity::PositionableEntity(BaseObject* creator) : WorldEntity(creator)
+    PositionableEntity::PositionableEntity(BaseObject* creator) : MovableEntity(creator)
     {
         RegisterObject(PositionableEntity);
@@ -57 +57 @@
         REGISTERDATA(this->getOrientation().z, network::direction::toclient);
     }
+
+    //void PositionableEntity::attachPhysicalObject(WorldEntity* object)
+    //{
+    //}
 }

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

@@ -31 +31 @@
 
 #include "OrxonoxPrereqs.h"
-#include "WorldEntity.h"
+#include "MovableEntity.h"
 
 namespace orxonox
 {
-    class _OrxonoxExport PositionableEntity : public WorldEntity
+    class _OrxonoxExport PositionableEntity : public MovableEntity
     {
         public:
@@ -71 +71 @@
             inline void setDirection(const Vector3& direction, Ogre::Node::TransformSpace relativeTo = Ogre::Node::TS_LOCAL, const Vector3& localDirectionVector = Vector3::NEGATIVE_UNIT_Z)
                 { this->node_->setDirection(direction, relativeTo, localDirectionVector); }
+
+        private:
+            //void attachPhysicalObject(WorldEntity* object);
     };
 }

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

@@ -32 +32 @@
 #include <cassert>
 #include <OgreSceneManager.h>
+#include "BulletCollision/CollisionShapes/btSphereShape.h"
 
 #include "core/CoreIncludes.h"
@@ -63 +64 @@
         this->node_->setOrientation(Quaternion::IDENTITY);
 
+        // Default behaviour does not include physics
+        this->bAddedToPhysicalWorld_ = false;
+        this->physicalBody_ = 0;
+
         this->registerVariables();
     }
@@ -73 +78 @@
             if (this->getScene()->getSceneManager())
                 this->getScene()->getSceneManager()->destroySceneNode(this->node_->getName());
+            
+            // Physics is not guaranteed, so check first
+            if (this->physicalBody_)
+            {
+                if (this->bAddedToPhysicalWorld_)
+                    this->getScene()->getPhysicalWorld()->removeRigidBody(this->physicalBody_);
+                if (this->physicalBody_->getCollisionShape())
+                    delete this->physicalBody_->getCollisionShape();
+                delete this->physicalBody_;
+            }
         }
     }
@@ -89 +104 @@
         XMLPortParamTemplate(WorldEntity, "scale3D", setScale3D, getScale3D, xmlelement, mode, const Vector3&);
         XMLPortParam(WorldEntity, "scale", setScale, getScale, xmlelement, mode);
+        XMLPortParam(WorldEntity, "collisionRadius", setcollisionRadius, getcollisionRadius, xmlelement, mode);
 
         XMLPortObject(WorldEntity, WorldEntity, "attached", attach, getAttachedObject, xmlelement, mode);
@@ -127 +143 @@
         object->parent_ = this;
         object->parentID_ = this->getObjectID();
+
+        // Do the physical connection if required
+        this->attachPhysicalObject(object);
     }
 
@@ -150 +169 @@
         return 0;
     }
+
+    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);
+        this->getScene()->getPhysicalWorld()->addRigidBody(this->physicalBody_);
+        this->bAddedToPhysicalWorld_ = true;
+    }
+
+    void WorldEntity::setcollisionRadius(float radius)
+    {
+        if (!this->physicalBody_)
+            createPhysicalBody();
+
+        // destroy old onw first
+        btCollisionShape* oldShape = this->physicalBody_->getCollisionShape();
+        if (oldShape)
+            delete oldShape;
+
+        this->physicalBody_->setCollisionShape(new btSphereShape(btScalar(radius)));
+    }
+
+    float WorldEntity::getcollisionRadius()
+    {
+        if (this->physicalBody_)
+        {
+            btSphereShape* sphere = dynamic_cast<btSphereShape*>(this->physicalBody_->getCollisionShape());
+            if (sphere)
+                return (float)sphere->getRadius();
+        }
+        return 0.0f;
+    }
 }

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

@@ -33 +33 @@
 
 #define OGRE_FORCE_ANGLE_TYPES
+#include <OgreSceneNode.h>
 
-#include <OgreSceneNode.h>
+#include "LinearMath/btMotionState.h"
+#include "BulletDynamics/Dynamics/btRigidBody.h"
 
 #include "network/Synchronisable.h"
@@ -42 +44 @@
 namespace orxonox
 {
-    class _OrxonoxExport WorldEntity : public BaseObject, public network::Synchronisable
+    class _OrxonoxExport WorldEntity : public BaseObject, public network::Synchronisable, public btMotionState
     {
         public:
@@ -125 +127 @@
                 { this->node_->scale(scale, scale, scale); }
 
+            void setcollisionRadius(float radius);
+            float getcollisionRadius();
+
+            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);
@@ -139 +148 @@
 
         protected:
+            //virtual btCollisionShape* getCollisionShape() = 0;
+
+            void createPhysicalBody();
+            virtual void attachPhysicalObject(WorldEntity* object) { }
+
             Ogre::SceneNode* node_;
+            bool bAddedToPhysicalWorld_;
+            btRigidBody* physicalBody_;
 
         private:
@@ -155 +171 @@
                 { this->roll(angle); }
 
+            // Bullet btMotionState related
+            virtual void setWorldTransform(const btTransform& worldTrans)
+            {
+            }
+
+            // Bullet btMotionState related
+            virtual void getWorldTransform(btTransform& worldTrans) const
+            {
+            }
+
             WorldEntity* parent_;
             unsigned int parentID_;