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 <features/areaFeature.h>
#include <vrfobjcore/entityCollision.h>
#include <vrfobjcore/featureCollision.h>
#include <vrfobjcore/simComponent.h>

#include <boost/ptr_container/ptr_vector.hpp>

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

class DtCollision;
class DtString;
class DtSimulationServices;
class Dt3dBoundingVolume;
class DtEntityType;

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<DtEntityType>             DtObjectObstructionIDContainer;
   typedef std::vector<const DtSimObject*> DtObjectObstructionContainer;
   typedef std::list<DtRwString>              DtFeatureTypeContainer;

   DtCollisionDetector(const DtSimulationServices* simServices);

   virtual ~DtCollisionDetector();

private:
   DtCollisionDetector(const DtCollisionDetector& orig);

   DtCollisionDetector& operator=(const DtCollisionDetector& orig);

public:

   virtual void setObjectToIgnore(const DtSimObject* vrfObject);

   virtual void addObjectObstructionID(const DtEntityType& objectObstructionType);
   virtual void removeObjectObstructionID(const DtEntityType& objectObstructionType);
  
   virtual void setObjectObstructionIDs(const DtObjectObstructionIDContainer& objectTypes);

   virtual void setFeatureObstructionTypes(const DtFeatureTypeContainer& featureTypes);

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

   virtual bool detectAllEntityCollisions(const Dt3dBoundingVolume& collisionBv,
      const DtVector& localPosition, const DtDcm& bvOrientation,
      std::list<std::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 DtSimObject& vrfObjectToTest) const;

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

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

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

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

   bool testInvariant() const;

protected:
   DtObjectObstructionIDContainer myObjectObstructionTypes;

   const DtSimulationServices* mySimulationServices;

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

   const DtSimObject* myObjectToIgnore;
};

bool DtSameOrAttached(const DtSimObject* primaryEntity, const DtSimObject& 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() override;

   virtual void processCollision(const T_Collision& collision) override;

   virtual T_Collision* closestCollision();

protected:
   T_Collision* myClosestCollision;
   double myClosestCollisionDistanceSquared;

};

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

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

   virtual void processCollision(const T_Collision& collision) override;

protected:
   DtCollisionList& myCollisionList;
};

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