Changeset 2466 for code/branches/presentation/src/orxonox/objects

Timestamp:

Dec 15, 2008, 4:33:50 PM (16 years ago)

Author:

rgrieder

Message:

Added callback for collisions. Every WorldEntity that collides against another will be called with the following function:
virtual bool collidesAgainst(WorldEntity* otherObject, btManifoldPoint& contactPoint);
btManifoldPoint is from Bullet and tells you more about the contact point, like position.

Per default, the callback is disabled. Enable it with this→enableCollisionCallback(), for instance in your derived class constructor.
Note that if you activate the callback for e.g. SpaceShips, but not for MovableEntities, then collidesAgainst will only be called in the SpaceShip. This could be changed however, just ask me.

Location:

code/branches/presentation/src/orxonox/objects

Files:

• Scene.cc (modified) (2 diffs)
• Scene.h (modified) (1 diff)
• weaponSystem/projectiles/Projectile.cc (modified) (1 diff)
• worldentities/WorldEntity.cc (modified) (5 diffs)
• worldentities/WorldEntity.h (modified) (3 diffs)
• worldentities/pawns/SpaceShip.cc (modified) (1 diff)

code/branches/presentation/src/orxonox/objects/Scene.cc

@@ -206 +206 @@
             this->physicalWorld_   = new btDiscreteDynamicsWorld(this->dispatcher_, this->broadphase_, this->solver_, this->collisionConfig_);
             this->physicalWorld_->setGravity(omni_cast<btVector3>(this->gravity_));
+
+            // also set the collision callback variable.
+            // Note: This is a global variable which we assign a static function.
+            // TODO: Check whether this (or anything about Bullet) works with multiple physics engine instances.
+            gContactAddedCallback = &Scene::collisionCallback;
         }
         else if (!wantPhysics && hasPhysics())
@@ -337 +342 @@
             this->physicalWorld_->removeRigidBody(object->getPhysicalBody());
     }
+
+    /*static*/ bool Scene::collisionCallback(btManifoldPoint& cp, const btCollisionObject* colObj0, int partId0,
+                                             int index0, const btCollisionObject* colObj1, int partId1, int index1)
+    {
+        // get the WorldEntity pointers
+        WorldEntity* object0 = (WorldEntity*)colObj0->getUserPointer();
+        assert(dynamic_cast<WorldEntity*>(object0));
+        WorldEntity* object1 = (WorldEntity*)colObj1->getUserPointer();
+        assert(dynamic_cast<WorldEntity*>(object1));
+
+        // false means that bullet will assume we didn't modify the contact
+        bool modified = false;
+        if (object0->isCollisionCallbackActive())
+        {
+            modified |= object0->collidesAgainst(object1, cp);
+            if (object1->isCollisionCallbackActive())
+                modified |= object1->collidesAgainst(object0, cp);
+        }
+        else
+            modified |= object1->collidesAgainst(object0, cp);
+
+        return modified;
+    }
 }

code/branches/presentation/src/orxonox/objects/Scene.h

@@ -120 +120 @@
                 { this->setGravity(this->gravity_); }
 
+            // collision callback from bullet
+            static bool collisionCallback(btManifoldPoint& cp, const btCollisionObject* colObj0, int partId0,
+                                          int index0, const btCollisionObject* colObj1, int partId1, int index1);
+
             // Bullet objects
             btDiscreteDynamicsWorld*             physicalWorld_;

code/branches/presentation/src/orxonox/objects/weaponSystem/projectiles/Projectile.cc

@@ -56 +56 @@
         this->setStatic(false);
         this->translate(Vector3(55, 0, 0), Ogre::Node::TS_LOCAL);
+
+        // Get notification about collisions
+        this->enableCollisionCallback();
 
         if (this->owner_)

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

@@ -85 +85 @@
         this->angularDamping_ = 0;
         this->friction_       = 0.5;
+        this->bCollisionCallbackActive_ = false;
 
         this->registerVariables();
@@ -144 +145 @@
         registerVariable(this->getScale3D(),    variableDirection::toclient, new NetworkCallback<WorldEntity>(this, &WorldEntity::scaleChanged));
 
