terrainInterface.h

Go to the documentation of this file.

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




#pragma once

#include "terrainInterface/terrainInterfaceDefines.h"
#include "terrainInterface/terrainImplementation.h"
#include "terrainInterface/terrainPagingGeometry.h"

#include "vrfutil/asyncJobServer.h"
#include "vrfutil/terrainInterfaceConfig.h"

#include <boost/scoped_ptr.hpp>

#include <features/feature.h>
#include <features/featureContext.h>
#include <features/pathFeature.h>
#include <features/pathFinder.h>
#include <features/obstacleFeature.h>
#include <features/sharedMemoryFeaturesDebugDrawer.h>
#include <features/attributeConfigParser.h>
#include <features/featureGeometry.h>

class DtTerrainImplementation;
class DtTerrainImplementationDescriptor;
class DtTerrainImplementationManager;
class DtConsoleCommandManager;
class DtConsoleCommand;
class DtGenericTerrainRecord;
class DtTerrainCapabilities;
class MAKVRinTerra::DtClosestPathFeatureFinder;

class DT_DLL_terrainInterface DtTerrainInterface
{
public:
   typedef std::map<std::string, std::string> TerrainSettings;
   typedef MAKVRinTerra::DtPathFinder DtPathFinder;

   struct OceanLayer
   {
      bool present; 
      double seaLevel; 
      double defaultSeaDepth; 
   };

public:
   DtTerrainInterface();
   
   virtual ~DtTerrainInterface();

   virtual bool init();

   virtual void tick();

   virtual bool isSameTerrain(const DtFilename&) const;

   virtual void addTerrainImplementation(const DtString& implementationName, 
      DtTerrainImplementationCreatorFcn creatorFcn);

   virtual bool loadTerrain(const DtString& filename, const TerrainSettings& settings = TerrainSettings());

   virtual bool loadTerrain(const DtString& filename,
      MAKVRinTerra::DtFeatureLoader& featureLoader, const TerrainSettings& settings = TerrainSettings());

   virtual bool unloadTerrain();
   virtual bool terrainIsLoaded();
   virtual DtString loadedFilename() const;

   virtual const Coordinate_System* coordinateSystem() const;
   virtual Coordinate_System* coordinateSystem();

   virtual std::auto_ptr<MAKVRinTerra::DtObstacleFeatureSet> obstacles(const std::string& type) const;

   virtual std::auto_ptr<MAKVRinTerra::DtObstacleFeatureSet> obstacles(
      MAKVRinTerra::DtObstacleFeatureSetAdapter::Config config);

   virtual std::auto_ptr<MAKVRinTerra::DtPathFeatureSet> paths(const std::string& type) const;
   
   virtual std::auto_ptr<MAKVRinTerra::DtFeatureSet> allFeatures(
      const std::string& type = std::string(), bool readDirectly = false) const;

   virtual double terrainHeightAboveSeaLevel(const DtPoint& databaseLocation,
      bool* dataAvailable = 0, bool overrideBlockingAssert = false) const;

   virtual bool terrainHeightAndIntersection(const DtVector& localLocation, 
      double& height, DtChordIntersectionRecord& record,
      DtIntersectionRecord::DtIntersectionType irtFlag = 
      DtIntersectionRecord::INT_ALL_DATA, bool* dataAvailable = 0, 
      bool overrideBlockingAssert = false) const;




















































































   virtual bool terrainHeightUnderWater(const DtVector& databaseLocation, 
      double& groundHeight, DtSurface& groundSurface, DtVector& groundNormal,
      double& waterHeight, DtSurface::DtMedium &topSurfaceMedium, 
      bool* dataAvailable = 0, bool overrideBlockingAssert = false) ;

   virtual bool terrainHeightUnderWaterDebug(const DtVector& databaseLocation, 
      double& groundHeight, DtSurface& groundSurface, DtVector& groundNormal,
      double& waterHeight, DtSurface::DtMedium &topSurfaceMedium, 
      bool debug,
      bool* dataAvailable =0, bool overrideBlockingAssert = false) ;

