DtDeInitializer.h

Go to the documentation of this file.

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


#pragma once

#include <vrvUtil/DtDebugLog.h>
#include <vrvUtil/DtDriverConfiguration.h> 
#include <vrvUtil/DtDeConfiguration.h>
#include <vrvUtil/DtGuiConfiguration.h>
#include <vrvUtil/DtInputDriverConfiguration.h>
#include <vrvUtil/DtDePathConfiguration.h>
#include <vrvUtil/DtDisplayConfiguration.h> 
#include <vrvUtil/DtConfiguration.h>
#include <vrvUtil/DtRecordHolder.h>
#include <vrvUtil/vrvUtil.h>

#include <vrvMath/DtVector2.h>
#include <vrvMath/DtVector3.h>

#include <vrvCore/DtRendererThreadingModel.h>

#include <makArchives/DtObserverStateRecord.h>

#include <unordered_set>

namespace makVrv
{

   class DtBaseRecordHolder;

   class DT_DLL_VRVUTIL DtDeInitializer : public DtConfiguration
   {
   public:

      enum DeMode
      {
         NoMode = 0,
         MasterMode = 1,
         SlaveMode = 2,
         DeMode_end  
      };

      enum DeFeatures
      {
         Features_None = 0,
         Features_2D = 1,
         Features_3D = 2,
         Features_Stealth = Features_3D | Features_2D,
         DeFeatures_end
      };


      typedef std::vector<std::pair<std::string, DtConfiguration> >
         DriverInstanceList;

      typedef std::map<std::string, std::string> AuthorizationCodeMap;

      typedef std::vector<std::pair<std::string, makArchives::DtObserverStateRecord> >
         ObserverStateMap;

      typedef std::map<std::string, DtBaseRecordHolder*> DefaultRecordMap;

      struct DisplayConnection
      {
         int port;
         std::string address;
         DtDisplayConfiguration configuration;

         template<class Archive>
         void serialize(Archive& ar, const unsigned int version)
         {
            ar& BOOST_SERIALIZATION_NVP(port);
            ar& BOOST_SERIALIZATION_NVP(address);
            ar& BOOST_SERIALIZATION_NVP(configuration);
         }
      };

      typedef std::vector<DisplayConnection> DisplayConnections;

   public:

      DtDeInitializer(const std::string& name = "");

      DtDeInitializer(const DtDeInitializer& initializer);

      DtDeInitializer& operator = (const DtDeInitializer& initializer);

      virtual ~DtDeInitializer();

      void setFeatures(DeFeatures features);

      DeFeatures features() const;

      bool featureSupported(DeFeatures feature) const;

      DT_DECLARE_serialize_FUNCTIONS

         const DtDriverConfiguration& driverConfiguration() const;
      DtDriverConfiguration& driverConfiguration();

      void setDriverConfiguration(const DtDriverConfiguration&);

      const DtGuiConfiguration& guiConfiguration() const;
      DtGuiConfiguration& guiConfiguration();

      void setGuiConfiguration(const DtGuiConfiguration& config);

      const DtInputDriverConfiguration& inputDriverConfiguration() const;
      DtInputDriverConfiguration& inputDriverConfiguration();

      void setInputDriverConfiguration(const DtInputDriverConfiguration& config);

      const std::string& displayName() const;

      void setDisplayEngineName(const std::string& name);

      DtDeInitializer::DeMode deMode() const;

      void setDeMode(DtDeInitializer::DeMode mode);

      void setDefaultDrivers(const DriverInstanceList& drivers);

      const DriverInstanceList& defaultDrivers() const;

      void setDeConfiguration(const DtDeConfiguration& config);

      DtDeConfiguration& deConfiguration();

      const DtDeConfiguration& deConfiguration() const;

      void setCoordinateSystem(const std::string& coordinateSystem,
         const std::string& parameters);

      const std::string& coordinateSystem() const;

      const std::string& coordinateSystemParameters() const;

      void setNotifyLevel(DtDebugLog::PrintLevel level);

      DtDebugLog::PrintLevel notifyLevel() const;

      void setLogFileName(const std::string& filename);

      const std::string& logFileName() const;

      void setModelPreloadFilename(const std::string& filename);

      const std::string& modelPreloadFilename() const;

