terrainSourcePager.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2025 MAK Technologies, Inc.
** All rights reserved.
*******************************************************************************/
#pragma once


#include <string>

#include <tbb/spin_rw_mutex.h>
#include <tbb/concurrent_queue.h>
#include <atomic>

#include <osg/Node>

#include <vantageTerrainImplementation/terrainPagerCommand.h>
#include <vantageTerrainImplementation/vantageTerrainImplementationDefines.h>
#include <vantageTerrainImplementation/tileData.h>
#include <vantageTerrainImplementation/cutoutCache.h>

#include <vrfutil/terrainInterfaceConfig.h>

#include <vrvCore/DtDynamicTerrainWorld.h>

#include <boost/unordered_map.hpp>
#include <boost/optional.hpp>

#include <boost/geometry.hpp>
#include <boost/geometry/geometries/point.hpp>
#include <boost/geometry/geometries/box.hpp>

#include <boost/geometry/index/rtree.hpp>

#include <map>

#define DO_NOT_USE_CUTOUT_CACHE

class DtVantageTerrainEngine;
class DtActivePageTracker;
class DtTerrainSourceTracker;
class DtVrfSimTerrainProcessor;
class Coordinate_System;

typedef std::multimap<int, DtTerrainPagerCommand*> DtCommandPriorityMultimap;