   virtual bool closestIntersection(const DtVector& localLocation, 
      DtPoint& intersectionPoint, bool* dataAvailable = 0, 
      bool overrideBlockingAssert = false) const;

   virtual bool closestIntersection(double lat, double lon, 
      DtPoint& intersectionPoint, bool* dataAvailable = 0, 
      bool overrideBlockingAssert = false) const;

   virtual bool closestIntersection(const DtVector& localLocation, 
      DtChordIntersectionRecord& record,
      DtIntersectionRecord::DtIntersectionType irtFlag = 
      DtIntersectionRecord::INT_ALL_DATA, bool* dataAvailable = 0, 
      bool overrideBlockingAssert = false) const;

   virtual bool closestIntersection(double lat, double lon, 
      DtChordIntersectionRecord& record,
      DtIntersectionRecord::DtIntersectionType irtFlag = 
      DtIntersectionRecord::INT_ALL_DATA, bool* dataAvailable = 0,
      bool overrideBlockingAssert = false) const;

   virtual bool closestIntersection(const std::list<DtVector>& localLocationList, 
      DtChordIntersectRecordList& recordList, int& numIntersections,
      DtIntersectionRecord::DtIntersectionType irtFlag = 
      DtIntersectionRecord::INT_ALL_DATA, bool* dataAvailable = 0, 
      bool overrideBlockingAssert = false) const;

   virtual bool intersect(const DtChord& chord, DtPoint& intersectionPoint, 
      double& intersectionTime, bool* dataAvailable = 0, 
      bool overrideBlockingAssert = false) const;

   virtual bool intersect(const DtChord& chord, 
      DtChordIntersectionRecord& record,
      DtIntersectionRecord::DtIntersectionType irtFlag = 
      DtIntersectionRecord::INT_ALL_DATA, bool* dataAvailable = 0,
      bool overrideBlockingAssert = false) const;

   virtual bool intersect(const DtSphere& sphere,
      DtSphereIntersectionRecord& record,
      DtIntersectionRecord::DtIntersectionType irtFlag = 
      DtIntersectionRecord::INT_ALL_DATA, bool* dataAvailable = 0, 
      bool overrideBlockingAssert = false) const;

   virtual bool allIntersectsAlongChord(const DtChord& chord,
      DtChordIntersectRecordList& intList,
      DtIntersectionRecord::DtIntersectionType irtFlag = 
      DtIntersectionRecord::INT_ALL_DATA, bool* dataAvailable = 0, 
      bool overrideBlockingAssert = false) const;

   virtual bool allIntersectsAlongChordDebug(const DtChord& chord,
      DtChordIntersectRecordList& intList,
      bool* dataAvailable = 0, 
      bool overrideBlockingAssert = false) const;

   virtual bool intersectList(const std::list<DtChord>& chordList, 
      DtChordIntersectRecordList& recordList, int& numTerrainIntersections,
      DtIntersectionRecord::DtIntersectionType irtFlag = 
      DtIntersectionRecord::INT_ALL_DATA, bool* dataAvailable = 0,
      bool overrideBlockingAssert = false) const;

   virtual void preloadTerrainAreas(
      const DtTerrainPagingGeometryList& preloadGeometry);

   virtual const DtTerrainCapabilities* terrainCapabilities() const;

   virtual bool addTerrainPassThroughLayer(const DtString& layerType);

   virtual void setAssertOnBlockingTerrainCalls(bool assertBlock);
   virtual bool assertOnBlockingTerrainCalls() const;

   virtual void setIntersectDataLoadExpireTime(const double& expireTime);
   virtual void expireDataLoadRequestsBeforeTime(const double& currentTime);

   virtual void setDataPath(const std::string&);
   virtual std::string dataPath() const;

   virtual void setUserDataPath(const std::string&);
   virtual std::string userDataPath() const;

   virtual void trianglesInArea(DtTriangleCallbackFcn func, 
      DtTriangleCallbackFinalizeFcn finalize, DtTerrainProcessPolygonsBox& box, void* usr) const;

   static void setModelDefinitionFilePath(const DtString& fullFilePath);
   static DtString modelDefinitionFilePath();

