Changeset 8190 in orxonox.OLD

Timestamp:

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

Author:

patrick

Message:

trunk: merged the cr branche to trunk

Location:

trunk/src

Files:

• defs/class_id.h (modified) (2 diffs)
• lib/BuildLibs.am (modified) (1 diff)
• lib/collision_detection/Makefile.am (modified) (2 diffs)
• lib/collision_detection/collision.cc (deleted)
• lib/collision_detection/collision.h (deleted)
• lib/collision_detection/obb_tree_node.cc (modified) (1 diff)
• lib/collision_reaction/Makefile.am (modified) (1 diff)
• lib/collision_reaction/collision.cc (copied) (copied from branches/cr/src/lib/collision_reaction/collision.cc)
• lib/collision_reaction/collision.h (copied) (copied from branches/cr/src/lib/collision_reaction/collision.h)
• lib/collision_reaction/collision_event.cc (copied) (copied from branches/cr/src/lib/collision_reaction/collision_event.cc)
• lib/collision_reaction/collision_event.h (copied) (copied from branches/cr/src/lib/collision_reaction/collision_event.h)
• lib/collision_reaction/collision_handle.cc (modified) (3 diffs)
• lib/collision_reaction/collision_handle.h (modified) (1 diff)
• lib/collision_reaction/collision_reaction.cc (copied) (copied from branches/cr/src/lib/collision_reaction/collision_reaction.cc)
• lib/collision_reaction/collision_reaction.h (copied) (copied from branches/cr/src/lib/collision_reaction/collision_reaction.h)
• lib/collision_reaction/cr_defs.h (copied) (copied from branches/cr/src/lib/collision_reaction/cr_defs.h)
• lib/collision_reaction/cr_engine.cc (modified) (3 diffs)
• lib/collision_reaction/cr_engine.h (modified) (5 diffs)
• lib/collision_reaction/cr_object_damage.cc (copied) (copied from branches/cr/src/lib/collision_reaction/cr_object_damage.cc)
• lib/collision_reaction/cr_object_damage.h (copied) (copied from branches/cr/src/lib/collision_reaction/cr_object_damage.h)
• lib/graphics/effects/atmospheric_engine.cc (modified) (1 diff)
• lib/physics/physics_interface.h (modified) (2 diffs)
• story_entities/game_world.cc (modified) (5 diffs)
• story_entities/game_world.h (modified) (1 diff)
• world_entities/projectiles/projectile.cc (modified) (1 diff)
• world_entities/world_entity.cc (modified) (8 diffs)
• world_entities/world_entity.h (modified) (7 diffs)

trunk/src/defs/class_id.h

@@ +1 @@
+
 /*
    orxonox - the future of 3D-vertical-scrollers
@@ -253 +254 @@
   CL_COLLISION                  =    0x00000711,
   CL_COLLISION_HANDLE           =    0x00000712,
+  CL_COLLISION_REACTION         =    0X00000713,
+  CL_CR_PHYSICS_MOMENTUM        =    0X00000714,
+  CL_CR_PHYSICS_GROUND          =    0X00000715,
+  CL_CR_PHYSICS_GROUND_WALK     =    0X00000716,
+  CL_CR_OBJECT_DAMAGE          =    0X00000717,
+  CL_CR_OBJECT_PICKUP           =    0X00000718,
+  CL_CR_VERTEX_TRAFO            =    0X00000719,
+  CL_CR_SPECIAL_CALLBACK        =    0X00000720,
+
+
   CL_BV_TREE                    =    0x00701000,
   CL_BV_TREE_NODE               =    0x00702000,
-  CL_OBB_TREE                   =    0x00000714,
-  CL_OBB_TREE_NODE              =    0x00000715,
+  CL_OBB_TREE                   =    0x00000721,
+  CL_OBB_TREE_NODE              =    0x00000722,
   CL_BOUNDING_VOLUME            =    0x00710000,
   CL_OBB                        =    0x00720000,

trunk/src/lib/BuildLibs.am

@@ -13 +13 @@
                 $(LIB_PREFIX)/particles/libORXparticles.a \
                 $(LIB_PREFIX)/collision_detection/libORXcd.a \
+                $(LIB_PREFIX)/collision_reaction/libORXcr.a \
                 $(LIB_PREFIX)/network/libORXnet.a \
                 $(LIB_PREFIX)/graphics/spatial_separation/libORXquadtree.a \

trunk/src/lib/collision_detection/Makefile.am

@@ -5 +5 @@
 
 libORXcd_a_SOURCES = cd_engine.cc \
-                     collision.cc \
                      obb.cc \
                      obb_tree.cc \
@@ -17 +16 @@
 noinst_HEADERS =     cd_engine.h \
                      collision_defs.h \
-                     collision.h \
                      obb.h \
                      obb_tree.h \

trunk/src/lib/collision_detection/obb_tree_node.cc

@@ -481 +481 @@
     PRINTF(5)("collision @ lvl %i, object %s vs. %s, (%p, %p)\n", this->depth, nodeA->getClassName(), nodeB->getClassName(), this->nodeLeft, this->nodeRight);
 
-    /* check if left node overlaps */
+
+    // left node
     if( this->nodeLeft != NULL )
     {
-      PRINTF(5)("Checking OBB %i vs %i: ", this->nodeLeft->getIndex(), treeNode->getIndex());
       if( this->overlapTest(this->nodeLeft->bvElement, treeNode->bvElement, nodeA, nodeB))
       {
-        this->nodeLeft->collideWith(treeNode->nodeLeft, nodeA, nodeB);
-        this->nodeLeft->collideWith(treeNode->nodeRight, nodeA, nodeB);
+        if( treeNode->nodeLeft != NULL)
+          this->nodeLeft->collideWith(treeNode->nodeLeft, nodeA, nodeB);
+        if( treeNode->nodeRight != NULL)
+          this->nodeLeft->collideWith(treeNode->nodeRight, nodeA, nodeB);
       }
     }
