terrainImplementation.h

Go to the documentation of this file.

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



#pragma once

#include "terrainInterface/terrainInterfaceDefines.h"
#include "terrainInterface/terrainIntersectOptions.h"
#include "terrainInterface/terrainInformation.h"
#include <geometry/intersectionRecord.h>
#include <geometry/chord.h>
#include <gdb/vectorNetworkRecord.h>
#include <gdb/vectorNetworkIntersectionRecord.h>
#include <vrfutil/vrfChordIntersectRecordList.h>
#include "tdbutil/stringKeyFactory.h"
#include "terrainInterface/terrainPagingGeometry.h"
#include "terrainInterface/terrainProcessPolygonsBox.h"
#include "features/feature.h"
#include "features/featureSet.h"
#include "features/featureContext.h"
#include "vrfutil/terrainInterfaceConfig.h"
#include <vlpi/appearance.h>

#include <string>
#include <boost/noncopyable.hpp>
#include <boost/signals2.hpp>

class DtVrfChordIntersectionRecord;
class DtVrfChordIntersectRecordList;
class DtScenarioExplorer;
class DtString;
class Coordinate_System;
class DtConsoleCommandManager;
class DtTerrainCapabilities;
class DtTaitBryan;
class DtTerrainIntersectOptions;
class DtTerrainIntersectStatus;
class DtEntityType;


struct DT_DLL_terrainInterface DtTerrainChangeNotificationInfo
{
   DtTerrainChangeNotificationInfo()
   {
      mySpatExtent = DtExtent::nullExtent();
      myChangeType = DtString::nullString();
      myIsInDefaultState = false;
      myLastStateWasDefaultState = true;
   }

   DtExtent mySpatExtent;
   DtString myChangeType;
   bool myIsInDefaultState;
   bool myLastStateWasDefaultState;
};

struct DtTerrainChangeNotificationInfoHash
{
   std::size_t operator()(const DtTerrainChangeNotificationInfo &val) const noexcept
   {
      std::size_t hExtentMinX = std::hash<double>{}(val.mySpatExtent.minX());
      std::size_t hExtentMinY = std::hash<double>{}(val.mySpatExtent.minY());
      std::size_t hExtentMinZ = std::hash<double>{}(val.mySpatExtent.minZ());
      std::size_t hExtentMaxX = std::hash<double>{}(val.mySpatExtent.maxX());
      std::size_t hExtentMaxY = std::hash<double>{}(val.mySpatExtent.maxY());
      std::size_t hExtentMaxZ = std::hash<double>{}(val.mySpatExtent.maxZ());
      std::size_t hChangeType = std::hash<std::string>{}(std::string(val.myChangeType.c_str()));
      std::size_t hIsInDefaultState = std::hash<bool>{}(val.myIsInDefaultState);
      std::size_t hLastStateWasDefaultState = std::hash<bool>{}(val.myLastStateWasDefaultState);

      std::size_t seed = 0;
      boost::hash_combine(seed, hExtentMinX);
      boost::hash_combine(seed, hExtentMinY);
      boost::hash_combine(seed, hExtentMinZ);
      boost::hash_combine(seed, hExtentMaxX);
      boost::hash_combine(seed, hExtentMaxY);
      boost::hash_combine(seed, hExtentMaxZ);
      boost::hash_combine(seed, hChangeType);
      boost::hash_combine(seed, hIsInDefaultState);
      boost::hash_combine(seed, hLastStateWasDefaultState);

      return seed;
   }
};

struct DtTerrainChangeNotificationInfoEqualto
{
   bool operator()(const DtTerrainChangeNotificationInfo &lhs, const DtTerrainChangeNotificationInfo &rhs) const noexcept
   {
      if (lhs.mySpatExtent == rhs.mySpatExtent &&
         lhs.myChangeType == rhs.myChangeType &&
         lhs.myIsInDefaultState == rhs.myIsInDefaultState &&
         lhs.myLastStateWasDefaultState == rhs.myLastStateWasDefaultState)
      {
         return true;
      }

      return false;
   }
};


typedef void (*DtCacheProgressCallbackFunction)(int requestId, int current, bool completed, double elapsedTime, void* usr);

typedef void(*DtTerrainChangeNotificationCallbackFcn)(const DtTerrainChangeNotificationInfo& terrainChangeInfo, void* userData);

namespace makArchives
{
   class DtGenericTerrainRecord;
}

namespace MAKVRinTerra
{
   class DtProj;
   class DtAerodromeLoader;
}

namespace makVrv
{
   class DtDynamicTerrainGeometry;
   class DtDynamicTerrainChange;
   class DtDynamicTerrainFeature;
   class DtDynamicTerrainChanges;
}

class DT_DLL_terrainInterface DtDynamicTerrainRequestHandle
{
public:

   class RequestHandleImpl
   {
   public:
      RequestHandleImpl() {};
      virtual void removeTerrainChange() = 0;
      virtual void releaseOwnership() = 0;
   };

   DtDynamicTerrainRequestHandle();

   DtDynamicTerrainRequestHandle(const std::shared_ptr<RequestHandleImpl>&);

