Changeset 9939 in orxonox.OLD for branches/coll_rect

Timestamp:

Nov 20, 2006, 12:53:27 AM (18 years ago)

Author:

patrick

Message:

removed some comilation problems.

Location:

branches/coll_rect/src

Files:

• lib/collision_detection/obb_tree_node.cc (modified) (1 diff)
• lib/collision_reaction/collision.h (modified) (4 diffs)
• lib/collision_reaction/collision_filter.cc (modified) (6 diffs)
• lib/collision_reaction/collision_filter.h (modified) (2 diffs)
• lib/collision_reaction/collision_tube.cc (modified) (2 diffs)
• lib/collision_reaction/collision_tube.h (modified) (1 diff)
• world_entities/world_entity.h (modified) (2 diffs)

branches/coll_rect/src/lib/collision_detection/obb_tree_node.cc

@@ -477 +477 @@
 {
   if( unlikely(treeNode == NULL || nodeA == NULL || nodeB == NULL))
+    return;
+
+  if( !CoRe::CollisionTube::getInstance()->isReactive( *nodeA, *nodeB) )
     return;
 

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

@@ -32 +32 @@
   {
   public:
+
     Collision();
     virtual ~Collision();
@@ -39 +40 @@
 
 
+    /* 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  const_iterator;   //!< constant iterator definition
+
+    /** registers a @param event CollisionEvent to take place */
+    inline void registerCollisionEvent(CollisionEvent* event) { this->_collisionEvents.push_back(event); this->bDispatched = false;}
+    /** @returns a vector of collision events */
+    inline const std::vector<CollisionEvent*>& getCollisionEvents() const { return this->_collisionEvents; }
+
+    void flushCollisionEvents();
+
+
+    /** @returns iterator pointing to the beginning of the collision event vector */
+    inline iterator       begin()        { return this->_collisionEvents.begin(); }
+    /** @returns const iterator pointing to the beginning of the collision event vector */
+    inline const_iterator begin() const  { return this->_collisionEvents.begin(); }
+    /** @returns iterator pointing to the end of the collision event vector */
+    inline iterator       end()          { return this->_collisionEvents.end(); }
+    /** @returns const iterator pointing to the end of the collision event vector */
+    inline const_iterator end() const    { return this->_collisionEvents.end(); }
+
+
+  private:
+    collisionVector  _collisionEvents;               //!< the collision event list
+
+
+
+    /* misc interface functions */
+  public:
     /** @return Collision WorldEntity A */
     inline WorldEntity* getEntityA() const { return this->entityA; }
     /** @return Collision WorldEntity B */
     inline WorldEntity* getEntityB() const { return this->entityB; }
+    inline bool match(const WorldEntity& entityA, WorldEntity& entityB) const {
+      return ((this->entityA == &entityA && this->entityB == &entityB) || (this->entityA == &entityB && this->entityB == &entityA)); }
+
     /** @return true if Entity A collides */
     inline bool isEntityACollide() const { return this->entityACollide; }
@@ -53 +88 @@
 
 
-    inline bool match(const WorldEntity& entityA, WorldEntity& entityB) const {
-      return ((this->entityA == &entityA && this->entityB == &entityB) || (this->entityA == &entityB && this->entityB == &entityA)); }
+
     /** @returns true if this Collision has already been dispatched */
     inline bool isDispatched() { return this->bDispatched; }
     /** sets the dispatched flag to true */
     inline void dispatched() { this->bDispatched = true; }
-
-    /** registers a @param event CollisionEvent to take place */
-    inline void registerCollisionEvent(CollisionEvent* event) { this->collisionEvents.push_back(event); this->bDispatched = false;}
-    /** @returns a vector of collision events */
-    inline const std::vector<CollisionEvent*>& getCollisionEvents() const { return this->collisionEvents; }
-
-
-    void flushCollisionEvents();
-
 
   private:
@@ -77 +102 @@
     bool                         bDispatched;                   //!< true if this collision has already been dispatched
 
-    std::vector<CollisionEvent*> collisionEvents;               //!< the collision event list
   };
 }

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

@@ -70 +70 @@
     if( likely(this->validCRType( type)))
     {
-      //check if this or any parent class isn't already registered
+      //check if this class isn't already registered
       std::vector<ClassID>::iterator it = this->_filters[type].begin();
       for(; it != this->_filters[type].end(); it++)
@@ -78 +78 @@
       }
 
-      // so subscribe the reaction finaly
+      // so subscribe the reaction finally
       this->_filters[type].push_back(target1);
       this->_bReactive = true;
