opcodeTerrainIntersectorImpl.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2008 MAK Technologies, Inc.
** All rights reserved.
*******************************************************************************/
/*******************************************************************************
** $RCSfile: opcodeTerrainIntersectorImpl.h,v $ $Revision: 1.5 $ $State: Exp $
*******************************************************************************/


#ifndef opcodeTerrainIntersectorImpl_h
#define opcodeTerrainIntersectorImpl_h

#define BAN_OPCODE_AUTOLINK

#include "Opcode.h"
#include <vector>
#include "gdb/triangleIndirect.h"
#include <vlutil/vlMutex.h>

// Enable this to create a log of all the chord intersection calls that
// are made though this interface.
// The resulting file can be used in the terrainPerformance test program.
//#define LOG_INTERSECTIONS

#ifdef LOG_INTERSECTIONS
#include <list>
#include "geometry/chord.h"
#endif


class DtTerrainDatabase;
class DtPoint;
class DtGdbNode;
class DtChordIntersectionRecord;
class DtChord;
class DtSphere;
class DtFileNode;

class DT_DLL_gdb DtOpcodeTerrainIntersectorImpl
{
public:
   DtOpcodeTerrainIntersectorImpl();
   virtual ~DtOpcodeTerrainIntersectorImpl();

   // Builds the opcode model based on this terrain.  The terrain
   // must triangularized before this is done.  
   virtual bool initFromGdb(DtTerrainDatabase* terrain);

   // \return A text string specifying the initialization state of the interface.
   // This will contain error text if initFromGdb() fails.
   virtual DtString initStateText() const;

   // \return The number of bytes used by the opcode interface and model.
   virtual unsigned int memoryUsage() const;

   // \return Information about the first intersection of the specified Chord.
   virtual bool chordIntersect(const DtChord& chord,
      DtChordIntersectionRecord& record,
      DtGdbNode::DtIntersectRecordType irtFlag = DtGdbNode::IRT_ALL_DATA_TERRAIN) const;

   virtual bool allIntersectsAlongChord(const DtChord& chord,
      DtChordIntersectRecordList& intList,
      DtGdbNode::DtIntersectRecordType irtFlag = DtGdbNode::IRT_ALL_DATA_TERRAIN,
      const DtFileNode* visitedFileNode = 0) const;

   virtual bool sphereIntersect(const DtSphere& sphere, DtSphereIntersectionRecord& record,
      DtGdbNode::DtIntersectRecordType irtFlag = DtGdbNode::IRT_ALL_DATA_TERRAIN) const;

protected:
   typedef std::pair<DtChordIntersectionRecord*, DtOpcodeTerrainIntersectorImpl*> RecordMeshPair;

   virtual bool makeOpcodeTriangleIndex(DtGdbNode* node);

   // \throws std::bad_alloc if there is not enough memory
   virtual void makeIndexedTriangleArray();

   // Returns the list of file nodes that intersects with the chord
   virtual bool intersectAnyFileNode(const DtChord& chord, std::vector<DtFileNode*>& vec) const;

   // Returns the list of file nodes whose extent intersects with the sphere's extent
   // or contain the sphere's center.
   virtual bool intersectAnyFileNode(const DtSphere& sphere, std::vector<DtFileNode*>& vec) const;

   // \brief Used to insert items inside a map in order
   virtual bool lessDistance(const Opcode::CollisionFace& c1, const Opcode::CollisionFace& c2);

protected:

   typedef std::vector<DtTriangleIndirect*> TriangleIndexType;

   IndexedTriangle* myIndexedTriangleArray;
   TriangleIndexType myTriangleIndex;
   unsigned int myNumberOfVertices;
   unsigned int myNumberOfTriangles;
   Opcode::Model myOpcodeModel;

   Opcode::OPCODECREATE myOPC;
   Opcode::MeshInterface myMeshInterface;
   DtString myInitStateText;

#ifdef LOG_INTERSECTIONS
   typedef std::list<std::pair<DtChord, DtGdbNode::DtIntersectRecordType> > DtIntersectionHistoryList;
   mutable DtIntersectionHistoryList myIntersectionHistory;
   mutable bool myIntersectionHistoryStarted;

   void writeIntersectionHistory() const;
   void addIntersectionHistory(const DtChord& chord, DtGdbNode::DtIntersectRecordType irtFlag) const;
#endif

   // Since OPCODE is not thread safe, use this mutex to protect
   // against multiple threads inside the intersection methods.
   mutable DtMutex myIntersectMutex;
   DtTerrainDatabase* myTerrainDb;
   std::vector<DtFileNode*> myFileNodes;
};

#endif