Changeset 2374 for code/branches/physics/src/orxonox/objects/worldentities/collisionshapes

Timestamp:

Dec 10, 2008, 1:38:17 PM (16 years ago)

Author:

rgrieder

Message:

Trying to synchronise phyiscs over the network.

• Removed derivation of CollisionShape from WorldEntity (BaseObject instead).

Location:

code/branches/physics/src/orxonox/objects/worldentities/collisionshapes

Files:

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

code/branches/physics/src/orxonox/objects/worldentities/collisionshapes/CollisionShape.cc

@@ -37 +37 @@
 #include "tools/BulletConversions.h"
 
+#include "CompoundCollisionShape.h"
+
 namespace orxonox
 {
     CreateFactory(CollisionShape);
 
-    CollisionShape::CollisionShape(BaseObject* creator) : StaticEntity(creator)
+    CollisionShape::CollisionShape(BaseObject* creator)
+        : BaseObject(creator)
+        , network::Synchronisable(creator)
     {
         RegisterObject(CollisionShape);
 
-        this->bIsCompound_ = false;
+        this->parent_ = 0;
+        this->parentID_ = (unsigned int)-1;
+        this->collisionShape_ = 0;
     }
 
@@ -55 +61 @@
     {
         SUPER(CollisionShape, XMLPort, xmlelement, mode);
+
+        XMLPortParamTemplate(CollisionShape, "position", setPosition, getPosition, xmlelement, mode, const Vector3&);
+        XMLPortParamTemplate(CollisionShape, "orientation", setOrientation, getOrientation, xmlelement, mode, const Quaternion&);
+        XMLPortParamLoadOnly(CollisionShape, "yaw",   yaw,   xmlelement, mode);
+        XMLPortParamLoadOnly(CollisionShape, "pitch", pitch, xmlelement, mode);
+        XMLPortParamLoadOnly(CollisionShape, "roll",  roll,  xmlelement, mode);
+        XMLPortParamTemplate(CollisionShape, "scale3D", setScale3D, getScale3D, xmlelement, mode, const Vector3&);
+        XMLPortParamLoadOnly(CollisionShape, "scale", setScale, xmlelement, mode);
     }
 
-    bool CollisionShape::isCollisionTypeLegal(WorldEntity::CollisionType type) const
+    void CollisionShape::registerVariables()
     {
-        if (type != WorldEntity::None)
-        {
-            ThrowException(PhysicsViolation, "A CollisionShape can only have CollisionType 'None'.");
-            return false;
-        }
-        else
-            return true;
+        REGISTERDATA(this->parentID_, network::direction::toclient, new network::NetworkCallback<CollisionShape>(this, &CollisionShape::updateParent));
     }
 
-    bool CollisionShape::hasNoTransform() const
+    void CollisionShape::updateParent()
     {
-        return (this->getPosition().positionEquals(Vector3(0, 0, 0), 0.001) &&
-                this->getOrientation().equals(Quaternion(1,0,0,0), Degree(0.1)));
+        CompoundCollisionShape* parent = dynamic_cast<CompoundCollisionShape*>(Synchronisable::getSynchronisable(this->parentID_));
+        if (parent)
+            parent->addChildShape(this);
     }
 
-    btVector3 CollisionShape::getTotalScaling()
+    bool CollisionShape::hasTransform() const
     {
-        return omni_cast<btVector3>(this->node_->getScale());
+        return (!this->position_.positionEquals(Vector3(0, 0, 0), 0.001) ||
+                !this->orientation_.equals(Quaternion(1,0,0,0), Degree(0.1)));
     }
 
@@ -84 +94 @@
     }
 
