Changeset 9892 in orxonox.OLD for branches/coll_rect/src/lib

Timestamp:

Oct 14, 2006, 1:25:47 AM (18 years ago)

Author:

patrick

Message:

new interface to collision registers, more transparent. some more functionality

Location:

branches/coll_rect/src/lib/collision_reaction

Files:

• collision.h (modified) (1 diff)
• collision_event.h (modified) (2 diffs)
• collision_handle.cc (modified) (1 diff)
• collision_handle.h (modified) (3 diffs)
• collision_tube.cc (modified) (2 diffs)
• collision_tube.h (modified) (3 diffs)
• cr_defs.h (modified) (1 diff)
• cr_engine.cc (modified) (2 diffs)
• cr_engine.h (modified) (2 diffs)
• cr_physics_full_walk.cc (modified) (1 diff)

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

@@ -53 +53 @@
 
 
-    inline bool match(const WorldEntity& entityA, WorldEntity& entityB) const { return (this->entityA == &entityA && this->entityB == &entityB); }
+    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; }

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

@@ -14 +14 @@
 
 #include "vector.h"
+#include "cr_engine.h"
 
 #include "cr_defs.h"
@@ -33 +34 @@
 
     /** collides two WorldEntities @param entityA world entity A, @param entityB world entity B, @param bvA volume A @param bvB volumeB */
-    inline void collide(int type, WorldEntity* entityA, WorldEntity* entityB, BoundingVolume* bvA, BoundingVolume* bvB)
+    inline void collide(CREngine::CollisionType type, WorldEntity* entityA, WorldEntity* entityB, BoundingVolume* bvA, BoundingVolume* bvB)
     { this->collisionType = type; this->entityA = entityA; this->entityB = entityB; this->bvA = bvA; this->bvB = bvB; }
     /** collides two WorldEntities @param entity world entity , @param ground ground plane, @param position position on the ground */
