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 "vrfutil/noArgumentCallbackList.h"

#include <features/feature.h>
#include <features/pathFeature.h>
#include <features/aStarGraph.h>
#include <features/areaFeature.h>
#include <features/sharedMemoryFeaturesDebugDrawer.h>
#include <features/attributeConfigParser.h>
#include <features/featureGeometry.h>

#include <fstream>

#include <boost/scoped_ptr.hpp>
#include <boost/ptr_container/ptr_list.hpp>

class DtTerrainImplementation;
class DtTerrainImplementationDescriptor;
class DtTerrainImplementationManager;
class DtConsoleCommandManager;
class DtTerrainCapabilities;
class DtCallbackQueue;
class MAKVRinTerra::DtClosestPathFeatureFinder;
class Dt3dBoundingVolume;

namespace makArchives
{
   class DtTerrainRecord;
   class DtGenericTerrainRecord;
}

typedef void (*DtGenericTerrainRecordCallbackFunction)(
   makArchives::DtGenericTerrainRecord* record, void* userData);

typedef DtCallbackList<makArchives::DtGenericTerrainRecord*> DtGenericTerrainRecordCallbackList;

class DT_DLL_terrainInterface DtTerrainInterface
{
public:
   enum LoadContext
   {
      VrfSimulationBackEnd = 1,
      NavGenerationTool = 2
   };

   typedef MAKVRinTerra::DtAStarGraph DtAStarGraph;

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

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

   virtual bool init(bool createConsoleManager = true);

   virtual void setConfigFile(const std::string&, bool reload=true);

   virtual const DtTerrainInterfaceConfig& configOptions() const;

   virtual void tick();

   virtual bool isSameTerrain(const DtFilename&) const;

   virtual bool isHighFidelityTerrain() const;

   DtTerrainImplementation* terrainImplementation() const
   {
      return myTerrainImpl;
   }

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

   virtual void addFeatureLayer(MAKVRinTerra::DtFeatureSet*);
   virtual void addFeatureLayer(boost::shared_ptr<MAKVRinTerra::DtFeatureSet>);

   virtual void addGenericTerrainRecordCallback(
      const DtString& recordType,
      DtGenericTerrainRecordCallbackFunction fcn, 
      void* user);

   virtual void removeGenericTerrainRecordCallback(
      const DtString& recordType,
      DtGenericTerrainRecordCallbackFunction fcn, 
      void* user);

   virtual void invokeGenericTerrainRecordCallbacks(
      makArchives::DtGenericTerrainRecord* record);

   virtual bool loadTerrain(const DtString& filename, LoadContext context = VrfSimulationBackEnd);

   virtual bool unloadTerrain(bool block = true);

   virtual bool loadModel(const DtFilename& f, const DtEntityType& t = DtEntityType());

   virtual double modelHeightDifferencesFromAppearances(int oldApp, int newApp) const;

   virtual bool createFromExtent(const Dt3dBoundingVolume&);

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

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

   virtual std::auto_ptr<MAKVRinTerra::DtAreaFeatureSet> areas(
      const std::string& type,
      const boost::shared_ptr<DtCallbackQueue>& = boost::shared_ptr<DtCallbackQueue>()) const;

   virtual std::auto_ptr<MAKVRinTerra::DtAreaFeatureSet> areas(
      const MAKVRinTerra::DtAreaFeatureSetAdapter::Config& config,
      const boost::shared_ptr<DtCallbackQueue>& = boost::shared_ptr<DtCallbackQueue>()) const;

   virtual std::auto_ptr<MAKVRinTerra::DtAreaFeatureSet> LOSfeatures() const;

   virtual std::auto_ptr<MAKVRinTerra::DtPathFeatureSet> paths(const std::string& type) const;
   
   virtual std::auto_ptr<MAKVRinTerra::DtFeatureSet> features(
      const std::string& queryName) const;

   virtual std::auto_ptr<MAKVRinTerra::DtFeatureSet> allFeatures() const;

   virtual std::auto_ptr<MAKVRinTerra::DtFeatureSet> featuresRaw(
      const std::string& queryName) const;

   virtual std::auto_ptr<MAKVRinTerra::DtFeatureSet> allFeaturesRaw() const;

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

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

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
































































































































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

   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, int flags = 0) ;

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

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

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

   virtual bool closestIntersection(double lat, double lon, 
      DtChordIntersectionRecord& record,
      DtIntersectionRecord::DtIntersectionType irtFlag = 
      DtIntersectionRecord::INT_ALL_DATA, bool* dataAvailable = 0,
      bool overrideBlockingAssert = false, bool doNotAddDefaultRecord = false, int flags = 0) 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, bool doNotAddDefaultRecord = false, int flags = 0) const;

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

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

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

   virtual bool allIntersectsAlongChordDebug(const DtChord& chord,
      DtChordIntersectRecordList& intList,
      bool* dataAvailable = 0, 
      bool overrideBlockingAssert = false, int flags = 0) 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, int flags = 0) const;

   virtual void preloadTerrainAreas(
      const DtTerrainPagingGeometryList& preloadGeometry);

   virtual void forceLoadTerrainAreas(
      const DtTerrainPagingGeometryList& forceLoadGeometry);

   virtual const DtTerrainCapabilities* terrainCapabilities() const;

   virtual bool addTerrainPassThroughLayer(const DtString& layerType);

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

   virtual void setWarnOnBlockingTerrainCalls(bool warnBlock);
   virtual bool warnOnBlockingTerrainCalls() const;

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

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

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

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

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

   virtual DtAStarGraph::Ptr pathFinder(const std::string&) const;

   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;

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;

protected:
   DtFilename myTerrainOptionsFilename;
   DtTerrainInterfaceConfig myFileConfig;

   typedef boost::ptr_list<MAKVRinTerra::DtFeatureSet> FeatureSetList;
   FeatureSetList myFeatureLayers;

   DtTerrainImplementation* myTerrainImpl;
   
   bool  myTerrainIsLoaded;

   DtTerrainImplementationManager* myTerrainImplManager;
   DtConsoleCommandManager* myConsoleCommandManager;
   DtString myLoadedFilename;
   DtString myUnresolvedFilename;

   DtTerrainPagingGeometryList myForceLoadAreas;

   double myLastFileTime;

   static double theTerrainPagingMaxHeight;

   MAKVRinTerra::DtProj::CPtr myProjObject;

   DtAsyncJobServer myAsyncJobServer;

   OceanLayer myGlobalOceanLayer;

   std::ofstream myDebugOutputFile;
   tbb::tick_count myLastDebugOutputTick;

   bool myIsHighFidelityModel;

   makArchives::DtTerrainRecord* myTerrainRecord;

   typedef std::map<DtString, DtGenericTerrainRecordCallbackList>
      DtGenericTerrainRecordCallbackListMap;
   DtGenericTerrainRecordCallbackListMap myGenericTerrainRecordCallbacklists;
};

#define DtRegisterTerrainImplementationFunctionName "DtRegisterTerrainImplementation"

typedef bool (*DtRegisterTerrainImplementationLibFcn)(DtTerrainInterface*);


#define DtDeregisterTerrainImplementationFunctionName "DtDeregisterTerrainImplementation"

typedef void (*DtDeregisterTerrainImplementationLibFcn)();