Changeset 2514 for code/branches/presentation

Timestamp:

Dec 21, 2008, 2:44:00 PM (16 years ago)

Author:

rgrieder

Message:

Resolved four issues with the collision shapes:

• NetworkCallback will of course not call functions virtually
• CompoundCollisionShapes with a WorldEntity parent don't have to attach themselves when synchronised
• Just in case: When changing a CollisionShape, the old gets destroyed AFTER everything has been updated
• CompoundCollisionShapes with a WorldEntity parent now update both the WE and the CompoundCollisionShape when something changes

Other changes

• Also replaced some redundant code while at it (updating the shapes was done individually)
• Like in WE, the CompoundCollisionShape deletes all its children when being destroyed itself. This requires in WE that the children get detached before the CompoundCollisionShape gets deleted.

Location:

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

Files:

• BoxCollisionShape.cc (modified) (3 diffs)
• BoxCollisionShape.h (modified) (1 diff)
• CollisionShape.cc (modified) (4 diffs)
• CollisionShape.h (modified) (3 diffs)
• CompoundCollisionShape.cc (modified) (2 diffs)
• CompoundCollisionShape.h (modified) (2 diffs)
• ConeCollisionShape.cc (modified) (3 diffs)
• ConeCollisionShape.h (modified) (1 diff)
• PlaneCollisionShape.cc (modified) (3 diffs)
• PlaneCollisionShape.h (modified) (1 diff)
• SphereCollisionShape.cc (modified) (3 diffs)
• SphereCollisionShape.h (modified) (1 diff)

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

@@ -45 +45 @@
 
         this->halfExtents_ = Vector3(1, 1, 1);
-        updateBox();
+        updateShape();
 
         this->registerVariables();
@@ -58 +58 @@
     void BoxCollisionShape::registerVariables()
     {
-        registerVariable(this->halfExtents_, variableDirection::toclient, new NetworkCallback<BoxCollisionShape>(this, &BoxCollisionShape::updateBox));
+        registerVariable(this->halfExtents_, variableDirection::toclient, new NetworkCallback<CollisionShape>(this, &CollisionShape::updateShape));
     }
 
@@ -71 +71 @@
     }
 
-    void BoxCollisionShape::updateBox()
+    btCollisionShape* BoxCollisionShape::createNewShape() const
     {
-        if (this->collisionShape_)
-            delete this->collisionShape_;
-        this->collisionShape_ = new btBoxShape(omni_cast<btVector3>(this->halfExtents_));
-        this->updateParent();
+        return new btBoxShape(omni_cast<btVector3>(this->halfExtents_));
     }
 }

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

@@ -46 +46 @@
 
             inline void setHalfExtents(const Vector3& extents)
-                { this->halfExtents_ = extents; updateBox(); }
+                { this->halfExtents_ = extents; updateShape(); }
             inline const Vector3& getHalfExtents() const
                 { return halfExtents_;}
 
             inline void setWidth(float value)
-                { this->halfExtents_.z = value / 2; updateBox(); }
+                { this->halfExtents_.z = value / 2; updateShape(); }
             inline float getWidth() const
                 { return this->halfExtents_.z * 2; }
 
             inline void setHeight(float value)
-                { this->halfExtents_.y = value / 2; updateBox(); }
+                { this->halfExtents_.y = value / 2; updateShape(); }
             inline float getHeight() const
                 { return this->halfExtents_.y * 2; }
 
             inline void setLength(float value)
-                { this->halfExtents_.x = value / 2; updateBox(); }
+                { this->halfExtents_.x = value / 2; updateShape(); }
             inline float getLength() const
                 { return this->halfExtents_.x * 2; }
 
-            void updateBox();
+        private:
+            btCollisionShape* createNewShape() const;
 
-        private:
             Vector3 halfExtents_;
      };

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

