Changeset 2303 for code/branches/physics/src/orxonox/objects/worldentities/WorldEntity.h

Timestamp:

Dec 1, 2008, 11:09:43 PM (15 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>

File:

• code/branches/physics/src/orxonox/objects/worldentities/WorldEntity.h (modified) (4 diffs)

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