DtOsgIntersector.h

Go to the documentation of this file.

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


#pragma once

#include <vrvOsg/vrvOsg.h>
#include <vrvOsg/DtOsgNodeTraversalFlags.h>
#include <vrvOsg/DtOsgRenderer.h>
#include <vrvOsg/DtOsgIntersector.h>

#include <vrvCore/DtIntersector.h>
#include <vrvCore/DtDe.h>

#include <osgUtil/IntersectVisitor>

#include <osg/Node>
#include <osgUtil/LineSegmentIntersector>

namespace osgUtil
{
   class Hit;
}

namespace osgViewer
{
   class View;
}

class DtVector;

namespace makVrv
{
   class DtOsgRenderer;
   class DtOsgIntersectVisitor;
   
   class DT_DLL_VRVOSG DtOsgIntersectorResult : public DtIntersectorResult
   {
   public:
      DtOsgIntersectorResult();
      
      DtOsgIntersectorResult( double x, double y, double z, double normalX, 
         double normalY, double normalZ, const DtUniqueID& id, 
         std::vector<osg::Vec3> triangle, osg::Matrixd localToWorld );
      
      DtOsgIntersectorResult( const DtOsgIntersectorResult& orig );
         
      DtOsgIntersectorResult& operator=( const DtOsgIntersectorResult &orig );
      
   public:      
      // 3 points of the intersected triangle
      std::vector<osg::Vec3> myHitTriangle;

      // matrix transform from world to triangle local coordinates
      osg::Matrixd myLocalToWorld;
   };
   
   class DT_DLL_VRVOSG DtOsgIntersector : public DtIntersector
   {
   public:
         
      // Abstract DtIntersector Implementation for OSG
       
      DtOsgIntersector( DtDe& de, int modelSet );
      
