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

Timestamp:

Nov 11, 2008, 10:30:49 PM (16 years ago)

Author:

rgrieder

Message:

• Added first basic construct of object hierarchy with physics.
• Added a few bullet classes to OrxonoxPrereqs.h
• Added bullet header files to the msvc projects.

No Implementation at all yet, but the game still compiles and runs. Please update the media repository.

Location:

code/branches/physics/src/orxonox

Files:

• OrxonoxPrereqs.h (modified) (1 diff)
• OrxonoxStableHeaders.h (modified) (2 diffs)
• objects/HelloBullet.cc (modified) (7 diffs)
• objects/HelloBullet.h (modified) (1 diff)
• objects/Scene.cc (modified) (4 diffs)
• objects/worldentities/ControllableEntity.cc (modified) (1 diff)
• objects/worldentities/ControllableEntity.h (modified) (1 diff)
• objects/worldentities/DynamicEntity.cc (deleted)
• objects/worldentities/DynamicEntity.h (deleted)
• objects/worldentities/KinematicEntity.cc (deleted)
• objects/worldentities/KinematicEntity.h (deleted)
• objects/worldentities/LinearEntity.cc (added)
• objects/worldentities/LinearEntity.h (added)
• objects/worldentities/MovableEntity.cc (modified) (2 diffs)
• objects/worldentities/MovableEntity.h (modified) (2 diffs)
• objects/worldentities/PositionableEntity.cc (copied) (copied from code/branches/physics/src/orxonox/objects/worldentities/StaticEntity.cc) (2 diffs)
• objects/worldentities/PositionableEntity.h (copied) (copied from code/branches/physics/src/orxonox/objects/worldentities/StaticEntity.h) (2 diffs)
• objects/worldentities/WorldEntity.cc (modified) (6 diffs)
• objects/worldentities/WorldEntity.h (modified) (5 diffs)

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

@@ -203 +203 @@
 }
 
+// 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/objects/HelloBullet.cc

@@ -34 +34 @@
 #include <OgreEntity.h>
 
-// #include "ogreode/OgreOde_Core.h"
-// #include "ogreode/OgreOdeGeometry.h"
 #include "util/Convert.h"
 #include "core/CoreIncludes.h"
@@ -52 +50 @@
         : BaseObject(creator)
     {
-           RegisterObject(HelloBullet);
-           COUT(0) << "HelloBullet loaded" << std::endl ;
-           int maxProxies = 1024;
+        RegisterObject(HelloBullet);
+        COUT(0) << "HelloBullet loaded" << std::endl ;
+        int maxProxies = 1024;
 
 
@@ -68 +66 @@
   //      dynamicsWorld = new btDiscreteDynamicsWorld(dispatcher,broadphase,solver,collisionConfiguration);
 
-        dynamicsWorld =  creator->getScene()->getPhysicalWorld();
-        dynamicsWorld-> setGravity(btVector3(0,-10,0));
+        dynamicsWorld = getCreator()->getScene()->getPhysicalWorld();
 
 
@@ -94 +91 @@
 
  
-
-//load floor mash
+        //load floor mash
         Ogre::SceneManager* sceneMgr = creator->getScene()->getSceneManager();
 
@@ -119 +115 @@
 
 
-// crate
+        // crate
 
         entity_ = sceneMgr->createEntity("crate","crate.mesh");
@@ -127 +123 @@
         entity_->setNormaliseNormals(true);
         entity_->setCastShadows(true);
-        sceneNode_ -> setPosition(Vector3(0,100,0));
-
-
-      
-
-
+        sceneNode_ -> setPosition(Vector3(0,100,0));
     }
 
@@ -181 +172 @@
     void HelloBullet::tick(float dt)
     {
-                dynamicsWorld->stepSimulation(dt,10);
-                btTransform trans;
-                fallRigidBody->getMotionState()->getWorldTransform(trans);
-               // COUT(0) << "sphere height: " << trans.getOrigin().getY() << std::endl;
-                sceneNode_ -> setPosition(Vector3(0,trans.getOrigin().getY(),0));
-        //      msleep(20);
-                
-                
+        dynamicsWorld->stepSimulation(dt,10);
+        btTransform trans;
+        fallRigidBody->getMotionState()->getWorldTransform(trans);
+        // COUT(0) << "sphere height: " << trans.getOrigin().getY() << std::endl;
+        sceneNode_ -> setPosition(Vector3(0,trans.getOrigin().getY(),0));
+        //      msleep(20);
     }
