Changeset 2562 for code/branches/presentation/src/orxonox/objects/collisionshapes

Timestamp:

Jan 1, 2009, 7:34:44 PM (16 years ago)

Author:

rgrieder

Message:

• Added WorldEntityCollisionShape to clarify when a CompoundCollisionShape belongs to a WE.
• Also fixed problems with the synchronisation of the CollisionShape hierarchy.

Location:

code/branches/presentation/src/orxonox/objects/collisionshapes

Files:

• CMakeLists.txt (modified) (1 diff)
• CollisionShape.cc (modified) (2 diffs)
• CollisionShape.h (modified) (3 diffs)
• CompoundCollisionShape.cc (modified) (8 diffs)
• CompoundCollisionShape.h (modified) (2 diffs)
• WorldEntityCollisionShape.cc (added)
• WorldEntityCollisionShape.h (added)

code/branches/presentation/src/orxonox/objects/collisionshapes/CMakeLists.txt

@@ -6 +6 @@
   PlaneCollisionShape.cc
   SphereCollisionShape.cc
+  WorldEntityCollisionShape.cc
 )
 

code/branches/presentation/src/orxonox/objects/collisionshapes/CollisionShape.cc

@@ -37 +37 @@
 #include "tools/BulletConversions.h"
 
+#include "objects/worldentities/WorldEntity.h"
 #include "CompoundCollisionShape.h"
-#include "objects/worldentities/WorldEntity.h"
+#include "WorldEntityCollisionShape.h"
 
 namespace orxonox
@@ -85 +86 @@
     void CollisionShape::parentChanged()
     {
-        CompoundCollisionShape* parent = dynamic_cast<CompoundCollisionShape*>(Synchronisable::getSynchronisable(this->parentID_));
-        if (parent)
-            parent->attach(this);
+        Synchronisable* parent = Synchronisable::getSynchronisable(this->parentID_);
+        // Parent can either be a WorldEntity or a CompoundCollisionShape. The reason is that the
+        // internal collision shape (which is compound) of a WE doesn't get synchronised.
+        CompoundCollisionShape* parentCCS = dynamic_cast<CompoundCollisionShape*>(parent);
+        if (parentCCS)
+            parentCCS->attach(this);
+        else
+        {
+            WorldEntity* parentWE = dynamic_cast<WorldEntity*>(parent);
+            if (parentWE)
+                parentWE->attachCollisionShape(this);
+        }
+    }
+
+    bool CollisionShape::notifyBeingAttached(CompoundCollisionShape* newParent)
+    {
+        if (this->parent_)
+            this->parent_->detach(this);
+
+        this->parent_ = newParent;
+
+        WorldEntityCollisionShape* parentWECCS = dynamic_cast<WorldEntityCollisionShape*>(newParent);
+        if (parentWECCS)
+            this->parentID_ = parentWECCS->getWorldEntityOwner()->getObjectID();
+        else
+            this->parentID_ = newParent->getObjectID();
+
+        return true;
+    }
+
+    void CollisionShape::notifyDetached()
+    {
+        this->parent_ = 0;
+        this->parentID_ = OBJECTID_UNKNOWN;
     }
 

code/branches/presentation/src/orxonox/objects/collisionshapes/CollisionShape.h

@@ -75 +75 @@
             bool hasTransform() const;
 
-            inline void setParent(CompoundCollisionShape* shape, unsigned int ID)
-                { this->parent_ = shape; this->parentID_ = ID; }
+            bool notifyBeingAttached(CompoundCollisionShape* newParent);
+            void notifyDetached();
 
         protected:
@@ -85 +85 @@
             btCollisionShape*       collisionShape_;
             CompoundCollisionShape* parent_;
+            unsigned int            parentID_;
 
         private:
@@ -90 +91 @@
             Quaternion              orientation_;
             Vector3                 scale_;
-            unsigned int            parentID_;
     };
 }

code/branches/presentation/src/orxonox/objects/collisionshapes/CompoundCollisionShape.cc

@@ -36 +36 @@
 #include "core/XMLPort.h"
 #include "tools/BulletConversions.h"
-#include "objects/worldentities/WorldEntity.h"
 
 namespace orxonox
@@ -47 +46 @@
 
         this->compoundShape_  = new btCompoundShape();
-        this->worldEntityParent_ = 0;
     }
 
@@ -59 +57 @@
             {
                 // make sure that the child doesn't want to detach itself --> speedup because of the missing update
-                it->first->setParent(0, OBJECTID_UNKNOWN);
+                it->first->notifyDetached();
                 delete it->first;
             }
@@ -74 +72 @@
     }
 
-    void CompoundCollisionShape::setWorldEntityParent(WorldEntity* parent)
-    {
-        // suppress synchronisation
-        this->setObjectMode(0x0);
-
-        this->worldEntityParent_ = parent;
-    }
-
     void CompoundCollisionShape::attach(CollisionShape* shape)
     {
@@ -91 +81 @@
             return;
         }
+
+        if (!shape->notifyBeingAttached(this))
+            return;
+
         this->attachedShapes_[shape] = shape->getCollisionShape();
 
@@ -101 +95 @@
             this->updatePublicShape();
         }
-
-        // network synchro
-        if (this->worldEntityParent_)
-        {
-            // This compound collision shape belongs to a WE and doesn't get synchronised
-            // So set our parent to be the WE
-            shape->setParent(this, this->worldEntityParent_->getObjectID());
-        }
-        else
-            shape->setParent(this, this->getObjectID());
     }
 
@@ -117 +101 @@
         if (this->attachedShapes_.find(shape) != this->attachedShapes_.end())
         {
-            shape->setParent(0, OBJECTID_UNKNOWN);
             this->attachedShapes_.erase(shape);
             if (shape->getCollisionShape())
                 this->compoundShape_->removeChildShape(shape->getCollisionShape());
+            shape->notifyDetached();
 
             this->updatePublicShape();
@@ -197 +181 @@
     }
 
-    void CompoundCollisionShape::updateParent()
-    {
-        if (this->parent_)
-            this->parent_->updateAttachedShape(this);
-        if (this->worldEntityParent_)
-            this->worldEntityParent_->notifyCollisionShapeChanged();
-    }
-
-    void CompoundCollisionShape::parentChanged()
-    {
-        if (!this->worldEntityParent_)
-            CollisionShape::parentChanged();
-    }
-
     CollisionShape* CompoundCollisionShape::getAttachedShape(unsigned int index) const
     {

code/branches/presentation/src/orxonox/objects/collisionshapes/CompoundCollisionShape.h

@@ -53 +53 @@
             void updateAttachedShape(CollisionShape* shape);
 
-            void setWorldEntityParent(WorldEntity* parent);
-
-        protected:
-            virtual void updateParent();
-
         private:
             void updatePublicShape();
-            void parentChanged();
             inline virtual btCollisionShape* createNewShape() const
                 { assert(false); return 0; }
@@ -66 +60 @@
             btCompoundShape* compoundShape_;
             std::map<CollisionShape*, btCollisionShape*> attachedShapes_;
-            WorldEntity* worldEntityParent_;
     };
 }