Changeset 8190 in orxonox.OLD for trunk/src/lib/collision_reaction/collision_handle.cc

Timestamp:

Jun 7, 2006, 3:00:01 PM (19 years ago)

Author:

patrick

Message:

trunk: merged the cr branche to trunk

File:

• trunk/src/lib/collision_reaction/collision_handle.cc (modified) (3 diffs)

trunk/src/lib/collision_reaction/collision_handle.cc

@@ -17 +17 @@
 #include "collision_handle.h"
 
+#include "world_entity.h"
+
+#include "collision.h"
+#include "collision_event.h"
+#include "collision_reaction.h"
+
+#include "cr_object_damage.h"
+
 using namespace std;
 
@@ -31 +39 @@
   this->type = type;
 
+  this->bCollided = false;
+  this->bDispatched = false;
+
+  if( this->type == CREngine::CR_PHYSICS_STEP_BACK)
+    this->bContinuousPoll = false;
+  else
+    this->bContinuousPoll = true;
+
+  if( this->type == CREngine::CR_OBJECT_DAMAGE)
+    this->bStopOnFirstCollision = true;
+  else
+   this->bStopOnFirstCollision = false;
+
+  switch( type)
+  {
+    case CREngine::CR_OBJECT_DAMAGE:
+      this->collisionReaction = new CRObjectDamage();
+      break;
+    default:
+      break;
+  };
 }
 
@@ -41 +70 @@
   // delete what has to be deleted here
 }
+
+/**
+ * restores the CollisionHandle to its initial state
+ */
+void CollisionHandle::reset()
+{
+  this->flushCollisions();
+}
+
+
+/**
+ * add more filter targets to this collision handle
+ *  @param classID the classid to look for
+ */
+void CollisionHandle::addTarget(long target)
+{
+  // make sure there is no dublicate
+  std::vector<long>::iterator it = this->targetList.begin();
+  for( ; it < this->targetList.end(); it++)
+    if( (*it) == target)
+      return;
+
+  // add element
+   PRINTF(0)("addTarget: %i \n", target);
+   this->targetList.push_back(target);
+}
+
+
+/**
+ * registers a new Collision Object
+ *  @param entityA WorldEntity A of the collision
+ *  @param entityB WorldEntity B of the collision
+ * if a there is already a collision object with the same stats
+ * registration will be skipped and the last collision object is returned
+ */
+Collision* CollisionHandle::registerCollision(WorldEntity* entityA, WorldEntity* entityB)
+{
+  //first get the collision object, multiple sources
+  Collision* c;
+  if( this->collisionList.empty() ||
+      ((this->collisionList.back())->getEntityA() != entityA && (this->collisionList.back())->getEntityB() != entityB )) {
+    c = CREngine::getInstance()->popCollisionObject();
+    c->collide(entityA, entityB);
+    this->collisionList.push_back(c);
+
+    // now register it as a shared collision with the other collision entity
+    CollisionHandle* ch = entityB->getCollisionHandle(this->type);
+    if( ch != NULL)
+      ch->registerSharedCollision(c);
+  }
+  else
+    c = this->collisionList.back();
+
+  return c;
+}
+
+
+/**
+ * register a Collision to the Collision handle.
+ *  @param collision the collision object to register
+ *
+ * This is used for internal collision registration: sharing the collision objects between Collision Reactions
+ * Therefore dispatching it only once
+ */
+void CollisionHandle::registerSharedCollision(Collision* collision)
+{
+  // fist check if we are listening for this Collision
+  if( !this->filterCollision(collision))
+    return;
+
+  // set the state to not dispatched
+  this->bDispatched = false;
+  this->bCollided = true;
+  collision->setEntityBCollide(true);
+
+  this->collisionList.push_back(collision);
+}
+
+
+/**
+ * this is the function to be called on a collision event for this handle
+ *  @param collision the collision objects containing all collision informations
+ */
+void CollisionHandle::registerCollisionEvent(CollisionEvent* collisionEvent)
+{
+  if( !this->filterCollisionEvent(collisionEvent))
+    return;
+
+  // set the state to not dispatched
+  this->bDispatched = false;
+  this->bCollided = true;
+
+  // checks if these WorldEntities have already collided or if its a new collision -> create a new Collision object
+ Collision* c = this->registerCollision(collisionEvent->getEntityA(), collisionEvent->getEntityB());
+ c->setEntityACollide(true);
+
+ c->registerCollisionEvent(collisionEvent);
+}
+
+
+/**
+ * flushes the collision list
+ */
+void CollisionHandle::flushCollisions()
+{
+  this->collisionList.clear();
+}
+
+
+/**
+ * handles the collisions and react according to algorithm
+ */
+void CollisionHandle::handleCollisions()
+{
+  // collision reaction calculations (for every collision there will be a reaction)
+  vector<Collision*>::iterator it = this->collisionList.begin();
+  for(; it < this->collisionList.end(); it++) {
+    if( !(*it)->isDispatched())
+    {
+      this->collisionReaction->reactToCollision(*it);
+      (*it)->flushCollisionEvents();
+    }
+  }
+
+  // now set state to dispatched
+  this->bDispatched = true;
+  this->bCollided = false;
+
+  this->flushCollisions();
+}
+
+
+/**
+ * filter out the CollisionEvents that are not wanted
+ *  @param collisionEvent the collision event to filter
+ */
+bool CollisionHandle::filterCollisionEvent(CollisionEvent* collisionEvent)
+{
+  vector<long>::iterator it = this->targetList.begin();
+  for(; it < this->targetList.end(); it++)
+  {
+    if( collisionEvent->getEntityA() == this->owner) {
+      if( collisionEvent->getEntityA()->isA((ClassID)(*it)))
+        return true; }
+    else {
+      if( collisionEvent->getEntityB()->isA((ClassID)(*it)))
+        return true; }
+  }
+
+  return false;
+}
+
+
+/**
+ * filter Collisions that are not wanted to be reacted to
+ *  @param collision the collision object to filter
+ */
+bool CollisionHandle::filterCollision(Collision* collision)
+{
+  vector<long>::iterator it = this->targetList.begin();
+  for(; it < this->targetList.end(); it++)
+  {
+    if( collision->getEntityA() == this->owner) {
+      if( collision->getEntityA()->isA((ClassID)(*it)))
+        return true; }
+      else {
+        if( collision->getEntityB()->isA((ClassID)(*it)))
+          return true; }
+  }
+
+  return false;
+}
+
+
+
+
+
+
+