class DT_DLL_vantageTerrainImplementation DtTerrainSourcePager
   : public DtTerrainInterfaceConfig
{
public:

   DtTerrainSourcePager(DtVantageTerrainEngine* terrainEngine, osgEarth::MapNode* mapNode);

   virtual ~DtTerrainSourcePager() override;

   virtual bool init();

   virtual void tick();

   virtual void setEarthFileName(const DtFilename& file);

   virtual void setCutoutFilename(const char* OptionalSuffixe=NULL);

   virtual bool isContainedWithinCutoutCache(const osgEarth::GeoExtent & extent, const osgEarth::TileKey & key);

   virtual DtTerrainSourceTracker* createTerrainSourceTracker(DtVantageTerrainEngine*) = 0;

   virtual DtTerrainSourceTracker* terrainSourceTracker();

   virtual void updatePageTracker(DtTerrainIntersectIDType intersectId = 0) = 0;

   virtual int highestPriorityPendingWork();

   virtual void processCommandQueue();

   virtual void setCurrentTime(const double& currentTime);

   virtual unsigned long numTriangles() const;

   virtual unsigned long numPendingCommands() const;
   virtual std::map<int, unsigned long> numPendingCommandsByPriority() const;

   virtual bool quitFlagSet() const;

   virtual void setQuit(bool);

   virtual const Coordinate_System* localCS() const;

   virtual void setLabel(const DtString&);
   virtual DtString label() const;

   virtual DtString type() const = 0;

   virtual unsigned queuePageReloadsWithinExtent(const osgEarth::GeoExtent & extent, const DtUUID& dynamicUuid, bool isRemoval = false);

   virtual void clearCutoutCache();

   virtual void clearTerrainEngineReference();

protected:
   class TerrainRecord
   {
   public:
      typedef boost::unordered_map<DtNodeId, TerrainRecord> Map;

      void add(const makVrv::DtDynamicTerrainWorld::FeatureHandle& h);
      void pageOut();

   protected:
      makVrv::DtDynamicTerrainWorld::FeatureHandle myFeatures;
   };

   class DynamicTerrainNode
   {
   public:
      DynamicTerrainNode(const DtUUID& dynamicTerrainUUID, const osgEarth::GeoExtent& extent);
      DynamicTerrainNode(const DynamicTerrainNode & clone);
      DynamicTerrainNode& operator=(const DynamicTerrainNode& rhs);
      
      void setGeoExent(const osgEarth::GeoExtent& extent);
      const osgEarth::GeoExtent& geoExtent() const;
      
      void setUUID(const DtUUID& dynamicTerrainUUID);
      const DtUUID& uuid() const;

   protected:
      osgEarth::GeoExtent myExtent;
      DtUUID myUuid;
      
   };

   typedef boost::geometry::model::point<double, 2, boost::geometry::cs::geographic<boost::geometry::degree> > DtDynamicTerrainRtreeCoord;
   typedef boost::geometry::model::box<DtDynamicTerrainRtreeCoord> DtDynamicTerrainRtreeBox;
   typedef std::pair<DtDynamicTerrainRtreeBox, std::shared_ptr<DynamicTerrainNode> > DtDynamicTerrainRtreeValue;

   typedef boost::geometry::index::rtree<DtDynamicTerrainRtreeValue, boost::geometry::index::quadratic<16> > DtDynamicTerrainRtree;

   
   class DtPendingTileKeyReload
   {
   public:
      DtPendingTileKeyReload();
      DtPendingTileKeyReload(const DtPendingTileKeyReload & clone);
      DtPendingTileKeyReload(const osgEarth::TileKey & key, bool isRemoval, unsigned count = 1);
      bool operator<(const DtPendingTileKeyReload & rhs) const;
      bool operator==(const DtPendingTileKeyReload & rhs) const;
      bool operator!=(const DtPendingTileKeyReload & rhs) const;
      DtPendingTileKeyReload & operator=(const DtPendingTileKeyReload & rhs);

      bool myIsRemoval;
      osgEarth::TileKey myTileKey;
   };

   typedef std::set<DtPendingTileKeyReload> DtPendingTileKeyReloadSet;

   virtual unsigned int addTerrain(const osg::ref_ptr<osg::Node>& node, DtVrfSimTerrainProcessor&,
      const char* debugWhoisCalling = "unknown", const char* defaulSoilType = "");
   
   virtual unsigned int removeTerrain(const osg::ref_ptr<osg::Node>& node, const char* debugWhoisCalling = "unknown");

   virtual void addTriangles(unsigned int, const char* debugString="unknown");
   
   virtual void removeTriangles(unsigned int, const char* debugString = "unknown");

   void modifyDynamicTerrainExtent(const DtPoint & swCorner, const DtPoint & neCorner, bool isRemoval, unsigned amount = 1);

   bool hasDynamicTerrainWithinExtent(const DtPoint & swCorner, const DtPoint& neCorner) const;

   bool modifyDynamicTerrain(const osgEarth::GeoExtent& dynamicTerrainExtent, const DtUUID& dynamicTerrainUUID, bool isRemoval);
   bool hasDynamicTerrainWithinExtent(std::vector<DtDynamicTerrainRtreeValue> & values, const osgEarth::GeoExtent & extent);

   void eraseCommand(DtCommandPriorityMultimap::iterator& itr);
   void eraseAndInsertCommand(DtCommandPriorityMultimap::iterator& itr);
   bool getFirsCommand(DtCommandPriorityMultimap::iterator& itrToProcess);

   typedef tbb::spin_rw_mutex Mutex;
   mutable Mutex myMutex;
   static tbb::spin_rw_mutex myMultiMapMutex;

   DtString myName;

   std::atomic<bool> myQuitFlag;

   DtVantageTerrainEngine* myTerrainEngine;

   DtTerrainSourceTracker* myTerrainSourceTracker;

   double myCurrentTime;
   
   DtPagerCommandQueue myCommandQueue;

   DtCommandPriorityMultimap myPriorityCommandMultimap;

   unsigned long myNumTriangles;

   tbb::spin_mutex myTerrainRecordsMutex;
   TerrainRecord::Map myTerrainRecords;

   boost::optional<short int> myDefaultBulletObjectMask;

   osgEarth::MapNode* myMapNode;
   const osgEarth::Map* myMap;
   const osgEarth::Profile* myMapProfile;

   DtFilename myEarthFile;

   const std::unique_ptr<DtCutoutCache> myCutoutCache;

   mutable tbb::spin_rw_mutex myPagedInTilesMapMutex;

   DtTerrainTileMap myPagedInTilesMap;

   mutable tbb::spin_rw_mutex myTileKeysForReloadMutex;
   DtPendingTileKeyReloadSet myTileKeysForReload;

   mutable tbb::spin_rw_mutex myDynamicTerrainRtreeMutex;

   DtDynamicTerrainRtree myDynamicTerrainRtree;

   std::set<osgEarth::TileKey> mySetOfTileKeysToReload;

   std::string myDefaultSoilType;
};