Changeset 2527 for code/branches/presentation/src/orxonox/objects/worldentities

Timestamp:

Dec 22, 2008, 10:23:29 PM (15 years ago)

Author:

rgrieder

Message:

• Forgot to account for collision shape position and orientation when attaching WEs
• addChildShape —> attach in CompoundCollisionShape
• Fixed an issue which allowed WE's to detach themselves from non-parents.
• Fixed an issue that occurred when physics was not active before attaching
• Added some forgotten const in WE (physics)
• When attaching WE's the child doesn't get modified anymore. Alternative: notifyDetached() and notifyBeingAttached(this) —> the child does the work

Location:

code/branches/presentation/src/orxonox/objects/worldentities

Files:

• Camera.cc (modified) (1 diff)
• WorldEntity.cc (modified) (8 diffs)
• WorldEntity.h (modified) (4 diffs)

code/branches/presentation/src/orxonox/objects/worldentities/Camera.cc

@@ -109 +109 @@
             float coeff = min(1.0f, 15.0f * dt);
 
-            Vector3 offset = this->getNode()->getWorldPosition() - this->cameraNode_->getWorldPosition();
+            Vector3 offset = this->getWorldPosition() - this->cameraNode_->getWorldPosition();
             this->cameraNode_->translate(coeff * offset);
 

code/branches/presentation/src/orxonox/objects/worldentities/WorldEntity.cc

@@ -71 +71 @@
         this->physicalBody_ = 0;
         this->bPhysicsActive_ = false;
+        this->bPhysicsActiveSynchronised_ = false;
+        this->bPhysicsActiveBeforeAttaching_ = false;
         this->collisionShape_ = new CompoundCollisionShape(this);
         // Note: CompoundCollisionShape is a Synchronisable, but must not be synchronised.
@@ -251 +253 @@
     void WorldEntity::attach(WorldEntity* object)
     {
-        // check first whether attaching is even allowed
-        if (object->hasPhysics())
-        {
-            if (!this->hasPhysics())
-            {
-                COUT(2) << "Warning: Cannot attach a physical object to a non physical one." << std::endl;
-                return;
-            }
-            else if (object->isDynamic())
-            {
-                COUT(2) << "Warning: Cannot attach a dynamic object to a WorldEntity." << std::endl;
-                return;
-            }
-            else if (object->isKinematic() && this->isDynamic())
-            {
-                COUT(2) << "Warning: Cannot attach a kinematic object to a dynamic one." << std::endl;
-                return;
-            }
-            else if (object->isKinematic())
-            {
-                COUT(2) << "Warning: Cannot attach a kinematic object to a static or kinematic one: Not yet implemented." << std::endl;
-                return;
-            }
-            else
-            {
-                object->deactivatePhysics();
-            }
-        }
-
         if (object == this)
         {
@@ -286 +259 @@
         }
 
-        if (object->getParent())
-            object->detachFromParent();
+        if (!object->notifyBeingAttached(this))
+            return;
 
         this->attachNode(object->node_);
-
         this->children_.insert(object);
-        object->parent_ = this;
-        object->parentID_ = this->getObjectID();
-
-        // collision shapes
+
         this->attachCollisionShape(object->getCollisionShape());
         // mass
@@ -302 +271 @@
     }
 