      void setDiscoveredModelPreloadFilename(const std::string& filename);

      const std::string& discoveredModelPreloadFilename() const;

      void setAutoLoadDrivers(bool autoLoad);

      bool autoLoadDrivers() const;

      void setAutoStartDrivers(const std::vector<std::string>& names);

      const std::vector<std::string>& autoStartDrivers() const;

      void setAuthorizationCodeMap(const AuthorizationCodeMap& map);

      void addAuthorizationCodeMapping(const std::string& key,
         const std::string& value);

      void removeAuthorizationCodeMapping(const std::string& key);

      const std::string* findAuthorizationCodeValue(const std::string& key) const;

      void setObserverStateMap(const ObserverStateMap& osm);

      const ObserverStateMap& observerStateMap() const;

      void setTerrainObserverViewsEnabled(bool enable);

      bool terrainObserverViewsEnabled() const;

      const std::vector<std::string>& mappingFilesToLoad() const;

      void setMappingFilesToLoad(const std::vector<std::string>&);

      const std::vector<std::string>& entityElementDefinitionHiersToMerge() const;
      void setEntityElementDefinitionHiersToMerge(const std::vector<std::string>& filesOrDirs);
      
      const std::vector<std::string>& entityElementDefinitionLeafsToMerge() const;
      void setEntityElementDefinitionLeafsToMerge(const std::vector<std::string>& filesOrDirs);
      
      const std::vector<std::string>& aggregateElementDefinitionHiersToMerge() const;
      void setAggregateElementDefinitionHiersToMerge(const std::vector<std::string>& filesOrDirs);
      
      const std::vector<std::string>& aggregateElementDefinitionLeafsToMerge() const;
      void setAggregateElementDefinitionLeafsToMerge(const std::vector<std::string>& filesOrDirs);
      
      const std::vector<std::string>& tacticalGraphicsElementDefinitionHiersToMerge() const;
      void setTacticalGraphicsElementDefinitionHiersToMerge(const std::vector<std::string>& filesOrDirs);
      
      const std::vector<std::string>& tacticalGraphicsElementDefinitionLeafsToMerge() const;
      void setTacticalGraphicsElementDefinitionLeafsToMerge(const std::vector<std::string>& filesOrDirs);
      
      const std::vector<std::string>& modelDefinitionFilesOrDirsToMerge() const;
      void setModelDefinitionFilesOrDirsToMerge(const std::vector<std::string>& filesOrDirs);
      
      const std::vector<std::string>& entityTypeMapFilesOrDirsToMerge() const;
      void setEntityTypeMapFilesOrDirsToMerge(const std::vector<std::string>& filesOrDirs);
      
      const std::vector<std::string>& aggregateTypeMapFilesOrDirsToMerge() const;
      void setAggregateTypeMapFilesOrDirsToMerge(const std::vector<std::string>& filesOrDirs);
      
      const std::vector<std::string>& tacticalGraphicsTypeMapFilesOrDirsToMerge() const;
      void setTacticalGraphicsTypeMapFilesOrDirsToMerge(const std::vector<std::string>& filesOrDirs);
      
      const bool overwriteMappingsOnMerge() const;
      void setOverwriteMappingsOnMerge( bool overwrite );
      
      const DisplayConnections& displayConnections() const;
      DisplayConnections& displayConnections();

      void setDisplayConnections(const DisplayConnections& displayConnections);

      void setAutoLoadFile(const std::string& file);

      const std::string& autoLoadFile() const;

      void setStartFullScreen(bool);

      bool startFullScreen() const;

      void addDefaultSettingsRecord(const std::string& recordName,
         const DtBaseRecordHolder& record);

      void removeDefaultSettingsRecord(const std::string& record);

      template <typename RecordType>
      bool findDefaultSettingsRecord(const std::string& name, RecordType& record) const
      {
         DefaultRecordMap::const_iterator iter = myDefaultRecords.find(name);
         if (iter != myDefaultRecords.end())
         {
            const DtRecordHolder<RecordType>* holder =
               dynamic_cast<const DtRecordHolder<RecordType>*>(iter->second);
            if (holder)
            {
               record = holder->record();
               return true;
            }
         }

         return false;
      }

      void setConstrainToTerrain(bool constrain);
      bool constrainToTerrain() const;

