Changeset 9988 in orxonox.OLD

Timestamp:

Dec 3, 2006, 4:55:19 PM (17 years ago)

Author:

patrick

Message:

removed most of the compiler bugs. more to come

Location:

branches/coll_rect/src

Files:

• lib/collision_reaction/collision.h (modified) (3 diffs)
• lib/collision_reaction/collision_filter.cc (modified) (6 diffs)
• lib/collision_reaction/collision_filter.h (modified) (2 diffs)
• lib/collision_reaction/collision_tube.h (modified) (3 diffs)
• lib/collision_reaction/cr_engine.cc (modified) (3 diffs)
• lib/collision_reaction/cr_engine.h (modified) (2 diffs)
• lib/collision_reaction/cr_object_damage.cc (modified) (1 diff)
• lib/collision_reaction/cr_physics_ground_walk.cc (modified) (1 diff)
• world_entities/world_entity.cc (modified) (1 diff)
• world_entities/world_entity.h (modified) (3 diffs)

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

@@ -31 +31 @@
   class Collision
   {
+
+    typedef std::vector<CollisionEvent*>                  CollisionVector;  //!< the vector containing all collision events
+    typedef std::vector<CollisionEvent*>::iterator        Iterator;         //!< iterator definition
+    typedef std::vector<CollisionEvent*>::const_iterator  ConstIterator;   //!< constant iterator definition
+
+
   public:
 
@@ -37 +43 @@
 
     /** collides two WorldEntities @param entityA world entity A, @param entityB world entity B, @param bvA volume A @param bvB volumeB */
-    inline void collide(WorldEntity* entityA, WorldEntity* entityB) { this->entityA = entityA; this->entityB = entityB; this->bDispatched = false; }
+    inline void collide(WorldEntity* entityA, WorldEntity* entityB) { this->_entityA = entityA; this->_entityB = entityB; }
 
 
     /* list stuff */
   public:
-    typedef std::vector<CollisionEvent*>                  CollisionVector;  //!< the vector containing all collision events
-    typedef std::vector<CollisionEvent*>::iterator        Iterator;         //!< iterator definition
-    typedef std::vector<CollisionEvent*>::const_iterator  ConstIterator;   //!< constant iterator definition
 
     /** registers a @param event CollisionEvent to take place */
-    inline void registerCollisionEvent(CollisionEvent* event) { this->_collisionEvents.push_back(event); this->bDispatched = false;}
+    inline void registerCollisionEvent(CollisionEvent* event) { this->_collisionEvents.push_back(event); }
 
     void reset();
@@ -87 +90 @@
     bool                         _entityBCollide;                //!< true if entity B is subscribed for collision reaction
 
-    collisionVector              _collisionEvents;               //!< the collision event list
+    CollisionVector              _collisionEvents;               //!< the collision event list
 
   };

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

@@ -21 +21 @@
 #include "collision.h"
 #include "collision_event.h"
-#include "collision_reaction.h"
 
-#include "cr_object_damage.h"
-#include "cr_physics_ground_walk.h"
-#include "cr_physics_full_walk.h"
 
 #include "debug.h"
@@ -112 +108 @@
     if( likely(this->validCRType( type)))
       this->_filters[type].clear();
+
+    for( int i = 0; i < CREngine::CR_NUMBER; i++)
+    {
+      if( this->_filters[i].size() > 0)
+      {
+        this->_bReactive = true;
+        break;
+      }
+    }
+
   }
 
@@ -121 +127 @@
     for(int i = 0; i < CREngine::CR_NUMBER; i++)
       this->_filters[i].clear();
+
+    this->_bReactive = false;
   }
 