-    /* check if right node overlaps */
-    if( likely( this->nodeRight != NULL))
-    {
-      PRINTF(5)("Checking OBB %i vs %i: ", this->nodeRight->getIndex(), treeNode->getIndex());
-      if(this->overlapTest(this->nodeRight->bvElement, treeNode->bvElement, nodeA, nodeB))
+
+    // right node
+    if( this->nodeRight != NULL )
+    {
+      if( this->overlapTest(this->nodeRight->bvElement, treeNode->bvElement, nodeA, nodeB))
       {
-        this->nodeRight->collideWith(treeNode->nodeLeft, nodeA, nodeB);
-        this->nodeRight->collideWith(treeNode->nodeRight, nodeA, nodeB);
+        if( treeNode->nodeLeft != NULL)
+          this->nodeRight->collideWith(treeNode->nodeLeft, nodeA, nodeB);
+        if( treeNode->nodeRight != NULL)
+          this->nodeRight->collideWith(treeNode->nodeRight, nodeA, nodeB);
       }
     }
 
-    /* so there is a collision and this is the last box in the tree (i.e. leaf) */
-    if( unlikely((this->nodeRight == NULL || this->nodeLeft == NULL) ||
-                 (treeNode->nodeRight == NULL || treeNode->nodeLeft == NULL)) )
-    {
-      nodeA->collidesWith(nodeB, treeNode->bvElement->center);
-      nodeB->collidesWith(nodeA, this->bvElement->center);
+
+    // hybrid mode: we reached the end of this obbtree, now reach the end of the other tree
+    if( this->nodeLeft == NULL && this->nodeRight == NULL)
+    {
+      if( treeNode->nodeLeft != NULL)
+        this->collideWith(treeNode->nodeLeft, nodeA, nodeB);
+      if( treeNode->nodeRight != NULL)
+        this->collideWith(treeNode->nodeRight, nodeA, nodeB);
+    }
+
+
+    // now check if we reached the end of both trees
+    if( unlikely((this->nodeRight == NULL && this->nodeLeft == NULL) &&
+        (treeNode->nodeRight == NULL && treeNode->nodeLeft == NULL)) )
+    {
+      nodeA->registerCollision(nodeA, nodeB, (BoundingVolume*)this->bvElement, (BoundingVolume*)treeNode->bvElement);
     }
 

trunk/src/lib/collision_reaction/Makefile.am

@@ -5 +5 @@
 
 libORXcr_a_SOURCES = cr_engine.cc \
-                     collision_handle.cc
+                     collision.cc \
+                     collision_event.cc \
+                     collision_handle.cc \
+                     collision_reaction.cc \
+                     cr_object_damage.cc
 
 
 
 noinst_HEADERS =     cr_engine.h \
-                                                                                 collision_handle.h
+                     collision.h \
+                     collision_event.h \
+                     collision_handle.h \
+                     cr_defs.h \
+                     collision_reaction.h \
+                     cr_object_damage.h
 

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;
+}
+
+
+
+
+
+
+

trunk/src/lib/collision_reaction/collision_handle.h

@@ -11 +11 @@
 
 #include <vector>
+#include <list>
 
 
 class Collision;
 class WorldEntity;
+class CollisionReaction;
 
-// struct CRType;
 
 
 //! A class for defining collision reactions and storing events
-class CollisionHandle : public BaseObject {
+class CollisionHandle : public BaseObject
+{
 
- public:
-  CollisionHandle(WorldEntity* owner, CREngine::CRType type);
-  virtual ~CollisionHandle();
+  public:
+    CollisionHandle(WorldEntity* owner, CREngine::CRType type);
+    virtual ~CollisionHandle();
+
+    void reset();
+
+    void addTarget(long target);
+    Collision* registerCollision(WorldEntity* entityA, WorldEntity* entityB);
+    void registerSharedCollision(Collision* collision);
+    void registerCollisionEvent(CollisionEvent* collisionEvent);
+
+    /** @returns true if regiestered some new collision events in this tick frame */
+    inline bool isCollided() const { return this->bCollided; }
+    /** @returns true if this collision handle has already been dispatched */
+    inline bool isDispatched() const { return this->bDispatched; }
+    /** @returns true if this handle should be pulled also if there are no collisions */
+    inline bool isContinuousPoll() const { return this->bContinuousPoll; }
+
+    void handleCollisions();
 
 
-  void addTarget();
-
-  void registerCollision(Collision* collision);
-
-  void handleCollisions();
+  private:
+    void flushCollisions();
+    bool filterCollisionEvent(CollisionEvent* collisionEvent);
+    bool filterCollision(Collision* collision);
 
 
- private:
-   WorldEntity*                  owner;                   //!< the worldenity this reaction will be applied on
-   CREngine::CRType              type;                    //!< the reaction type
 
-   bool                          bDispatched;             //!< true if this handle has already been dispatched
-   bool                          bStopOnFirstCollision;   //!< true if the cd of this object should be terminated after one match
+  private:
+    WorldEntity*                  owner;                   //!< the worldenity this reaction will be applied on
+    CREngine::CRType              type;                    //!< the reaction type
 
-   std::vector<Collision*>       collisionList;           //!< a list full of collisions
-   std::vector<long>             targetList;              //!< a list of target classes for filtering
+    bool                          bContinuousPoll;         //!< if this is true
+    bool                          bDispatched;             //!< true if this handle has already been dispatched
+    bool                          bStopOnFirstCollision;   //!< true if the cd of this object should be terminated after one match
+    bool                          bCollided;               //!< true if the CollsionHandle has registered some new collisions
+
+    std::vector<Collision*>       collisionList;           //!< a list full of collisions
+    std::vector<long>             targetList;              //!< a list of target classes for filtering
+
+    CollisionReaction*            collisionReaction;       //!< reference to the collision reaction object
 
 };

trunk/src/lib/collision_reaction/cr_engine.cc

@@ -16 +16 @@
 #define DEBUG_SPECIAL_MODULE DEBUG_MODULE_COLLISION_REACTION
 
+
+
+#include "collision.h"
+#include "collision_event.h"
+#include "collision_handle.h"
+#include "cr_defs.h"
+
 #include "cr_engine.h"
 
@@ -25 +32 @@
  */
 CREngine::CREngine ()
+  : BaseObject()
 {
    this->setClassID(CL_CR_ENGINE, "CREngine");
    this->setName("CREngine");
 
+   this->init();
 }
 
@@ -42 +51 @@
 {
   CREngine::singletonRef = NULL;
+
+  if( this->collisionsUnused.size() != CR_MAX_COLLISIONS)
+    PRINTF(0)("CollisionReaction Error: Collision cache size missmatch: %i of %i\n", this->collisionsUnused.size(), CR_MAX_COLLISIONS);
+  if( this->collisionEventsUnused.size() != CR_MAX_COLLISION_EVENTS)
+    PRINTF(0)("CollisionReaction Error: CollisionEvent cache size missmatch: %i of %i\n", this->collisionEventsUnused.size(), CR_MAX_COLLISION_EVENTS);
+
+  this->reset();
+
+  vector<Collision*>::iterator it1 = this->collisionsUnused.begin();
+  for(; it1 < this->collisionsUnused.end(); it1++)
+    delete *it1;
+  vector<CollisionEvent*>::iterator it2 = this->collisionEventsUnused.begin();
+  for(; it2 < this->collisionEventsUnused.end(); it2++)
+    delete *it2;
+
+  this->collisionsUnused.clear();
+  this->collisionEventsUnused.clear();
+}
+
+/**
+ * inits the CREngine to a working state
+ */
+void CREngine::init()
+{
+  // create a list of Collision events (precaching)
+  for( int i = 0; i < CR_MAX_COLLISIONS; i++)
+    this->collisionsUnused.push_back(new Collision());
+  for( int i = 0; i < CR_MAX_COLLISION_EVENTS; i++)
+    this->collisionEventsUnused.push_back(new CollisionEvent());
 }
 
 
+/**
+ * flushes the CollisionHandles and restores the CREngine to the initial state
+ */
+void CREngine::reset()
+{
+  // first clear all CollisionHandles
 
+  vector<CollisionHandle*>::iterator it = this->collisionHandles.begin();
+  for(; it < this->collisionHandles.end(); it++)
+  {
+    (*it)->reset();
+    delete *it;
+  }
 
-CollisionHandle* CREngine::subscribeReaction(WorldEntity* owner, CRType type, int nrOfTargets, ...)
-{
-
-  va_list itemlist;
-  va_start (itemlist, type);
-//  for (int i = 0; i < nrOfTargets; i++)
-  //  this->targetList.push_back(va_arg(itemlist, int));
-  va_end(itemlist);
+  this->collisionHandles.clear();
 }
 
 
+/**
+ * subscribes a WorldEntity for a CollisionReaction
+ *  @param owner: the WE to subscribe
+ *  @param type: the type of collision reaction to perform
+ *  @return the newly created CollisionHandle
+ */
+CollisionHandle* CREngine::subscribeReaction(WorldEntity* owner, CRType type)
+{
+  CollisionHandle* ch = new CollisionHandle(owner, type);
+  this->collisionHandles.push_back(ch);
+
+  return ch;
+}
 
 
+/**
+ * unsubscribe reaction from the reaction list
+ *  @param collisionHandle the CollisionHandle to remove
+ *  @param returns true if worked collrectly
+ */
+bool CREngine::unsubscribeReaction(CollisionHandle* collisionHandle)
+{
+  std::vector<CollisionHandle*>::iterator it;
+  for( it = this->collisionHandles.begin(); it != this->collisionHandles.end(); it++)
+  {
+    if( *it == collisionHandle)
+    {
+      this->collisionHandles.erase(it);
+      delete collisionHandle;
+      return true;
+    }
+  }
+  return false;
+}
+
+
+/**
+ * processes the collisions by calling the EventHandlers
+ */
+void CREngine::handleCollisions()
+{
+  std::vector<CollisionHandle*>::iterator it;
+  for( it = this->collisionHandles.begin(); it != this->collisionHandles.end(); it++)
+  {
+    if( (*it)->isCollided() || (*it)->isContinuousPoll())  //does it have any collisions to report at all
+    {
+      (*it)->handleCollisions();
+    }
+  }
+  this->flushCollisions();
+}
+
+
+/**
+ * flushes all the collision lists and puts them to their initial state
+ */
+void CREngine::flushCollisions()
+{
+  vector<Collision*>::iterator it1 = this->collisionsUsed.begin();
+  for(; it1 < this->collisionsUsed.end(); it1++)
+    this->collisionsUnused.push_back(*it1);
+
+  vector<CollisionEvent*>::iterator it2 = this->collisionEventsUsed.begin();
+  for(; it2 < this->collisionEventsUsed.end(); it2++)
+    this->collisionEventsUnused.push_back(*it2);
+
+  this->collisionsUsed.clear();
+  this->collisionEventsUsed.clear();
+}
+
+
+void CREngine::debug()
+{
+
+}
+

trunk/src/lib/collision_reaction/cr_engine.h

@@ -2 +2 @@
  * @file cr_engine.h
  * @brief The collision reaction engine, defining generic collision reactions to collision events
-*/
+ *
+ * some parts of this module are tuned for efficiency. They are probably not self-explenatory anymore :D
+ *  - Collision/ CollisionEvent objects recycling: This class contains a class of precached objects of these types
+ *      they are used for fast registration of collision events: These objects can be get by the interface functions and
+ *      are returned after one cycle automaticly by reseting the cached lists to its initial state. So do not wonder :D
+ */
 
 #ifndef _CR_ENGINE_
@@ -8 +13 @@
 
 #include "base_object.h"
-#include <stdarg.h>
+
 #include <vector>
 
@@ -14 +19 @@
 class CollisionHandle;
 class Collision;
+class CollisionEvent;
 class WorldEntity;
 
@@ -22 +28 @@
   public:
   typedef enum CRType {
-    CR_PHYSICS_MOMENTUM   = 0,
-    CR_PHYSICS_GROUND,
-    CR_PHYSICS_GROUND_WALK,
+    CR_PHYSICS_MOMENTUM   = 0,    //!< physical reaction: conservervation of momentum
+    CR_PHYSICS_STEP_BACK,         //!< physical reaction: just go to the last position without collisions
+    CR_PHYSICS_GROUND,            //!< physical reaction: stand on the ground, no movement: simulating simple normal force away from the gravity force
+    CR_PHYSICS_GROUND_WALK,       //!< physical reaction: walking on the ground (inkl. hills etc)
+    CR_PHYSICS_DAMAGE,            //!< physical reaction: daling damage according to the object energy and their structural stability
 
-    CR_OBJECT_DAMAGE,
-    CR_OBJECT_PICKUP,
+    CR_OBJECT_DAMAGE,             //!< object raction: deals damage according to the objects specific damage potential (like weapons, nukes, etc.)
+    CR_OBJECT_PICKUP,             //!< object rection: calling the objects pickup functions, let them handle the collision (once!)
 
-    CR_VERTEX_TRAFO,
+    CR_VERTEX_TRAFO,              //!< vertex trafo: transforming the vertex according to the damage
 
-    CR_SPECIAL_CALLBACK,
+    CR_SPECIAL_CALLBACK,          //!< special: call a callback function
 
     CR_NUMBER
@@ -39 +47 @@
 
   /** @returns a Pointer to the only object of this Class */
-  inline static CREngine* getInstance(void) { if (!singletonRef) singletonRef = new CREngine();  return singletonRef; };
+  inline static CREngine* getInstance() { if (!singletonRef) singletonRef = new CREngine();  return singletonRef; };
+
+  void reset();
 
 
-  CollisionHandle* subscribeReaction(WorldEntity* worldEntity, CRType type, int nrOfTargets, ...);
+  CollisionHandle* subscribeReaction(WorldEntity* worldEntity, CRType type);
 
-  bool unsubscribeReaction(WorldEntity* worldEntity);
   bool unsubscribeReaction(CollisionHandle* collisionHandle);
-
 
   void handleCollisions();
 
   /** @returns an instance to a collision object. instead of creating new object this ones can be resycled */
-  inline Collision* getCollisionObject() { /* return the first element of the cache list*/ }
-  /** @param collision: returns the Collision object back to the cache list */
-  inline void putCollisionObject(Collision* collision) { this->cachedCollisions.push_back(collision); }
+  inline Collision* popCollisionObject() {
+    if( !this->collisionsUnused.empty()) {
+      this->collisionsUsed.push_back(this->collisionsUnused.back()); this->collisionsUnused.pop_back(); return this->collisionsUsed.back(); } else return NULL; }
+
+
+  /** @return an instanco of a CollisionEvent object. instead of creating a new object this ones can be used and resycled */
+  inline CollisionEvent* popCollisionEventObject() {
+    if( !this->collisionEventsUnused.empty()) {
+      this->collisionEventsUsed.push_back(this->collisionEventsUnused.back()); this->collisionEventsUnused.pop_back(); return this->collisionEventsUsed.back(); } else return NULL; }
+
+  void debug();
 
 
 private:
-  CREngine(void);
+  CREngine();
+  void init();
+
+  void flushCollisions();
 
 
 private:
   std::vector<CollisionHandle*>       collisionHandles;         //!< list with the collision handles
-  std::vector<Collision*>             cachedCollisions;         //!< a list of unused, cached collision events
+
+  std::vector<Collision*>             collisionsUsed;           //!< a list of used, cached collisions
+  std::vector<Collision*>             collisionsUnused;         //!< a list of unused, cached collisions
+
+  std::vector<CollisionEvent*>        collisionEventsUsed;      //!< a list of used, cached collision events
+  std::vector<CollisionEvent*>        collisionEventsUnused;    //!< a list of unused, cached collision events
 
   static CREngine*                    singletonRef;             //!< the reference to the CREngine object (singleton)

trunk/src/lib/graphics/effects/atmospheric_engine.cc

@@ -127 +127 @@
     for (it = weatherEffects->begin(); it != weatherEffects->end(); it++)
     {
-      printf("%s::%s \n", (*it)->getClassName(), (*it)->getName());
+/*      printf("%s::%s \n", (*it)->getClassName(), (*it)->getName());*/
       dynamic_cast<WeatherEffect*>(*it)->tick(dt);
     }

trunk/src/lib/physics/physics_interface.h

@@ -39 +39 @@
   inline float getTotalMass( void ) const { return mass + massChildren; };
 
+  /** @returns the velocity */
+  inline const Vector getVelocity() { return this->velocity; }
+  /** @returns the acceleration */
+  inline const Vector getAcceleration() { return this->acceleration; }
+
   virtual void applyForce(const Vector& force);
   virtual void applyField(Field* field);
@@ -51 +56 @@
   float          massChildren;          //!< Sum of the masses of the children nodes
 
+  Vector         velocity;              //!< the velocity of the masspoint
+  Vector         acceleration;          //!< acceleration of the masspoint
+
   Vector         forceSum;              //!< Total central force for this tick
   Quaternion     momentumSum;           //!< Total momentum in this tick

trunk/src/story_entities/game_world.cc

@@ -136 +136 @@
   AnimationPlayer::getInstance();
   PhysicsEngine::getInstance();
-
+  CREngine::getInstance();
 }
 
@@ -199 +199 @@
   delete AnimationPlayer::getInstance();
   delete PhysicsEngine::getInstance();
+  delete CREngine::getInstance();
 
   State::setCurrentStoryEntity(NULL);
@@ -278 +279 @@
     /* process time */
     this->tick ();
-    /* process collision */
-    this->collide ();
+    /* collision detection */
+    this->collisionDetection ();
+    /* collision reaction */
+    this->collisionReaction ();
     /* update the state */
     this->update ();
@@ -408 +411 @@
  * kicks the CDEngine to detect the collisions between the object groups in the world
  */
-void GameWorld::collide()
+void GameWorld::collisionDetection()
 {
   CDEngine::getInstance()->checkCollisions(this->dataTank->objectManager->getObjectList(OM_GROUP_00),
@@ -422 +425 @@
       this->dataTank->objectManager->getObjectList(OM_COMMON));
 
+}
+
+
+void GameWorld::collisionReaction()
+{
+  CREngine::getInstance()->handleCollisions();
 }
 

trunk/src/story_entities/game_world.h

@@ -68 +68 @@
     virtual void update();
     virtual void checkGameRules();
-    virtual void collide();
+    virtual void collisionDetection();
+    virtual void collisionReaction();
 
     void drawEntityList(const ObjectManager::EntityList& drawList ) const;

trunk/src/world_entities/projectiles/projectile.cc

@@ -38 +38 @@
   this->target = NULL;
   this->removeNode();
+
+  /* character attributes */
+  this->setHealth(1.0f);
+  this->setDamage(100.0f); // default damage of a projectile set to 100.0 damage points
 
   this->explosionBuffer = NULL;

trunk/src/world_entities/world_entity.cc

@@ -32 +32 @@
 #include "camera.h"
 
-#include "cr_engine.h"
 #include "collision_handle.h"
+#include "collision_event.h"
+
+#include <stdarg.h>
 
 
@@ -59 +61 @@
   this->healthMax = 1.0f;
   this->health = 1.0f;
+  this->damage = 0.0f; // no damage dealt by a default entity
   this->scaling = 1.0f;
 
@@ -68 +71 @@
   this->objectListIterator = NULL;
 
+  // reset all collision handles to NULL == unsubscribed state
+  for(int i = 0; i < CREngine::CR_NUMBER; ++i)
+    this->collisionHandles[i] = NULL;
+  this->bReactive = false;
+
+  // registering default reactions:
+  this->subscribeReaction(CREngine::CR_OBJECT_DAMAGE, CL_WORLD_ENTITY);
+  this->subscribeReaction(CREngine::CR_PHYSICS_GROUND, CL_TERRAIN);
+
   this->toList(OM_NULL);
 
@@ -91 +103 @@
   if (this->healthWidget != NULL)
     delete this->healthWidget;
+
+  this->unsubscribeReaction();
 }
 
@@ -249 +263 @@
  * subscribes this world entity to a collision reaction
  *  @param type the type of reaction to subscribe to
+ *  @param target1 a filter target (classID)
+ */
+void WorldEntity::subscribeReaction(CREngine::CRType type, long target1)
+{
+  this->subscribeReaction(type);
+
+  // add the target filter
+  this->collisionHandles[type]->addTarget(target1);
+}
+
+
+/**
+ * subscribes this world entity to a collision reaction
+ *  @param type the type of reaction to subscribe to
+ *  @param target1 a filter target (classID)
+ */
+void WorldEntity::subscribeReaction(CREngine::CRType type, long target1, long target2)
+{
+  this->subscribeReaction(type);
+
+  // add the target filter
+  this->collisionHandles[type]->addTarget(target1);
+  this->collisionHandles[type]->addTarget(target2);
+}
+
+
+/**
+ * subscribes this world entity to a collision reaction
+ *  @param type the type of reaction to subscribe to
+ *  @param target1 a filter target (classID)
+ */
+void WorldEntity::subscribeReaction(CREngine::CRType type, long target1, long target2, long target3)
+{
+  this->subscribeReaction(type);
+
+  // add the target filter
+  this->collisionHandles[type]->addTarget(target1);
+  this->collisionHandles[type]->addTarget(target2);
+  this->collisionHandles[type]->addTarget(target3);
+}
+
+
+/**
+ * subscribes this world entity to a collision reaction
+ *  @param type the type of reaction to subscribe to
+ *  @param target1 a filter target (classID)
+ */
+void WorldEntity::subscribeReaction(CREngine::CRType type, long target1, long target2, long target3, long target4)
+{
+  this->subscribeReaction(type);
+
+  // add the target filter
+  this->collisionHandles[type]->addTarget(target1);
+  this->collisionHandles[type]->addTarget(target2);
+  this->collisionHandles[type]->addTarget(target3);
+  this->collisionHandles[type]->addTarget(target4);
+}
+
+
+/**
+ * subscribes this world entity to a collision reaction
+ *  @param type the type of reaction to subscribe to
  *  @param nrOfTargets number of target filters
  *  @param ... the targets as classIDs
  */
-void WorldEntity::subscribeReaction(CREngine::CRType type, int nrOfTargets, ...)
-{}
+void WorldEntity::subscribeReaction(CREngine::CRType type)
+{
+  if( this->collisionHandles[type] != NULL)  {
+    PRINTF(2)("Registering for a CollisionReaction already subscribed to! Skipping\n");
+    return;
+  }
+
+  this->collisionHandles[type] = CREngine::getInstance()->subscribeReaction(this, type);
+
+  // now there is at least one collision reaction subscribed
+  this->bReactive = true;
+}
+
+
+/**
+ * unsubscribes a specific reaction from the worldentity
+ *  @param type the reaction to unsubscribe
+ */
+void WorldEntity::unsubscribeReaction(CREngine::CRType type)
+{
+  if( this->collisionHandles[type] == NULL)
+    return;
+
+  CREngine::getInstance()->unsubscribeReaction(this->collisionHandles[type]);
+  this->collisionHandles[type] = NULL;
+
+  // check if there is still any handler registered
+  for(int i = 0; i < CREngine::CR_NUMBER; ++i)
+  {
+    if( this->collisionHandles[i] != NULL)
+    {
+      this->bReactive = true;
+      return;
+    }
+  }
+  this->bReactive = false;
+}
+
+
+/**
+ * unsubscribes all collision reactions
+ */
+void WorldEntity::unsubscribeReaction()
+{
+  for( int i = 0; i < CREngine::CR_NUMBER; i++)
+    this->unsubscribeReaction((CREngine::CRType)i);
+
+  // there are no reactions subscribed from now on
+  this->bReactive = false;
+}
+
+
+/**
+ * registers a new collision event to this world entity
+ *  @param entityA entity of the collision
+ *  @param entityB entity of the collision
+ *  @param bvA colliding bounding volume of entityA
+ *  @param bvB colliding bounding volume of entityA
+ */
+bool WorldEntity::registerCollision(WorldEntity* entityA, WorldEntity* entityB, BoundingVolume* bvA, BoundingVolume* bvB)
+{
+  // is there any handler listening?
+  if( !this->bReactive)
+    return false;
+
+  // get a collision event
+  CollisionEvent* c = CREngine::getInstance()->popCollisionEventObject();
+  assert(c != NULL); // if this should fail: we got not enough precached CollisionEvents: alter value in cr_defs.h
+  c->collide(entityA, entityB, bvA, bvB);
+
+  for( int i = 0; i < CREngine::CR_NUMBER; ++i)
+    if( this->collisionHandles[i] != NULL)
+      this->collisionHandles[i]->registerCollisionEvent(c);
+}
+
+
+/**
+ * registers a new collision event to this woeld entity
+ *  @param entity the entity that collides
+ *  @param plane it stands on
+ *  @param position it collides on the plane
+ */
+bool WorldEntity::registerCollision(WorldEntity* entity, Plane* plane, Vector position)
+{
+  // is there any handler listening?
+  if( !this->bReactive)
+    return false;
+
+  // get a collision event
+  CollisionEvent* c = CREngine::getInstance()->popCollisionEventObject();
+  assert(c != NULL); // if this should fail: we got not enough precached CollisionEvents: alter value in cr_defs.h
+  c->collide(entity, plane, position);
+
+  for( int i = 0; i < CREngine::CR_NUMBER; ++i)
+    if( this->collisionHandles[i] != NULL)
+      this->collisionHandles[i]->registerCollisionEvent(c);
+}
 
 
@@ -324 +495 @@
 void WorldEntity::collidesWithGround(const Vector& feet, const Vector& ray_1, const Vector& ray_2)
 {
-  
+
   // PRINTF(0)("BSP_GROUND: Player collides \n", this->getClassName() );
-  
+
   Vector v = this->getAbsDirX();
   v.x *= 10;
@@ -332 +503 @@
   v.z *= 10;
   Vector u = this->getAbsDirY();
-  
+
   if(feet.x == (u.x+this->getAbsCoor().x) &&  feet.y == u.y +this->getAbsCoor().y && feet.z == this->getAbsCoor().z)
   {
-    
+
   this->setAbsCoor(ray_2 - v);
   }
@@ -342 +513 @@
     if(ray_1.x == this->getAbsCoor().x + v.x && ray_1.y == this->getAbsCoor().y + v.y + 0.1 && ray_1.z ==this->getAbsCoor().z + v.z)
     {
-      this->setAbsCoor(feet -u );  
-    }
-      
-    this->setAbsCoor(ray_2 - v);  
-   
+      this->setAbsCoor(feet -u );
+    }
+
+    this->setAbsCoor(ray_2 - v);
+
   }
 }

