Changeset 10006 in orxonox.OLD

Timestamp:

Dec 4, 2006, 2:24:40 PM (17 years ago)

Author:

patrick

Message:

removed many very heavy segfaults

Location:

branches/coll_rect/src

Files:

• lib/collision_reaction/collision.h (modified) (1 diff)
• lib/collision_reaction/collision_event.h (modified) (1 diff)
• lib/collision_reaction/collision_filter.cc (modified) (3 diffs)
• lib/collision_reaction/collision_tube.cc (modified) (4 diffs)
• lib/collision_reaction/collision_tube.h (modified) (1 diff)
• lib/collision_reaction/cr_engine.cc (modified) (8 diffs)
• lib/collision_reaction/cr_engine.h (modified) (2 diffs)
• lib/graphics/importer/bsp_manager.cc (modified) (6 diffs)
• world_entities/world_entity.h (modified) (1 diff)

branches/coll_rect/src/lib/collision_reaction/collision.h

@@ -71 +71 @@
     /** @return Collision WorldEntity B */
     inline WorldEntity* getEntityB() const { return this->_entityB; }
-    inline bool match(const WorldEntity& entityA, WorldEntity& entityB) const {
+    inline bool same(const WorldEntity& entityA, WorldEntity& entityB) const {
       return ((this->_entityA == &entityA && this->_entityB == &entityB) || (this->_entityA == &entityB && this->_entityB == &entityA)); }
 

branches/coll_rect/src/lib/collision_reaction/collision_event.h

@@ -49 +49 @@
 
     /** @return CollisionEvent WorldEntity A */
-    inline WorldEntity* getEntityA() const
-    {
-      return this->entityA;
-    }
+    inline const WorldEntity* getEntityA() const  { return this->entityA; }
     /** @return CollisionEvent WorldEntity B */
-    inline WorldEntity* getEntityB() const
-    {
-      return this->entityB;
-    }
+    inline const WorldEntity* getEntityB() const  { return this->entityB; }
     /** @return Bounding Volume from EntityA */
-    inline BoundingVolume* getBVA() const
-    {
-      return this->bvA;
-    }
+    inline const BoundingVolume* getBVA() const { return this->bvA; }
     /** @return Bounding Volume from EntityB */
-    inline BoundingVolume* getBVB() const
-    {
-      return this->bvB;
-    }
+    inline const BoundingVolume* getBVB() const {  return this->bvB;  }
 
     /** @return ground plane if collided with bsp model */
-    inline Vector getGroundNormal()
-    {
-      return this->groundNormal;
-    }
+    inline const Vector& getGroundNormal() const  { return this->groundNormal; }
 
     /** @return position of the position, only accurate if this is a collision with the ground!!! */
-    inline Vector getCollisionPosition()
-    {
-      return this->position;
-    }
+    inline const Vector& getCollisionPosition() const  {  return this->position;  }
 
     /** @return the type of the collision */
-    inline int getType()
-    {
-      return this->collisionType;
-    }
+    inline int getType() const  {  return this->collisionType;  }
 
     /** @return true if the entity is in the wall */
-    inline bool isInWall()
-    {
-      return this->bInWall;
-    }
+    inline bool isInWall() const  {  return this->bInWall;  }
 
 

branches/coll_rect/src/lib/collision_reaction/collision_filter.cc

@@ -142 +142 @@
   bool CollisionFilter::operator()(const WorldEntity& entity) const
   {
-    // if there are no installed criterions just ommit and
-    if( this->isReactive())
+    PRINTF(0)("operator()(const WorldEntity& entity)\n");
+
+    // if there are no installed criterions just ommit and return
+    if( !this->isReactive())
       return false;
 
@@ -149 +151 @@
     for( int i = 0; i < CREngine::CR_NUMBER; i++ )
     {
-      std::vector<ClassID>::const_iterator it = this->_filters[i].begin();
-      for(; it != this->_filters[i].end(); i++ )
+      TargetIteratorConst it = this->_filters[i].begin();
+      for(; it != this->_filters[i].end(); it++ )
+      {
+         PRINTF(0)("[%i] check %s is a %s?\n", i, entity.getClassName().c_str(), (*it).name().c_str());
         if( unlikely(entity.isA(*it) ) )
           return true;
+      }
     }
 
@@ -168 +173 @@
   bool CollisionFilter::operator()(const WorldEntity& entity, const CREngine::ReactionType type) const
   {
+    assert(&entity != NULL);
+
+    PRINTF(0)("operator()(const WorldEntity& entity, const CREngine::ReactionType type)\n");
     // if there are no installed criterions just omit and return
     if( !this->isReactive())
       return false;
 
+
     // goes through all registered filter criterions and looks for matches
     TargetIteratorConst it = this->_filters[type].begin();
     for(; it != this->_filters[type].end(); it++ )
-      if( unlikely(entity.isA(*it)))
+    {
+       PRINTF(0)("size: %i - %s is a %s?\n", this->_filters[type].size(), entity.getClassName().c_str(), (*it).name().c_str());
+      if( entity.isA(*it))
         return true;
+    }
 
     return false;

branches/coll_rect/src/lib/collision_reaction/collision_tube.cc

@@ -27 +27 @@
 #include "cr_physics_full_walk.h"
 
+#include "debug.h"
 
 
@@ -52 +53 @@
   CollisionTube::~CollisionTube ()
   {
+    this->reset();
+  }
+
+
+
+  /**
+   * resets the collision tube after each collision detection cycle
+   */
+  void CollisionTube::reset()
+  {
     this->_collisionList.clear();
+  }
+
+
+  /**
+   * gets the collision object useable for collision events registarations
+   * @param entityA collision partner 1
+   * @param entityB collision partner 2
+   * @return the collision object to be used
+   */
+  Collision* CollisionTube::registerCollision(WorldEntity* entityA, WorldEntity* entityB)
+  {
+    assert( entityA != NULL && entityB != NULL);
+
+    Collision* collision = NULL;
+    if( !this->_collisionList.empty())
+      collision = this->_collisionList.back();
+
+    // check if there is already a collision defined between these objects or this is the first collision at all
+    if( collision == NULL || !collision->same(*entityA, *entityB))
+    {
+      collision = CREngine::getInstance()->popCollisionObject();
+      collision->collide( entityA, entityB);
+      this->_collisionList.push_back(collision);
+    }
+
+    return collision;
   }
 
@@ -67 +104 @@
   void CollisionTube::registerCollisionEvent(WorldEntity* entityA, WorldEntity* entityB, BoundingVolume* bvA, BoundingVolume* bvB)
   {
-    Collision* collision = NULL;
-    if( !this->_collisionList.empty())
-      collision = this->_collisionList.back();
-
-    // check if there is already a collision defined between these objects or this is the first collision at all
-    if( collision == NULL || !collision->match(*entityA, *entityB))
-    {
-      collision = CREngine::getInstance()->popCollisionObject();
-      collision->collide( entityA, entityB);
-    }
+    // first get a useable collision object
+    Collision* collision = this->registerCollision(entityA, entityB);
 
     // now register the new collision event
@@ -95 +124 @@
    */
   void CollisionTube::registerCollisionEvent(CREngine::CollisionType type, WorldEntity* entity, WorldEntity* groundEntity,
-                              const Vector& normal, const Vector& position, bool bInWall)
+      const Vector& normal, const Vector& position, bool bInWall)
   {
-    // get last collision
-    Collision* collision = NULL;
-    if( !this->_collisionList.empty())
-      collision = this->_collisionList.back();
-
-    // check if there is already a collision defined between these objects
-    if( collision == NULL || !collision->match(*entity, *groundEntity))
-    {
-      // get a new collision object
-      collision = CREngine::getInstance()->popCollisionObject();
-      collision->collide( entity, groundEntity);
-    }
+    // first get a useable collision object
+    Collision* collision = this->registerCollision(entity, groundEntity);
 
     // now register the new collision event

branches/coll_rect/src/lib/collision_reaction/collision_tube.h

@@ -70 +70 @@
     void registerCollisionEvent(CREngine::CollisionType type, WorldEntity* entity, WorldEntity* groundEntity,
                                 const Vector& normal, const Vector& position, bool bInWall = false);
+    Collision* registerCollision(WorldEntity* entityA, WorldEntity* entityB);
+
+    void reset();
 
     /** @returns an iterator pointing to the beginning of the list */

branches/coll_rect/src/lib/collision_reaction/cr_engine.cc

@@ -66 +66 @@
       PRINTF(0)("CollisionReaction Error: CollisionEvent cache size missmatch: %i of %i\n", this->collisionEventsUnused.size(), CR_MAX_COLLISION_EVENTS);
 
-    this->flushCollisions();
+    this->reset();
 
     CollisionIterator it1 = this->collisionsUnused.begin();
@@ -121 +121 @@
       return this->collisionsUsed.back();
     }
-    else return NULL;
+    else
+    {
+      PRINTF(0)("There is no Collision Object left in the precache table, fatal error will cause segfault, change CR_MAX_COLLISIONS\n");
+      assert(false);
+      return NULL;
+    }
   }
 
@@ -136 +141 @@
       return this->collisionEventsUsed.back();
     }
-    else return NULL;
+    else
+    {
+      PRINTF(0)("There is no Collision Object left in the precache table, fatal error will cause segfault, change CR_MAX_COLLISION_EVENTS\n");
+      assert(false);
+      return NULL;
+    }
   }
 