-    void CollisionShape::scale3D(const Vector3& scale)
+    void CollisionShape::setScale(float scale)
     {
         ThrowException(NotImplemented, "Cannot set the scale of a collision shape: Not yet implemented.");

code/branches/physics/src/orxonox/objects/worldentities/collisionshapes/CollisionShape.h

@@ -32 +32 @@
 #include "OrxonoxPrereqs.h"
 
-#include "objects/worldentities/StaticEntity.h"
+#include "util/Math.h"
+#include "core/BaseObject.h"
 
 namespace orxonox
 {
-    class _OrxonoxExport CollisionShape : public StaticEntity
+    class _OrxonoxExport CollisionShape : public BaseObject, public network::Synchronisable
     {
         public:
@@ -43 +44 @@
 
             virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
+            void registerVariables();
 
-            btCollisionShape* getCollisionShape() const { return this->collisionShape_; }
-            bool isCompoundShape() const { return this->bIsCompound_; }
+            inline void setPosition(const Vector3& position)
+                { this->position_ = position; }
+            inline const Vector3& getPosition() const
+                { return this->position_; }
 
-            bool hasNoTransform() const;
-            virtual btVector3 getTotalScaling();
+            inline void setOrientation(const Quaternion& orientation)
+                { this->orientation_ = orientation; }
+            inline const Quaternion& getOrientation() const
+                { return this->orientation_; }
+
+            void yaw(const Degree& angle)   { this->orientation_ = this->orientation_ * Quaternion(angle, Vector3::UNIT_Y); }
+            void pitch(const Degree& angle) { this->orientation_ = this->orientation_ * Quaternion(angle, Vector3::UNIT_X); }
+            void roll(const Degree& angle)  { this->orientation_ = this->orientation_ * Quaternion(angle, Vector3::UNIT_Z); }
+
+            virtual void setScale3D(const Vector3& scale);
+            virtual void setScale(float scale);
+            inline const Vector3& getScale3D(void) const
+                { return this->scale_; }
+
+            virtual inline btCollisionShape* getCollisionShape() const
+                { return this->collisionShape_; }
+
+            bool hasTransform() const;
+
+            inline void setParent(CompoundCollisionShape* shape, unsigned int ID)
+                { this->parent_ = shape; this->parentID_ = ID; }
 
         protected:
-            bool              bIsCompound_;
             btCollisionShape* collisionShape_;
 
         private:
-            virtual void setScale3D(const Vector3& scale);
-            virtual void scale3D(const Vector3& scale);
+            void updateParent();
 
-            bool isCollisionTypeLegal(WorldEntity::CollisionType type) const;
+            Vector3           position_;
+            Quaternion        orientation_;
+            Vector3           scale_;
+            CompoundCollisionShape* parent_;
+            unsigned int      parentID_;
     };
 }

code/branches/physics/src/orxonox/objects/worldentities/collisionshapes/CompoundCollisionShape.cc

@@ -44 +44 @@
         RegisterObject(CompoundCollisionShape);
 
-        this->bIsCompound_    = true;
+        this->collisionShape_ = 0;
         this->compoundShape_  = new btCompoundShape();
-        this->collisionShape_ = this->compoundShape_;
     }
 
@@ -58 +57 @@
     {
         SUPER(CompoundCollisionShape, XMLPort, xmlelement, mode);
+        // Attached collision shapes
+        XMLPortObject(CompoundCollisionShape, CollisionShape, "", addChildShape, getChildShape, xmlelement, mode);
+    }
 
