terrainInterface.h

Go to the documentation of this file.

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




#pragma once

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

#include "vrfutil/asyncJobServer.h"
#include "vrfutil/terrainInterfaceConfig.h"
#include <readerWriter/noArgumentCallbackList.h>
#include "vrfutil/rwDynamicTerrainInformation.h"

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

#include <fstream>

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

#include <vector>

class DtTerrainImplementation;
class DtTerrainImplementationDescriptor;
class DtTerrainImplementationManager;
class DtConsoleCommandManager;
class DtTerrainCapabilities;
class DtVrfCallbackQueue;
class MAKVRinTerra::DtClosestPathFeatureFinder;
class Dt3dBoundingVolume;
class DtTerrainIndexParameters;
class DtEntityType;
class DtScenarioExplorer;

namespace makArchives
{
   class DtTerrainRecord;
   class DtGenericTerrainRecord;
}

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

typedef DtCallbackList<makArchives::DtGenericTerrainRecord*> DtGenericTerrainRecordCallbackList;
typedef boost::shared_ptr<DtGenericTerrainRecordCallbackList> DtGenericTerrainRecordCallbackListPtr;

typedef void(*DtTerrainChangeNotificationCallbackFcn)(const DtExtent& spatExtent, void* userData);

typedef boost::signals2::signal<void ()> DtTerrainUnloadSignalType;

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

   typedef MAKVRinTerra::DtAStarGraph DtAStarGraph;

   struct OceanLayer
   {
      bool present; 
      double seaLevel; 
      double defaultSeaDepth; 
      DtSurface::DtMedium defaultSurfaceMedium;
      double landAboveWaterMinimumSeparation;
   };

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;

   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 void addTerrainChangeNotificationCallback(DtTerrainChangeNotificationCallbackFcn fcn,
      void* user);

   virtual void removeTerrainChangeNotificationCallback(DtTerrainChangeNotificationCallbackFcn fcn,
      void* user);

   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(), bool hasOceanLayer = true);

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

   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<DtVrfCallbackQueue>& = boost::shared_ptr<DtVrfCallbackQueue>()) const;

   virtual std::auto_ptr<MAKVRinTerra::DtAreaFeatureSet> areas(
      const MAKVRinTerra::DtAreaFeatureSetAdapter::Config& config,
      const boost::shared_ptr<DtVrfCallbackQueue>& = boost::shared_ptr<DtVrfCallbackQueue>()) 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 bool hasAerodromes() const;

   virtual MAKVRinTerra::DtAerodromeLoader::AerodromeData aerodromeData(const std::string& airportCode) const;

   virtual std::vector<MAKVRinTerra::DtAerodromeLoader::AerodromeData> aerodromesWithinRange(const DtVector& center, double range) const;

   virtual std::vector<MAKVRinTerra::DtAerodromeLoader::AerodromeData> aerodromesInArea(const std::vector<DtVector>&) const;

   virtual std::vector<MAKVRinTerra::DtAerodromeLoader::AerodromeData> aerodromesAtLocation(const DtVector& location) const;

   virtual std::vector<MAKVRinTerra::DtAerodromeLoader::RunwayData> runwayAtLocation(const DtVector& location) const;

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

   virtual double terrainHeightAboveSeaLevel(DtTerrainIntersectStatus& status,
      const DtPoint& databaseLocation,
      const DtTerrainIntersectOptions& options = DtTerrainIntersectOptions()) const;

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

   virtual bool terrainHeightAndIntersection(DtTerrainIntersectStatus& status,
      const DtVector& localLocation,
      double& height, DtVrfChordIntersectionRecord& record,
      const DtTerrainIntersectOptions& options = DtTerrainIntersectOptions()) const;

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

   virtual bool terrainHeightAndIntersectionBelow(DtTerrainIntersectStatus& status,
      const DtVector& localLocation,
      double& height, DtVrfChordIntersectionRecord& record,
      const DtTerrainIntersectOptions& options = DtTerrainIntersectOptions()) 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 terrainHeightUnderWater(DtTerrainIntersectStatus& status,
      const DtVector& databaseLocation,
      double& groundHeight, DtSurface& groundSurface, DtVector& groundNormal,
      double& waterHeight, DtSurface::DtMedium &topSurfaceMedium,
      const DtTerrainIntersectOptions& options = DtTerrainIntersectOptions());

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

   virtual bool closestIntersection(DtTerrainIntersectStatus& status,
      const DtVector& localLocation, DtPoint& intersectionPoint,
      bool doNotAddDefaultRecord = false,
      const DtTerrainIntersectOptions& options = DtTerrainIntersectOptions()) 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(DtTerrainIntersectStatus& status,
      double lat, double lon,
      DtPoint& intersectionPoint,
      bool doNotAddDefaultRecord = false,
      const DtTerrainIntersectOptions& options = DtTerrainIntersectOptions()) const;

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

   virtual bool closestIntersection(DtTerrainIntersectStatus& status,
      const DtVector& localLocation,
      DtVrfChordIntersectionRecord& record,
      bool doNotAddDefaultRecord = false,
      const DtTerrainIntersectOptions& options = DtTerrainIntersectOptions()) const;

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

   virtual bool closestIntersection(DtTerrainIntersectStatus& status,
      double lat, double lon,
      DtVrfChordIntersectionRecord& record,
      bool doNotAddDefaultRecord = false,
      const DtTerrainIntersectOptions& options = DtTerrainIntersectOptions()) const;

   virtual bool closestIntersection(const std::list<DtVector>& localLocationList, 
      DtVrfChordIntersectRecordList& 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 closestIntersection(DtTerrainIntersectStatus& status,
      const std::list<DtVector>& localLocationList,
      DtVrfChordIntersectRecordList& recordList, int& numIntersections,
      bool doNotAddDefaultRecord = false,
      const DtTerrainIntersectOptions& options = DtTerrainIntersectOptions()) const;

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

   virtual bool intersect(DtTerrainIntersectStatus& status,
      const DtChord& chord, DtPoint& intersectionPoint,
      double& intersectionTime,
      const DtTerrainIntersectOptions& options = DtTerrainIntersectOptions()) const;

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

   virtual bool intersect(DtTerrainIntersectStatus& status,
      const DtChord& chord,
      DtVrfChordIntersectionRecord& record,
      const DtTerrainIntersectOptions& options = DtTerrainIntersectOptions()) const;

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

   virtual bool allIntersectsAlongChord(DtTerrainIntersectStatus& status,
      const DtChord& chord,
      DtVrfChordIntersectRecordList& intList,
      const DtTerrainIntersectOptions& options = DtTerrainIntersectOptions()) const;

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

   virtual bool allIntersectsAlongChordDebug(DtTerrainIntersectStatus& status,
      const DtChord& chord,
      DtVrfChordIntersectRecordList& intList,
      const DtTerrainIntersectOptions& options = DtTerrainIntersectOptions()) const;

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

   virtual bool intersectList(DtTerrainIntersectStatus& status,
      const std::list<DtChord>& chordList,
      DtVrfChordIntersectRecordList& recordList, int& numTerrainIntersections,
      const DtTerrainIntersectOptions& options = DtTerrainIntersectOptions()) const;

   virtual void preloadTerrainAreas(
      const DtTerrainPagingGeometryList& preloadGeometry);

   virtual void forceLoadTerrainAreas(
      const DtTerrainPagingGeometryList& forceLoadGeometry);

   virtual bool dataAvailable(const DtTerrainPagingGeometryList& geometry);

   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 void trianglesInArea(DtTriangleOutputInterface& func, DtTerrainProcessPolygonsBox& box) const;

   virtual DtTerrainInformation* terrainInformation();

   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;

   virtual DtTerrainGeometryHandle* createEntityGeometry(const DtFilename& file);

   virtual DtTerrainGeometryHandle* createEntityGeometry(const DtEntityType& file);

   virtual void loadVisuals(const DtScenarioExplorer&);

   virtual void clearCache();

   virtual DtDynamicTerrainRequestHandle addDynamicTerrainChangeRequest(
      double time,
      const std::map<DtString, DtString>& keyValueChanges,
      const DtVector& centerLocation, double radius);

   virtual DtDynamicTerrainRequestHandle addDynamicTerrainChangeRequest(
      double time,
      const std::map<DtString, DtString>& keyValueChanges,
      const std::vector<DtVector>& vertices, double width);

   virtual DtDynamicTerrainRequestHandle addDynamicTerrainChangeRequest(
      double time,
      const std::map<DtString, DtString>& keyValueChanges,
      const std::list<DtVector>& vertices);

   virtual DtDynamicTerrainRequestHandle addDynamicTerrainChangeRequest(
      double time,
      makVrv::DtDynamicTerrainChange* command);

   virtual void dynamicTerrainFeaturesInArea(
      const DtVector& centerLocation, double radius,
      std::list<DtRwDynamicTerrainInformation>& dynamicTerrainInfo, bool* dataAvailable = NULL,
      const DtString& filterKey = DtString::nullString());

   virtual void dynamicTerrainFeaturesInArea(
      const std::list<DtVector>& vertices, double width,
      std::list<DtRwDynamicTerrainInformation>& dynamicTerrainInfo, bool* dataAvailable = NULL,
      const DtString& filterKey = DtString::nullString());

   virtual void dynamicTerrainFeaturesInArea(
      const std::list<DtVector>& vertices,
      std::list<DtRwDynamicTerrainInformation>& dynamicTerrainInfo, bool* dataAvailable = NULL,
      const DtString& filterKey = DtString::nullString());

   virtual bool extractDynamicTerrainFeatureInformation(const makVrv::DtDynamicTerrainFeature& feature,
      DtRwDynamicTerrainInformation& dynamicTerrainInfo, const DtString& filterKey = DtString::nullString()) const;

   virtual DtDynamicTerrainQueryHandle queryDynamicTerrainFeatures(
      const DtDynamicTerrainQueryCallback& callback,
      makVrv::DtDynamicTerrainGeometry* geometry = 0,
      bool useOriginalGeometry = false);

   virtual void queryCurrentDynamicTerrainFeatures(
      const DtDynamicTerrainQueryCallback& callback,
      makVrv::DtDynamicTerrainGeometry* geometry = 0,
      bool useOriginalGeometry = false);

   virtual void cacheTerrainArea(int requestId,
      unsigned minLOD, unsigned maxLOD, const DtExtent& cacheArea,
      DtCacheProgressCallbackFunction fcn = 0, void* usr = 0);

   virtual void cancelCacheTerrainArea(int requestId);

   virtual void writeTerrainIndex(const DtString& name = DtString());

   virtual bool oceanLayerPresent() const;

   virtual void setOceanLayerPresent(bool b);

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

   virtual void setNonPolygonalWaterHeight(double d);

   virtual double defaultWaterDepth(const DtVector& localLocation) const;

   virtual void setDefaultWaterDepth(double);

   virtual double defaultSurfaceElevation(const DtVector& localLocation) const;

   virtual DtSurface::DtMedium mediumForUnspecPolygonsUnderWater() const;
   
   virtual void setMediumForUnspecPolygonsUnderWater(DtSurface::DtMedium m);

   virtual double landAboveWaterMinimumSeparation() const;

   virtual void setLandAboveWaterMinimumSeparation(double);

   virtual void setAccumulateIntersections(bool value);

   virtual bool accumulateIntersections() const;

   virtual void getIntersections(std::vector<DtChord>& accumulatedChords, std::vector<DtPoint>& accumulatedIntersections) const;
   
   virtual boost::signals2::connection connectToUnloadTerrain(const DtTerrainUnloadSignalType::slot_type & slotIn);

   boost::signals2::signal<void(bool)> signal_terrainPaging;

   boost::signals2::signal<void(bool)> signal_jobQueueStatusChanged;

protected:
   void insertNonPolyWaterIntoIntersectionList(
      DtVrfChordIntersectionRecord& waterInterx, 
      DtVrfChordIntersectRecordList& intrxList) const;
      
   virtual DtVrfChordIntersectionRecord blankSurfaceIntersectionRecord(
      const DtVector& localLocation, const double height) const;

   virtual bool nonPolygonalWaterIntersect(
      const DtChord& chord,
      DtVrfChordIntersectRecordList& waterRecords,
      DtIntersectionRecord::DtIntersectionType irtFlag = DtIntersectionRecord::INT_ALL_DATA) const;

   typedef std::map<DtString, DtGenericTerrainRecordCallbackListPtr >
      DtGenericTerrainRecordCallbackListMap;

   virtual DtGenericTerrainRecordCallbackListPtr findOrAddCallbackList(DtGenericTerrainRecordCallbackListMap& map,
      const DtString& recordType);

   virtual void accumulateIntersections(const DtChord& chord, const DtVrfChordIntersectionRecord& record) const;
   virtual void accumulateIntersections(const DtChord& chord, const DtVrfChordIntersectRecordList& intList) const;
   virtual void accumulateIntersections(const std::list<DtChord>& chordList, const DtVrfChordIntersectRecordList& recordList) const;

protected:
   virtual void terrainPaging(bool);

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;

   makArchives::DtTerrainRecord* myTerrainRecord;


   DtGenericTerrainRecordCallbackListMap myGenericTerrainRecordCallbacklists;

   //DtTerrainChangeNotificationCallbackList myTerrainChangeNotificationCallbackList;

   bool myAccumulateIntersections;

   std::vector<DtChord> myAccumulatedChords;
   std::vector<DtPoint> myAccumulatedIntersectionPoints;

   DtTerrainUnloadSignalType myUnloadTerrainSignal;
   bool myActive = false;
};

#define DtRegisterTerrainImplementationFunctionName "DtRegisterTerrainImplementation"

typedef bool (*DtRegisterTerrainImplementationLibFcn)(DtTerrainInterface*);


#define DtDeregisterTerrainImplementationFunctionName "DtDeregisterTerrainImplementation"

typedef void (*DtDeregisterTerrainImplementationLibFcn)();