   void removeTerrainChange();

   void releaseOwnership();

private:

   std::shared_ptr<RequestHandleImpl> myImpl;
};

class DT_DLL_terrainInterface DtDynamicTerrainQueryHandle
{
public:

   class QueryHandleImpl
   {
   public:
      QueryHandleImpl() {};
      virtual void removeQuery() = 0;
      virtual void releaseOwnership() = 0;
   };

   DtDynamicTerrainQueryHandle();

   DtDynamicTerrainQueryHandle(const std::shared_ptr<QueryHandleImpl>&);

   void removeQuery();

   void releaseOwnership();

private:

   std::shared_ptr<QueryHandleImpl> myImpl;
};

typedef boost::function<void (const makVrv::DtDynamicTerrainFeature&)>
   DtDynamicTerrainQueryCallback;

class DT_DLL_terrainInterface DtTerrainGeometryHandle
{
public:
   virtual ~DtTerrainGeometryHandle();

   virtual bool isDisabled() const = 0;

   virtual void disable() = 0;

   virtual void setAppearance(DtAppearance app) = 0;

   virtual void setPosition(const DtPoint& location, const DtDcm& orientation) = 0;

   virtual DtVector position() const = 0;
   virtual DtDcm orientation() const = 0;
};

class DT_DLL_terrainInterface DtTerrainImplementation
   : boost::noncopyable
{
public:
   DtTerrainImplementation(DtConsoleCommandManager* cmdManager);
   virtual ~DtTerrainImplementation();

   virtual MAKVRinTerra::DtFeatureDatabase& featureDatabase();
   virtual const MAKVRinTerra::DtFeatureDatabase& featureDatabase() const;

   virtual MAKVRinTerra::DtFeatureContext& featureContext();
   virtual const MAKVRinTerra::DtFeatureContext& featureContext() const;

   virtual MAKVRinTerra::DtAerodromeLoader& aerodromeLoader();
   virtual const MAKVRinTerra::DtAerodromeLoader& aerodromeLoader() const;
   virtual void cacheAerodromes();

   virtual void init();

   virtual void finishedLoading(const MAKVRinTerra::DtProj& proj);

   virtual bool loadTerrain(const makArchives::DtGenericTerrainRecord& rec) = 0;

   virtual void clearCache();

   virtual void shutdown(bool block=true);

   virtual const Coordinate_System* coordinateSystem() const = 0;

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

   virtual bool createFromExtent(const Dt3dBoundingVolume&);

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

   virtual DtTerrainInterfaceConfig& configurationOptions();
   virtual const DtTerrainInterfaceConfig& configurationOptions() const;

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

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

   virtual void preloadTerrainAreas(
      const DtTerrainPagingGeometryList& preloadGeometry) {};

   virtual bool dataAvailable(
      const DtTerrainPagingGeometryList& geometry,
      DtTerrainIntersectOptions::Fidelity = DtTerrainIntersectOptions::MAX_FIDELITY) { return true; }

   virtual const DtTerrainCapabilities* terrainCapabilities() const = 0;

   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 processTrianglesInArea(DtTriangleOutputInterface&, const DtTerrainProcessPolygonsBox&, DtTerrainCategoryMask terrainCategoryMask) const = 0;

   virtual void processTrianglesForGeometry(DtTriangleOutputInterface&, DtTerrainGeometryId) const {};

   virtual DtTerrainInformation* terrainInformation() { return NULL; };

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

   virtual bool hasFeatureContext() const;

   virtual DtTerrainGeometryHandle* createEntityGeometry(const DtFilename& file) { return 0; }

   virtual DtTerrainGeometryHandle* createEntityGeometry(const DtEntityType& file) { return 0; }

   virtual void loadVisuals(const DtScenarioExplorer&) {};

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

   typedef boost::function<void (const makVrv::DtDynamicTerrainFeature&)>
      DtDynamicTerrainQueryCallback;

   /*
   virtual DtDynamicTerrainRequestHandle addDynamicTerrainCraterRequest(
      double time,
      makVrv::DtDynamicTerrainChange* command,
      const std::map<DtString, DtString>& keyValueChanges,
      const DtVector& centerLocation,
      double radius) {
      return DtDynamicTerrainRequestHandle(); }
      */

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

   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);

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

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

   virtual void invokeTerrainChangeNotificationCallBacks();

   virtual void blockOnPendingOperations() {};

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

protected:
   DtTerrainInterfaceConfig myConfig;

   bool myAssertOnBlockingTerrainCalls;
   bool myWarnOnBlockingTerrainCalls;

   std::unique_ptr<MAKVRinTerra::DtFeatureDatabase> myFeatureDatabase;
   std::unique_ptr<MAKVRinTerra::DtFeatureContext> myFeatureContext;
   std::shared_ptr<MAKVRinTerra::DtAerodromeLoader> myAerodromeLoader;
};

typedef DtStringKeyFactoryWithParam<DtTerrainImplementation, 
   DtConsoleCommandManager*> DtTerrainImplementationFactory;
typedef DtTerrainImplementationFactory::DtCreatorFcn 
   DtTerrainImplementationCreatorFcn;