DtDeInitializer.h

Go to the documentation of this file.

/*****************************************************************************
* Copyright (c) 2021 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 <makArchives/DtObserverStateRecord.h>

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 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 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 setNumAlphaBits(unsigned short numBits);
      unsigned short numAlphaBits() const;

      void setRealizeMinimapModelSet(bool val);

      bool realizeMinimapModelSet() const;

      void setIndirectRendering(bool val);

      bool indirectRendering() 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;

      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;

      void setEnableOcclusionCulling(bool val);

      bool enableOcclusionCulling() 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)
         {
            ar & BOOST_SERIALIZATION_NVP(myEnableOcclusionCulling);
         }

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

      }

   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;

      DisplayConnections myDisplayConnections;
      std::string myAutoLoadFile;

      bool myFullScreenFlag;
      bool myUsePseudoFullScreen;
      bool myConstrainToTerrainFlag;
      bool mySpeedScalingFlag;
      bool myVertexSelectsParentFlag;
      bool myRealizeMinimapModelSetFlag;
      bool myBatchedRenderingFlag; // NOT USED
      bool myIndirectRenderingFlag;
      bool myNoEntityDefinitionLoadingFlag;
      bool myNoAggregateDefinitionLoadingFlag;
      bool myNoTacticalGraphicsDefinitionLoadingFlag;
      bool myNoModelDefinitionLoadingFlag;
      bool myNoEntityTypeMapLoadingFlag;
      bool myNoAggregateTypeMapLoadingFlag;
      bool myNoTacticalGraphicsTypeMapLoadingFlag;
      bool mySynchronizedOceanFlag;
      bool mySynchronizedNtpTimeFlag;
      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 myNumAlphaBits;
      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 myEnableOcclusionCulling;
      bool myTerrainObserverViewsEnabled;
   };

}

BOOST_CLASS_VERSION( makVrv::DtDeInitializer, 21 )