   virtual boost::shared_ptr<DtAsyncJobMapEntry> makePathAsync(const DtPoint& localStart, 
      const DtPoint& localDestination, const std::string& type,
      const double& maxSearchRadius, const double& startProximityThreshold,
      DtPathFinder::DtWeightFactorsListPtr weightFactors = 
         DtPathFinder::DtWeightFactorsListPtr(new DtPathFinder::DtWeightFactorsList));

   virtual bool onPathFeature(
      const DtPoint& location, const DtString& type, double buffer = 0.5);

   virtual boost::shared_ptr<DtAsyncJobMapEntry> addAsyncJob(DtAsyncJob* job);

   MAKVRinTerra::DtProj::CPtr localProj() const;

   MAKVRinTerra::DtFeaturesDebugger& debugger() const;

   MAKVRinTerra::DtQuery findQuery(const std::string& name) const;

   const double topoDistance(const DtPoint& start, const DtPoint& end, 
      const MAKVRinTerra::DtProj& localProj);

   MAKVRinTerra::DtClosestPathFeatureFinder closestFeatureOnNetwork(
      const std::string& type, const DtPoint& startingLocation,
      const double& searchRadius, bool* dataAvailable = NULL);

   void breakUpChord(const MAKVRinTerra::DtProj&, const DtChord& chord,
      std::vector<DtChord>& chords) const;

   void breakUpChord(const DtChord& chord, std::vector<DtChord>& chords) const;

   virtual boost::shared_ptr<DtTerrainInterfaceConfig> config() const;

protected:

   virtual bool nonPolygonalWaterHeight(const DtVector& localLocation,
      double& height) const;

   virtual double defaultWaterDepth(const DtVector& localLocation) const;

   virtual double defaultSurfaceElevation(const DtVector& localLocation) const;

   virtual DtSurface::DtMedium mediumForUnspecPolygonsUnderWater() const;

   virtual double landAboveWaterMinimumSeparation() const;

   void insertNonPolyWaterIntoIntersectionList(
      DtChordIntersectionRecord& waterInterx, 
      DtChordIntersectRecordList& intrxList) const;
      
   virtual DtChordIntersectionRecord blankSurfaceIntersectionRecord(
      const DtVector& localLocation, const double height) const;

   virtual bool nonPolygonalWaterIntersect(const DtChord& chord,
      DtChordIntersectionRecord& waterInterxRecord) const;

   virtual DtPathFinder::Path makePath(
      const DtPoint& localStart, const DtPoint& localDestination, 
      const std::string& type, const double& maxSearchRadius,
      const double& startProximityThreshold,
      boost::function<bool ()> cancelCheck,
      DtPathFinder::ReturnCode& result,
      DtPathFinder::DtWeightFactorsListPtr weightFactors = 
         DtPathFinder::DtWeightFactorsListPtr(new DtPathFinder::DtWeightFactorsList)) const;

   virtual void loadConfigurationFile(const DtFilename& filename);

protected:

   DtTerrainImplementation* myTerrainImpl;
   
   bool  myTerrainIsLoaded;

   DtTerrainImplementationManager* myTerrainImplManager;
   DtConsoleCommandManager* myConsoleCommandManager;
   std::list<DtConsoleCommand*> myCommandList;
   DtString myLoadedFilename;
   DtString myUnresolvedFilename;

   double myLastFileTime;

   TerrainSettings mySettings;

   static DtString theModelDefinitionFilePath;
   static double theTerrainPagingMaxHeight;

   boost::scoped_ptr<MAKVRinTerra::DtFeatureContext> myFeatureContext;

   MAKVRinTerra::DtProj::CPtr myProjObject;

   DtAsyncJobServer myAsyncJobServer;

   boost::shared_ptr<DtTerrainInterfaceConfig> myConfig;
   DtFilename myConfigFilename;
   OceanLayer myGlobalOceanLayer;
};

#define DtRegisterTerrainImplementationFunctionName "DtRegisterTerrainImplementation"

typedef bool (*DtRegisterTerrainImplementationLibFcn)(DtTerrainInterface*);