terrainInterfaceConfig.h

Go to the documentation of this file.

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



#pragma once

#include <vrfutil/vrfutilDefines.h>
#include <readerWriter/readerWriter.h>
#include <readerWriter/rwInt.h>
#include <readerWriter/rwReal.h>
#include <readerWriter/rwString.h>
#include <readerWriter/rwBoolean.h>
#include "readerWriter/rwVector.h"
#include <vrfutil/rwTemplatedList.h>

#include <iosfwd>

#include <boost/noncopyable.hpp>

class DtReaderWriterRegistry;

class DT_DLL_vrfutil DtTerrainInterfaceConfig
   : public DtReaderWriter
   , boost::noncopyable
{
   class DT_DLL_vrfutil Configator : boost::noncopyable
   {
   public:
      virtual ~Configator();
      virtual bool configure(DtReaderWriter&, bool ignoreUnspecified=true) const = 0;
   };

   template <typename D>
   class TerrainParam : public D, public Configator
   {
   public:
      explicit TerrainParam(
         const std::string& name, DtReaderWriterRegistry* parentRegistry)
         : D(name, parentRegistry)
      {
         //this->setValueSpecified(false, true);
         this->myValueSpecified = true;
      }

      explicit TerrainParam(const std::string& name, bool def, DtReaderWriterRegistry* parent)
         : D(def, name, parent)
      {
         //this->setValueSpecified(false, true);
         this->myValueSpecified = true;
      }

      template <typename T>
      explicit TerrainParam(const std::string& name, T def, DtReaderWriterRegistry* parent)
         : D(name, def, parent)
      {
         //this->setValueSpecified(false, true);
         this->myValueSpecified = true;
      }

      virtual bool valuePresent() const
      {
         return this->valueSpecified();
      }

      virtual bool configure(DtReaderWriter& rw, bool ignoreUnspecified) const
      {
         if (ignoreUnspecified && !valuePresent())
            return true;

         if (D* rwD = dynamic_cast<D*>(&rw))
         {
            *rwD = *this;
            return true;
         }

         return false;
      }

      template <typename T>
      TerrainParam& operator=(T t)
      {
         D::operator=(t);
         this->setValueSpecified(true);
         return *this;
      }
   };

   template <typename T>
   class ListT : public DtRwTemplatedListPtr<T, true>
      , public Configator
   {
      typedef DtRwTemplatedListPtr<T, true> ListBase;

   public:
      ListT(const std::string& name, DtReaderWriterRegistry* parentRegistry)
         : ListBase(name, parentRegistry)
      {
      }

      virtual bool configure(DtReaderWriter& rw, bool ignoreUnspecified) const
      {
         ListBase* rwlist = dynamic_cast<ListBase*>(&rw);
         if (!rwlist)
            return false;

         rwlist->removeAndDeleteAll();

         bool success = true;
         typename ListBase::iterator iter(*this);
         for (T* info=iter.first(); info; info=iter.next())
         {
            std::auto_ptr<T> t(new T());
            info->configure(*t, ignoreUnspecified);
            rwlist->add(t.release());
         }

         return success;
      }

      //using ListBase::operator=;
   };

   typedef TerrainParam<DtRwBoolean>       TBool;
   typedef TerrainParam<DtRwInt>           TInt;
   typedef TerrainParam<DtRwReal>          TReal;
   typedef TerrainParam<DtRwString>        TString;
   typedef TerrainParam<DtRwVector>        TVector;
   typedef ListT<DtTerrainInterfaceConfig> TList;

   TList subconfigurations;

public:
   explicit DtTerrainInterfaceConfig(const std::string& matchPattern = "");

   DtTerrainInterfaceConfig& operator=(const DtTerrainInterfaceConfig&);

   virtual bool loadFromFile(const std::string& file, std::ostream& log);
   virtual bool loadFromFile(const std::string& file);

   virtual bool loadFromSourceSpecificFile(
      const std::string& file,
      const std::string& ext = "mtl");

   virtual void configure(
      DtTerrainInterfaceConfig& config,
      const std::string& matchText,
      bool ignoreUnspecified=true) const;

   virtual void configure(DtTerrainInterfaceConfig& config, bool ignoreUnspecified=true) const;

   virtual void configurePaths(std::string& path) const;

   virtual void print(std::ostream&, bool printUnspecified=true) const;

   DtString prettyPrint() const;

   void setName(const DtString&);

   TInt maxNetworkThreads;

   TInt maxUnusedFeatures;

   TInt areaPageTableLoadingThreads;

   TInt featuresHighestLoadLOD;

   TInt featuresLowestLoadLOD;

   TInt featuresPerTileTarget;

   TInt featuresMaxIndexLOD;

   TInt minFeaturesToIndexTile;

   TReal featuresIndexRatio;

   TBool deduplicateFeatures;

   TBool cacheLastFeatureTile;

   TBool loadTerraPageImagery;

   TBool loadTerraPageLocalMaterials;

   TInt pathFinderMaxSize;

   TInt pathFinderPageTableDepth;

   TReal pathFinderLoadTimeout;

   TReal pathFinderVertexTolerance;

   TInt pathFinderMinVertexSearch;

   TReal pathFinderDotProductDistanceThreshold;

   TReal pathFinderMinSearchRadius;

   TInt triangleThreshold;

   TInt cacheOnlyMaxLod;

   TBool loadImagery;

   TInt blockingIntersectPageInPriority;

   TInt intersectPageInPriority;

   TInt pageOutPriority;

   TInt defaultPreloadPriority;

   TVector spatialSubdivisionDimensions;

   TBool useS57ForTerrainGeneration;

   TBool oceanLayerPresent;

   TReal seaLevel;

   TReal seaFloor;

   TBool useSoundingPoints;

   TBool pageFeatures;

   TString LOSFeaturesQueryName;

   TReal featuresMinUnloadTime;

   TInt terrainMinUnloadIntersectDiff;

   TInt minElevationIndexLOD;

   TInt maxElevationIndexLOD;

   TReal elevationTriangleOutputMergeTolerance;

   TReal elevationIntersectTriangleMergeTolerance;

   TReal maxChordLengthBeforeSplit;

   TInt maxElevationChordSplitTestLOD;

   TInt lowFidelityIntersectionLOD;

   TString pluginsDirectory;

   TInt featureIntersectionMode;

   TBool activePagerTbbMode;

   TInt nbTerrainThread;

   static void setModelDefinitionDefault(const std::string&);

   std::string modelDefinitionPath() const;

   std::string simCachePath() const;

   std::string featureConfigFile() const;

protected:
   TString myModelDefinitionPath;

   TString mySimCachePath;

   TString myFeatureConfigFile;
};

DT_DLL_vrfutil std::ostream& operator<<(std::ostream&, const DtTerrainInterfaceConfig&);