-        XMLPortObject(CompoundCollisionShape, CollisionShape, "", addChildShape, getChildShape, xmlelement, mode);
+    btCollisionShape* CompoundCollisionShape::getCollisionShape() const
+    {
+        // Note: Returning collisionShape_ means that it's the only one and has no transform.
+        //       So we can get rid of the additional overhead with the compound shape.
+        if (this->collisionShape_)
+            return this->collisionShape_;
+        else if (this->childShapes_.size() != 0)
+            return this->compoundShape_;
+        else
+            return 0;
     }
 
     void CompoundCollisionShape::addChildShape(CollisionShape* shape)
     {
-        this->childShapes_.push_back(shape);
+        if (!shape || !shape->getCollisionShape())
+            return;
+        assert(this->compoundShape_);
         btTransform transf(omni_cast<btQuaternion>(shape->getOrientation()), omni_cast<btVector3>(shape->getPosition()));
-        shape->getCollisionShape()->setLocalScaling(shape->getTotalScaling());
         this->compoundShape_->addChildShape(transf, shape->getCollisionShape());
+
+        if (this->childShapes_.size() == 1 && this->childShapes_[0] && !this->childShapes_[0]->hasTransform())
+        {
+            // --> Only shape to be added, no transform; add it directly
+            this->collisionShape_ = shape->getCollisionShape();
+        }
+        else
+        {
+            // Make sure we use the compound shape
+            this->collisionShape_ = 0;
+        }
+
+        // network synchro
+        shape->setParent(this, this->getObjectID());
     }
 

code/branches/physics/src/orxonox/objects/worldentities/collisionshapes/CompoundCollisionShape.h

@@ -48 +48 @@
             CollisionShape* getChildShape(unsigned int index) const;
 
+            virtual btCollisionShape* getCollisionShape() const;
+
         private:
             btCompoundShape* compoundShape_;

code/branches/physics/src/orxonox/objects/worldentities/collisionshapes/PlaneCollisionShape.cc

@@ -21 +21 @@
  *
  *   Author:
- *      Reto Grieder
+ *      Martin Stypinski
  *   Co-authors:
  *      ...
@@ -30 +30 @@
 #include "PlaneCollisionShape.h"
 
-#include "BulletCollision/CollisionShapes/btStaticPlaneShape.h"
-
-#include "tools/BulletConversions.h"
 #include "core/CoreIncludes.h"
 #include "core/XMLPort.h"
@@ -45 +42 @@
         RegisterObject(PlaneCollisionShape);
 
-        this->planeShape_ = new btStaticPlaneShape(btVector3(1,1,1), 0);
+        this->planeShape_ = new btStaticPlaneShape(btVector3(1, 1, 1), 0);
         this->collisionShape_ = this->planeShape_;
+        this->planeNormal_ = Vector3(1, 1, 1);
+        this->planeOffset_ = 0.0f;
     }
 
@@ -52 +51 @@
     {
         if (this->isInitialized())
-            delete this->collisionShape_;
+            delete this->planeShape_;
     }
 
-    void PlaneCollisionShape::setNormal(const Vector3& normal)
+    void PlaneCollisionShape::registerVariables()
     {
-        btScalar offset = this->planeShape_->getPlaneConstant();
-        delete this->collisionShape_;
-        this->planeShape_ = new btStaticPlaneShape(omni_cast<btVector3>(normal), offset);
-        this->collisionShape_ = this->planeShape_;
-    }
-
-    void PlaneCollisionShape::setOffset(float offset)
-    {
-        btVector3 normal = this->planeShape_->getPlaneNormal();
-        delete this->collisionShape_;
-        this->planeShape_ = new btStaticPlaneShape(normal, offset);
-        this->collisionShape_ = this ->planeShape_;
+        REGISTERDATA(this->planeNormal_, network::direction::toclient, new network::NetworkCallback<PlaneCollisionShape>(this, &PlaneCollisionShape::planeNormalChanged));
+        REGISTERDATA(this->planeOffset_, network::direction::toclient, new network::NetworkCallback<PlaneCollisionShape>(this, &PlaneCollisionShape::planeOffsetChanged));
     }
 
@@ -75 +64 @@
         SUPER(PlaneCollisionShape, XMLPort, xmlelement, mode);
 
-        XMLPortParam(PlaneCollisionShape, "normal", setNormal, getNormal, xmlelement, mode);
-        XMLPortParam(PlaneCollisionShape, "offset", setOffset, getOffset, xmlelement, mode);    
+        XMLPortParam(PlaneCollisionShape, "planeNormal", setNormal, getNormal, xmlelement, mode);
+        XMLPortParam(PlaneCollisionShape, "planeOffset", setOffset, getOffset, xmlelement, mode);    
     }
 