trunk/src/world_entities/world_entity.h

@@ -15 +15 @@
 #include "glincl.h"
 #include <vector>
-#include <stdarg.h>
+
+#include "physics_interface.h"
 
 
@@ -24 +25 @@
 
 class BVTree;
+class BoundingVolume;
 class Model;
 class CollisionHandle;
+class Collision;
+class Plane;
 
 
@@ -72 +76 @@
 
   /* --- Collision Reaction Block --- */
-  void subscribeReaction(CREngine::CRType type, int nrOfTargets, ...);
+  void subscribeReaction(CREngine::CRType type);
+  void subscribeReaction(CREngine::CRType type, long target1);
+  void subscribeReaction(CREngine::CRType type, long target1, long target2);
+  void subscribeReaction(CREngine::CRType type, long target1, long target2, long target3);
+  void subscribeReaction(CREngine::CRType type, long target1, long target2, long target3, long target4);
+
+  void unsubscribeReaction(CREngine::CRType type);
+  void unsubscribeReaction();
+
+  bool registerCollision(WorldEntity* entityA, WorldEntity* entityB, BoundingVolume* bvA, BoundingVolume* bvB);
+  bool registerCollision(WorldEntity* entity, Plane* plane, Vector position);
+  /** @return true if there is at least on collision reaction subscribed */
+  inline bool isReactive() const { return this->bReactive; }
+
+  CollisionHandle* getCollisionHandle(CREngine::CRType type) const { return this->collisionHandles[type]; }
 
 
@@ -98 +116 @@
 
   /* --- Character Attribute Block --- */
