terrainSourceTracker.h

Go to the documentation of this file.

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


#pragma once

#include <vantageTerrainImplementation/terrainSourcePager.h>
#include <vantageTerrainImplementation/vantageTerrainImplementationDefines.h>
#include <vantageTerrainImplementation/osgToBullet.h>

#include <geometry/sphere.h>

#include <terrainInterface/terrainPagingGeometry.h>
#include <terrainInterface/terrainIntersectOptions.h>

#include <terrainInterface/debugDrawTerrainOutputInterface.h>

#include <vrfutil/terrainInterfaceConfig.h>
#include <vrfutil/sphere2.h>

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

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

#include <osgEarth/TileKey>

typedef boost::unordered_multimap<DtNodeId, std::shared_ptr<btCollisionObject> > DtNodeToCollObjMMap;
typedef std::pair<DtNodeToCollObjMMap::iterator, DtNodeToCollObjMMap::iterator> 
DtNodeToCollObjRangePair;

class DtVantageTerrainEngine;
struct DtTileData;

struct TileCache
{
public:  
   TileCache(std::shared_ptr<DtTileData> tilePointer, const DtChord* chord = NULL) :
      myTilePointer(tilePointer),
      myIsChord(false)
   {
      if (chord != NULL)
      {
         myIsChord = true;
         myPt0 = chord->endpoint0();
         myPt1 = chord->endpoint1();
      }
   }
   TileCache(const TileCache& tile) :
      myTilePointer(tile.myTilePointer),
      myIsChord(tile.myIsChord),
      myPt0(tile.myPt0),
      myPt1(tile.myPt1)
   {

   }

   std::shared_ptr<DtTileData> myTilePointer;
   bool myIsChord;
   DtPoint myPt0;
   DtPoint myPt1;
};

typedef std::vector<TileCache> tileDataCacheVector;

class DT_DLL_vantageTerrainImplementation DtTerrainSourceTracker
{
public:

   DtTerrainSourceTracker(DtVantageTerrainEngine*, DtPagerCommandQueue* commandQueue, osgEarth::MapNode* mapNode);

   virtual ~DtTerrainSourceTracker();

   virtual DtTerrainInterfaceConfig& configOptions();
   virtual const DtTerrainInterfaceConfig& configOptions() const;

   virtual bool init(DtTerrainSourcePager&);

   virtual boost::optional<DtTerrainIntersectOptions::Fidelity> intersectFidelity() const;

   virtual DtTerrainCategoryMask terrainCategories() const;

   virtual bool dataAvailable(DtPagingMetaDataPtr metaData, 
      DtTerrainPagingGeometryPtr geometry) = 0;

   virtual void pageInData(DtPagingMetaDataPtr metaData, 
      DtTerrainPagingGeometryPtr geometry) = 0;

   //Should return true if the tracker is capable of paging out data.
   virtual bool canPageOutData(DtTerrainIntersectIDType intersectId) = 0;

   virtual DtTerrainIntersectIDType findOldestPagedData(unsigned int& numTriangles) = 0;

   virtual void pageOutOldestData(const int priority) = 0;

   virtual void addNodesToCollisionMapping(DtNodeId node, 
      DtCollisionObjectList* collObjList);

   virtual void removeNodeToCollisionMappings(DtNodeId node);

   virtual DtCollisionObjectList collisionObjectsForNode(DtNodeId node);

   virtual osgEarth::MapNode* mapNode() const;

   virtual const osgEarth::Profile* profile() const;

   virtual const Coordinate_System* localCS() const;

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

   virtual void printInfo() const;
   
   virtual void getPageOutData(DtNodeBoundingList& nodeBoundingList);

   virtual void getPageInData(DtNodeBoundingList& nodeBoundingList);

   virtual void getProceduralTreeTile(DtDebugDrawTerrainOutputInterface::terrainLineList& nodeBoundingList);

   virtual unsigned getMaxLODForBilinearIntersection() const;

   virtual double intersetionTriangleMergeTolerance() const;

   virtual bool useLandCoverData() const;

   virtual bool useLifeMapLayer() const;

   virtual void getSoilFromString(const std::string & soilType, DtSurface& surface) const;

   virtual double triangleOutputMergeTolerance() const;

   virtual unsigned minElevationIndexLOD() const;

   virtual unsigned maxElevationIndexLOD() const;

   virtual unsigned maxLOD() const;

   virtual bool useRawElevation() const;

   virtual osgEarth::TileKey getBestTileKey(const osgEarth::TileKey&) const;

   virtual bool findTileInCache(const DtTerrainPagingGeometry* geometry, std::vector< std::shared_ptr<DtTileData> >& data,
      const DtChord* chord=NULL) const;

   virtual void addTileToCache(const std::shared_ptr<DtTileData>& data, const DtChord* chord = NULL);

   virtual void clearTileCache();

   virtual unsigned minElevationTileLoadingLOD() const;
   virtual void setMinElevationTileLoading(unsigned lod);


protected:

   DtString myLabel;

   DtTerrainInterfaceConfig myConfig;

   DtPagerCommandQueue* myCommandQueue;

   DtNodeToCollObjMMap myNodeToCollObjMMap;

   mutable tbb::spin_rw_mutex myMutex;

   mutable tbb::spin_rw_mutex myTileCacheMutex;

   DtVantageTerrainEngine* myVantageTerrainEngine;

   const osg::ref_ptr<osgEarth::MapNode> myMapNode;
   const osgEarth::Map* myMap;
   const osgEarth::Profile* myMapProfile;

   tileDataCacheVector myTileDataCache;

   std::atomic<int> myTileCacheHit;
   std::atomic<int> myTileCacheQuery;

   unsigned myMinElevationTileLoadingLOD;

   DtTerrainSourcePager* myPager;
};

class DT_DLL_vantageTerrainImplementation TileDataCallback
{
public:
   TileDataCallback() { myIsFinished = false; };

   virtual bool operator()(const std::shared_ptr<DtTileData>& tile) = 0;

   virtual bool finish() const { return myIsFinished; }
   virtual void setFinish(bool finish) { myIsFinished=finish; }

protected:
   
   bool myIsFinished;
};