      void setSpeedScaling(bool scale);
      bool speedScaling() const;

      void setVertexSelectsParent(bool selectsParent);
      bool vertexSelectsParent() const;

      void setDoubleBuffering(bool buffer);
      bool doubleBuffer() const;

      void setVSync(bool sync);
      bool vsync() const;
      
      void setEnableTracyProfiling(bool enableProfiling);
      bool enableTracyProfiling() const;

      void setFixedFrameRate(unsigned int framesPerSecond);
      unsigned int fixedFrameRate() const;

      void setNumDepthBits(unsigned short numBits);
      unsigned short numDepthBits() const;

      void setNumStencilBits(unsigned short numBits);
      unsigned short numStencilBits() const;

      void setRealizeMinimapModelSet(bool val);

      bool realizeMinimapModelSet() const;

      void setIndirectEntityRendering(bool val);

      bool indirectEntityRendering() const;

      void setBufferClearUsesCompute(bool val);

      bool bufferClearUsesCompute() const;

      virtual void setLimitEntityTextures(const DtVector2<int>& resolution);
      virtual const DtVector2<int>& limitEntityTextures(void) const;

      virtual void setLimitEntityTexturesProportional(bool proportional);
      virtual bool limitEntityTexturesProportional(void) const;

      virtual void excludeFromTextureLimits(const std::string& modelDef);
      virtual const std::unordered_set<std::string>& modelDefsExcludedFromTextureLimits(void) const;

      virtual void setLimitTerrainTextures(const DtVector2<int>& resolution);
      virtual const DtVector2<int>& limitTerrainTextures() const;

      virtual void setLimitEarthTerrainTextures(int resolution);
      virtual int limitEarthTerrainTextures() const;


      virtual void setLimitEarthSplattingTextures(int resolution);
      virtual int limitEarthSplattingTextures() const;

      virtual void setLimitEarthVegetationTextures(int resolution);
      virtual int limitEarthVegetationTextures() const;

      virtual void setLimitGpuMemoryPercentage(int percentageCutoff);
      virtual int limitGpuMemoryPercentage(void) const;

      virtual void setEntityGridCellSize(const DtVector3<int>& cellSize);
      virtual DtVector3<int> entityGridCellSize(void) const;

      void setNoEntityDefinitionLoading(bool val);

      bool noEntityDefinitionLoading() const;

      void setNoAggregateDefinitionLoading(bool val);

      bool noAggregateDefinitionLoading() const;

      void setNoTacticalGraphicsDefinitionLoading(bool val);

      bool noTacticalGraphicsDefinitionLoading() const;

      void setNoModelDefinitionLoading(bool val);

      bool noModelDefinitionLoading() const;

      void setNoEntityTypeMapLoading(bool val);

      bool noEntityTypeMapLoading() const;

      void setNoAggregateTypeMapLoading(bool val);

      bool noAggregateTypeMapLoading() const;

      void setNoTacticalGraphicsTypeMapLoading(bool val);

      bool noTacticalGraphicsTypeMapLoading() const;

      void setIgnoreZoomForSpeedtreeLod(bool val);

      bool ignoreZoomForSpeedtreeLod() const;

      void setSuppressHatIntersectOnAttach(bool val);

      bool suppressHatIntersectOnAttach() const;

      void setSynchronizedNtpTime(bool val);

      bool synchronizedNtpTime() const;

      void setDofConstraintsEnabled(bool enabled);

      bool dofConstraintsEnabled() const;

      virtual void setKdTreesDisabled(bool disabled);
      virtual bool kdTreesDisabled() const;

      virtual void setForceTextShaping(bool force);
      virtual bool forceTextShaping() const;

      void setUseNonBlockingSendForSlaves(bool nonBlocking);

      bool useNonBlockingSendForSlaves() const;

      void setAntiAliasingLevel(unsigned short level);
      unsigned short antiAliasingLevel() const;

      void setPathConfiguration(const DtDePathConfiguration& pathConfig);

      DtDePathConfiguration& pathConfiguration();

      const DtDePathConfiguration& pathConfiguration() const;

      void setInitLibXml(bool enabled);

      bool initLibXml() const;

      void setCheckForData(bool check);

      bool checkForData() const;

      void setUsePseudoFullScreen(bool enable);

      bool usePseudoFullScreen() const;