@@ -147 +157 @@
     // for all collisions:
     CollisionIterator ci = CollisionTube::getInstance()->begin();
-    for(; ci < CollisionTube::getInstance()->end(); ++ci)
+    for(; ci < CollisionTube::getInstance()->end(); ci++)
     {
       for( int i = CREngine::CR_PHYSICS_MOMENTUM; i < CREngine::CR_NUMBER; i++)
@@ -153 +163 @@
         if( _reactionList[i] == NULL)
           continue;
+
+        assert((*ci)->getEntityA() != NULL && (*ci)->getEntityB() != NULL);
+
+        PRINTF(0)("CR CHECK: collision between: %s, %s\n", (*ci)->getEntityA()->getClassName().c_str(), (*ci)->getEntityB()->getClassName().c_str());
 
         // check if entity A or B is subscibed for this event
@@ -161 +175 @@
           PRINTF(0)("react to %i\n", i);
         }
-
-        (*ci)->reset();
       }
-    }
-
-    this->flushCollisions();
+      (*ci)->reset();
+    }
+
+    this->reset();
   }
 
@@ -173 +186 @@
    * flushes all the collision lists and puts them to their initial state
    */
-  void CREngine::flushCollisions()
+  void CREngine::reset()
   {
     CollisionIterator it1 = this->collisionsUsed.begin();
@@ -185 +198 @@
     this->collisionsUsed.clear();
     this->collisionEventsUsed.clear();
+
+    CollisionTube::getInstance()->reset();
   }
 