-
 }

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

@@ -33 +33 @@
 #include "core/BaseObject.h"
 
-#include "ogrebullet/Dynamics/OgreBulletDynamics.h"
+#include "btBulletCollisionCommon.h"
+#include "btBulletDynamicsCommon.h"
 
 #include "Tickable.h"

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

@@ -62 +62 @@
                 this->rootSceneNode_ = 0;
             }
-        // create bullet world; bullet solver etc.
+        }
+        else
+        {
+            // create a dummy SceneManager of our own since we don't have Ogre::Root.
+            this->sceneManager_ = new Ogre::DefaultSceneManager("");
+            this->rootSceneNode_ = this->sceneManager_->getRootSceneNode();
+        }
+
+        /////////////
+        // Physics //
+        /////////////
+
+        // create bullet world; bullet solver etc.
 
         // int maxProxies = 1024;
@@ -70 +82 @@
         bt32BitAxisSweep3* broadphase = new bt32BitAxisSweep3(worldAabbMin,worldAabbMax);
 
-        this -> collisionConfiguration_ = new btDefaultCollisionConfiguration();
+        this -> collisionConfiguration_ = new btDefaultCollisionConfiguration();
         this -> dispatcher_ = new btCollisionDispatcher(collisionConfiguration_);
 
@@ -77 +89 @@
         this -> dynamicsWorld_ =  new btDiscreteDynamicsWorld(dispatcher_,broadphase,solver_,collisionConfiguration_);
 
-      //  dynamicsWorld->setGravity(btVector3(0,-10,0));
+        dynamicsWorld_->setGravity(btVector3(0,-10,0));
 
-        }
-        else
-        {
-            // create a dummy SceneManager of our own since we don't have Ogre::Root.
-            this->sceneManager_ = new Ogre::DefaultSceneManager("");
-            this->rootSceneNode_ = this->sceneManager_->getRootSceneNode();
-        }
 
         // test test test
@@ -108 +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/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/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

@@ -28 +28 @@
 
 #include "OrxonoxStableHeaders.h"
-#include "StaticEntity.h"
+#include "PositionableEntity.h"
 #include "core/CoreIncludes.h"
 
 namespace orxonox
 {
-    CreateFactory(StaticEntity);
+    CreateFactory(PositionableEntity);
 
-    StaticEntity::StaticEntity(BaseObject* creator) : WorldEntity(creator)
+    PositionableEntity::PositionableEntity(BaseObject* creator) : MovableEntity(creator)
     {
-        RegisterObject(StaticEntity);
+        RegisterObject(PositionableEntity);
 
         this->registerVariables();
     }
 
-    StaticEntity::~StaticEntity()
+    PositionableEntity::~PositionableEntity()
     {
     }
 
-    void StaticEntity::registerVariables()
+    void PositionableEntity::registerVariables()
     {
         REGISTERDATA(this->getPosition().x, network::direction::toclient);
@@ -57 +57 @@
         REGISTERDATA(this->getOrientation().z, network::direction::toclient);
     }
+
+    //void PositionableEntity::attachPhysicalObject(WorldEntity* object)
+    //{
+    //}
 }

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

@@ -27 +27 @@
  */
 
-#ifndef _StaticEntity_H__
-#define _StaticEntity_H__
+#ifndef _PositionableEntity_H__
+#define _PositionableEntity_H__
 
 #include "OrxonoxPrereqs.h"
-#include "WorldEntity.h"
+#include "MovableEntity.h"
 
 namespace orxonox
 {
-    class _OrxonoxExport StaticEntity : public WorldEntity
+    class _OrxonoxExport PositionableEntity : public MovableEntity
     {
         public:
-            StaticEntity(BaseObject* creator);
-            virtual ~StaticEntity();
+            PositionableEntity(BaseObject* creator);
+            virtual ~PositionableEntity();
 
             void registerVariables();
@@ -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);
     };
 }
 
-#endif /* _StaticEntity_H__ */
+#endif /* _PositionableEntity_H__ */

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_;