      void setUseHighestPriority(bool enable);

      bool useHighestPriority() const;

      void setTcpSendTimeout(double timeout);
      double tcpSendTimeout() const;

      void setAutoReconnectPeriod(double period);

      double autoReconnectPeriod() const;

      bool autoReconnectEnabled() const;
      void setUseReverseZBuffer(bool val);

      bool useReverseZBuffer() const;

      void setExtraArgs(const std::string& argString);

      const std::string& extraArgs() const;

      void setDisableDynamicTerrain(bool val);

      bool disableDynamicTerrain() const;

      bool indirectUsesExternalRenderer(void) const;

      void setindirectUsesExternalRenderer(bool val);

      bool enablePersistentShadowTechnique(void) const;

      void setEnablePersistentShadowTechnique(bool val);

      void setRendererThreadingModel(DtRendererThreadingModel threadingModel);

      DtRendererThreadingModel rendererThreadingModel(void) const;

      void setShowErrorDialogs(bool show);

      bool showErrorDialogs() const;

      void disableModelSet( unsigned int );
      bool modelSetDisabled( unsigned int ) const;
      const std::set<unsigned int>& disabledModelSets() const;

      virtual void setEnableMutexesOnIndirectDataStructures( bool enabled );
      virtual const bool locksEnabledOnIndirectDataStructures() const;

   protected:

