DtIntersector.h

Go to the documentation of this file.

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


#pragma once
#include <vrvCore/vrvCore.h>
#include <vrvCore/DtUniqueID.h>
#include <vrvCore/DtTickable.h>

#include <vrvGraphicsUtils/DtColorValue.h>
#include <vrvUtil/DtVirtualBaseClass.h>
#include <boost/unordered_map.hpp>
#include <vector>
#include <map>


namespace makVrv
{   
   class DtDe;
   class DtChannel;

   class DtSceneObjectAgent;
   class Dt3DSegmentedLineModelAgent;

   class DT_DLL_VRVCORE DtIntersectorResult
   {
   public:
      // For this purpose, a triangle is described as 9 doubles; x0, y0, z0,
      // x1, x2, etc...
      typedef std::vector<double> DtIntersectTriangle;

   public:
      DtIntersectorResult();

      DtIntersectorResult( const DtIntersectorResult& orig );

      DtIntersectorResult& operator=( const DtIntersectorResult& orig );

      bool operator==(const DtIntersectorResult&) const;

      bool operator!=(const DtIntersectorResult& rhs) const
      {
         return !(*this == rhs);
      }

   public:

      bool hasIntersect;

      double x;

      double y;

      double z;

      double normalX;

      double normalY;

      double normalZ;
     
      DtUniqueID id;

      bool hasIntersectTriangle;

      DtIntersectTriangle isectTriangle;

      bool dynamicOcean;

      double startX;

      double startY;

      double startZ;

      double endX;

      double endY;

      double endZ;
   };

   class DtDrawnIntersector;

   class DT_DLL_VRVCORE DtIntersector
   {
   public:

      enum IntersectProperties 
      {
         AllNodes = 0,
         PickableNodes = 1,
         SupportNodes = 2,
         NodesThatReceivesShadows = 4,
         NodesThatCastsShadows = 8
      };

      enum DynamicOceanProperties 
      {
         DynamicOceanPropertyMsl = 0,
         DynamicOceanPropertyWaves = 1,
         DynamicOceanPropertyIgnore = 2
      };

      typedef std::vector<DtIntersectorResult> DtIntersections;

      DtIntersector( DtDe& de );

      virtual ~DtIntersector();

      virtual void setDynamicOceanProperties( DynamicOceanProperties properties );
       
      DynamicOceanProperties dynamicOceanProperties() const;

      virtual bool findNearestIntersectionToPoint(double x, double y, double z,
         double vx, double vy, double vz, DtIntersectorResult& intersection,
         IntersectProperties properties = AllNodes, 
         std::vector<DtElementID>* ignoreList = 0, bool returnTriangle = false,
         double maxIsectorLength = -1., bool useHighLod = false ) = 0;

      virtual bool findAllIntersectionsThroughPoint( double x, double y, double z,
         double vx, double vy, double vz, DtIntersections& intersections, 
         IntersectProperties properties = AllNodes, 
         std::vector<DtElementID>* ignoreList = 0, bool sort = true, 
         bool useHighLod = false ) = 0;

      virtual bool findFirstIntersectWithLineSegment( 
         double x, double y, double z, double end_x, double end_y, double end_z,
         DtIntersectorResult& intersection, 
         IntersectProperties properties=AllNodes, 
         std::vector<DtElementID>* ignoreList=0, 
         bool useHighLod = false) = 0;

      virtual bool findAllIntersectWithLineSegment( 
         double x, double y, double z, double end_x, double end_y, double end_z,
         DtIntersections& intersections, 
         IntersectProperties properties=AllNodes, 
         std::vector<DtElementID>* ignoreList=0, bool sort=true, 
         bool useHighLod = false ) = 0;

      virtual bool pick( DtChannel& channel, double mx, double my, 
         DtIntersectorResult& intersection, 
         IntersectProperties properties=AllNodes, 
         std::vector<DtElementID>* ignoreList=0) = 0;