@@ -42 +42 @@
 namespace orxonox
 {
-    CreateFactory(CollisionShape);
-
     CollisionShape::CollisionShape(BaseObject* creator)
         : BaseObject(creator)
@@ -62 +60 @@
     CollisionShape::~CollisionShape()
     {
+        // Detach from parent
+        if (this->isInitialized() && this->parent_)
+            this->parent_->removeChildShape(this);
     }
 
@@ -79 +80 @@
     void CollisionShape::registerVariables()
     {
-        registerVariable(this->parentID_, variableDirection::toclient, new NetworkCallback<CollisionShape>(this, &CollisionShape::parentChanged));
+        registerVariable(this->parentID_, variableDirection::toclient, new NetworkCallback<CollisionShape>(this, &CollisionShape::parentChangedCallback));
     }
 
     void CollisionShape::parentChanged()
     {
-        Synchronisable* synchronisable = Synchronisable::getSynchronisable(this->parentID_);
-        CompoundCollisionShape* CCSparent = dynamic_cast<CompoundCollisionShape*>(synchronisable);
-        if (CCSparent)
-            CCSparent->addChildShape(this);
-        else
-        {
-            WorldEntity* WEparent = dynamic_cast<WorldEntity*>(synchronisable);
-            if (WEparent)
-                WEparent->attachCollisionShape(this);
-        }
+        CompoundCollisionShape* parent = dynamic_cast<CompoundCollisionShape*>(Synchronisable::getSynchronisable(this->parentID_));
+        if (parent)
+            parent->addChildShape(this);
     }
 
@@ -118 +112 @@
     }
 
+    void CollisionShape::updateShape()
+    {
+        btCollisionShape* oldShape = this->collisionShape_;
+        this->collisionShape_ = this->createNewShape();
+        // When we recreate the shape, we have to inform the parent about this to update the shape
+        this->updateParent();
+        if (oldShape)
+            delete oldShape;
+    }
+
     void CollisionShape::calculateLocalInertia(btScalar mass, btVector3& inertia) const
     {

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

@@ -66 +66 @@
                 { return this->scale_; }
 
+            void updateShape();
+
             void calculateLocalInertia(float mass, btVector3& inertia) const;
 
@@ -78 +80 @@
         protected:
             virtual void updateParent();
+            virtual void parentChanged();
+            // Note: This is required because the NetworkCallback will not call functions virtually
+            void parentChangedCallback() { this->parentChanged(); }
+            virtual btCollisionShape* createNewShape() const = 0;
 
             btCollisionShape*       collisionShape_;
@@ -83 +89 @@
 
         private:
-            void parentChanged();
-
             Vector3                 position_;
             Quaternion              orientation_;

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

@@ -54 +54 @@
         if (this->isInitialized())
         {
-            // Notify children about removal
+            // Delete all children
             for (std::map<CollisionShape*, btCollisionShape*>::iterator it = this->childShapes_.begin();
                 it != this->childShapes_.end(); ++it)
             {
+                // make sure that the child doesn't want to detach itself --> speedup because of the missing update
                 it->first->setParent(0, OBJECTID_UNKNOWN);
+                delete it->first;
             }
 
@@ -197 +199 @@
         if (this->parent_)
             this->parent_->updateChildShape(this);
-        else if (this->worldEntityParent_)
+        if (this->worldEntityParent_)
             this->worldEntityParent_->notifyCollisionShapeChanged();
+    }
+
+    void CompoundCollisionShape::parentChanged()
+    {
+        if (!this->worldEntityParent_)
+            CollisionShape::parentChanged();
     }
 

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

@@ -33 +33 @@
 
 #include <vector>
+#include <cassert>
 #include "CollisionShape.h"
 
@@ -59 +60 @@
         private:
             void updatePublicShape();
+            void parentChanged();
+            inline virtual btCollisionShape* createNewShape() const
+                { assert(false); return 0; }
 
             btCompoundShape* compoundShape_;

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

@@ -46 +46 @@
         this->radius_ = 1.0f;
         this->height_ = 1.0f;
-        updateCone();
+        updateShape();
 
         this->registerVariables();
@@ -59 +59 @@
     void ConeCollisionShape::registerVariables()
     {
-        registerVariable(this->radius_, variableDirection::toclient, new NetworkCallback<ConeCollisionShape>(this, &ConeCollisionShape::updateCone));
-        registerVariable(this->height_, variableDirection::toclient, new NetworkCallback<ConeCollisionShape>(this, &ConeCollisionShape::updateCone));
+        registerVariable(this->radius_, variableDirection::toclient, new NetworkCallback<CollisionShape>(this, &CollisionShape::updateShape));
+        registerVariable(this->height_, variableDirection::toclient, new NetworkCallback<CollisionShape>(this, &CollisionShape::updateShape));
     }
 
@@ -71 +71 @@
     }
 
