vrfSimOptions.h

Go to the documentation of this file.

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

/*******************************************************************************
** Modify this class to add options that you can use to set up
** initial simulation state.  This object is used exclusively by the
** DtVrfApp class.
*******************************************************************************/

#pragma once

#include "vrfutil/vrfPluginRecordManager.h"
#include "vrfutil/vrfSimOptionsInterface.h"

#include <vlutil/vlMachineTypes.h>
#include <vlutil/vlFilename.h>
#include <mtl/configVariable.h>
#include <mtl/multiConfigVariable.h>
#include <mtl/mtlEnvironment.h>

#include <vrfExtObjects/vrfExtApplicationInitializer.h>

class DtVrfSimOptions
   : public DtVrfExtApplicationInitializer
   , public DtVrfSimOptionsInterface
{
public:
   // Default constructor
   DtVrfSimOptions(int argc, char** argv, const char* appName, const char* appVersion);

   // Destructor
   virtual ~DtVrfSimOptions();

   // This function will read a configuration file and set all
   // of the appropriate values in the options object.
   virtual bool readConfigurationFile(const DtFilename& mtlFile);

public:
   // Returns the frequency of vrfObject update messages for entities
   virtual DtFloat64 entVrfDataTimeThreshold() const;
   
   // Returns the frequency of heartbeat messages
   virtual int statusUpdateHeartbeat() const;

   // Returns the default simulation model set to use to load
   // parameter database, communication model, physical world
   // parameters
   virtual DtFilename simulationModelSetFilename() const;
   
   // Forces DtCgf::loadScenario to reload the parameter database
   virtual bool forceParameterDbReload() const;

   // The frame rate above which the back-end will sleep in order to yield CPU
   // time to other processes. Once the frame rate drops below this level, the
   // back-end will no longer sleep. This parameter only takes effect when the
   // simulation is running in variable frame mode.
   // @{
   virtual void setTargetFrameRate(int rate);
   virtual int targetFrameRate() const;
   // @} 

   // Returns whether to use Performance Counter or System Clock
   virtual int clockMode() const;

   // Returns the default rotation threshold
   virtual double rotationThreshold() const;
   
   // Returns the default translation threshold
   virtual double translationThreshold() const;
   
   // Returns the default aggregate dimension threshold
   virtual double aggDimensionThreshold() const;

   // Default path to search for parameter database files, when no path is
   // specified in a given scenario file.
   virtual void setDefaultParameterDatabasePath(const DtFilename& path);
   virtual const DtFilename& defaultParameterDatabasePath() const;

   // Default path to search for terrain database files, when no path is 
   // specified in a given scenario file.
   virtual void setDefaultTerrainDatabasePath(const DtFilename& path);
   virtual const DtFilename& defaultTerrainDatabasePath() const;

   // DI-Guy configuration files
   // Returns whether to use DI-Characters inside Vr-Forces
   virtual bool useDIGuy() const;

   // Character data file generated from DI0Guy
   virtual DtFilename diGuyCharacterDataFile() const;

   // Animations configuration file used to augment character data file
   virtual DtFilename diGuyAnimationsFile() const;

   // Whether or not the frame rate statistics of the backend should be logged,
   // presumably (but not definitely) to file.
   virtual bool logFrameRateStats() const;
   virtual void setLogFrameRateStats(bool yesOrNo);

   virtual void setRejectMismatchedScenarioMessages(bool);
   virtual bool rejectMismatchedScenarioMessages() const;

   virtual bool enableNavigationLabDebugging() const;
   virtual void setEnableNavigationLabDebugging(bool enable);

   // Sets whether or not to publish zero velocity (and acceleration) when paused.  Default
   // is true
   virtual void setPublishZeroVelocityWhenPaused(bool);
   virtual bool publishZeroVelocityWhenPaused() const;

   // When the simulation is paused set the dead reckoning algorithm for aggregates and entities to static.
   // This turned on in conjunction with publishZeroVelocityWhenPaused turn off will pause the objects
   // in a VR-Forces run simulation and still show current values for velocity, speed, acceleration, etc.
   virtual void setSetDeadReckoningAlgorithmToStaticOnPause(bool);
   virtual bool setDeadReckoningAlgorithmToStaticOnPause() const;

   // Aggregate spatial model tick characteristics.  Times are given in seconds
   // Indicates whether tick rates are to be specified using simulation time or
   // real time.  Default is false.
   virtual bool aggregateSpatialModelTickPeriodUsesRealTime() const;
   virtual void setAggregateSpatialModelTickPeriodUsesRealTime(bool yesOrNo);
   
   // Aggregate spatial model tick period in seconds.  Default is 0.0 (tick as
   // fast as possible).
   virtual double aggregateSpatialModelTickPeriod() const;
   virtual void setAggregateSpatialModelTickPeriod(double period);

   // Aggregate spatial model tick variance in seconds.  Default is 0.0.
   virtual double aggregateSpatialModelTickVariance() const;
   virtual void setAggregateSpatialModelTickVariance(double variance);

   // Always tick as fast as possible while paused.  Overrides above tick rate
   // parameters for aggregate spatial model when simulation is paused.  Default is true.
   virtual bool tickAggregateSpatialModelAsFastAsPossibleWhilePaused() const;
   virtual void setTickAggregateSpatialModelAsFastAsPossibleWhilePaused(bool yesOrNo);

   virtual int sessionId() const;
   virtual int appIdRangeMax() const;
   virtual void setAppIdRangeMax(int);
   virtual DtFilename batchFile() const;
   virtual DtFilename scenarioFile() const;
   virtual DtFilename terrainFile() const;

   virtual bool useAbsoluteTimeStamps() const;

   virtual int frontEndProcessId() const;

   virtual void setStartInRunMode(bool);
   virtual bool startInRunMode() const;

#ifdef WIN32
   virtual void setDoNotUseConsole(bool);
   virtual bool usingConsole() const;

   virtual void setStartMinimized(bool);
   virtual bool startMinimized() const;
#endif
   
   virtual void setDaemonMode(bool);
   virtual bool daemonMode() const;

#if DtHLA
   // HLA only - run back-end in HLA time management mode.
   virtual bool runInTimeManagementMode() const;
   virtual void setRunInTimeManagementMode(bool yesNo);
#endif

#if DtDIS
   virtual double heartbeatVariance() const;
   virtual void setHeartbeatVariance(double variance);

   virtual std::vector<DtString> additionalDestinationAddresses() const;

   virtual void setAdditionalDestinationAddresses(const DtString& addresses);

   virtual void setAdditionalDestinationAddresses(const std::vector<DtString>& addresses);
#endif

   virtual void setReuseEntityIdentifiersOnScenarioLoad(bool);
   virtual bool reuseEntityIdentifiersOnScenarioLoad() const;

   virtual void setTaskVisualizationPublicationMode(short state);
   virtual short taskVisualizationPublicationMode() const;

   virtual void setUseDrawControlForTaskVisualizations(bool);
   virtual bool useDrawControlForTaskVisualizations() const;

   // When parsing command line, is variables are set, copy them to "real" variables
   virtual void parseCmdLine();

   virtual short simMgmtPduProcessLevel() const;

   virtual int cgfDispatcherReceivePort() const;
   virtual void setCgfDispatcherReceivePort(int port);

   // Returns plugins to load
   const std::vector<std::string>& pluginsToLoad() const;

   virtual void setLoadPluginIfVersionMismatch(bool);
   virtual bool loadPluginIfVersionMismatch() const;

   virtual void setPluginsDirectory(const DtFilename&);
   virtual const DtFilename& pluginsDirectory() const;

   virtual DtString additionalSystemScriptsDirectory() const;
   virtual void setAdditionalSystemScriptsDirectory(const DtString&);

   virtual void setDoNotUsePluginsDirectory(bool b);
   virtual bool doNotUsePluginsDirectory() const;

   virtual DtFilename outputFile() const;
   virtual void setOutputFile(const DtFilename& s);

   // Sets the notify level for all streams managed by this console manager.
   virtual void setNotifyLevel(DtNotifyLevelType level);
   // \return The current notification level.
   virtual DtNotifyLevelType notifyLevel() const;

   // If true, DtInfo, DtWarn, etc. log messages from the backend will
   // be sent in comment interactions to the GUI.  Default is true.
   // \note This does not affect the object console logs, only the
   // backend logs.
   virtual void setSendBackendLogToNetwork(bool v);
   virtual bool sendBackendLogToNetwork() const;

   // If true, terrain subpages will be fully loaded instead of on demand
   virtual void setFullyLoadTerrain(bool v);
   virtual bool fullyLoadTerrain() const;

   // If true, blocking terrain calls will cause an assert when a debug back-end
   // is in run mode.
   virtual void setAssertOnBlockingTerrainCalls(bool b);
   virtual bool assertOnBlockingTerrainCalls() const;

   // The address of the network interface to be used for non HLA/DIS 
   // communications with the GUI.
   // Defaults to a null string, indicating that VRF will automatically detect
   // the network interface.
   virtual void setHostAddress(const DtString& address);
   virtual DtString hostAddress() const;

   // The address of the network interface to be used for non HLA/DIS 
   // communications, as reported to the GUI or remote controller.
   // Defaults to a null string, indicating that VRF will report the hostAddress.
   virtual void setReportedHostAddress(const DtString& address);
   virtual DtString reportedHostAddress() const;

   virtual void setAppDataDir(const DtString&);
   virtual DtString appDataDir() const;

   virtual void setupSettingsDirectory(const DtFilename& f, bool useSharedSettingsDirectory);

   virtual void setDataDir(const DtString&);
   virtual DtString dataDir() const;

   virtual void setUserDataDir(const DtString&);
   virtual DtString userDataDir() const;

   // Mapping file for SIDC to Dis Enumerations
   virtual void setMsdlSidcMappingFile(const DtString& address);
   virtual DtFilename msdlSidcMappingFile() const;

   // Mapping file for Country Codes to Dis Enumerations
   virtual void setCountryCodesMappingFile(const DtString& address);
   virtual DtFilename countryCodesMappingFile() const;

   virtual void setNonVrfObjectsUUIDScheme(const DtString&);
   virtual DtString nonVrfObjectsUUIDScheme() const;

   virtual void outputMtl();
#if USE_VLD_MEMORY_TRACKING && _DEBUG
   virtual bool useVld() const;
#endif

   virtual void setMainThreadWaitForQueue(bool enable);
   virtual void setNumCallbackThreads(unsigned n);
   virtual void setDisableParallelTick(bool use);
   virtual void setIssueSimExitOnFinishTestCommand(bool shouldExit);


   virtual bool mainThreadWaitForQueue() const;
   virtual unsigned numCallbackThreads() const;
   virtual bool disableParallelTick() const;
   virtual bool issueSimExitOnFinishTestCommand() const;

   virtual void setGamewareMemorySize(int sizeInMb);
   virtual int gamewareMemorySize() const;

   virtual void setGamewareQueryTimeBudget(double ms);
   virtual double gamewareQueryTimeBudget() const;

   virtual void setRegenerateNavigationDataAtRuntime(bool v);
   virtual bool regenerateNavigationDataAtRuntime() const;

   virtual void setMaxNavigationRegenerationThreads(int threads);
   virtual int maxNavigationRegenerationThreads() const;

   virtual void setNavigationRegenerationDelay(double delay);
   virtual double navigationRegenerationDelay() const;

   virtual void setEnableLogFileTimestamps(bool v);
   virtual bool enableLogFileTimestamps() const;

#ifdef WIN32
   virtual void setMainThreadToHighPriority(bool);
#endif

   virtual std::vector<DtString> enabledChannels() const;

   virtual bool suppressDataAvailableException() const;
   virtual void setSuppressDataAvailableException(bool);

   DtApplicationSettings& settings() { return mySettings; };

protected:
   // This routine will tell the myMtlEnv object what variables to expect
   // to read from the mtl file.  Modify this routine to add your new
   // variables.  This routine is called from loadMtlFile().
   virtual void initializeMtlParams();

   // This routine will set internal member variables from those
   // read from the mtl file
   virtual void setVariablesFromMtl();
   virtual void processStringList(std::vector<DtString>& v, const std::vector<DtString>& list) const;

   // Initializes variables that can be used to check which plugins to load
   virtual void initPluginVariables();

   // Process all .mtl files found in the supplied plugin directory to see which plugins to load
   virtual void processPluginsDirectory(const DtFilename& directory);

private:
   // Copy constructor; not implemented
   DtVrfSimOptions(const DtVrfSimOptions& orig);

   // Assignment operator; not implemented
   DtVrfSimOptions& operator=(const DtVrfSimOptions& rhs);

protected:
   // The name of an alternate parameter database file to load upon startup.
   DtConfigVariable<DtString>    mySimulationModelSetFile;
   
   // Filename of batch file to load at startup.
   DtConfigVariable<DtString>    myBatchFile;

   // Cgf tick performance parameters
   DtConfigVariable<int>         myTargetFrameRate;
   
   // Set 0 to use Performance Counter, or 1 to use System Clock
   DtConfigVariable<int>         myClockMode;

   // Integer session Id.  Applications with a common session Id must share
   // the same terrain database, and are capable of controlling one another 
   // through interface messages.
   DtConfigVariable<int>         mySessionId;

   // Integer mak app id range when going beyon the 65K limit for entity creation on one app id.
   DtConfigVariable<int>         myAppIdRangeMax;

   // The name of a scenario (.scn) file to load upon startup (optional)
   DtConfigVariable<DtString>    myScenarioFile;

   DtConfigVariable<DtString>   mySharedSettingsDirectory;

   DtConfigVariable<bool>       myUseUserSettingsDirectory;

   // The name of a terrain file to load upon startup (optional - new scenario)
   DtConfigVariable<DtString>    myTerrainFile;

   // Set true to use DI-Guy Characters in Vr-Forces
   short                         myUseDIGuy;

   // Configuration files for setting up DI-Guy characters
   DtConfigVariable<DtString>    myDIGuyCharacterDataFile;
   DtConfigVariable<DtString>    myDIGuyAnimationsFile;

   // MTL file to load.  Note this is here only for --help purposes as this
   // variable is parsed outside of the normal parsing routine
   DtConfigVariable<DtString>    mySettingsFile;

   // Where the app data directory is located
   DtConfigVariable<DtString>    myAppDataDir;

   // Where the data directory is located
   DtConfigVariable<DtString>    myDataDir;

   // Where the user data directory is located
   DtConfigVariable<DtString>    myUserDataDir;

   // Semi-colon separated list of directories to load system scripts from
   DtConfigVariable<DtString>    myAdditionalSystemScriptsDirectory;

   // Process ID of the front-end that started us (combined mode)
   DtConfigVariable<int>         myFrontEndPID;
#ifndef WIN32
   // Whether to start in daemon mode or not. (UNIX only)
   DtConfigVariable<bool>        myCmdDaemonMode;
   short myDaemonMode;
#endif

#if DtHLA
   // HLA only - flag indicating whether or not to run in HLA time
   // management mode.
   DtConfigVariable<bool>        myCmdRunInTimeManagementMode;
   int myRunInTimeManagementMode;
#endif

#ifdef DtDIS
   DtFloat64      myHeartbeatVariance;

   DtString       myAdditionalDestinationAddresses;
#endif

   short          myReuseEntityIdentifiersOnScenarioLoad;

   // Port number for incoming files in the DtCgfDispatcher
   int myCgfDispatcherReceivePort;

   DtString myReportedHostAddress;
   
   DtFloat64   myEntVrfDataTimeThreshold;
   int         myStatusUpdateHeartbeat;
   short       myForceParameterDbReload;

   // Default threshold values
   DtFloat64   myDefaultTranslationThreshold;
   DtFloat64   myDefaultRotationThreshold;
   DtFloat64   myDefaultAggDimensionThreshold;

   // Should the Cgf log performance (frame rate) stats or not
   short       myLogFrameRateStatistics;

   short       myEnableNavigationLabDebugging;

   // Configure aggregate spatial model
   short myASM_tickPeriodUsesRealTime;
   double myASM_minTickPeriod;
   double myASM_minTickPeriodVariance;
   short myASM_tickFastAsPossibleWhilePaused;

   DtFilename  myDefaultParameterDatabasePath;
   DtFilename  myDefaultTerrainDatabasePath;
   
   // Start in run mode
   short myStartInRunMode;

#ifdef WIN32
   short myDoNotUseConsole;
   short myStartMinimized;
#endif
   
   DtFilename myPluginsDirectory;

   // Parameters for command line only
#ifdef WIN32
   DtConfigVariable<bool>             myCmdNotUsingConsole;
   DtConfigVariable<bool>             myCmdStartMinimized;
#endif
   DtConfigVariable<bool>             myCmdStartInRunMode;
   DtConfigVariable<bool>             myCmdDoNotUsePluginsDirectory;
   DtConfigVariable<bool>             myCmdUseAbsoluteTimeStamps;

   DtConfigVariable<bool>             myCmdLogFrameRateStatistics;

   DtMultiConfigVariable<std::string>    myPluginFiles;
   
   DtMultiConfigVariable<DtString>    myEnabledChannels;

   std::vector<std::string> myPluginsToLoad;
   bool  myDoNotUsePluginsDirectory;
   DtConfigVariable<DtString> myOutputFile;

   // Parameter for processing sim mgmt PDUs
   short       mySimMgmtPduProcessLevel;

   short       myLoadPluginIfVersionMismatch;

   // Starting object console notify level.  Default is 2
   int myObjectConsoleNotifyLevel;
   short mySendBackendLogToNetwork;

   DtConfigVariable<bool>             myCmdFullyLoadTerrain;
   short                              myFullyLoadTerrain;

   short                              myAssertOnBlockingTerrainCalls;
   short                              myPublishZeroVelocityWhenPaused;
   short                              mySetDeadReckoningAlgorithmToStaticOnPause;

   DtVrfPluginRecordManager            myPluginRecordManager;

   // Address of the network interface to use for non-DIS/HLA communication with GUI.
   DtConfigVariable<DtString> myHostAddress;

   DtConfigVariable<DtString> myMsdlSidcMappingFile;
   DtConfigVariable<DtString> myCountryCodesMappingFile;
   DtConfigVariable<DtString> myNonVrfObjectsUUIDScheme;

   DtConfigVariable<int>  myCmdNumCallbackThreads;
   DtConfigVariable<bool> myCmdMainThreadWaitForQueue;
   DtConfigVariable<bool> myCmdDisableParallelTick;

   DtConfigVariable<bool> myCmdIssueSimExitOnFinishTestCommand;

   short myMainThreadWaitForQueue;
   short myDisableParallelTick;
   short myIssueSimExitOnFinishTestCommand;

#ifdef WIN32
   DtConfigVariable<bool> myCmdSetMainThreadToHighPriority;
   short mySetMainThreadToHighPriority;
#endif
#if USE_VLD_MEMORY_TRACKING && _DEBUG
   DtConfigVariable<bool> myUseVld;
#endif

   short myTaskVisualizationPublicationMode;
   short myUseDrawControlForTaskVisualizations;

   int myGamewareMemorySize;
   double myGamewareQueryTimeBudget;
   short myRegenerateNavigationDataAtRuntime;
   int myMaxNavigationRegenerationThreads;
   double myNavigationRegenerationDelay;

   short myEnableLogFileTimestamps;

   short myRejectMismatchedScenarioMessages;

   DtConfigVariable<bool> myCmdSuppressDataAvailableException;
   int mySuppressDataAvailableException;
};

inline const std::vector<std::string>& DtVrfSimOptions::pluginsToLoad() const
{
   return myPluginsToLoad;
}