@@ -135 +143 @@
   {
     // if there are no installed criterions just ommit and
-    if( this->bReactive())
+    if( this->isReactive())
       return false;
 
@@ -142 +150 @@
     {
       TargetIterator it = this->_filters[i].begin();
-      for(; it != this->_filters[i].end(); i++ )
-        if( unlikely(entity.isA(*it)))
-          return true;
+
+
+//       for(; it != this->_filters[i].end(); i++ )
+//         if( unlikely(entity.isA(*it) ) )
+//           return true;
     }
 
@@ -161 +171 @@
   {
     // if there are no installed criterions just omit and return
-    if( !this->bReactive())
+    if( !this->isReactive())
       return false;
 

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

@@ -63 +63 @@
     void unsubscribeReactions();
 
-    inline bool isSubscribed(CREngine::ReactionType type) const { /*if( this->validCRType(type)) return this->_filters[type] != NULL; else return false;*/}
-
   private:
     std::vector<ClassID>          _filters[CREngine::CR_NUMBER];  //!< an array of filter targets: for each collision type a list of filter objects
@@ -72 +70 @@
   public:
     /** @returns true if this handle should be pulled also if there are no collisions, can also be set with this function (reference)*/
-    inline bool& bContinousPoll() { return this->_bContinuousPoll; }
+    inline bool isContinousPoll() { return this->_bContinuousPoll; }
     /** @returns true if this filter should be pulled always */
-    inline bool bContinousPoll() const { return this->_bContinuousPoll; }
+    inline bool isContinousPoll() const { return this->_bContinuousPoll; }
+    /** @returns true if this filter is reactive i.e. at least one filter criterion installed */
+    inline bool isReactive() const { return this->_bReactive; }
+
+
+  private:
     /** @returns true if this @param type Collision Reaction type is a valid number */
     inline bool validCRType(const CREngine::ReactionType& type) const {return (type >= 0 && type < CREngine::CR_NUMBER); }
-    /** @returns true if this filter is reactive i.e. at least one filter criterion installed */
-    inline bool bReactive() const { return this->_bReactive; }
+
 
   private:

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

@@ -49 +49 @@
 
     typedef std::vector<Collision*>::iterator     CollisionIterator;
+    typedef std::vector<Collision*>               CollisionVector;
+
 
     /* Constructor/Deconstructor/Singleton Interface */
@@ -59 +61 @@
     CollisionTube(const CollisionTube& tube) {}
 
-    static CollisionTube*          instance;            //!< the singleton instance
+    static CollisionTube*          instance;                         //!< the singleton instance
 
 
@@ -69 +71 @@
 
     /** @returns an iterator pointing to the beginning of the list */
-    CollisionIterator& begin() { return this->_collisionList.begin(); }
+    CollisionIterator begin() { return this->_collisionList.begin(); }
     /** @returns an iterator pointing to the end of the list */
-    CollisionIterator& end()   { return this->_collisionList.end(); }
+    CollisionIterator end()   { return this->_collisionList.end(); }
 
 
   private:
-    std::vector<Collision*>         _collisionList;                      //!< the list of collisions since the last processing
+    CollisionVector             _collisionList;                      //!< the list of collisions since the last processing
 
 

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

@@ -17 +17 @@
 
 
+#include "cr_object_damage.h"
+#include "cr_physics_full_walk.h"
+#include "cr_physics_ground_walk.h"
 
 #include "collision.h"
 #include "collision_event.h"
 #include "collision_filter.h"
+#include "collision_tube.h"
 #include "cr_defs.h"
 
@@ -62 +66 @@
       PRINTF(0)("CollisionReaction Error: CollisionEvent cache size missmatch: %i of %i\n", this->collisionEventsUnused.size(), CR_MAX_COLLISION_EVENTS);
 
-    this->reset();
     this->flushCollisions();
 
-    CollisionList it1 = this->collisionsUnused.begin();
+    CollisionIterator it1 = this->collisionsUnused.begin();
     for(; it1 < this->collisionsUnused.end(); it1++)
       delete *it1;
-    CollisionEventList it2 = this->collisionEventsUnused.begin();
+    CollisionEventIterator it2 = this->collisionEventsUnused.begin();
     for(; it2 < this->collisionEventsUnused.end(); it2++)
       delete *it2;
@@ -146 +149 @@
     for(; ci < CollisionTube::getInstance()->end(); ++ci)
     {
-      for( int i = CREngine::CR_PHYSICS_MOMENTUM; i < CREngine::CR_NUBER; i++)
+      for( int i = CREngine::CR_PHYSICS_MOMENTUM; i < CREngine::CR_NUMBER; i++)
       {
         // check if entity A or B is subscibed for this event
-        if( (*ci)->getEntityA()->bReactibe((*it)->getEnityB(), i) || (*ci)->getEntityB()->bReactibe((*it)->getEnityA(), i))
-          (*ci)->reactToCollision(*ci);
+        if( (*ci)->getEntityA()->isReactive(*(*ci)->getEntityB(), (CREngine::ReactionType)i) ||
+            (*ci)->getEntityB()->isReactive(*(*ci)->getEntityA(), (CREngine::ReactionType)i))
+          this->_reactionList[i]->reactToCollision(*ci);
 
         (*ci)->reset();

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

@@ -31 +31 @@
     ObjectListDeclaration(CREngine);
 
+    typedef std::vector<CollisionEvent*>             CollisionEventVector;
+    typedef std::vector<Collision*>                  CollisionVector;
     typedef std::vector<Collision*>::iterator        CollisionIterator;
     typedef std::vector<CollisionEvent*>::iterator   CollisionEventIterator;
@@ -90 +92 @@
     static CREngine*                    singletonRef;             //!< the reference to the CREngine object (singleton)
 
-    std::vector<Collision*>             collisionsUsed;           //!< a list of used, cached collisions
-    std::vector<Collision*>             collisionsUnused;         //!< a list of unused, cached collisions
+    CollisionVector                     collisionsUsed;           //!< a list of used, cached collisions
+    CollisionVector                     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
+    CollisionEventVector                collisionEventsUsed;      //!< a list of used, cached collision events
+    CollisionEventVector                collisionEventsUnused;    //!< a list of unused, cached collision events
 
     CollisionReaction*                  _reactionList[CREngine::CR_NUMBER];  //!< the collision reaction list containing all reactions types

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

@@ -74 +74 @@
     }
 
-    collision->flushCollisionEvents();
-    collision->dispatched();
-
     //   const std::vector<CollisionEvent*>* collisionEvents = &(collision->getCollisionEvents());
     //   std::vector<CollisionEvent*>::const_iterator it = collisionEvents->begin();

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

@@ -79 +79 @@
 
 
-    const std::vector<CollisionEvent*>* collisionEvents = &(collision->getCollisionEvents());
-    std::vector<CollisionEvent*>::const_iterator it = collisionEvents->begin();
-    for(; it != collisionEvents->end(); it++)
+    std::vector<CollisionEvent*>::const_iterator it = collision->begin();
+    for(; it != collision->end(); it++)
     {
 

branches/coll_rect/src/world_entities/world_entity.cc

@@ -77 +77 @@
   this->lastObjectListNumber = OM_INIT;
 
-  // reset all collision handles to NULL == unsubscribed state
-  this->bReactive = false;
-  this->bOnGround = false;
+  this->_bOnGround = false;
 
   // registering default reactions:

branches/coll_rect/src/world_entities/world_entity.h

@@ -88 +88 @@
   void unsubscribeReactions();
 
-  inline bool isSubscribed(CoRe::CREngine::ReactionType type) const { return this->_collisionFilter.isSubscribed( type); }
-
   /** @return true if there is at least on collision reaction subscribed */
-  inline bool isReactive() const { return this->bReactive; }
+  inline bool isReactive() const { return this->_collisionFilter.isReactive(); }
 
   /** @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->isReactive() || (this->_collisionFilter(worldEntity)); }
+  inline bool isReactive( const WorldEntity& worldEntity) const { return this->_collisionFilter.isReactive() || (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, CoRe::CREngine::ReactionType type) const
-  { return this->isReactive() || (this->_collisionFilter(worldEntity, type)); }
+  inline bool isReactive( const WorldEntity& worldEntity, const CoRe::CREngine::ReactionType& type) const
+  { return this->_collisionFilter.isReactive() || (this->_collisionFilter(worldEntity, type)); }
 
 
@@ -103 +101 @@
 
   /** @returns true if this entity is standing on ground (BSP model) */
-  bool isOnGround() const { return this->bOnGround; }
+  bool isOnGround() const { return this->_bOnGround; }
   /** @param flag: marks if this entity is standing on ground */
-  void setOnGround(bool flag) { this->bOnGround = flag; }
+  void setOnGround(bool flag) { this->_bOnGround = flag; }
 
   virtual void destroy( WorldEntity* killer );
@@ -201 +199 @@
   /* collision reaction stuff */
   CoRe::CollisionFilter   _collisionFilter;                //!< filter for collision event filtering (not every entity listens to all collisions)
-  bool                    bReactive;                       //!< true if there is at least one collision reaction subscibed
-
+  bool                    _bOnGround;                      //!< flag true if the object is on the ground
 
   PhysicsInterface        physicsInterface;                //!< the physics object of the WorldEntity
-  bool                    bOnGround;                       //!< true if this entity is standing on the ground
 
   /* network help structures */