      virtual ~DtOsgIntersector();
     
      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 );
                 
      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 );
          
      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);
          
      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 );
                 
      virtual bool pick( DtChannel& channel, double mx, double my, 
         DtIntersectorResult& intersection, 
         IntersectProperties properties=AllNodes, 
         std::vector<DtElementID>* ignoreList=0);
         
      virtual bool pickAll( DtChannel* channel, double mx, double my, 
         DtIntersections& intersections, IntersectProperties properties=AllNodes, 
         std::vector<DtElementID>* ignoreList=0);
         
   public:
   
      // OSG-specific Interface
  
      typedef std::vector<DtOsgIntersectorResult> DtOsgIntersections;
      
         
      virtual bool findNearestIntersection(double x, double y, double z,
         double vx, double vy, double vz, DtOsgIntersectorResult& intersection,
         const DtOsgRenderer::RootList& intersectionRoots, 
         osg::Node::NodeMask mask=DtOsgNodeFlags::FlagAllOn,
         std::list<osg::Node*>* excludeNodeList=0, bool returnHitTriangle=false, 
         double maxIsectorLength=-1.0, bool useHighLod=false );
      
      virtual bool findIntersectionsThroughPoint(double x, double y, double z,
         double vx, double vy, double vz, 
         DtOsgIntersector::DtOsgIntersections& intersections,
         const DtOsgRenderer::RootList& intersectionRoots,
         osg::Node::NodeMask mask=DtOsgNodeFlags::FlagAllOn, 
         std::list<osg::Node*>* excludeNodeList=0, bool returnHitTriangle=false, 
         double maxIsectorLength=-1.0, bool sort=true, bool useHighLod=false );
 
      virtual bool intersectLineSegmentWithScene( double x, double y, double z,
         double end_x, double end_y, double end_z,
         DtOsgIntersectorResult& intersection, 
         const DtOsgRenderer::RootList& intersectionRoots,
         osg::Node::NodeMask mask=DtOsgNodeFlags::FlagAllOn, 
         std::list<osg::Node*>* excludeNodeList=0,
         bool returnHitTriangle=false, bool useHighLod=false );
 
      virtual bool intersectLineSegmentWithScene( double x, double y, double z,
         double end_x, double end_y, double end_z,
         DtOsgIntersector::DtOsgIntersections& intersections, 
         const DtOsgRenderer::RootList& intersectionRoots,
         osg::Node::NodeMask mask=DtOsgNodeFlags::FlagAllOn, 
         std::list<osg::Node*>* excludeNodeList=0,
         bool returnHitTriangle=false, bool sort=true, bool useHighLod=false );
         
      virtual bool pick( osgViewer::View& view, double mx, double my, 
         DtOsgIntersectorResult& intersection,
         osg::Node::NodeMask mask=DtOsgNodeFlags::FlagAllOn,
         std::list<osg::Node*>* excludeNodeList=0,
         bool returnHitTriangle=false );
         
      virtual bool pick( osgViewer::View& view, double mx, double my, 
         DtOsgIntersector::DtOsgIntersections& intersections,
         osg::Node::NodeMask mask=DtOsgNodeFlags::FlagAllOn,
         std::list<osg::Node*>* excludeNodeList=0,
         bool returnHitTriangle=false );
         
   public:
      
      static osg::Node::NodeMask nodeMaskFromIntersectProperties(
         IntersectProperties properties );
     
      static bool anyNodeInNodePath(std::list<osg::Node*>* n, 
         osg::NodePath const& path);    
        
   protected:

      virtual float distanceToResult2(double x, double y, double z, DtOsgIntersectorResult& result);

      virtual bool calcEndpointsFromDirectionAndLength( double x, double y, 
         double z, double vx, double vy, double vz, double length, 
         const DtOsgRenderer::RootList& intersectionRoots, DtVector& startPoint, 
         DtVector& endPoint ) const;
          
      void getExcludeNodesFromIgnoreList( std::vector<DtUniqueID>* ignoreList,
         std::list<osg::Node*>& excludeNodes );      
     
      osg::Vec3d worldIntersectPoint( const osgUtil::Hit& hit ); 
      
      osg::Vec3d worldIntersectPoint( 
         const osgUtil::LineSegmentIntersector::Intersection& hit ); 
         
      osg::Vec3d localToWorld( const osg::Vec3& local, const osg::Matrix& localToWorld ); 
   
      bool findIdFromNodePath( const osg::NodePath& nodePath, DtUniqueID& id );

      osg::Camera * getActiveCamera(osgViewer::View& view);

      void updateInstanceIntersectElementId(DtOsgIntersectorResult &result);
         
      bool fillResultFromHit(DtOsgIntersectorResult& result,  const osgUtil::Hit& hit,
         bool returnHitTriangle ) ;
         
      bool fillResultFromHit(DtOsgIntersectorResult& result,  
         const osgUtil::LineSegmentIntersector::Intersection& hit, 
         bool returnHitTriangle ) ;
      
      osgUtil::IntersectVisitor::HitList& getLineSegmentIntersection(
         osgUtil::IntersectVisitor& collisionVisitor, double x, double y, double z,
          double end_x, double end_y, double end_z, 
          const DtOsgRenderer::RootList& intersectionRoots, osg::Node::NodeMask mask);
         
      bool processLineSegmentIntersection( 
         osgUtil::IntersectVisitor::HitList& hitList,
         std::list<osg::Node*>* excludeNodeList, bool returnHitTriangle, 
         DtOsgIntersectorResult& intersection );
         
       bool processLineSegmentIntersection( const osg::Vec3d& testPoint,
         osgUtil::IntersectVisitor::HitList& hitList,
         std::list<osg::Node*>* excludeNodeList, bool returnHitTriangle, 
         DtOsgIntersectorResult& intersection );
     
      bool processLineSegmentIntersection( const osg::Vec3d& testPoint, 
         osgUtil::IntersectVisitor::HitList& hitList,
         std::list<osg::Node*>* excludeNodeList, bool returnHitTriangle, 
         DtOsgIntersector::DtOsgIntersections& intersections, bool sort );
      
      bool processPickIntersection( 
         osgUtil::LineSegmentIntersector::Intersections& hitList,
         std::list<osg::Node*>* excludeNodeList, bool returnHitTriangle, 
         DtOsgIntersectorResult& intersection );
         
      bool processPickIntersection( 
         osgUtil::LineSegmentIntersector::Intersections& hitList,
         std::list<osg::Node*>* excludeNodeList, bool returnHitTriangle, 
         DtOsgIntersector::DtOsgIntersections& intersections );

      void setupCollisionVisitor( bool useHighLod, DtOsgIntersectVisitor& visitor );

      bool shouldInstanceIntersect(osg::Node::NodeMask nodeMask);
         
   protected:
      int myModelSet;
   };

   class DtOsgIntersectorSorter
   {
   public:
      DtOsgIntersectorSorter( const osg::Vec3d& reference )
      : myReference( reference ) {}
      
      inline bool operator() ( const DtOsgIntersectorResult& a, 
         const DtOsgIntersectorResult& b )
      {
         osg::Vec3d diffA = osg::Vec3d(a.x, a.y, a.z) - myReference;
         osg::Vec3d diffB = osg::Vec3d(b.x, b.y, b.z) - myReference;
         return diffA.length2() > diffB.length2();
      }
   protected:
      osg::Vec3d myReference;
   };
   
   class DT_DLL_VRVOSG DtOsgIntersectorCreator : public DtIntersectorCreator
   {
   public:   
      virtual DtIntersector* create(DtDe& de, int modelSet );
   };
}