+  /** @returns the damage dealt by this world entity */
+  float getDamage() const { return this->damage; }
+  /** sets the damage dealt to @param damage damage per second */
+  void setDamage(float damage) { this->damage = damage; }
   /** @returns the Energy of the entity */
   float getHealth() const { return this->health; };
@@ -107 +129 @@
   OrxGui::GLGuiWidget* getHealthWidget();
   bool hasHealthWidget() const { return this->healthWidget; };
-  
+
   virtual void varChangeHandler( std::list<int> & id );
+
+
+  //FIXME: the PhysicsInterface and the whole PEngine should probably be reviewed. Here its just used to store the vars
+  /* --- Physics Interface --- */
+  inline PhysicsInterface getPhysicsInterface() const { return this->physicsInterface; }
+  inline float getMass() const { return this->physicsInterface.getMass(); }
+  inline float getTotalMass() const { return this->physicsInterface.getTotalMass(); }
+
 
   /* --- Misc Stuff Block --- */
@@ -128 +158 @@
 private:
   /// TODO maybe we will move the following three entries and the corresponding functions to Playable AND NPC
+  float                   damage;             //!< the damage dealt to other objects by colliding.
   float                   health;             //!< The Energy of this Entity, if the Entity has any energy at all.
   float                   healthMax;          //!< The Maximal energy this entity can take.