@@ -132 +132 @@
    * if the WorldEntity entity is actualy responsive for a certain other WorldEntity
    */
-  bool CollisionFilter::operator()(const WorldEntity* entity) const
+  bool CollisionFilter::operator()(const WorldEntity& entity) const
   {
     // if there are no installed criterions just ommit and
@@ -143 +143 @@
       std::vector<ClassID>::const_iterator it = this->_filters[i].begin();
       for(; it != this->_filters[i].end(); i++ )
-        if( unlikely(entity->isA(*it)))
+        if( unlikely(entity.isA(*it)))
           return true;
     }
@@ -158 +158 @@
   * if the WorldEntity entity is actualy responsive for a certain other WorldEntity
    */
-  bool CollisionFilter::operator()(const WorldEntity* entity, const CREngine::ReactionType type) const
+  bool CollisionFilter::operator()(const WorldEntity& entity, const CREngine::ReactionType type) const
   {
     // if there are no installed criterions just ommit and
@@ -166 +166 @@
     // goes through all registered filter criterions and looks for matches
     std::vector<ClassID>::const_iterator it = this->_filters[type].begin();
-    for(; it != this->_filters[type].end(); i++ )
-      if( unlikely(entity->isA(*it)))
+    for(; it != this->_filters[type].end(); it++ )
+      if( unlikely(entity.isA(*it)))
         return true;
 

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

@@ -46 +46 @@
 
 
+  public:
     /* Defines Operators */
-    bool operator()(const WorldEntity* entity) const;
-    bool operator()(const WorldEntity* entity, const CREngine::ReactionType type) const;
+    bool operator()(const WorldEntity& entity) const;
+    bool operator()(const WorldEntity& entity, const CREngine::ReactionType type) const;
 
 
@@ -59 +60 @@
     void unsubscribeReaction(CREngine::ReactionType type);
     void unsubscribeReactions();
+
+    inline bool isSubscribed(CREngine::ReactionType type) const { /*if( this->validCRType(type)) return this->_filters[type] != NULL; else return false;*/}
 
   private:

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

@@ -95 +95 @@
                               const Vector& normal, const Vector& position, bool bInWall)
   {
+    // get last collision
     Collision* collision = this->_collisionList.back();
 
     // check if there is already a collision defined between these objects
-    if( !collision->match(*entity, *groundEntity))
+    if( collision != NULL && !collision->match(*entity, *groundEntity))
     {
+      // get a new collision object
       collision = CREngine::getInstance()->popCollisionObject();
       collision->collide( entity, groundEntity);
@@ -117 +119 @@
   void CollisionTube::handleCollisions()
   {
-    //
+    // for all collisions:
+    std::vector<Collision*>::iterator collisions = this->_collisionList.begin();
+    for(; collisions < this->_collisionList.end(); collisions++)
+    {
+
+
+      // for all collision events of each collision:
+      Collision::iterator events = (*collisions)->begin();
+      for(; events < (*collisions)->end(); events++)
+      {
+
+      }
+    }
   }
 
 
-  /**
-   * checks if two objects are
-   */
-  bool CollisionTube::needCollisionChecking(const WorldEntity& entityA, const WorldEntity& entityB)
-  {
-    //if( !this->isReactive( entityA, entityB) )
-    //  return false;
 
-    //if( entityA->)
-
-  }
 
 

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

@@ -75 +75 @@
     /* Misc State Informations */
   public:
-    /** @returns true if at least one of both WorldEntities are subscribed for a collision check */
+    /** @returns true if at least one of both WorldEntities are subscribed for a collision reaction */
     inline bool isReactive(const WorldEntity& entityA, const WorldEntity& entityB) const
-      { return (entityA.isReactive() && entityB.isReactive()); }
-    bool needCollisionChecking(const WorldEntity& entityA, const WorldEntity& entityB);
+      { return (entityA.isReactive(entityB) && entityB.isReactive(entityA)); }
 
   };

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; }
-
-  const CoRe::CollisionFilter& getCollisionFilter(CoRe::CREngine::ReactionType type) const { return this->collisionFilter; }
+  inline bool isReactive( const WorldEntity& worldEntity) const { return this->isReactive() || (this->_collisionFilter(worldEntity)); }
+
+  const CoRe::CollisionFilter& getCollisionFilter(CoRe::CREngine::ReactionType type) const { return this->_collisionFilter; }
 
   /** @returns true if this entity is standing on ground (BSP model) */
@@ -191 +194 @@
 
   /* collision reaction stuff */
-  CoRe::CollisionFilter   collisionFilter;                 //!< filter for collision event filtering (not every entity listens to all collisions)
+  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