-    void ConeCollisionShape::updateCone()
+    btCollisionShape* ConeCollisionShape::createNewShape() const
     {
-        if (this->collisionShape_)
-            delete this->collisionShape_;
-        this->collisionShape_ = new btConeShape(this->radius_, this->height_);
-        this->updateParent();
+        return  new btConeShape(this->radius_, this->height_);
     }
 }

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

@@ -46 +46 @@
 
             inline void setRadius(float value)
-                { this->radius_ = value; updateCone(); }
+                { this->radius_ = value; updateShape(); }
             inline float getRadius() const
                 { return radius_; }
 
             inline void setHeight(float value)
-                { this->height_ = value; updateCone(); }
+                { this->height_ = value; updateShape(); }
             inline float getHeight() const
                 { return this->height_; }
 
-            void updateCone();
+        private:
+            btCollisionShape* createNewShape() const;
 
-        private:
             float radius_;
             float height_;

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

@@ -46 +46 @@
         this->normal_ = Vector3(0, 1, 0);
         this->offset_ = 0.0f;
-        updatePlane();
+        updateShape();
 
         this->registerVariables();
@@ -59 +59 @@
     void PlaneCollisionShape::registerVariables()
     {
-        registerVariable(this->normal_, variableDirection::toclient, new NetworkCallback<PlaneCollisionShape>(this, &PlaneCollisionShape::updatePlane));
-        registerVariable(this->offset_, variableDirection::toclient, new NetworkCallback<PlaneCollisionShape>(this, &PlaneCollisionShape::updatePlane));
+        registerVariable(this->normal_, variableDirection::toclient, new NetworkCallback<CollisionShape>(this, &CollisionShape::updateShape));
+        registerVariable(this->offset_, variableDirection::toclient, new NetworkCallback<CollisionShape>(this, &CollisionShape::updateShape));
     }
 
@@ -71 +71 @@
     }
 
-    void PlaneCollisionShape::updatePlane()
+    btCollisionShape* PlaneCollisionShape::createNewShape() const
     {
-        if (this->collisionShape_)
-            delete this->collisionShape_;
-        this->collisionShape_ = new btStaticPlaneShape(omni_cast<btVector3>(this->normal_), this->offset_);
-        this->updateParent();
+        return new btStaticPlaneShape(omni_cast<btVector3>(this->normal_), this->offset_);
     }
 }

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

@@ -46 +46 @@
 
             inline void setNormal(const Vector3& normal)
-                { this->normal_ = normal; updatePlane(); }
+                { this->normal_ = normal; updateShape(); }
             inline const Vector3& getNormal()
                 { return normal_;}
 
             inline void setOffset(float offset)
-                { this->offset_ = offset; updatePlane(); }
+                { this->offset_ = offset; updateShape(); }
             inline float getOffset()
                 { return this->offset_;}
 
-            void updatePlane();
+        private:
+            btCollisionShape* createNewShape()const;
 
-        private:
             Vector3 normal_;
             float   offset_;

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

@@ -45 +45 @@
 
         this->radius_ = 1.0f;
-        updateSphere();
+        updateShape();
 
         this->registerVariables();
@@ -58 +58 @@
     void SphereCollisionShape::registerVariables()
     {
-        registerVariable(this->radius_, variableDirection::toclient, new NetworkCallback<SphereCollisionShape>(this, &SphereCollisionShape::updateSphere));
+        registerVariable(this->radius_, variableDirection::toclient, new NetworkCallback<CollisionShape>(this, &CollisionShape::updateShape));
     }
 
@@ -68 +68 @@
     }
 
-    void SphereCollisionShape::updateSphere()
+    btCollisionShape* SphereCollisionShape::createNewShape() const
     {
-        if (this->collisionShape_)
-            delete this->collisionShape_;
-        // When we recreate the shape, we have to inform the parent about this to update the shape
-        this->collisionShape_ = new btSphereShape(this->radius_);
-        this->updateParent();
+        return new btSphereShape(this->radius_);
     }
 }

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

@@ -46 +46 @@
 
             inline void setRadius(float radius)
-                { this->radius_ = radius; updateSphere(); }
+                { this->radius_ = radius; updateShape(); }
             inline float getRadius() const
                 { return this->radius_; }
 
-            void updateSphere();
+        private:
+            btCollisionShape* createNewShape() const;
 
-        private:
             float radius_;
     };