-    btVector3 PlaneCollisionShape::getTotalScaling()
+    void PlaneCollisionShape::setNormal(const Vector3& normal)
     {
-        return omni_cast<btVector3>(this->node_->getScale()); //* this->radius_;
+        delete this->planeShape_;
+        this->planeNormal_ = normal;
+        this->planeShape_ = new btStaticPlaneShape(omni_cast<btVector3>(normal), this->planeOffset_);
+        this->collisionShape_ = this->planeShape_;
+    }
+
+    void PlaneCollisionShape::setOffset(float offset)
+    {
+        delete this->planeShape_;
+        this->planeOffset_ = offset;
+        this->planeShape_ = new btStaticPlaneShape(omni_cast<btVector3>(this->planeNormal_), offset);
+        this->collisionShape_ = this->planeShape_;
     }
 }

code/branches/physics/src/orxonox/objects/worldentities/collisionshapes/PlaneCollisionShape.h

@@ -21 +21 @@
  *
  *   Author:
- *      Reto Grieder
+ *      Martin Stypinski
  *   Co-authors:
  *      ...
@@ -33 +33 @@
 
 #include "BulletCollision/CollisionShapes/btStaticPlaneShape.h"
-
 #include "CollisionShape.h"
 
@@ -44 +43 @@
             virtual ~PlaneCollisionShape();
 
+            void registerVariables();
             virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
 
-               
-            
             inline float getOffset()
                 { return this->planeShape_->getPlaneConstant();}
+            void setOffset(float offset);
 
             inline btVector3 getNormal()
                 { return this->planeShape_->getPlaneNormal();}
-            void setOffset(float offset);
             void setNormal(const Vector3& normal);
 
-           private:
-            virtual btVector3 getTotalScaling();
+            inline void planeNormalChanged()
+                { this->setNormal(this->planeNormal_); }
 
+            inline void planeOffsetChanged()
+                { this->setOffset(this->planeOffset_); }
+
+        private:
             btStaticPlaneShape* planeShape_;
+            Vector3             planeNormal_;
+            float               planeOffset_;
      };
 }

code/branches/physics/src/orxonox/objects/worldentities/collisionshapes/SphereCollisionShape.cc

@@ -46 +46 @@
         this->sphereShape_ = new btSphereShape(1.0f);
         this->collisionShape_ = this->sphereShape_;
+
+        this->registerVariables();
     }
 
@@ -52 +54 @@
         if (this->isInitialized())
             delete this->collisionShape_;
+    }
+
+    void SphereCollisionShape::registerVariables()
+    {
+        REGISTERDATA(this->radius_, network::direction::toclient, new network::NetworkCallback<SphereCollisionShape>(this, &SphereCollisionShape::radiusChanged));
     }
 
@@ -61 +68 @@
     }
 
-    btVector3 SphereCollisionShape::getTotalScaling()
+    void SphereCollisionShape::setRadius(float radius)
     {
-        return omni_cast<btVector3>(this->node_->getScale()) * this->radius_;
+        // TODO: Think about where this could be referenced already.
+        this->radius_ = radius;
+        delete this->sphereShape_;
+        this->sphereShape_ = new btSphereShape(radius);
     }
 }

code/branches/physics/src/orxonox/objects/worldentities/collisionshapes/SphereCollisionShape.h

@@ -42 +42 @@
             virtual ~SphereCollisionShape();
 
+            void registerVariables();
             virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
 
-            inline void setRadius(float radius)
-                { this->radius_ = radius; }
+            void setRadius(float radius);
             inline float getRadius() const
                 { return this->radius_;}
 
+            inline void radiusChanged()
+                { this->setRadius(this->radius_); }
+
         private:
-            virtual btVector3 getTotalScaling();
-
             btSphereShape* sphereShape_;
             float          radius_;