collisionDetector.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2004 MAK Technologies, Inc.
** All rights reserved.
*******************************************************************************/




#pragma once

#include "vrfmodel/vrfmodelDefines.h"
#include "vrfobjcore/simComponent.h"
#include "vrfobjcore/vrfObjectManager.h"
#include "vrfobjcore/entityCollision.h"
#include "vrfobjcore/featureCollision.h"

#include <features/areaFeature.h>

#include <list>
#include <set>
#include <vector>
#include <boost/unordered_set.hpp>
#include <boost/ptr_container/ptr_vector.hpp>

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 boost::unordered_set<const DtVrfObject*> DtObjectObstructionContainer;
   typedef std::list<DtRwString>              DtFeatureTypeContainer;

   DtCollisionDetector(DtSimManager* simManager);

   virtual ~DtCollisionDetector();

private:
   DtCollisionDetector(const DtCollisionDetector& orig);

   DtCollisionDetector& operator=(const DtCollisionDetector& orig);

public:

   virtual void setObjectToIgnore(const DtVrfObject* vrfObject);

   virtual void addObjectObstructionID(const DtObjectType& objectObstructionID);
   virtual void removeObjectObstructionID(const DtObjectType& objectObstructionID);
  
   virtual void setObjectObstructionIDs(const DtObjectObstructionIDContainer& objectIDs);

   virtual void setFeatureObstructionTypes(const DtFeatureTypeContainer& featureTypes);

   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 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 detectFeatureCollision(Dt3dBoundingVolume& collisionBV, 
      DtCollisionProcessor<DtFeatureCollision>&, const DtVector& localPosition, const DtDcm& bvOrientation) const;

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

   bool testInvariant() const;

protected:
   DtObjectObstructionIDContainer myObjectObstructionIDs;

   DtSimManager* mySimManager;

   DtFeatureTypeContainer myObstructionTypes;
   boost::shared_ptr<MAKVRinTerra::DtAreaFeatureSet::List> myObstructions;

   const 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_