      template<class Archive>
      void _serialize(Archive& ar, const unsigned int version)
      {
         ar& DT_SERIALIZE_BASE(DtConfiguration);
         ar& DT_SERIALIZE_MEMBER(myDriverConfiguration);
         ar& DT_SERIALIZE_MEMBER(myGuiConfiguration);
         ar& DT_SERIALIZE_MEMBER(myInputDriverConfiguration);
         ar& DT_SERIALIZE_MEMBER(myDisplayEngineName);

         ar& DT_SERIALIZE_MEMBER(myDeMode);
         ar& DT_SERIALIZE_MEMBER(myDriverInstances);
         ar& DT_SERIALIZE_MEMBER(myCoordinateSystem);
         ar& DT_SERIALIZE_MEMBER(myCoordinateSystemParameters);

         ar& DT_SERIALIZE_MEMBER(myDeConfiguration);

         ar& DT_SERIALIZE_MEMBER(myAutoLoadDriversFlag);

         ar& DT_SERIALIZE_MEMBER(myAutoStartDrivers);
         ar& DT_SERIALIZE_MEMBER(myMappingFilesToLoad);

         ar& DT_SERIALIZE_MEMBER(myDisplayConnections);
         ar& DT_SERIALIZE_MEMBER(myAutoLoadFile);
         ar& DT_SERIALIZE_MEMBER(myFullScreenFlag);
         ar& DT_SERIALIZE_MEMBER(myConstrainToTerrainFlag);
         ar& DT_SERIALIZE_MEMBER(mySpeedScalingFlag);

         ar& DT_SERIALIZE_MEMBER(myDoubleBufferFlag);
         ar& DT_SERIALIZE_MEMBER(myVSyncFlag);

         ar& DT_SERIALIZE_MEMBER(myDefaultRecords);

         if (version >= 2)
         {
            ar& BOOST_SERIALIZATION_NVP(myInitLibXml);
         }
         if (version >= 3)
         {
            ar& BOOST_SERIALIZATION_NVP(myFeatures);
         }
         if (version >= 4)
         {
            ar& BOOST_SERIALIZATION_NVP(myVertexSelectsParentFlag);
         }

         if (version >= 5)
         {
            ar& BOOST_SERIALIZATION_NVP(myCheckForData);
         }

         if (version >= 6)
         {
            ar& BOOST_SERIALIZATION_NVP(myBatchedRenderingFlag); // NOT USED
         }

         if (version >= 7)
         {
            ar& BOOST_SERIALIZATION_NVP(mySynchronizedOceanFlag);
         }
         if (version >= 8)
         {
            ar& BOOST_SERIALIZATION_NVP(mySynchronizedNtpTimeFlag);
         }
         if (version >= 9)
         {
            ar& BOOST_SERIALIZATION_NVP(myIgnoreZoomForSpeedtreeLod);
         }
         if (version >= 10)
         {
            ar& BOOST_SERIALIZATION_NVP(mySuppressHatIntersectOnAttach);
         }
         if (version >= 11)
         {
            ar& BOOST_SERIALIZATION_NVP(myUsePseudoFullScreen);
         }
         if (version >= 12)
         {
            ar& BOOST_SERIALIZATION_NVP(myUseHighestPriorityFlag);
         }
         if (version >= 13)
         {
            ar& BOOST_SERIALIZATION_NVP(myDisableKdTrees);
         }
         if (version >= 14)
         {
            ar& BOOST_SERIALIZATION_NVP(myForceTextShaping);
         }
         if (version >= 15)
         {
            ar& BOOST_SERIALIZATION_NVP(myUseNonBlockingSendForSlaves);
         }
         if (version >= 16)
         {
            ar& BOOST_SERIALIZATION_NVP(myNoEntityDefinitionLoadingFlag);
            ar& BOOST_SERIALIZATION_NVP(myNoAggregateDefinitionLoadingFlag);
            ar& BOOST_SERIALIZATION_NVP(myNoTacticalGraphicsDefinitionLoadingFlag);
            ar& BOOST_SERIALIZATION_NVP(myNoModelDefinitionLoadingFlag);
            ar& BOOST_SERIALIZATION_NVP(myNoEntityTypeMapLoadingFlag);
            ar& BOOST_SERIALIZATION_NVP(myNoAggregateTypeMapLoadingFlag);
            ar& BOOST_SERIALIZATION_NVP(myNoTacticalGraphicsTypeMapLoadingFlag);
            ar& BOOST_SERIALIZATION_NVP(myEntityElementDefinitionHiersToMerge);
            ar& BOOST_SERIALIZATION_NVP(myEntityElementDefinitionLeafsToMerge);
            ar& BOOST_SERIALIZATION_NVP(myAggregateDefinitionHiersToMerge);
            ar& BOOST_SERIALIZATION_NVP(myAggregateDefinitionLeafsToMerge);
            ar& BOOST_SERIALIZATION_NVP(myTacticalGraphicsDefinitionHiersToMerge);
            ar& BOOST_SERIALIZATION_NVP(myTacticalGraphicsDefinitionLeafsToMerge);
            ar& BOOST_SERIALIZATION_NVP(myModelDefinitionsToMerge);
         }
         if (version >= 17)
         {
            ar& BOOST_SERIALIZATION_NVP(myUseReverseZBuffer);
            ar& BOOST_SERIALIZATION_NVP(myExtraArgs);
         }

         if (version >= 18)
         {
            ar& BOOST_SERIALIZATION_NVP(myDisableDynamicTerrain);
         }

         if (version >= 19)
         {
            ar& BOOST_SERIALIZATION_NVP(myPreloadClouds);
            ar& BOOST_SERIALIZATION_NVP(myEnableMetaflightInstancing); // NOT USED
            ar& BOOST_SERIALIZATION_NVP(myMetaflightMinInstances);     // NOT USED
         }

         if (version >= 20 && version <= 23)
         {
            bool myEnableOcclusionCulling = false;
            ar& BOOST_SERIALIZATION_NVP(myEnableOcclusionCulling); // NOT USED: https://jira.mak.com/browse/VRV-4698
         }

         if (version >= 21)
         {
            ar& BOOST_SERIALIZATION_NVP(myTerrainObserverViewsEnabled);
         }

         if (version >= 22)
         {
            ar& BOOST_SERIALIZATION_NVP(myDofConstraintsEnabled);
         }

         if (version >= 23)
         {
            ar& BOOST_SERIALIZATION_NVP(myEnableTracyProfiling);
         }

      }

   protected:

      DtDriverConfiguration myDriverConfiguration;
      DtGuiConfiguration myGuiConfiguration;
      DtInputDriverConfiguration myInputDriverConfiguration;
      std::string myDisplayEngineName;

      DtDePathConfiguration myPathConfiguration;
      DtDeConfiguration myDeConfiguration;

      DeMode myDeMode;
      DriverInstanceList myDriverInstances;
      std::string myCoordinateSystem;
      std::string myCoordinateSystemParameters;
      int myNotifyLevel;
      std::string myLogFileName;
      std::string myModelPreloadFilename;
      std::string myDiscoveredModelPreloadFilename;

