examples/extentTerrainImplementation/extentTerrainImplementation.h

Go to the documentation of this file.

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

//\file extentTerrainImplementation.h
//\ingroup terrainInterface

//\brief

#pragma once

#include "terrainInterface/terrainImplementation.h"
#include "terrainInterface/terrainCapabilities.h"

class DtCoordinateSystem;
class DtVectorNetwork;
namespace makArchives
{
   class DtGenericTerrainRecord;
}

//This terrain implementation is an algorithmic representation of the world
//as a flat earth extent.  All soil types are returned as 
//the undefined soil type.
class DtExtentTerrainImplementation : public DtTerrainImplementation
{
public:

   DtExtentTerrainImplementation(DtConsoleCommandManager* cmdMgr);
   virtual ~DtExtentTerrainImplementation();

   //Static creator function
   static DtTerrainImplementation* create(DtConsoleCommandManager* cmdMgr);

   //Called with the generic terrain record from the mtf file.
   //Use to setup initial values on terrain load.
   virtual bool loadTerrain(const makArchives::DtGenericTerrainRecord& record,
      const TerrainSettings& settings = TerrainSettings());

   //Returns myCoordinateSystem 
   virtual const Coordinate_System* coordinateSystem() const;

   //Returns topmost intersection of chord with terrain in record. 
   //irtFlag specifies what intersection
   //data should be filled in for the record.
   virtual bool chordIntersect(const DtChord& chord,
      DtChordIntersectionRecord& record,
      DtIntersectionRecord::DtIntersectionType irtFlag = 
      DtIntersectionRecord::INT_ALL_DATA,
      bool* dataAvailable = 0, bool overrideBlockingAssert = false) const;

   //Returns all intersections of chord with terrain. intList is the list of each intersection record.
   //irtFlag specifies what intersection data should be filled in for the record.
   //In this example there will only ever be at most 1 intersection.
   virtual bool allIntersectsAlongChord(const DtChord& chord,
      DtChordIntersectRecordList& intList,
      DtIntersectionRecord::DtIntersectionType irtFlag = 
      DtIntersectionRecord::INT_ALL_DATA,
      bool* dataAvailable = 0, bool overrideBlockingAssert = false) const;

   //Returns intersection of sphere with the terrain in the record irtFlag specifies what intersection
   //data should be filled in for the record.
   virtual bool sphereIntersect(const DtSphere& sphere, DtSphereIntersectionRecord& record,
      DtIntersectionRecord::DtIntersectionType irtFlag = 
      DtIntersectionRecord::INT_ALL_DATA,
      bool* dataAvailable = 0, bool overrideBlockingAssert = false) const;

   //Returns myVectorNetwork
   virtual const DtVectorNetwork* vectorNetwork() const;

   //User passes in the chord to intersect the vector network and the vectorRecord defining the 
   //desired search parameters like the kind of features to be searched. Returns the best feature 
   //intersection and associated data in the vectorIntersectionRecord if there is an intersection.
   //Returns false if there is no intersection.
   virtual bool intersectVectorNetwork(const DtChord& chord,
      DtVectorNetworkRecord* vectorRecord, 
      DtVectorNetworkIntersectionRecord* vectorIntersectionRecord) const;

   //Returns the capabilities of the current terrain.
   virtual const DtTerrainCapabilities* terrainCapabilities() const;

   //Used by B-HAVE for creating path data.  func is a function to be called
   //on the triangles in the terrain.  box is an extent that determines which
   //triangles should be considered.  finalize is called once all triangles
   //have been processed.
   virtual void processTrianglesInArea(DtTriangleCallbackFcn func, 
      DtTriangleCallbackFinalizeFcn finalize, 
      const DtTerrainProcessPolygonsBox& box, void* usr);

protected:

   //Fill in the intersection record based on the result of the intersection
   //test.
   void fillHitRecord(DtChordIntersectionRecord& rec, 
      const DtChord& chord, const DtPoint& chordNormal, double intersectTime,
      DtIntersectionRecord::DtIntersectionType irtFlag) const;

   //Function that actually does the chord-extent intersection test.
   bool chordExtentIntersect(const DtChord& chord, 
      DtChordIntersectionRecord& hit, 
      DtIntersectionRecord::DtIntersectionType irtFlag) const;

protected:
   Coordinate_System* myCoordinateSystem;
   DtVectorNetwork * myVectorNetwork;
   DtTerrainCapabilities myCapabilities;
};