include/vrfmodel/collisionDetector.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2004 MAK Technologies, Inc.
** All rights reserved.
*******************************************************************************/
/*******************************************************************************
** $RCSfile: collisionDetector.h,v $ $Revision: 1.16 $ $State: Exp $
*******************************************************************************/




#ifndef collisionDetector_H_
#define collisionDetector_H_

#include "vrfmodel/vrfmodelDefines.h"
#include "vrfobjcore/simCmpnt.h"
#include "vrfobjcore/vrfObjMgr.h"
#include "vrfobjcore/vectorObstruction.h"
#include "vrfobjcore/entityCollision.h"
#include "vrfobjcore/vectorObstructionCollision.h"
#include "vrfobjcore/vectorObstructionID.h"
#include "vlutil/vlSmartPointers.h"

#include <list>
#include <set>
#include <vector>

class DtCollision;
class DtString;
class DtSimManager;
class Dt3dBoundingVolume;
class DtObjectType;

template <typename T_Collision>
class DtCollisionProcessor
{
public:
   DtCollisionProcessor() {};
   virtual ~DtCollisionProcessor() {};

   virtual void processCollision(const T_Collision& collision) = 0;
};

class DT_DLL_vrfmodel DtCollisionDetector
{
public:
   
   typedef std::set<DtObjectType> DtObjectObstructionIDContainer;
   typedef DtObjectObstructionIDContainer::iterator DtObjectObstructionIDIter;
   typedef DtObjectObstructionIDContainer::const_iterator DtObjectObstructionIDConstIter;
   
   typedef std::list<DtVectorObstructionID> DtVectorObstructionIDContainer;
   typedef DtVectorObstructionIDContainer::iterator DtVectorObstructionIDIter;
   typedef DtVectorObstructionIDContainer::const_iterator DtVectorObstructionIDConstIter;
      
   typedef std::set<DtVrfObject*> DtObjectObstructionContainer;
   typedef DtObjectObstructionContainer::iterator DtObjectObstructionIter;
   typedef DtObjectObstructionContainer::const_iterator DtObjectObstructionConstIter;

   typedef std::set<DtVectorObstruction*> DtVectorObstructionContainer;
   typedef DtVectorObstructionContainer::iterator DtVectorObstructionIter;
   typedef DtVectorObstructionContainer::const_iterator DtVectorObstructionConstIter;


   DtCollisionDetector(DtSimManager* simManager);

   virtual ~DtCollisionDetector();

private:
   DtCollisionDetector(const DtCollisionDetector& orig);

   DtCollisionDetector& operator=(const DtCollisionDetector& orig);

public:

   virtual void setObjectToIgnore(DtVrfObject* vrfObject);

   virtual void addObjectObstructionID(const DtObjectType& objectObstructionID);
   virtual void addVectorObstructionID(const DtVectorObstructionID& vectorObstructionIDs);

   virtual void removeObjectObstructionID(const DtObjectType& objectObstructionID);
   virtual void removeVectorObstructionID(const DtVectorObstructionID& vectorObstructionID);
  
   virtual void setObjectObstructionIDs(const DtObjectObstructionIDContainer& objectIDs);
   virtual void setVectorObstructionIDs(const DtVectorObstructionIDContainer& vectorIDs);

   virtual DtObjectObstructionIDIter objectIDsBegin();
   virtual DtObjectObstructionIDConstIter objectIDsBegin() const;

   virtual DtVectorObstructionIDIter vectorIDsBegin();
   virtual DtVectorObstructionIDConstIter vectorIDsBegin() const;

   virtual DtObjectObstructionIDIter objectIDsEnd();
   virtual DtObjectObstructionIDConstIter objectIDsEnd() const;

   virtual DtVectorObstructionIDIter vectorIDsEnd();
   virtual DtVectorObstructionIDConstIter vectorIDsEnd() const;

   virtual bool detectPotentialCollision(Dt3dBoundingVolume& collisionBv,
      const DtVector& localPosition, const DtDcm& bvOrientation,
      DtCollision*& potentialCollision);

   virtual bool detectAllEntityCollisions(Dt3dBoundingVolume& collisionBv,
      const DtVector& localPosition, const DtDcm& bvOrientation,
      std::list<DtBoost::shared_ptr<DtEntityCollision> >& collisionList);

   virtual bool getObjectObstructions(DtObjectObstructionContainer& objectObstructions) const;
   virtual bool getObjectObstructions(Dt3dBoundingVolume& boundingVolume, 
      const DtVector& bvLocation, const DtDcm& bvOrientation,
      DtObjectObstructionContainer& objectObstructions) const;

   virtual bool vrfObjectObstructionPredicate(const DtVrfObject& vrfObjectToTest) const;


   virtual bool getVectorObstructions(DtVectorObstructionContainer& vectorObstructions) const;
   virtual bool getVectorObstructions(Dt3dBoundingVolume& boundingVolume, 
      const DtVector& bvLocation, const DtDcm& bvOrientation,
      DtVectorObstructionContainer& obstructionsToTest) const;

   virtual bool checkForCollision(Dt3dBoundingVolume& collisionBV, 
      DtCollision& potentialCollision, const DtVector& localPosition,
      const DtDcm& bvOrientation) const;

protected:
   bool detectNewClosestCollision(Dt3dBoundingVolume& collisionBV, DtCollision*& potentialCollision,
      const DtVector& localPosition, const DtDcm& bvOrientation) const;

   bool detectObjectCollision(Dt3dBoundingVolume& collisionBV, 
      DtCollisionProcessor<DtEntityCollision>& collisionProcessor, const DtVector& localPosition, 
      const DtDcm& bvOrientation) const;
   bool detectVectorCollision(Dt3dBoundingVolume& collisionBV, 
      DtCollisionProcessor<DtVectorObstructionCollision>&, const DtVector& localPosition, const DtDcm& bvOrientation) const;

   DtCollision* primaryCollision(DtCollision* firstCollision, DtCollision* secondCollision) const;

   bool testInvariant() const;

protected:
   DtObjectObstructionIDContainer myObjectObstructionIDs;
   DtVectorObstructionIDContainer myVectorObstructionIDs;

   DtSimManager* mySimManager;

   DtVrfObject* myObjectToIgnore;
};

bool DtSameOrAttached(const DtVrfObject* primaryEntity, const DtVrfObject& secondaryEntity);

bool DtWithinDistance(const DtVector& startLocation,
                      const DtVector& endLocation,
                      double offset,
                      double distanceSquared,
                      double& actualDistanceSquared);



template <typename T_Collision>
class DtClosestCollisionProcessor : public DtCollisionProcessor<T_Collision>
{
public:
   DtClosestCollisionProcessor(T_Collision* initialCollision = 0);
   virtual ~DtClosestCollisionProcessor();

   virtual void processCollision(const T_Collision& collision);

   virtual T_Collision* closestCollision();

protected:
   T_Collision* myClosestCollision;
   double myClosestCollisionDistanceSquared;

};

template <typename T_Collision>
class DtAllCollisionProcessor : public DtCollisionProcessor<T_Collision>
{
public:
   typedef std::list<DtBoost::shared_ptr<T_Collision> > DtCollisionList;

   DtAllCollisionProcessor(DtCollisionList& collisionList);
   virtual ~DtAllCollisionProcessor();

   virtual void processCollision(const T_Collision& collision);

protected:
   DtCollisionList& myCollisionList;
};

#define callbackList_inl_
#include "vrfmodel/collisionDetector.inl"
#undef  callbackList_inl_

#endif