      bool myAutoLoadDriversFlag;

      AuthorizationCodeMap myAuthorizationCodeMap;

      std::vector<std::string> myAutoStartDrivers;
      ObserverStateMap myObserverStateMap;
      std::vector<std::string> myMappingFilesToLoad;
      std::vector<std::string> myEntityElementDefinitionHiersToMerge;
      std::vector<std::string> myEntityElementDefinitionLeafsToMerge;
      std::vector<std::string> myAggregateDefinitionHiersToMerge;
      std::vector<std::string> myAggregateDefinitionLeafsToMerge;
      std::vector<std::string> myTacticalGraphicsDefinitionHiersToMerge;
      std::vector<std::string> myTacticalGraphicsDefinitionLeafsToMerge;
      std::vector<std::string> myModelDefinitionsToMerge;
      std::vector<std::string> myEntityTypeMapsToMerge;
      std::vector<std::string> myAggregateTypeMapsToMerge;
      std::vector<std::string> myTacticalGraphicsTypeMapsToMerge;
      std::set<unsigned int> myDisabledModelSets;

      DisplayConnections myDisplayConnections;
      std::string myAutoLoadFile;

      bool myOverwriteMappingsOnMerge;
      bool myFullScreenFlag;
      bool myUsePseudoFullScreen;
      bool myConstrainToTerrainFlag;
      bool mySpeedScalingFlag;
      bool myVertexSelectsParentFlag;
      bool myRealizeMinimapModelSetFlag;
      bool myBatchedRenderingFlag; // NOT USED
      bool myIndirectEntityRendering;
      bool myBufferClearUsesCompute;
      bool myNoEntityDefinitionLoadingFlag;
      bool myNoAggregateDefinitionLoadingFlag;
      bool myNoTacticalGraphicsDefinitionLoadingFlag;
      bool myNoModelDefinitionLoadingFlag;
      bool myNoEntityTypeMapLoadingFlag;
      bool myNoAggregateTypeMapLoadingFlag;
      bool myNoTacticalGraphicsTypeMapLoadingFlag;
      bool mySynchronizedOceanFlag;
      bool mySynchronizedNtpTimeFlag;
      bool myDofConstraintsEnabled;
      bool myEnableTracyProfiling;

      bool myDisableKdTrees;
      bool myForceTextShaping;
      bool myUseHighestPriorityFlag;
      double myTcpSendTimeout;
      double myAutoReconnectPeriod;

      bool myDoubleBufferFlag;
      bool myVSyncFlag;
      unsigned int myFrameRate;
      unsigned short myNumDepthBits;
      unsigned short myNumStencilBits;
      unsigned short myAntiAliasingLevel;
      bool myInitLibXml;
      bool myCheckForData;
      bool myIgnoreZoomForSpeedtreeLod;
      bool mySuppressHatIntersectOnAttach;
      bool myUseNonBlockingSendForSlaves;

      DefaultRecordMap myDefaultRecords;

      DeFeatures myFeatures;
      bool myUseReverseZBuffer;
      std::string myExtraArgs;

      bool myDisableDynamicTerrain;
      bool myPreloadClouds; //NOT USED

      bool myEnableMetaflightInstancing;     // NOT USED
      unsigned int myMetaflightMinInstances; // NOT USED

      bool myTerrainObserverViewsEnabled;

      DtVector2<int> myLimitEntityTexturesResolution;

      bool myLimitEntityTexturesProportional;

      std::unordered_set<std::string> myModelDefsExcludedFromTextureLimits;

      DtVector2<int> myLimitTerrainTexturesResolution;

      int myLimitGpuMemoryPercentage;

      DtVector3<int> myEntityGridCellSize = DtVector3<int>(5000, 5000, 5000);

      bool myShowErrorDialogs;
      bool myIndirectStructureMutexesEnabled;

      bool myIndirectUsesExternalRenderer = true;

      bool myEnablePersistentShadowTechnique = true;

      int myLimitEarthTerrainTextures = -1;
      int myLimitEarthSplattingTextures = -1;
      int myLimitEarthVegetationTextures = -1;

      DtRendererThreadingModel myRendererThreadingModel = RTM_SingleThreaded;
   };

}

BOOST_CLASS_VERSION(makVrv::DtDeInitializer, 23)