Changeset 7945 in orxonox.OLD

Timestamp:

May 29, 2006, 12:48:21 AM (18 years ago)

Author:

patrick

Message:

cr: collision objects handling

Location:

branches/cr/src

Files:

• lib/collision_reaction/collision_handle.cc (modified) (1 diff)
• lib/collision_reaction/collision_handle.h (modified) (1 diff)
• lib/collision_reaction/cr_engine.cc (modified) (4 diffs)
• lib/collision_reaction/cr_engine.h (modified) (2 diffs)
• world_entities/world_entity.cc (modified) (4 diffs)
• world_entities/world_entity.h (modified) (1 diff)

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

@@ -72 +72 @@
 }
 
+/**
+ * flushes the collision list
+ */
+void CollisionHandle::flushCollisions()
+{
+  std::vector<Collision*>::iterator it;
+  for( it = this->collisionList.begin(); it != this->collisionList.end(); it++)
+    CREngine::getInstance()->pushCollisionObject(*it);
+  this->collisionList.clear();
+}
 
+
+/**
+ * handles the collisions and react according to algorithm
+ */
+void CollisionHandle::handleCollisions()
+{
+
+  // collision reaction calculations
+
+  // now set state to dispatched
+  this->bDispatched = true;
+  this->flushCollisions();
+}

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

@@ -20 +20 @@
 
 //! 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 addTarget(long classID);
+    void addTarget(long classID);
 
-  void registerCollision(Collision* collision);
+    void registerCollision(Collision* collision);
 
-  void handleCollisions();
-  void flushCollsions();
+    void handleCollisions();
 
 
- private:
-   WorldEntity*                  owner;                   //!< the worldenity this reaction will be applied on
-   CREngine::CRType              type;                    //!< the reaction type
+  private:
+    void flushCollisions();
 
-   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
 
-   std::vector<Collision*>       collisionList;           //!< a list full of collisions
-   std::vector<long>             targetList;              //!< a list of target classes for filtering
+  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
+
+    std::vector<Collision*>       collisionList;           //!< a list full of collisions
+    std::vector<long>             targetList;              //!< a list of target classes for filtering
 
 };

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

@@ -19 +19 @@
 
 #include "collision.h"
+#include "collision_handle.h"
 #include "cr_defs.h"
 
@@ -51 +52 @@
 }
 
-
+/**
+ * inits the CREngine to a working state
+ */
 void CREngine::init()
 {
@@ -62 +65 @@
 
 void CREngine::reset()
-{}
+{
+  // first clear all CollisionHandles
+  std::vector<CollisionHandle*>::iterator it;
+  for( it = this->collisionHandles.begin(); it != this->collisionHandles.end(); it++)
+    delete *it;
+  this->collisionHandles.clear();
+}
 
 
@@ -72 +81 @@
 CollisionHandle* CREngine::subscribeReaction(WorldEntity* owner, CRType type)
 {
+  CollisionHandle* ch = new CollisionHandle(owner, type);
+  this->collisionHandles.push_back(ch);
+}
 
-}
 
 bool CREngine::unsubscribeReaction(WorldEntity* worldEntity)

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

@@ -41 +41 @@
   inline static CREngine* getInstance() { if (!singletonRef) singletonRef = new CREngine();  return singletonRef; };
 
-  void init();
   void reset();
 
@@ -60 +59 @@
   void debug();
 
+
 private:
   CREngine();
+  void init();
 
 

branches/cr/src/world_entities/world_entity.cc

@@ -33 +33 @@
 
 #include "collision_handle.h"
+#include "collision.h"
 
 #include <stdarg.h>
@@ -68 +69 @@
   this->objectListNumber = OM_INIT;
   this->objectListIterator = NULL;
+
+  // reset all collision handles to NULL == unsubscribed state
+  for(int i = 0; i < CREngine::CR_NUMBER; ++i)
+    this->collisionHandles[i] = NULL;
 
   this->toList(OM_NULL);
@@ -242 +247 @@
 void WorldEntity::subscribeReaction(CREngine::CRType type, int nrOfTargets, long target...)
 {
+  if( this->collisionHandles[type] != NULL)  {
+    PRINTF(2)("Registering for a CollisionReaction already subscribed to! Skipping\n");
+    return;
+  }
 
   this->collisionHandles[type] = CREngine::getInstance()->subscribeReaction(this, type);
@@ -257 +266 @@
  *  @param collisionEvent the event
  */
-void WorldEntity::registerCollision(WorldEntity* entityA, WorldEntity* entityB, BouningVolume* bvA, BoundingVolume* bvB)
+bool WorldEntity::registerCollision(WorldEntity* entityA, WorldEntity* entityB, BoundingVolume* bvA, BoundingVolume* bvB)
 {
   // create a collision event

branches/cr/src/world_entities/world_entity.h

@@ -71 +71 @@
   /* --- Collision Reaction Block --- */
   void subscribeReaction(CREngine::CRType type, int nrOfTargets, long target, ...);
-  void registerCollision(WorldEntity* entityA, WorldEntity* entityB, BoundingVolume* bvA, BoundingVolume* bvB);
+  bool registerCollision(WorldEntity* entityA, WorldEntity* entityB, BoundingVolume* bvA, BoundingVolume* bvB);