@@ -140 +171 @@
   bool                    bVisible;           //!< If it should be visible.
 
-  OM_LIST                           objectListNumber;   //!< The ObjectList from ObjectManager this Entity is in.
-  ObjectManager::EntityList::iterator objectListIterator; //!< The iterator position of this Entity in the given list of the ObjectManager.
+  OM_LIST                 objectListNumber;                //!< The ObjectList from ObjectManager this Entity is in.
+  ObjectManager::EntityList::iterator objectListIterator;  //!< The iterator position of this Entity in the given list of the ObjectManager.
 
-  
-  //network stuff
-  
-  float       scaling;                         //!< model's scaling factor
-  int         scaling_handle;                  //!< handle for syncing var
-  
-  std::string modelFileName;                  //!< model's file name
-  int         modelFileName_handle;           //!< handle for syncing var
-  CollisionHandle**       collisionHandles;
 
+
+  float                   scaling;                         //!< model's scaling factor
+  int                     scaling_handle;                  //!< handle for syncing var
+
+  std::string             modelFileName;                   //!< model's file name
+  int                     modelFileName_handle;            //!< handle for syncing var
+
+  CollisionHandle*        collisionHandles[CREngine::CR_NUMBER];  //!< the list of the collision reactions
+  bool                    bReactive;                              //!< true if there is at least one collision reaction subscibed
+
+  PhysicsInterface        physicsInterface;                //!< the physics object of the WorldEntity
 
 };