Changeset 8190 in orxonox.OLD for trunk/src/lib

Timestamp:

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

Author:

patrick

Message:

trunk: merged the cr branche to trunk

Location:

trunk/src/lib

Files:

• BuildLibs.am (modified) (1 diff)
• collision_detection/Makefile.am (modified) (2 diffs)
• collision_detection/collision.cc (deleted)
• collision_detection/collision.h (deleted)
• collision_detection/obb_tree_node.cc (modified) (1 diff)
• collision_reaction/Makefile.am (modified) (1 diff)
• collision_reaction/collision.cc (copied) (copied from branches/cr/src/lib/collision_reaction/collision.cc)
• collision_reaction/collision.h (copied) (copied from branches/cr/src/lib/collision_reaction/collision.h)
• collision_reaction/collision_event.cc (copied) (copied from branches/cr/src/lib/collision_reaction/collision_event.cc)
• collision_reaction/collision_event.h (copied) (copied from branches/cr/src/lib/collision_reaction/collision_event.h)
• collision_reaction/collision_handle.cc (modified) (3 diffs)
• collision_reaction/collision_handle.h (modified) (1 diff)
• collision_reaction/collision_reaction.cc (copied) (copied from branches/cr/src/lib/collision_reaction/collision_reaction.cc)
• collision_reaction/collision_reaction.h (copied) (copied from branches/cr/src/lib/collision_reaction/collision_reaction.h)
• collision_reaction/cr_defs.h (copied) (copied from branches/cr/src/lib/collision_reaction/cr_defs.h)
• collision_reaction/cr_engine.cc (modified) (3 diffs)
• collision_reaction/cr_engine.h (modified) (5 diffs)
• collision_reaction/cr_object_damage.cc (copied) (copied from branches/cr/src/lib/collision_reaction/cr_object_damage.cc)
• collision_reaction/cr_object_damage.h (copied) (copied from branches/cr/src/lib/collision_reaction/cr_object_damage.h)
• graphics/effects/atmospheric_engine.cc (modified) (1 diff)
• physics/physics_interface.h (modified) (2 diffs)

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