-    inline void collide(int type, WorldEntity* entity, WorldEntity* groundEntity, Vector normal, Vector position, bool bInWall)
+    inline void collide(CREngine::CollisionType type, WorldEntity* entity, WorldEntity* groundEntity, Vector normal, Vector position, bool bInWall)
     {
       this->collisionType = type;

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

@@ -38 +38 @@
    * @todo this constructor is not jet implemented - do it
   */
-  CollisionHandle::CollisionHandle (WorldEntity* owner, CREngine::CRType type)
+  CollisionHandle::CollisionHandle (WorldEntity* owner, CREngine::ReactionType type)
   {
     this->registerObject(this, CollisionHandle::_objectList);

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

@@ -30 +30 @@
 
   public:
-    CollisionHandle(WorldEntity* owner, CREngine::CRType type);
+    CollisionHandle(WorldEntity* owner, CREngine::ReactionType type);
     virtual ~CollisionHandle();
 
@@ -47 +47 @@
     inline bool isContinuousPoll() const { return this->bContinuousPoll; }
     /** @returns the type */
-    inline CREngine::CRType getType() const { return this->type; }
+    inline CREngine::ReactionType getType() const { return this->type; }
 
     void handleCollisions();
@@ -61 +61 @@
   private:
     WorldEntity*                  owner;                   //!< the worldenity this reaction will be applied on
-    CREngine::CRType              type;                    //!< the reaction type
+    CREngine::ReactionType              type;                    //!< the reaction type
 
     bool                          bContinuousPoll;         //!< if this is true

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

@@ -40 +40 @@
   CollisionTube::CollisionTube ()
   {
-
+    this->registerObject(this, CollisionTube::_objectList);
   }
 
@@ -65 +65 @@
   {
     Collision* collision = this->_collisionList.back();
+
+    // check if there is already a collision defined between these objects
     if( collision->match(*entityA, *entityB))
-    {}
+    {
+      CollisionEvent* collisionEvent = CREngine::getInstance()->popCollisionEventObject();
+      collisionEvent->collide( CREngine::CR_COLLISION_TYPE_OBB, entityA, entityB, bvA, bvB);
+      collision->registerCollisionEvent( collisionEvent);
+    }
   }
 

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

@@ -3 +3 @@
  *
  * collision tube collects all collisions from all entities
+ *
+ *  The collision events are saved in the _collisionList vector in a fixed hirarchy: a collision is defined by the world entities
+ *  that collide. For each collision there is an entry in _collisionList. Each collision itself again contains collision events which are
+ *  defined as collisions between the boundibg volumes (BV) of the world entities. This could look like this:
+ *
+ *  - Collision (WorldEntity_i  <=> WorldEntity_j)
+ *     +- CollisionEvent( some BV <=> some other BV)
+ *     +- CollisionEvent( some BV <=> some other BV)
+ *  - Collision (WorldEntity_k <=> WorldEntity_l)
+ *     +- CollisionEvent( some BV <=> some other BV)
+ *     +- CollisionEvent( some BV <=> some other BV)
+ *     +- CollisionEvent( some BV <=> some other BV)
+ *     +- CollisionEvent( some BV <=> some other BV)
+ *  - ... etc ...
+ *
+ *
+ *  When the collisions are processed by the handleCollision() function each collision pair is checked for their reactions (since each
+ *  WorldEntity can define several reactions to a collision). After all the reactions are calculated and applied the collision object is
+ *  put back.
  */
 
@@ -24 +43 @@
   class CollisionReaction;
 
-  //! A class for defining collision reactions and storing events
+  //! A class containing all CollisionEvents (structured as defined in the file doxygen tags)
   class CollisionTube : public BaseObject
   {
@@ -32 +51 @@
   public:
     CollisionTube();
-    ~CollisionTube();
+    virtual ~CollisionTube();
 
     /** @returns true if at least one of both WorldEntities are subscribed for a collision check */

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

@@ -38 +38 @@
 #define COLLISION_TYPE_AXIS_Z_NEG  6
 //!< the collision is a obb collision
-#define COLLISION_TYPE_OBB      8
+#define COLLISION_TYPE_OBB         8
 
 

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

@@ -89 +89 @@
 
   /**
+   * @returns an instance to a collision object. instead of creating new object this ones can be resycled
+   */
+  Collision* CREngine::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
+   */
+  CollisionEvent* CREngine::popCollisionEventObject()
+  {
+    if( !this->collisionEventsUnused.empty())
+    {
+      this->collisionEventsUsed.push_back(this->collisionEventsUnused.back());
+      this->collisionEventsUnused.pop_back();
+      return this->collisionEventsUsed.back();
+    }
+    else return NULL;
+  }
+
+
+  /**
    * flushes the CollisionHandles and restores the CREngine to the initial state
    */
@@ -112 +141 @@
    *  @return the newly created CollisionHandle
    */
-  CollisionHandle* CREngine::subscribeReaction(WorldEntity* owner, CRType type)
+  CollisionHandle* CREngine::subscribeReaction(WorldEntity* owner, ReactionType type)
   {
     CollisionHandle* ch = new CollisionHandle(owner, type);

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

@@ -31 +31 @@
 
   public:
-    typedef enum CRType {
-      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_WALK,       //!< physical reaction: stand on the ground, no movement: simulating simple normal force away from the gravity force
-      CR_PHYSICS_FULL_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
+    typedef enum ReactionType {
+      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_WALK,              //!< physical reaction: stand on the ground, no movement: simple normal force away from the gravity force
+      CR_PHYSICS_FULL_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,             //!< 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_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,              //!< vertex trafo: transforming the vertex according to the damage
+      CR_VERTEX_TRAFO,                     //!< vertex trafo: transforming the vertex according to the damage
 
-      CR_SPECIAL_CALLBACK,          //!< special: call a callback function
+      CR_SPECIAL_CALLBACK,                 //!< special: call a callback function
 
       CR_NUMBER
     };
+
+    typedef enum CollisionType {
+      CR_COLLISION_TYPE_AXIS_X       = 0,  //!< collision on x axis
+      CR_COLLISION_TYPE_AXIS_X_NEG,        //!< collision on negative x axis
+      CR_COLLISION_TYPE_AXIS_Y,            //!< collision on y axis
+      CR_COLLISION_TYPE_AXIS_Y_NEG,        //!< collision on negative y axis
+      CR_COLLISION_TYPE_AXIS_Z,            //!< collision on z axis
+      CR_COLLISION_TYPE_AXIS_Z_NEG,        //!< collision on negative z axis
+      CR_COLLISION_TYPE_OBB,               //!< object aligned bounding box collide
+
+      CR_COLLISION_TYPE_NUMBER
+    };
+
+
+#define COLLISION_TYPE_AXIS_X      1
+#define COLLISION_TYPE_AXIS_X_NEG  2
+//!< the collision axis y collision event
+#define COLLISION_TYPE_AXIS_Y      3
+#define COLLISION_TYPE_AXIS_Y_NEG  4
+//!< the collision axis z collision event
+#define COLLISION_TYPE_AXIS_Z      5
+#define COLLISION_TYPE_AXIS_Z_NEG  6
+//!< the collision is a obb collision
+#define COLLISION_TYPE_OBB         8
 
     virtual ~CREngine(void);
@@ -53 +77 @@
     inline static CREngine* getInstance() { if (!singletonRef) singletonRef = new CREngine();  return singletonRef; };
 
+    CollisionHandle* subscribeReaction(WorldEntity* worldEntity, ReactionType type);
+    bool unsubscribeReaction(CollisionHandle* collisionHandle);
+
+
+    Collision* popCollisionObject();
+    CollisionEvent* popCollisionEventObject();
     void reset();
 
-
-    CollisionHandle* subscribeReaction(WorldEntity* worldEntity, CRType type);
-
-    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* 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();

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

@@ -72 +72 @@
 
     float CR_MAX_WALK_HEIGHT = 15.0f;
-    float CR_THRESHOLD = 0.2f;
+//    float CR_THRESHOLD = 0.2f;
 
     float height = 0.0f;