      virtual bool pickAll( DtChannel* channel, double mx, double my, 
         DtIntersections& intersections, 
         IntersectProperties properties=AllNodes, 
         std::vector<DtElementID>* ignoreList=0) = 0;

   protected:
      DtDe& myDe;
      DynamicOceanProperties myDynamicOceanProperties;

      struct CachedPick
      {
         CachedPick()
         : simTime(0.0)
         , channel(0)
         , mx(0)
         , my(0)
         , properties(DtIntersector::AllNodes)
         , ignoreList(0)
         {
         }

         bool operator==(const CachedPick& b)
         {
            return simTime == b.simTime &&
               channel == b.channel &&
               mx == b.mx &&
               my == b.my &&
               properties == b.properties &&
               ignoreList == b.ignoreList;
         }

         double simTime;
         DtChannel* channel;
         double mx; 
         double my;
         IntersectProperties properties;
         std::vector<DtElementID>* ignoreList;
      };

      CachedPick myLastPick;
      bool myLastPickSucceeded;
      DtIntersectorResult myLastResult;

   };

   class DT_DLL_VRVCORE DtDrawnIntersector
   {
   public:
      DtDrawnIntersector( DtDe& de );
      virtual ~DtDrawnIntersector();

      virtual void draw( const DtIntersector::DtIntersections& results );

      virtual void setColors( const DtColorValue& failedColor,
         const DtColorValue& oddColor, const DtColorValue& evenColor );

   protected:
      DtDe& myDe;
      typedef std::vector<Dt3DSegmentedLineModelAgent*> LineModelList;
      LineModelList myLineModels;
      typedef std::vector<DtSceneObjectAgent*> SceneObjectList;
      SceneObjectList mySceneObjects;
      DtColorValue myFailedIntersectorColor;
      DtColorValue myOddSegmentIntersectorColor;
      DtColorValue myEvenSegmentIntersectorColor;
   };

   class DT_DLL_VRVCORE DtDrawnIntersectorManager : public DtTickable
   {
   public:
      DtDrawnIntersectorManager( DtDe& de );
      virtual ~DtDrawnIntersectorManager();

      virtual void update( DtTime tNow );

      virtual void drawIntersection( 
         const DtIntersector::DtIntersections& results, double duration );

   protected:
      DtDe& myDe;

      typedef std::multimap<double, DtDrawnIntersector* > DtDrawnIntersectorMap;
      DtDrawnIntersectorMap myDrawnIntersectorMap;
   };


   class DT_DLL_VRVCORE DtIntersectorManager : public DtVirtualBaseClass
   {
   public:
      virtual ~DtIntersectorManager();

      static DtIntersectorManager& instance(DtDe& de);

      static void registerInstance(DtDe& de, DtIntersectorManager* anInstance);     

      virtual DtIntersector& modelSetIntersector(int modelSet);

      virtual DtIntersector& characterIntersector();

      virtual void registerCharacterIntersector(DtIntersector* intersector);

      virtual void drawIntersection( const DtIntersectorResult& result, 
         double duration );

      virtual void drawIntersection( 
         const DtIntersector::DtIntersections& results, double duration );

   protected:
      DtIntersectorManager(DtDe& de);

   protected:
      typedef boost::unordered_map<int, DtIntersector*> IntersectorMap;
      DtDe& myDe;
      IntersectorMap myIntersectors;
      DtIntersector* myCharacterIntersector;
      DtDrawnIntersectorManager myDrawnIntersectorManager;
   };

   class DT_DLL_VRVCORE DtIntersectorCreator : public DtVirtualBaseClass
   {
   public:

      static DtIntersectorCreator& instance(DtDe& de);

      static void registerInstance(DtDe& de, DtIntersectorCreator* anInstance);     

      virtual DtIntersector* create( DtDe& de, int modelSet ) = 0;
   };
}