-        registerVariable((int&)this->collisionTypeSynchronised_,
-                                                variableDirection::toclient, new NetworkCallback<WorldEntity>(this, &WorldEntity::collisionTypeChanged));
+        // Physics stuff
         registerVariable(this->mass_,           variableDirection::toclient, new NetworkCallback<WorldEntity>(this, &WorldEntity::massChanged));
         registerVariable(this->restitution_,    variableDirection::toclient, new NetworkCallback<WorldEntity>(this, &WorldEntity::restitutionChanged));
@@ -152 +152 @@
         registerVariable(this->angularDamping_, variableDirection::toclient, new NetworkCallback<WorldEntity>(this, &WorldEntity::angularDampingChanged));
         registerVariable(this->friction_,       variableDirection::toclient, new NetworkCallback<WorldEntity>(this, &WorldEntity::frictionChanged));
+        registerVariable(this->bCollisionCallbackActive_,
+                                                variableDirection::toclient, new NetworkCallback<WorldEntity>(this, &WorldEntity::collisionCallbackActivityChanged));
+        registerVariable((int&)this->collisionTypeSynchronised_,
+                                                variableDirection::toclient, new NetworkCallback<WorldEntity>(this, &WorldEntity::collisionTypeChanged));
         registerVariable(this->bPhysicsActiveSynchronised_,
                                                 variableDirection::toclient, new NetworkCallback<WorldEntity>(this, &WorldEntity::physicsActivityChanged));
 
+        // Attach to parent if necessary
         registerVariable(this->parentID_,       variableDirection::toclient, new NetworkCallback<WorldEntity>(this, &WorldEntity::parentChanged));
     }
@@ -192 +197 @@
         else
             this->deactivatePhysics();
+    }
+
+    void WorldEntity::collisionCallbackActivityChanged()
+    {
+        if (this->hasPhysics())
+        {
+            if (bCollisionCallbackActive_)
+                this->physicalBody_->setCollisionFlags(this->physicalBody_->getCollisionFlags() |
+                    btCollisionObject::CF_CUSTOM_MATERIAL_CALLBACK);
+            else
+                this->physicalBody_->setCollisionFlags(this->physicalBody_->getCollisionFlags() &
+                    !btCollisionObject::CF_CUSTOM_MATERIAL_CALLBACK);
+        }
     }
 
@@ -525 +543 @@
         recalculateMassProps();
         resetPhysicsProps();
+        collisionCallbackActivityChanged();
         activatePhysics();
     }

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

@@ -240 +240 @@
             void notifyChildMassChanged();
 
+            virtual inline bool collidesAgainst(WorldEntity* otherObject, btManifoldPoint& contactPoint)
+                { return false; } /* With false, Bullet assumes no modification to the collision objects. */
+
+            inline void enableCollisionCallback()
+                { this->bCollisionCallbackActive_ = true; this->collisionCallbackActivityChanged(); }
+            inline void disableCollisionCallback()
+                { this->bCollisionCallbackActive_ = false; this->collisionCallbackActivityChanged(); }
+            inline bool isCollisionCallbackActive()
+                { return this->bCollisionCallbackActive_; }
+
         protected:
             virtual bool isCollisionTypeLegal(CollisionType type) const = 0;
@@ -253 +263 @@
             void collisionTypeChanged();
             void physicsActivityChanged();
+            void collisionCallbackActivityChanged();
             inline void massChanged()
                 { this->setMass(this->mass_); }
@@ -279 +290 @@
             btScalar                     friction_;
             btScalar                     childrenMass_;
+            bool                         bCollisionCallbackActive_;
     };
 

code/branches/presentation/src/orxonox/objects/worldentities/pawns/SpaceShip.cc

@@ -61 +61 @@
         // Be aware of this call: The collision type legality check will not reach derived classes!
         this->setCollisionType(WorldEntity::Dynamic);
+        // Get notification about collisions
+        this->enableCollisionCallback();
 
         this->setConfigValues();