branches/coll_rect/src/lib/collision_reaction/cr_engine.h

@@ -73 +73 @@
     inline static CREngine* getInstance() { if (!singletonRef) singletonRef = new CREngine();  return singletonRef; };
 
-
     Collision* popCollisionObject();
     CollisionEvent* popCollisionEventObject();
@@ -86 +85 @@
     void init();
 
-    void flushCollisions();
+    void reset();
 
 

branches/coll_rect/src/lib/graphics/importer/bsp_manager.cc

@@ -1217 +1217 @@
   {
     CoRe::CollisionTube::getInstance()->registerCollisionEvent( CoRe::CREngine::CR_COLLISION_TYPE_AXIS_X ,
-                              this->parent, entity,
+                              entity, this->parent,
                               Vector(testPlane->x, testPlane->y, testPlane->z),
                               collPos,
@@ -1256 +1256 @@
   {
     CoRe::CollisionTube::getInstance()->registerCollisionEvent( CoRe::CREngine::CR_COLLISION_TYPE_AXIS_X_NEG,
-                              this->parent, entity,
+                              entity, this->parent,
                               Vector(testPlane->x, testPlane->y, testPlane->z),
                               collPos,
@@ -1351 +1351 @@
   if( yCollisionUp)
   {
-    CoRe::CollisionTube::getInstance()->registerCollisionEvent( CoRe::CREngine::CR_COLLISION_TYPE_AXIS_Y, this->parent,
-                              entity,
+    CoRe::CollisionTube::getInstance()->registerCollisionEvent( CoRe::CREngine::CR_COLLISION_TYPE_AXIS_Y,
+                              entity, this->parent,
                               Vector(testPlane->x, testPlane->y, testPlane->z),
                               collPos, SolidFlag);
@@ -1404 +1404 @@
   if( yCollisionDown)
   {
-    CoRe::CollisionTube::getInstance()->registerCollisionEvent( CoRe::CREngine::CR_COLLISION_TYPE_AXIS_Y_NEG , this->parent,
-                              entity,
+    CoRe::CollisionTube::getInstance()->registerCollisionEvent( CoRe::CREngine::CR_COLLISION_TYPE_AXIS_Y_NEG ,
+                              entity, this->parent,
                               Vector(testPlane->x, testPlane->y, testPlane->z),
                               collPos, SolidFlag);
@@ -1483 +1483 @@
 
   if( zCollisionRight) {
-    CoRe::CollisionTube::getInstance()->registerCollisionEvent( CoRe::CREngine::CR_COLLISION_TYPE_AXIS_Z , this->parent,
-                              entity,
+    CoRe::CollisionTube::getInstance()->registerCollisionEvent( CoRe::CREngine::CR_COLLISION_TYPE_AXIS_Z ,
+                              entity, this->parent,
                               Vector(testPlane->x, testPlane->y, testPlane->z),
                               collPos , SolidFlag);
@@ -1522 +1522 @@
 
   if( zCollisionLeft) {
-    CoRe::CollisionTube::getInstance()->registerCollisionEvent( CoRe::CREngine::CR_COLLISION_TYPE_AXIS_Z_NEG , this->parent,
-                               entity,
+    CoRe::CollisionTube::getInstance()->registerCollisionEvent( CoRe::CREngine::CR_COLLISION_TYPE_AXIS_Z_NEG ,
+                               entity, this->parent,
                                Vector(testPlane->x, testPlane->y, testPlane->z),
                                collPos , SolidFlag);

branches/coll_rect/src/world_entities/world_entity.h

@@ -92 +92 @@
 
   /** @param worldEntity the world entity to be checked @returns true if there is a collisionreaction registered for the worldEntity */
-  inline bool isReactive( const WorldEntity& worldEntity) const { return this->_collisionFilter.isReactive() || (this->_collisionFilter(worldEntity)); }
+  inline bool isReactive( const WorldEntity& worldEntity) const { return this->_collisionFilter(worldEntity); }
   /** @param worldEntity the world entity to be checked @param type special reaction type @returns true if collision reaction reg. */
   inline bool isReactive( const WorldEntity& worldEntity, const CoRe::CREngine::ReactionType& type) const
-  { return this->_collisionFilter.isReactive() || (this->_collisionFilter(worldEntity, type)); }
+  { return this->_collisionFilter(worldEntity, type); }