+    bool WorldEntity::notifyBeingAttached(WorldEntity* newParent)
+    {
+        // check first whether attaching is even allowed
+        if (this->hasPhysics())
+        {
+            if (!newParent->hasPhysics())
+            {
+                COUT(2) << "Warning: Cannot attach a physical object to a non physical one." << std::endl;
+                return false;
+            }
+            else if (this->isDynamic())
+            {
+                COUT(2) << "Warning: Cannot attach a dynamic object to a WorldEntity." << std::endl;
+                return false;
+            }
+            else if (this->isKinematic() && newParent->isDynamic())
+            {
+                COUT(2) << "Warning: Cannot attach a kinematic object to a dynamic one." << std::endl;
+                return false;
+            }
+            else if (this->isKinematic())
+            {
+                COUT(2) << "Warning: Cannot attach a kinematic object to a static or kinematic one: Not yet implemented." << std::endl;
+                return false;
+            }
+        }
+
+        if (this->isPhysicsActive())
+            this->bPhysicsActiveBeforeAttaching_ = true;
+        this->deactivatePhysics();
+
+        if (this->parent_)
+            this->detachFromParent();
+
+        this->parent_ = newParent;
+        this->parentID_ = newParent->getObjectID();
+
+        // apply transform to collision shape
+        this->collisionShape_->setPosition(this->getPosition());
+        this->collisionShape_->setOrientation(this->getOrientation());
+        // TODO: Scale
+        
+        return true;
+    }
+
     void WorldEntity::detach(WorldEntity* object)
     {
+        if (this->children_.find(object) == this->children_.end())
+        {
+            CCOUT(2) << "Warning: Cannot detach an object that is not a child." << std::endl;
+            return;
+        }
+
         // collision shapes
         this->detachCollisionShape(object->getCollisionShape());
+
         // mass
         if (object->getMass() > 0.0f)
@@ -315 +336 @@
         this->detachNode(object->node_);
         this->children_.erase(object);
-        object->parent_ = 0;
-        object->parentID_ = OBJECTID_UNKNOWN;
-
-        // Note: It is possible that the object has physics but was disabled when attaching
-        object->activatePhysics();
+
+        object->notifyDetached();
+    }
+
+    void WorldEntity::notifyDetached()
+    {
+        this->parent_ = 0;
+        this->parentID_ = OBJECTID_UNKNOWN;
+
+        // reset orientation of the collisionShape (cannot be set within a WE usually)
+        this->collisionShape_->setPosition(Vector3::ZERO);
+        this->collisionShape_->setOrientation(Quaternion::IDENTITY);
+        // TODO: Scale
+
+        if (this->bPhysicsActiveBeforeAttaching_)
+        {
+            this->activatePhysics();
+            this->bPhysicsActiveBeforeAttaching_ = false;
+        }
     }
 
@@ -351 +386 @@
     void WorldEntity::attachCollisionShape(CollisionShape* shape)
     {
-        this->collisionShape_->addChildShape(shape);
+        this->collisionShape_->attach(shape);
         // Note: this->collisionShape_ already notifies us of any changes.
     }
@@ -357 +392 @@
     void WorldEntity::detachCollisionShape(CollisionShape* shape)
     {
-        this->collisionShape_->removeChildShape(shape);
+        this->collisionShape_->detach(shape);
         // Note: this->collisionShape_ already notifies us of any changes.
     }
@@ -363 +398 @@
     CollisionShape* WorldEntity::getAttachedCollisionShape(unsigned int index) const
     {
-        return this->collisionShape_->getChildShape(index);
+        return this->collisionShape_->getAttachedShape(index);
     }
 

code/branches/presentation/src/orxonox/objects/worldentities/WorldEntity.h

@@ -244 +244 @@
             CollisionShape* getAttachedCollisionShape(unsigned int index) const;
 
-            inline CompoundCollisionShape* getCollisionShape()
+            inline CompoundCollisionShape* getCollisionShape() const
                 { return this->collisionShape_; }
-            inline btRigidBody* getPhysicalBody()
+            inline btRigidBody* getPhysicalBody() const
                 { return this->physicalBody_; }
 
@@ -259 +259 @@
             inline void disableCollisionCallback()
                 { this->bCollisionCallbackActive_ = false; this->collisionCallbackActivityChanged(); }
-            inline bool isCollisionCallbackActive()
+            inline bool isCollisionCallbackActive() const
                 { return this->bCollisionCallbackActive_; }
 
@@ -271 +271 @@
             void recalculateMassProps();
             void resetPhysicsProps();
+
+            bool notifyBeingAttached(WorldEntity* newParent);
+            void notifyDetached();
 
             // network callbacks
@@ -293 +296 @@
             bool                         bPhysicsActive_;
             bool                         bPhysicsActiveSynchronised_;
+            bool                         bPhysicsActiveBeforeAttaching_;
             CompoundCollisionShape*      collisionShape_;
             btScalar                     mass_;