VR-Forces 4.8 Class Documentation
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Groups Pages
cgf.h
Go to the documentation of this file.
1 /*******************************************************************************
2 ** Copyright (c) 2019 MAK Technologies, Inc.
3 ** All rights reserved.
4 *******************************************************************************/
5 
6 #pragma once
7 
10 
12 
13 #ifdef WIN32
14 #include <winsock2.h>
15 #endif
16 
17 #include <vlutil/vlFilename.h>
18 #include <vlutil/vlTime.h>
19 #include <vl/hostStructs.h>
20 #include <vector>
21 #include <vlutil/vlPrint.h>
22 #include "vrfMsgTransport/defaultSimulationModelSetValidatorManager.h"
23 #include <vrfobjcore/translatableStream.h>
24 #include <vrfobjcore/vrfObjectManager.h>
25 #include <vrfobjcore/vrfObjectReference.h>
26 #include <readerWriter/noArgumentCallbackList.h>
27 #include "vrfcgf/snapshotManager.h"
28 #include "vrfutil/scenario.h"
29 #include "vrfutil/scenarioExplorer.h"
30 #include "vrfutil/outputLogger.h"
31 #include "vrfutil/rwActivities.h"
32 #include "vrfutil/fastForwardSettings.h"
33 #include <boost/unordered_set.hpp>
34 
35 class DtOrbatManager;
36 class DtAdminContent;
37 class DtIfScenarioStatus;
38 class DtSimulationModelSet;
39 class DtExerciseConn;
40 class DtScenario;
41 class DtScenarioExplorer;
42 class DtPhysicalWorld;
43 class DtVrfNavAreaManager;
44 class DtCommModelManager;
45 class DtTerrainInterface;
46 class DtVrfCreator;
47 class DtEventManager;
48 struct DtInMemorySnapshot;
49 class DtSimManager;
50 class DtScriptedTaskManager;
51 class DtScenarioEventManager;
52 class DtHazardAreaManager;
53 class DtIntelCollectionAreaManager;
54 class DtCompressedFileTransporter;
55 class DtIfSaveScenario;
56 class DtScriptedObjectsMovementManager;
57 class DtVrfStatusPublisher;
58 class DtEmbeddedEntityInfoManager;
59 class DtAggregateSpatialModel;
60 class DtDetonationManager;
61 class DtAmmunitionManager;
62 class DtFireManager;
63 class DtGlobalPlanManager;
64 class DtJoyDeviceManager;
65 class DtHostilityManager;
66 class DtEngagementZonesManager;
67 class DtScenarioExtrasMgr;
68 class DtCustomReportManager;
69 class DtStealthCommandsManager;
70 class DtFactoryManager;
71 class DtVrfObject;
72 class DtObjectType;
73 class DtList;
74 class DtSimTask;
75 class DtSetDataRequest;
76 class DtPlan;
77 class DtPaperMapDatabase;
78 class DtMapDatum;
79 class DtVrfParameterDb;
80 class DtSimMessage;
81 class DtResourceMonitor;
82 class DtRadarCoverageMonitor;
83 class DtTerrainProfileRequestManager;
84 class DtVrfObjectIdGenerator;
85 class DtVrfPlugin;
86 class DtVrfPluginManager;
87 class DtHlaExerciseClock;
88 class DtExerciseClock;
89 class DtSimCommand;
90 class DtImportExportScenarioDescriptionManager;
91 class DtLuaObjectSerializer;
92 struct DtOrganizationManagerReadyCallbackInfo;
93 class DtConsoleCommandOwner;
94 class DtSimTerrainRequestManager;
95 class DtTimer;
96 class DtVrfSimOptionsInterface;
97 class DtSpawnSinkManager;
98 class DtSnapshotManager;
99 class DtSimCommandDistributor;
100 class DtApplicationSettings;
101 
114 #include "vrfcgf/vrfcgfDefines.h"
115 class DT_DLL_vrfcgf DtCgf
116 {
117 public:
118 
125  DtCgf(const DtSimulationAddress& addr, const DtU32& capabilities = 0xffff);
126 
150  virtual bool init(DtExerciseConn* conn, DtU32 sessionId = 1, DtVrfCreator* creator = 0,
151  int entityAdvisory = 100);
152 
154  virtual ~DtCgf();
155 
157  virtual const DtVrfSimOptionsInterface* simOptions() const;
158 
160  virtual void setSimOptions(const DtVrfSimOptionsInterface&);
161 
164  virtual void tick();
165 
168  virtual void sendFinalStatus();
169 
170  //-------------------------------------------------------
172  //-------------------------------------------------------
173 
175  virtual bool importScenarioDescriptionFile(const DtFilename& file, const DtString& format,
176  const std::map<std::string, std::string>& importData);
177 
181  virtual DtString exportScenarioDescriptionFile(const DtFilename& file, const DtString& format,
182  const std::map<std::string, std::string>& exportData);
183 
185  virtual void setAppDataDir(const DtString&);
186  virtual DtFilename appDataDir() const;
187 
189 #if DtHLA
190  virtual void setSimulationAddress(const DtSimulationAddress&);
191 #endif
192 
194  virtual void setUserDataDir(const DtString&);
195  virtual DtFilename userDataDir() const;
196 
198  virtual void setDataDir(const DtString&);
199  virtual DtFilename dataDir() const;
200 
202  virtual void setAppIdRangeMax(int);
203  int appIdRangeMax() const;
204 
208  virtual bool loadScenario(const DtFilename& name, int scenarioRunId = 0,
209  bool isOrbatEnabled = false, bool createGlobalEnv = false,
210  bool createGlobalDynamicTerrain = false);
211 
218  virtual bool loadScenario(const DtScenario& scenario, int scenarioRunId = 0,
219  bool isOrbatEnabled = false, bool createGlobalEnv = false,
220  bool createGlobalDynamicTerrain = false);
221 
223  virtual void queueRollbackTo(DtInMemorySnapshot* chkp, int scenarioRunId = 0);
224 
226  virtual bool rollbackTo(DtInMemorySnapshot* chkp, int scenarioRunId = 0);
227 
229  virtual void clearSimulationObjects();
230 
233  virtual bool importScenario(const DtScenario&);
234  virtual bool importScenario(const DtFilename&);
235 
242  virtual bool newScenario(const DtFilename& dbname =
243  DtFilename::nullFilename(), const DtFilename& simulationModelSet =
244  DtFilename::nullFilename());
245 
247  DtIfScenarioStatus* scenarioStatus() { return myScenarioStatus; };
248  const DtIfScenarioStatus* scenarioStatus() const { return myScenarioStatus; };
249 
250  virtual void sendScenarioStatusMessage();
251 
255  virtual bool saveScenario(const DtFilename& savename, bool saveAsSip = false);
256 
258  virtual bool takeSnapshot(DtInMemorySnapshot*);
259 
262  virtual void rollbackToSimTime(double simTime);
263 
266  virtual void takeSnapshot(bool makeBase);
267 
270  virtual bool saveSnapshot(const DtFilename& saveFolder,
271  DtCompressedFileTransporter&, DtIfSaveScenario* msg, const DtSimulationAddress& requestor);
272 
276  virtual bool saveSimulationObjectGroup(DtFilename saveFolder, const DtString& groupName,
277  int flags, boost::unordered_set<DtUUID>& uuidsSaved, bool& savAsZipFile);
278 
284  virtual bool createSimulationObjectGroup(const DtString& group, int flags, int force, const DtVector& geocentricLocation,
285  double offsetRotation, bool storedInZipFile = false);
286 
291  virtual void closeScenario(const DtFilename& terrainToOpen = "", bool forceCloseAll = false);
292 
297  virtual bool loadAdditionalObjectParameters(const DtFilename& paramsFileName,
298  const DtReaderWriter::SearchPaths& searchPaths, bool preloadParameters = false);
299 
302  virtual void run();
303 
305  virtual void pause();
306 
312  virtual void rewind(int scenarioRunId = 0);
313 
315  virtual void setRejectMismatchedScenarioMessages(bool);
316  virtual bool rejectMismatchedScenarioMessages() const;
317 
322 
323  virtual void setForceParameterDbReload(bool reload);
324  virtual bool forceParameterDbReload() const;
326 
330 
331  virtual void setEnableResourceMonitor(bool b);
332  virtual bool isResourceMonitorEnabled() const;
334 
336  virtual bool canSimulate() const { return myCanSimulate; };
337 
339  virtual bool aboutToLoadOrRewindScenario() const { return myAboutToLoadOrRewindScenario; };
340 
344  virtual void setSmsValidationEnabled(bool b);
345 
357 
358  virtual const DtFilename& defaultTerrainDirectory();
359  virtual void setDefaultTerrainDirectory(const DtFilename& directory);
361 
362  virtual bool logFrameRateStatistics() const;
363  virtual void setLogFrameRateStatistics(bool yesOrNo);
364 
366  virtual void sendServerLoadMessage(const DtString& error, int level = DtNlWarn);
367 
372 
373  virtual const DtFilename& defaultSimulationModelSetFilename();
374  virtual void setDefaultSimulationModelSetFilename(const DtFilename& filename);
376 
378 
379  virtual void setUseDIGuy(bool diguy);
380  virtual bool useDIGuy() const;
382 
386 
387  virtual const DtFilename& diGuyAnimationsFilename();
388  virtual void setDIGuyAnimationsFilename(const DtFilename& filename);
390 
392 
393  void setClockMode(int clockMode);
395 
397 
398  virtual void setMsdlSidcMappingFile(const DtFilename&);
399  virtual const DtFilename& msdlSidcMappingFile() const;
401 
403 
404  virtual void setCountryCodesMappingFile(const DtFilename&);
405  virtual const DtFilename& countryCodesMappingFile() const;
407 
410  virtual DtSimulationModelSet* defaultModelSet();
411 
412  //-------------------------------------------------------
414  //-------------------------------------------------------
415 
418  virtual void deleteObject(const DtUUID& name, bool andRemoveFromOrbat = true) const;
419 
422  virtual void deleteObject(const DtEntityIdentifier& objectIdentifier, bool andRemoveFromOrbat = true) const;
423 
424  //-------------------------------------------------------
426  //-------------------------------------------------------
427 
429 
440  virtual DtVrfObject* createWaypoint(const DtVector& localPosition,
441  const DtString& uniqueName = DtString::nullString()) const;
442 
444 
457  virtual DtVrfObject* createRoute(const DtList& vertices,
458  const DtString& uniqueName = DtString::nullString()) const;
459 
461 
473  virtual DtVrfObject* createPhaseLine(
474  const DtVector& dbPoint1,
475  const DtVector& dbPoint2,
476  const DtString& uniqueName = DtString::nullString()) const;
477 
479 
491  virtual DtVrfObject* createControlArea(
492  const DtList& vertices,
493  const DtString& uniqueName = DtString::nullString()) const;
494 
496 
508  virtual DtVrfObject* createObstacle(
509  const DtList& vertices,
510  const DtString& uniqueName = DtString::nullString()) const;
511 
513 
526  virtual DtVrfObject* createDisaggregationArea(
527  const DtList& vertices,
528  const DtString& uniqueName = DtString::nullString()) const;
529 
530  //-------------------------------------------------------
532  //-------------------------------------------------------
533 
535 
564  virtual DtVrfObject* createEntity(
565  const DtEntityType& entityType,
566  DtForceType force,
567  const DtVector& dbPosition,
568  DtReal heading,
569  const DtString& entityName = DtString::nullString(),
570  bool allowBlocking = true,
571  std::list<DtAdminContent*>* initialAdminContent = 0,
572  bool addToOrbat = true) const;
573 
574 
576 
607  virtual DtVrfObject* createAggregate(
608  const DtEntityType& aggregateType,
609  DtForceType force,
610  const DtVector& localPosition,
611  DtReal heading,
612  const std::vector<DtUUID>& subordinates = std::vector<DtUUID>(),
613  const DtString& aggregateName = DtString::nullString(),
614  bool addToOrbat = true) const;
615 
627  virtual DtVrfObject* createAggregate(
628  const DtEntityType& aggregateType,
629  DtForceType force,
630  const DtVector& localPosition,
631  DtReal heading,
632  bool createSubordinates,
633  const DtString& aggregateName = DtString::nullString(),
634  bool allowBlocking = true,
635  bool addToOrbat = true) const;
636 
648  virtual bool addSubordinate(DtVrfObject* subordinate,
649  DtVrfObject* aggregate);
650 
666  virtual bool removeSubordinate(DtVrfObject* subordinate,
667  DtVrfObject* aggregate);
668 
669  //-------------------------------------------------------
671  //-------------------------------------------------------
672 
679  virtual void assignTask(const DtVrfObject* entity, const DtSimTask& task);
680 
688  virtual void sendSetDataRequest(const DtVrfObject* entity,
689  const DtSetDataRequest& request);
690 
693  virtual void assignPlanByUUID(const DtUUID&, const DtPlan& plan);
694 
699  virtual void abandonPlan(const DtVrfObject* entity);
700 
705  virtual void restartPlan(const DtVrfObject* entity);
706 
707  //-------------------------------------------------------
709  //-------------------------------------------------------
710 
714  virtual void logObjectConsoleToFile(DtVrfObject* object,
715  DtFilename filename = DtFilename::nullFilename());
716 
718  virtual void stopLoggingObjectConsoleToFile(DtVrfObject* object);
719 
723  virtual void setObjectConsoleNotificationLevel(DtVrfObject* object,
724  DtNotifyLevelType level);
725 
728  virtual void setPublishZeroVelocityWhenPaused(bool);
729  virtual bool publishZeroVelocityWhenPaused() const;
730 
734  virtual void setSetDeadReckoningAlgorithmToStaticOnPause(bool);
735  virtual bool setDeadReckoningAlgorithmToStaticOnPause() const;
736 
742  virtual bool reuseEntityIdentifiersOnScenarioLoad() const;
743  virtual void setReuseEntityIdentifiersOnScenarioLoad(bool);
744 
746  virtual void setTaskVisualizationPublicationMode(DtTaskVisualizationPublicationMode mode);
747  virtual DtTaskVisualizationPublicationMode taskVisualizationPublicationMode() const;
748 
751  virtual void setUseDrawControlForTaskVisualizations(bool);
752  virtual bool useDrawControlForTaskVisualizations() const;
753 
754  //-------------------------------------------------------
756  //-------------------------------------------------------
757 
760  virtual DtSimManager* simManager() const;
761 
763  virtual DtImportExportScenarioDescriptionManager* importExportScenarioDescriptionManager() const;
764 
767  virtual DtResourceMonitor* resourceMonitor() const;
768 
770  virtual DtRadarCoverageMonitor* radarCoverageMonitor() const;
771 
773  virtual DtTerrainProfileRequestManager* terrainProfileRequestManager() const;
774 
776  virtual DtVrfObjectIdGenerator* vrfObjectIdGenerator() const;
777 
780  virtual DtFactoryManager* factoryManager() const;
781 
783  virtual DtSnapshotManager* snapshotManager() const;
784 
787  virtual DtVrfObjectManager* vrfObjectManager() const;
788 
791  virtual DtDebugDrawManager* debugDrawManager() const;
792 
794  virtual DtScriptedTaskManager* scriptedTaskManager() const;
795 
797  virtual DtScenarioEventManager* scenarioEventManager() const;
798 
800  virtual DtEventManager* eventManager() const;
801 
803  virtual DtHazardAreaManager* hazardAreaManager() const;
804 
806  virtual DtIntelCollectionAreaManager* intelCollectionAreaManager() const;
807 
809  virtual DtScriptedObjectsMovementManager* ScriptedObjectsMovementManager() const;
810 
813  virtual DtAggregateSpatialModel* aggregateSpatialModel() const;
814 
817  virtual DtDetonationManager* detonationManager() const;
818 
821  virtual DtAmmunitionManager* ammunitionManager() const;
822 
825  virtual DtFireManager* fireManager() const;
826 
831  virtual DtScenarioExtrasMgr* scenarioExtrasMgr() const;
832 
834  virtual DtVrfParameterDb* parameterDatabase() const;
835 
837  virtual DtGlobalPlanManager* globalPlanManager();
838 
840  virtual DtStealthCommandsManager* stealthCommandsManager();
841 
844 
845  virtual DtTerrainInterface* terrainInterface();
846  virtual const DtTerrainInterface* terrainInterface() const;
848 
851 
852  virtual DtPhysicalWorld* physicalWorld();
853  virtual const DtPhysicalWorld* physicalWorld() const;
855 
857  virtual void setPhysicalWorld(DtPhysicalWorld* newPhysicalWorld);
858 
859  virtual DtVrfNavAreaManager* vrfNavAreaManager();
860  virtual const DtVrfNavAreaManager* vrfNavAreaManager() const;
861 
862  virtual void setVrfNavAreaManager(DtVrfNavAreaManager* newVrfNavAreaManager);
863 
864  virtual DtSpawnSinkManager* spawnSinkManager();
865  virtual const DtSpawnSinkManager* spawnSinkManager() const;
866 
868 
869  virtual DtCommModelManager* commModelManager();
870  virtual const DtCommModelManager* commModelManager() const;
872 
874 
875  virtual DtSimTerrainRequestManager* simTerrainRequestManager();
876  virtual const DtSimTerrainRequestManager* simTerrainRequestManager() const;
878 
880  virtual DtSimCommandDistributor* simCommandDistributor();
881 
883  virtual DtScenario* scenario() const;
884 
887  virtual const DtSimulationAddress& simulationAddress() const;
888 
894  virtual int sessionId() const;
895 
901 
902  virtual DtU32 scenarioCapabilities() const;
903  virtual void setScenarioCapabilities(DtU32 v);
904  virtual void setScenarioCapability(DtU32 v, bool);
906 
909 
910  virtual DtString applicationType() const;
911  virtual void setApplicationType(const DtString& type);
913 
916  virtual DtVrfStatusPublisher* statusPublisher() const;
917 
920  virtual DtExerciseConn* exerciseConn() const;
921 
925  virtual void useMapDatum(const DtMapDatum& mapDatum);
926 
928  virtual void setParameterDbLoaded(bool flag);
929 
930  virtual void setMaxDrainInputTime(DtFloat64 maxTime);
931  virtual DtFloat64 maxDrainInputTime() const;
932 
933 #ifdef DtHLA
934  virtual void setMinDrainInputTime(DtFloat64 minTime);
935  virtual DtFloat64 minDrainInputTime() const;
936 #else
937  virtual void setMaxDrainInputReads(int maxReads);
938  virtual int maxDrainInputReads() const;
939 #endif
940 
946  virtual void setDefaultParameterDbDirectory(const DtFilename& filename);
947 
949  virtual DtFilename objectGroupsRoot() const;
950 
951 #if DtHLA
952  virtual void setRunInTimeManagementMode(bool yesOrNo);
955  virtual bool runInTimeManagementMode() const;
956 
960  static void startTimeManagement(void* usr);
961  static void stopTimeManagement(void* usr);
962 
965  virtual void processStartTimeManagement();
966  virtual void processStopTimeManagement();
967 
968 #endif
969 
974  virtual bool reinitializeScenario();
975 
976  virtual void setFullyLoadTerrain(bool yesOrNo);
977  virtual bool fullyLoadTerrain() const;
978 
982 
983  virtual void setAssertOnBlockingTerrainCalls(bool b);
984  virtual bool assertOnBlockingTerrainCalls() const;
986 
987  //-------------------------------------------------------
989  //-------------------------------------------------------
990 
993  virtual void addPluginToLoad(const DtString&);
994 
997  virtual void setLoadPluginsIfVersionMismatch(bool);
998  virtual bool loadPluginsIfVersionMismatch() const;
999 
1001  virtual bool createAndInitPluginManager(DtVrfCreator* creator);
1002 
1005  virtual void initializePluginCommandLineArguments(DtApplicationSettings& appInitializer);
1006 
1008 
1009  DtVrfCreator* vrfCreator();
1010  const DtVrfCreator* vrfCreator() const;
1012 
1016 
1017  virtual void addPreLoadTerrainCallback(
1018  DtCallbackList<const DtFilename&>::DtCallbackFunctionType fcn, void* usrData);
1019  virtual void removePreLoadTerrainCallback(
1020  DtCallbackList<const DtFilename&>::DtCallbackFunctionType fcn, void* usrData);
1022 
1026 
1027  virtual void addPostLoadTerrainCallback(
1028  DtCallbackList<const DtFilename&>::DtCallbackFunctionType fcn, void* usrData);
1029  virtual void removePostLoadTerrainCallback(
1030  DtCallbackList<const DtFilename&>::DtCallbackFunctionType fcn, void* usrData);
1032 
1035  virtual void runForDuration(double);
1036 
1038  virtual void stopSimulationDurationTimer();
1039 
1041  static void runDurationCompleteCallback(void*);
1042  virtual void processRunDurationComplete();
1043 
1045  virtual void setPublishingGlobalEnvironment(bool);
1046 
1050 
1051  virtual void addPreLoadScenarioCallback(
1052  DtCallbackList<DtScenario&>::DtCallbackFunctionType fcn, void* usrData);
1053  virtual void removePreLoadScenarioCallback(
1054  DtCallbackList<DtScenario&>::DtCallbackFunctionType fcn, void* usrData);
1056 
1058 
1059  virtual void addPreScenarioReinitializeCallback(
1060  DtCallbackList<DtScenario&>::DtCallbackFunctionType fcn, void* usrData);
1061  virtual void removePreScenarioReinitializeCallback(
1062  DtCallbackList<DtScenario&>::DtCallbackFunctionType fcn, void* usrData);
1064 
1067 
1068  virtual void addPostScenarioReinitializeCallback(
1069  DtCallbackList<const DtScenario&>::DtCallbackFunctionType fcn, void* usrData);
1070  virtual void removePostScenarioReinitializeCallback(
1071  DtCallbackList<const DtScenario&>::DtCallbackFunctionType fcn, void* usrData);
1073 
1075 
1076  virtual void addPreCreateSimulationObjectGroupCallback(
1077  DtCallbackList<DtScenario&>::DtCallbackFunctionType fcn, void* usrData);
1078  virtual void removePreCreateSimulationObjectGroupCallback(
1079  DtCallbackList<DtScenario&>::DtCallbackFunctionType fcn, void* usrData);
1081 
1085 
1086  virtual void addPostLoadScenarioCallback(
1087  DtCallbackList<const DtScenario&>::DtCallbackFunctionType fcn, void* usrData);
1088  virtual void removePostLoadScenarioCallback(
1089  DtCallbackList<const DtScenario&>::DtCallbackFunctionType fcn, void* usrData);
1091 
1093 
1094  virtual void addPostCreateSimulationObjectGroupCallback(
1095  DtCallbackList<const DtScenario&>::DtCallbackFunctionType fcn, void* usrData);
1096  virtual void removePostCreateSimulationObjectGroupCallback(
1097  DtCallbackList<const DtScenario&>::DtCallbackFunctionType fcn, void* usrData);
1099 
1101 
1102  virtual void addPreImportScenarioCallback(
1103  DtCallbackList<DtScenario&>::DtCallbackFunctionType fcn, void* usrData);
1104  virtual void removePreImportScenarioCallback(
1105  DtCallbackList<DtScenario&>::DtCallbackFunctionType fcn, void* usrData);
1107 
1109 
1110  virtual void addPostImportScenarioCallback(
1111  DtCallbackList<const DtScenario&>::DtCallbackFunctionType fcn, void* usrData);
1112  virtual void removePostImportScenarioCallback(
1113  DtCallbackList<const DtScenario&>::DtCallbackFunctionType fcn, void* usrData);
1115 
1118 
1119  virtual void addPreSaveScenarioCallback(
1120  DtCallbackList<DtScenario&>::DtCallbackFunctionType fcn, void* usrData);
1121  virtual void removePreSaveScenarioCallback(
1122  DtCallbackList<DtScenario&>::DtCallbackFunctionType fcn, void* usrData);
1124 
1127 
1128  virtual void addPostSaveScenarioCallback(
1129  DtCallbackList<const DtScenario&>::DtCallbackFunctionType fcn, void* usrData);
1130  virtual void removePostSaveScenarioCallback(
1131  DtCallbackList<const DtScenario&>::DtCallbackFunctionType fcn, void* usrData);
1133 
1136 
1137  virtual void addPreCloseScenarioCallback(
1138  DtNoArgumentCallbackList::DtCallbackFunctionType fcn, void* usrData);
1139  virtual void removePreCloseScenarioCallback(
1140  DtNoArgumentCallbackList::DtCallbackFunctionType fcn, void* usrData);
1142 
1145 
1146  virtual void addPostCloseScenarioCallback(
1147  DtNoArgumentCallbackList::DtCallbackFunctionType fcn, void* usrData);
1148  virtual void removePostCloseScenarioCallback(
1149  DtNoArgumentCallbackList::DtCallbackFunctionType fcn, void* usrData);
1151 
1153 
1154  virtual void addPreSaveSimulationObjectGroupsCallback(
1155  DtCallbackList<DtScenario&>::DtCallbackFunctionType fcn, void* usrData);
1156  virtual void removePreSaveSimulationObjectGroupsCallback(
1157  DtCallbackList<DtScenario&>::DtCallbackFunctionType fcn, void* usrData);
1159 
1161 
1162  virtual void addPostSaveSimulationObjectGroupsCallback(
1163  DtCallbackList<const DtScenario&>::DtCallbackFunctionType fcn, void* usrData);
1164  virtual void removePostSaveSimulationObjectGroupsCallback(
1165  DtCallbackList<const DtScenario&>::DtCallbackFunctionType fcn, void* usrData);
1167 
1170 
1171  virtual void addScenarioPauseCallback(
1172  DtNoArgumentCallbackList::DtCallbackFunctionType fcn, void* usrData);
1173  virtual void removeScenarioPauseCallback(
1174  DtNoArgumentCallbackList::DtCallbackFunctionType fcn, void* usrData);
1176 
1179 
1180  virtual void addScenarioRunCallback(
1181  DtNoArgumentCallbackList::DtCallbackFunctionType fcn, void* usrData);
1182  virtual void removeScenarioRunCallback(
1183  DtNoArgumentCallbackList::DtCallbackFunctionType fcn, void* usrData);
1185 
1190 
1191  virtual void addPreScenarioRewindCallback(
1192  DtNoArgumentCallbackList::DtCallbackFunctionType fcn, void* usrData);
1193  virtual void removePreScenarioRewindCallback(
1194  DtNoArgumentCallbackList::DtCallbackFunctionType fcn, void* usrData);
1196 
1199 
1200  virtual void addPostScenarioRewindCallback(
1201  DtNoArgumentCallbackList::DtCallbackFunctionType fcn, void* usrData);
1202  virtual void removePostScenarioRewindCallback(
1203  DtNoArgumentCallbackList::DtCallbackFunctionType fcn, void* usrData);
1205 
1208 
1209  virtual void addPostTickCallback(
1210  DtNoArgumentCallbackList::DtCallbackFunctionType fcn, void* usrData);
1211  virtual void removePostTickCallback(
1212  DtNoArgumentCallbackList::DtCallbackFunctionType fcn, void* usrData);
1214 
1216 
1217  virtual void setTimeToQuit(bool);
1218  virtual bool timeToQuit() const;
1220 
1224  virtual bool executeSimCommand(const DtSimCommand& simCommand);
1225 
1228  virtual void unloadTerrain();
1229 
1231  virtual bool isOrbatEnabled() const;
1232 
1234  virtual bool canSleep() const;
1236  virtual double timeScale() const;
1237 
1238 public:
1239 
1243  static void objectParametersOpCallback(DtSimMessage* msg, void* usr);
1244 
1245 protected:
1247  static void scenarioDescriptionCallback(DtSimMessage*, void* usr);
1248  virtual void processScenarioDescription(DtSimMessage*);
1249 
1251  static void setScenarioFilenameCallback(DtSimMessage*, void* usr);
1252  virtual void processSetScenarioFilename(DtSimMessage*);
1253 
1255  static void setRunDurationCallback(DtSimMessage*, void* usr);
1256  virtual void processSetRunDuration(DtSimMessage*);
1257 
1259  static void actionCategoriesRequestCallback(DtSimMessage* msg, void* usr);
1260  virtual void processActionCategoriesRequest(DtSimMessage* msg);
1261 
1263  static void scenarioStatusRequestCallback(DtSimMessage* msg, void* usr);
1264  virtual void processScenarioStatusRequest(DtSimMessage* msg);
1265 
1267  static void adjustSettingsForTimeMultiplierCallback(DtFloat64 timeMult, void* usr);
1268 
1269 private:
1271  DtCgf(const DtCgf& original);
1273  DtCgf& operator=(const DtCgf& original);
1274 
1275 protected:
1278  virtual DtFilename spawnManagerTemplateFile(const DtScenarioExplorer&) const;
1279 
1281  virtual void loadAllPlugins();
1282 
1284  virtual bool loadComponentAttachmentTable(const DtFilename& filename);
1290  virtual bool loadTerrain(const DtFilename& filename);
1291 
1295  virtual DtFilename findTerrainFile(const DtFilename& startFile, const std::vector<DtFilename>& searchPaths,
1296  const std::string& extension) const;
1297 
1299  virtual bool loadOrderOfBattle(const DtFilename& filename);
1300  virtual bool loadOrderOfBattleFromZipFile(const DtFilename& scenarioZipFile, const DtFilename& filename);
1301  virtual bool loadOrderOfBattle(const DtInMemorySnapshot::OOB&);
1302 
1304  virtual bool loadScenarioScripts(const DtFilename& filename);
1305  virtual bool loadScenarioScriptsFromZipFile(const DtFilename& scenarioZipFile, const DtFilename& filename);
1306  virtual bool loadScenarioScripts(const std::string& buffer);
1307 
1309  virtual bool loadOrbat(const DtFilename& filename, DtOrbatManager* intoOm = 0, bool clearBeforeLoading = true);
1310  virtual bool loadOrbatFromZipFile(const DtFilename& scenarioZipFile, const DtFilename& filename, DtOrbatManager* intoOm = 0, bool clearBeforeLoading = true);
1311  virtual bool loadOrbat(const std::string& buffer, DtOrbatManager* intoOm = 0, bool clearBeforeLoading = true);
1312 
1315  virtual void prepareForScenarioReinitialize();
1316 
1318  virtual bool isScenarioReinitializing() const;
1319 
1323  virtual bool loadParameterDb(const DtFilename& filename,
1324  const DtReaderWriter::SearchPaths& searchPaths, bool clearLoadedObjects = true, bool preloadParameters = false);
1325 
1328  virtual bool loadObjectParametersDBFile(const DtFilename& opdFile,
1329  const DtReaderWriter::SearchPaths& searchPaths, bool clearLoadedObjects = true, bool preloadParameters = false);
1330 
1334  virtual bool loadPhysicalWorldFile(const DtFilename& file, bool force = false);
1335 
1339  virtual bool loadDetonationParametersFile(const DtFilename& file, bool force = false);
1340 
1341  virtual bool loadTerrainDeformationParametersFile(const DtFilename& file, bool force = false);
1342 
1346  virtual bool loadAmmunitionParametersFile(const DtFilename& file, bool force = false);
1347 
1349  virtual bool loadPlans(const DtFilename& filename);
1350  virtual bool loadPlansFromZipFile(const DtFilename& scenarioZipFile, const DtFilename& filename);
1351  virtual bool loadPlans(const std::string& buffer);
1352 
1354  virtual bool loadGlobalPlans(const DtFilename& filename);
1355  virtual bool loadGlobalPlansFromZipFile(const DtFilename& scenarioZipFile, const DtFilename& filename);
1356 
1358  virtual void loadHostilityAndExtras(const DtScenarioExplorer& se);
1359  virtual void loadHostilityAndExtrasFromZipFile(const DtFilename& scenarioZipFile, const DtScenarioExplorer& se);
1360  virtual void loadHostilityAndExtras(const std::string& buffer);
1361 
1364  virtual void loadActivities(const DtScenarioExplorer&);
1365 
1368  virtual void loadModelSetFiles(const DtScenarioExplorer&);
1369 
1372  virtual void loadActionCategories(const DtFilename& f);
1373 
1374  virtual bool loadForceHostility(const DtFilename& filename, bool clear = true);
1375  virtual bool loadForceHostilityFromZipFile(const DtFilename& scenarioZipFile, const DtFilename& filename, bool clear = true);
1376 
1377  virtual bool loadScenarioExtras(const DtFilename& filename);
1378  virtual bool loadScenarioExtrasFromZipFile(const DtFilename&, const DtFilename& filename);
1379  virtual bool loadScenarioExtras(const std::string& buffer);
1380 
1383  virtual void processObjectParametersOp(DtSimMessage * msg);
1384 
1385 
1388  virtual void emptyParametersDB();
1389 
1400  virtual void setFrameRateMode(const DtString& mode, DtReal deltaTime);
1401 
1403  virtual void setAutoReorganization(bool onOff);
1404 
1407  virtual void drainInput();
1408 
1412  virtual DtVrfPlugin* loadPlugin(const DtString&);
1413 
1418 #if DtHLA
1419  DtHlaExerciseClock* exerciseClock() const;
1420 #else
1421  DtExerciseClock* exerciseClock() const;
1422 #endif
1423 
1426  virtual bool setupCommModelsForScenario(const DtScenarioExplorer& e);
1427 
1431  virtual void updateReadyStatus();
1432 
1434  virtual void processOrganizationManagerReady(const DtOrganizationManagerReadyCallbackInfo&);
1435  static void organizationManagerReadyCallback(const DtOrganizationManagerReadyCallbackInfo&, void* usr);
1436 
1439 
1440  static void simCommandCallback(DtSimMessage* msg, void* usr);
1441  virtual void processSimCommand(DtSimMessage* msg);
1443 
1447 
1448  static void deferredLoadScenarioCallback(void * data);
1449  virtual void processDeferredLoadScenario();
1450 
1453  virtual void processLoadScenario(const DtScenario* = 0, const DtInMemorySnapshot* = 0);
1455 
1457 
1458  static void deferredReinitializeScenarioCallback(void * data);
1459  virtual void processDeferredReinitializeScenario();
1461 
1466 
1467  static void deferredRollbackCallback(void * data);
1468  virtual void processDeferredRollback();
1470 
1474 
1475  static void deferredImportScenarioCallback(void * data);
1476  virtual void processDeferredImportScenario();
1478 
1482 
1483  static void deferredRewindCallback(void * data);
1484  virtual void processDeferredRewind();
1486 
1489  virtual void clearAllSimulationModelSetInformation();
1490 
1491  virtual void adjustSettingsForTimeMultiplier(double timeMultiplier);
1492 
1494  virtual void initializeCgfConsoleCommands();
1495 
1496 protected:
1497  DtVrfSimOptionsInterface* mySimOptions;
1498 
1500  DtSimulationAddress mySimulationAddress;
1501 
1503  DtU32 mySessionId;
1504 
1506  bool myOK;
1507 
1509  bool myTimeToQuit;
1510 
1512  DtVrfPluginManager* myPluginManager;
1513  std::vector<DtString> myPluginsToLoad;
1514  bool myLoadPluginsIfVersionMismatch;
1515 
1517  DtTerrainInterface* myTerrainInterface;
1518 
1520  DtPhysicalWorld* myPhysicalWorld;
1521 
1522  DtVrfNavAreaManager* myVrfNavAreaManager;
1523 
1524  DtSpawnSinkManager* mySpawnSinkManager;
1525 
1526  DtCommModelManager* myCommModelManager;
1527 
1528  DtSimTerrainRequestManager* mySimTerrainRequestManager;
1529 
1531  DtExerciseConn* myExerciseConn;
1532 
1534  DtSimManager* mySimManager;
1535 
1537  DtScenario* myScenario;
1538 
1540  DtVrfStatusPublisher* myStatusPublisher;
1541 
1543  DtVrfObjectManager* myVrfObjectManager;
1544 
1546  DtDebugDrawManager* myDebugDrawManager;
1547 
1548  DtAggregateSpatialModel* myAggregateSpatialModel;
1549 
1550  DtDetonationManager* myDetonationManager;
1551  DtAmmunitionManager* myAmmunitionManager;
1552  DtScriptedTaskManager* myScriptedTaskManager;
1553  DtScenarioEventManager* myScenarioEventManager;
1554  DtHazardAreaManager* myHazardAreaManager;
1555  DtIntelCollectionAreaManager* myIntelCollectionAreaManager;
1556  DtScriptedObjectsMovementManager* myScriptedObjectsMovementManager;
1557  DtFireManager* myFireManager;
1558 
1559  DtLuaObjectSerializer* myLuaObjectSerializer;
1560 
1562  DtResourceMonitor* myResourceMonitor;
1563 
1565  DtRadarCoverageMonitor* myRadarCoverageMonitor;
1566 
1568  DtTerrainProfileRequestManager* myTerrainProfileRequestManager;
1569 
1571  DtVrfObjectIdGenerator* myVrfObjectIdGenerator;
1572 
1574  DtVrfParameterDb* myParameterDatabase;
1575 
1577  DtEmbeddedEntityInfoManager* myEmbeddedEntityInfoManager;
1578 
1580  bool myForceParameterDbReload;
1581 
1582  DtGlobalPlanManager* myGlobalPlanManager;
1583 
1584  DtHostilityManager* myHostilityManager;
1585  DtEngagementZonesManager* myEngagementZonesManager;
1586 
1587  DtScenarioExtrasMgr* myScenarioExtrasManager;
1588 
1590  DtFactoryManager* myFactoryManager;
1591 
1593  DtStealthCommandsManager* myStealthCommandsManager;
1594 
1595  DtSimCommandDistributor* mySimCommandDistributor;
1596  DtEventManager* myEventManager;
1597 
1602  DtFilename myVrfTerrainPathDirectory;
1603 
1607  DtFilename myDefaultTerrainDirectory;
1608 
1610  DtFilename myDefaultSimulationModelSetFilename;
1611 
1613  bool myUseDIGuy;
1614 
1616  DtFilename myDIGuyAnimationsFilename;
1617 
1619  int myClockMode;
1620 
1622  DtFilename myMsdlSidcMappingFile;
1623 
1625  DtFilename myCountryCodesMappingFile;
1626 
1628  DtFilename myFastForwardSettingsFile;
1629 
1632  bool myParameterDbLoaded;
1633 
1635  DtFilename myCurrentParameterDatabaseFilename;
1636 
1640  DtFilename myDefaultParameterDbDirectory;
1641 
1642  DtCallbackList<const DtFilename&> myPreLoadTerrainCallbacks;
1643  DtCallbackList<const DtFilename&> myPostLoadTerrainCallbacks;
1644  DtCallbackList<DtScenario&> myPreLoadScenarioCallbacks;
1645  DtCallbackList<const DtScenario&> myPostLoadScenarioCallbacks;
1646  DtCallbackList<DtScenario&> myPreScenarioReinitializeCallbacks;
1647  DtCallbackList<const DtScenario&> myPostScenarioReinitializeCallbacks;
1648  DtCallbackList<DtScenario&> myPreCreateSimulationObjectGroupCallbacks;
1649  DtCallbackList<const DtScenario&> myPostCreateSimulationObjectGroupCallbacks;
1650  DtCallbackList<DtScenario&> myPreImportScenarioCallbacks;
1651  DtCallbackList<const DtScenario&> myPostImportScenarioCallbacks;
1652  DtCallbackList<DtScenario&> myPreSaveScenarioCallbacks;
1653  DtCallbackList<const DtScenario&> myPostSaveScenarioCallbacks;
1654 
1655  DtCallbackList<DtScenario&> myPreSaveSimulationObjectGroupsCallbacks;
1656  DtCallbackList<const DtScenario&> myPostSaveSimulationObjectGroupsCallbacks;
1657 
1658  DtNoArgumentCallbackList myPreCloseScenarioCallbacks;
1659  DtNoArgumentCallbackList myPostCloseScenarioCallbacks;
1660  DtNoArgumentCallbackList myScenarioRunCallbacks;
1661  DtNoArgumentCallbackList myScenarioPauseCallbacks;
1662  DtNoArgumentCallbackList myPreScenarioRewindCallbacks;
1663  DtNoArgumentCallbackList myPostScenarioRewindCallbacks;
1664  DtNoArgumentCallbackList myPostTickCallbacks;
1665 
1666  DtFloat64 myMaxDrainInputTime;
1667 #if DtHLA
1668  DtFloat64 myMinDrainInputTime;
1669 #else
1670  int myMaxDrainInputReads;
1671 #endif
1672 
1677  void setVrfCreator(DtVrfCreator* creator);
1679 
1681 
1682  bool ownVrfCreator() const;
1683  void setOwnVrfCreator(bool yesOrNo);
1685 
1687  virtual bool differingModelSets(DtScenario*) const;
1688 
1689 protected:
1692  bool myOwnVrfCreatorFlag;
1693  DtVrfCreator* myVrfCreator;
1694 
1695 #if DtHLA
1696  bool myRunInTimeManagementMode;
1697 #endif
1698 
1700  bool myFullyLoadTerrain;
1701 
1705  bool myAssertOnBlockingTerrainCalls;
1706 
1710 #if DtHLA
1711  DtHlaExerciseClock* myExerciseClockPtr;
1712 #else
1713  DtExerciseClock* myExerciseClockPtr;
1714 #endif
1715 
1716  DtFastForwardSettings myFastForwardSettings;
1717 
1720  DtSimulationModelSet* myDefaultModelSet;
1721 
1725  DtScenario myScenarioToLoad;
1726 
1727  bool myCreateGlobalEnvironment;
1728  bool myCreateGlobalDynamicTerrain;
1729  bool myCreatedGlobalEnvironment;
1730  bool myCreatedGlobalDynamicTerrain;
1731 
1736  bool myWasPaused;
1737 
1739  DtImportExportScenarioDescriptionManager* myImportScenarioDescriptionManager;
1740 
1741  DtConsoleCommandOwner* myConsoleCommands;
1742 
1745  typedef std::pair<std::string, bool> ActionCategory;
1746  typedef std::map<std::string, ActionCategory> ActionCategories;
1747  ActionCategories myActionCategories;
1748 
1750  DtIfScenarioStatus* myScenarioStatus;
1751 
1752  bool myPublishingGlobalEnvironment;
1753  bool myAboutToLoadOrRewindScenario;
1754  bool myReinitializingScenario;
1755  bool myPublishZeroVelocityWhenPaused;
1756  bool mySetDeadReckoningAlgorithmToStaticOnPause;
1757 
1758  DtTaskVisualizationPublicationMode myTaskVisualizationPublicationMode;
1759  bool myUseDrawControlForTaskVisualizations;
1760 
1761  bool myReuseEntityIdentifiersOnScenarioLoad;
1762 
1763  DtRwActivities myActivities;
1764  bool mySmsValidationEnabled;
1765  DtDefaultSimulationModelSetValidatorManager mySimulationModelSetValidator;
1766  DtSnapshotManager* mySnapshotManager;
1767 
1768  std::vector<DtFilename> myObjectGroupsRoot;
1769 
1770  struct SimulationObjectGroupInformation
1771  {
1772  DtlObjPtr planArgs;
1773  DtlObjPtr oobArgs;
1774  };
1775 
1776  std::set<DtGlobalObjectDesignator> myRemoteObjectGlobalIds;
1777 
1778  typedef std::map<DtString, SimulationObjectGroupInformation> StoredSimulationObjectGroupInformation;
1779  StoredSimulationObjectGroupInformation myStoredSimulationObjectGroupInformation;
1780 
1781  int myRollbackToId;
1782  bool myCanSimulate;
1783  bool myIsLoaded;
1784  bool myHasModelSetInformationLoadedAfterClose;
1785  int myReloadDelay;
1786  bool myRejectMismatchedScenarioMessages;
1787  DtU32 myScenarioCapabilities;
1788  int myAppIdRangeMax;
1789 
1790  std::set<DtFilename> myLoadedModelSets;
1791 
1792  DtInMemorySnapshot* myQueuedRollback;
1793  int myQueuedRollbackScenarioRunId;
1794 };
1795 
DtUUID
UUID is a unique ID wrapper class.
Definition: rwUUID.h:222
DtCgf::myIsLoaded
bool myIsLoaded
Definition: cgf.h:1783
DtCgf::mySimManager
DtSimManager * mySimManager
Pointer to the DtSimManager.
Definition: cgf.h:1534
DtCgf::myCreateGlobalEnvironment
bool myCreateGlobalEnvironment
Definition: cgf.h:1727
DtCgf::myPublishingGlobalEnvironment
bool myPublishingGlobalEnvironment
Definition: cgf.h:1752
DtCgf::myUseDIGuy
bool myUseDIGuy
Set true to use DI-Guy Characters in Vr-forces.
Definition: cgf.h:1613
DtCgf::myScenarioStatus
DtIfScenarioStatus * myScenarioStatus
Scenario status message to be sent out upon request.
Definition: cgf.h:1750
DtCgf::myFastForwardSettingsFile
DtFilename myFastForwardSettingsFile
Fast forward settings file.
Definition: cgf.h:1628
DtSimTerrainRequestManager
Definition: simTerrainRequestManager.h:32
DtResourceMonitor
Class: DtResourceMonitor.
Definition: resourceMonitor.h:58
DtCgf::myAmmunitionManager
DtAmmunitionManager * myAmmunitionManager
Definition: cgf.h:1551
DtCgf::myGlobalPlanManager
DtGlobalPlanManager * myGlobalPlanManager
Definition: cgf.h:1582
DtCgf::myUseDrawControlForTaskVisualizations
bool myUseDrawControlForTaskVisualizations
Definition: cgf.h:1759
DtAmmunitionManager
The DtAmmunitionManager is a clas that will maintain ammunition (that which is not published...
Definition: ammunitionManager.h:17
DtCgf::myScriptedTaskManager
DtScriptedTaskManager * myScriptedTaskManager
Definition: cgf.h:1552
DtVrfObject
DtVrfObject is used to represent any type of simulated object (entities, aggregate, control objects) in a VR-Forces application.
Definition: vrfObject.h:215
DtTimer
Instances of DtTimer are used to maintain the information needed to represent some kind of scheduled ...
Definition: timer.h:45
DtCgf::myRunInTimeManagementMode
bool myRunInTimeManagementMode
Definition: cgf.h:1696
DtCgf::myStealthCommandsManager
DtStealthCommandsManager * myStealthCommandsManager
Stealth commands manager.
Definition: cgf.h:1593
DtVrfParameterDb
Instances of DtVrfParameterDb are the database of DtVrfObjectParameters objects used in the construct...
Definition: vrfParameterDb.h:35
DtCgf::myScenarioPauseCallbacks
DtNoArgumentCallbackList myScenarioPauseCallbacks
Definition: cgf.h:1661
DtCgf::myPreLoadScenarioCallbacks
DtCallbackList< DtScenario & > myPreLoadScenarioCallbacks
Definition: cgf.h:1644
DtInMemorySnapshot
Structure holds a complete single-backend snapshot state in memory.
Definition: snapshotManager.h:31
DtScenario
Definition: scenario.h:52
DtCgf::myPreCreateSimulationObjectGroupCallbacks
DtCallbackList< DtScenario & > myPreCreateSimulationObjectGroupCallbacks
Definition: cgf.h:1648
DtCgf::myOK
bool myOK
Flag indicating whether we have been successfully initialized.
Definition: cgf.h:1506
DtCgf::myEventManager
DtEventManager * myEventManager
Definition: cgf.h:1596
DtCgf::myPreCloseScenarioCallbacks
DtNoArgumentCallbackList myPreCloseScenarioCallbacks
Definition: cgf.h:1658
DtCgf::mySimCommandDistributor
DtSimCommandDistributor * mySimCommandDistributor
Definition: cgf.h:1595
DtCgf::myPhysicalWorld
DtPhysicalWorld * myPhysicalWorld
The current physical world.
Definition: cgf.h:1520
DtCgf::myDefaultSimulationModelSetFilename
DtFilename myDefaultSimulationModelSetFilename
Default simulation model set file to load.
Definition: cgf.h:1610
DtCgf::scenarioStatus
const DtIfScenarioStatus * scenarioStatus() const
Definition: cgf.h:248
DtCgf::myFullyLoadTerrain
bool myFullyLoadTerrain
Flag indicating whether to fully load terrain subpages for paged terrain.
Definition: cgf.h:1700
DtNoArgumentCallbackList::DtCallbackFunctionType
void(* DtCallbackFunctionType)(void *)
The function signature of the callback function.
Definition: noArgumentCallbackList.h:156
DtCgf::ActionCategory
std::pair< std::string, bool > ActionCategory
Map of ID and screen string for action categories.
Definition: cgf.h:1745
DtCgf::myPreScenarioReinitializeCallbacks
DtCallbackList< DtScenario & > myPreScenarioReinitializeCallbacks
Definition: cgf.h:1646
makVrv::vrvTacticalGraphicUtilities::level
DT_DLL_VRVCORE DtTaitBryan level(const DtCoordinateSystem &cs, const DtVector &localOrigin, double topoHeading)
Returns a level orientation with the topographic heading.
DtCgf::myScenarioExtrasManager
DtScenarioExtrasMgr * myScenarioExtrasManager
Definition: cgf.h:1587
DtScenarioExplorer
class DtScenarioExplorer:
Definition: scenarioExplorer.h:26
DtCgf::mySmsValidationEnabled
bool mySmsValidationEnabled
Definition: cgf.h:1764
DtCgf::myPostCreateSimulationObjectGroupCallbacks
DtCallbackList< const DtScenario & > myPostCreateSimulationObjectGroupCallbacks
Definition: cgf.h:1649
DtScriptedTaskManager
Definition: scriptedTaskManager.h:74
DtCommModelManager
Holds all radio networks for the current exercise.
Definition: commModelManager.h:25
DtCgf::myVrfObjectIdGenerator
DtVrfObjectIdGenerator * myVrfObjectIdGenerator
Pointer to the DtVrfObjectIdGenerator.
Definition: cgf.h:1571
DtVrfSimOptionsInterface
Options for the configuring the sim.
Definition: vrfSimOptionsInterface.h:19
DtSpawnSinkManager
Definition: spawnSinkManager.h:22
DtIfSaveScenario
class DtIfSaveScenario:
Definition: ifSaveScenario.h:23
DtCgf::myScenario
DtScenario * myScenario
The current scenario.
Definition: cgf.h:1537
DtCgf::SimulationObjectGroupInformation::oobArgs
DtlObjPtr oobArgs
Definition: cgf.h:1773
DtEngagementZonesManager
The DtEngagementZonesManager will keep track of all the engagement zones and their state...
Definition: engagementZonesManager.h:22
DtCgf::myObjectGroupsRoot
std::vector< DtFilename > myObjectGroupsRoot
Definition: cgf.h:1768
DtRadarCoverageMonitor
Definition: radarCoverageMonitor.h:32
DtCgf::myVrfTerrainPathDirectory
DtFilename myVrfTerrainPathDirectory
Terrain data directory from environment variable VRF_TERRAIN_PATH.
Definition: cgf.h:1602
DtCgf::myTimeToQuit
bool myTimeToQuit
Flag indicating whether or not the app should quit.
Definition: cgf.h:1509
DtTerrainProfileRequestManager
Definition: terrainProfileRequestManager.h:31
DtCgf::myPostCloseScenarioCallbacks
DtNoArgumentCallbackList myPostCloseScenarioCallbacks
Definition: cgf.h:1659
DtFastForwardSettings
Definition: fastForwardSettings.h:12
DtCgf::myPostTickCallbacks
DtNoArgumentCallbackList myPostTickCallbacks
Definition: cgf.h:1664
DtVrfObjectIdGenerator
This class will, in DIS or HLA, generate the unique id necessary to pass into the object publisher to...
Definition: vrfObjectIdGenerator.h:22
DtCgf::myResourceMonitor
DtResourceMonitor * myResourceMonitor
Pointer to the DtResourceMonitor.
Definition: cgf.h:1562
DtOrbatManager
This class derives from the DtOrganizationManager and will handle all requests as it pertains to the ...
Definition: orbatManager.h:25
DtHazardAreaManager
The DtHazardAreaManager will keep track of all hazard area objects and their state.
Definition: hazardAreaManager.h:20
DtCgf::myCreateGlobalDynamicTerrain
bool myCreateGlobalDynamicTerrain
Definition: cgf.h:1728
DtCgf::myCanSimulate
bool myCanSimulate
Definition: cgf.h:1782
DtCgf::myVrfNavAreaManager
DtVrfNavAreaManager * myVrfNavAreaManager
Definition: cgf.h:1522
DtLuaObjectSerializer
Definition: luaObjectSerializer.h:22
DtCgf::myHasModelSetInformationLoadedAfterClose
bool myHasModelSetInformationLoadedAfterClose
Definition: cgf.h:1784
DtCgf::myAppIdRangeMax
int myAppIdRangeMax
Definition: cgf.h:1788
DtFireManager
The DtFireManager class exists to centralize the processing of fire interactions. ...
Definition: fireManager.h:42
DtCgf::myQueuedRollback
DtInMemorySnapshot * myQueuedRollback
Definition: cgf.h:1792
DtCgf::myCommModelManager
DtCommModelManager * myCommModelManager
Definition: cgf.h:1526
DtCgf::myCreatedGlobalDynamicTerrain
bool myCreatedGlobalDynamicTerrain
Definition: cgf.h:1730
DtIfScenarioStatus
Definition: ifScenarioStatus.h:28
DtCgf::mySimOptions
DtVrfSimOptionsInterface * mySimOptions
Definition: cgf.h:1497
DtHostilityManager
This class keeps track of which forces are hostile to which other forces in the simulation.
Definition: hostilityManager.h:34
DtDebugDrawManager
Debug Draw Manager (back end) that receive (DIS/HLA) messages from a VRF GUI and then connect to the ...
Definition: debugDrawManager.h:36
DtCgf::myClockMode
int myClockMode
Configuration for the clock to be used for absolute time stamping (in windows)
Definition: cgf.h:1619
DtCgf::mySimulationModelSetValidator
DtDefaultSimulationModelSetValidatorManager mySimulationModelSetValidator
Definition: cgf.h:1765
DtCgf::myReuseEntityIdentifiersOnScenarioLoad
bool myReuseEntityIdentifiersOnScenarioLoad
Definition: cgf.h:1761
DtCgf::myStatusPublisher
DtVrfStatusPublisher * myStatusPublisher
Pointer to the DtStatusPublisher.
Definition: cgf.h:1540
DtCgf::myRemoteObjectGlobalIds
std::set< DtGlobalObjectDesignator > myRemoteObjectGlobalIds
Definition: cgf.h:1776
DtCgf::myTaskVisualizationPublicationMode
DtTaskVisualizationPublicationMode myTaskVisualizationPublicationMode
Definition: cgf.h:1758
DtCgf::myDIGuyAnimationsFilename
DtFilename myDIGuyAnimationsFilename
DI_Guy animation configuration file to load.
Definition: cgf.h:1616
DtObjectType
Definition: objectType.h:27
DtCgf::myRejectMismatchedScenarioMessages
bool myRejectMismatchedScenarioMessages
Definition: cgf.h:1786
DtCgf::myParameterDatabase
DtVrfParameterDb * myParameterDatabase
Pointer to the DtVrfParameterDb.
Definition: cgf.h:1574
DtCgf::myPreSaveScenarioCallbacks
DtCallbackList< DtScenario & > myPreSaveScenarioCallbacks
Definition: cgf.h:1652
DtCgf::myPreLoadTerrainCallbacks
DtCallbackList< const DtFilename & > myPreLoadTerrainCallbacks
Definition: cgf.h:1642
DtInMemorySnapshot::OOB
std::vector< std::string * > OOB
Definition: snapshotManager.h:41
DtCgf::StoredSimulationObjectGroupInformation
std::map< DtString, SimulationObjectGroupInformation > StoredSimulationObjectGroupInformation
Definition: cgf.h:1778
DtScenarioEventManager
The scenario event manager will keep track of all scenario event objects and their state...
Definition: scenarioEventManager.h:32
DtSetDataRequest
DtSetDataRequest is an abstract base class from which real setDataRequests can derive.
Definition: setDataRequest.h:40
DtCgf::myEmbeddedEntityInfoManager
DtEmbeddedEntityInfoManager * myEmbeddedEntityInfoManager
Pointer to the DtEmbeddedEntityInfoManager.
Definition: cgf.h:1577
DtCgf::myImportScenarioDescriptionManager
DtImportExportScenarioDescriptionManager * myImportScenarioDescriptionManager
The scenario description manager used to import scenario description files.
Definition: cgf.h:1739
DtCgf::myCreatedGlobalEnvironment
bool myCreatedGlobalEnvironment
Definition: cgf.h:1729
DtPhysicalWorld
The DtPhysicalWorld is the primary interface to and manager of all of the &quot;physical&quot; aspects of the s...
Definition: physicalWorld.h:87
DtCgf::myDetonationManager
DtDetonationManager * myDetonationManager
Definition: cgf.h:1550
DtVrfPlugin
The plugin manager will load external loadable objects in order to provide additional functionality t...
Definition: vrfPluginManager.h:33
DtCgf::myCountryCodesMappingFile
DtFilename myCountryCodesMappingFile
Country codes mapping file.
Definition: cgf.h:1625
DtCgf::myDefaultParameterDbDirectory
DtFilename myDefaultParameterDbDirectory
Default parameter database directory to search in when parameter database being specified is not an a...
Definition: cgf.h:1640
DtEventManager
Definition: eventManager.h:23
DtEmbeddedEntityInfoManager
DtEmbeddedEntityInfoManager is the central point for type-keyed data caching in the backend...
Definition: embeddedEntityInfoManager.h:32
DtCgf::myScenarioEventManager
DtScenarioEventManager * myScenarioEventManager
Definition: cgf.h:1553
DtCgf::myTerrainProfileRequestManager
DtTerrainProfileRequestManager * myTerrainProfileRequestManager
Pointer to the DtTerrainProfileRequestManager.
Definition: cgf.h:1568
DtVrfNavAreaManager
The DtVrfNavAreaManager manages all of the nav areas currently created in the sim.
Definition: vrfNavAreaManager.h:41
DtImportExportScenarioDescriptionManager
Definition: importExportScenarioDescriptionManager.h:31
DtPaperMapDatabase
Definition: paperMapDatabase.h:20
DtCgf::myPostLoadTerrainCallbacks
DtCallbackList< const DtFilename & > myPostLoadTerrainCallbacks
Definition: cgf.h:1643
DtSimMessage
File: simMsg.h.
Definition: simMessage.h:35
DtCgf::myStoredSimulationObjectGroupInformation
StoredSimulationObjectGroupInformation myStoredSimulationObjectGroupInformation
Definition: cgf.h:1779
DtCgf::myVrfObjectManager
DtVrfObjectManager * myVrfObjectManager
Pointer to the DtVrfObjectManager.
Definition: cgf.h:1543
DtCgf::myScenarioRunCallbacks
DtNoArgumentCallbackList myScenarioRunCallbacks
Definition: cgf.h:1660
DtNoArgumentCallbackList
This class works just as DtCalllbackTable, but manages callbacks that have no arguments, and therefore don&#39;t fit in the template defined by DtCallbackList.
Definition: noArgumentCallbackList.h:152
dataDir
std::string dataDir()
DtCgf::myPluginManager
DtVrfPluginManager * myPluginManager
The current plugin manager.
Definition: cgf.h:1512
DtReaderWriter::SearchPaths
std::vector< DtFilename > SearchPaths
Definition: readerWriter.h:92
DtCgf::myQueuedRollbackScenarioRunId
int myQueuedRollbackScenarioRunId
Definition: cgf.h:1793
DtCompressedFileTransporter
Definition: compressedFileTransporter.h:24
DtCgf::myWasPaused
bool myWasPaused
Used to hold the paused state during a rewindScenario operation.
Definition: cgf.h:1736
DtCallbackList
Definition: noArgumentCallbackList.h:91
DtCgf::myIntelCollectionAreaManager
DtIntelCollectionAreaManager * myIntelCollectionAreaManager
Definition: cgf.h:1555
DtCgf::myAssertOnBlockingTerrainCalls
bool myAssertOnBlockingTerrainCalls
If true, blocking terrain calls will cause an assert when a debug back-end is in run mode...
Definition: cgf.h:1705
DtCgf::myPreSaveSimulationObjectGroupsCallbacks
DtCallbackList< DtScenario & > myPreSaveSimulationObjectGroupsCallbacks
Definition: cgf.h:1655
DtVrfStatusPublisher
Instances of DtVrfStatusPublisher are used to send information about a VR-Forces simulation engine to...
Definition: vrfStatusPublisher.h:29
DtCgf::myPostSaveSimulationObjectGroupsCallbacks
DtCallbackList< const DtScenario & > myPostSaveSimulationObjectGroupsCallbacks
Definition: cgf.h:1656
DtCgf::myDefaultModelSet
DtSimulationModelSet * myDefaultModelSet
Default simulation model set.
Definition: cgf.h:1720
DtCgf::myActivities
DtRwActivities myActivities
Definition: cgf.h:1763
DtVrfPluginManager
Definition: vrfPluginManager.h:73
DtCgf::myRadarCoverageMonitor
DtRadarCoverageMonitor * myRadarCoverageMonitor
Pointer to the DtRadarCoverageMonitor.
Definition: cgf.h:1565
DtConsoleCommandOwner
A utility class for use with DtConsoleCommandManager.
Definition: consoleCommandManager.h:157
DtFactoryManager
Instances of DtFactoryManager are responsible for maintaining all the factories.
Definition: factoryManager.h:74
vrvControlToolkit::DtFloat64
double DtFloat64
Definition: vrvControlStructTypes.h:36
DtTerrainInterface
DtTerrainInterface allows access to common terrain calls without having to know the terrain implement...
Definition: terrainInterface.h:84
DtCgf::myFactoryManager
DtFactoryManager * myFactoryManager
Pointer to the DtFactoryManager.
Definition: cgf.h:1590
DtCgf::myActionCategories
ActionCategories myActionCategories
Definition: cgf.h:1747
DtSimCommand
DtSimCommand is an abstract base class from which commands can derive.
Definition: simCommand.h:32
DtCgf::myScenarioToLoad
DtScenario myScenarioToLoad
Used to contain the scenario we want to during loadScenario operation.
Definition: cgf.h:1725
DtCgf::myHazardAreaManager
DtHazardAreaManager * myHazardAreaManager
Definition: cgf.h:1554
DtCgf::myAggregateSpatialModel
DtAggregateSpatialModel * myAggregateSpatialModel
Definition: cgf.h:1548
DtCgf::myPluginsToLoad
std::vector< DtString > myPluginsToLoad
Definition: cgf.h:1513
DtCgf::myPostSaveScenarioCallbacks
DtCallbackList< const DtScenario & > myPostSaveScenarioCallbacks
Definition: cgf.h:1653
DtCgf::myReinitializingScenario
bool myReinitializingScenario
Definition: cgf.h:1754
error
Definition: asyncJobServer.h:39
DtVrfCreator
Instances of DtVrfCreator are responsible for creating all of the objects needed to create and manage...
Definition: vrfCreator.h:252
DtPlan
class DtPlan:
Definition: plan.h:90
DtIntelCollectionAreaManager
The scenario event manager will keep track of all Intel Collection area objects and their state...
Definition: intelCollectionAreaManager.h:21
DtCgf::myPreImportScenarioCallbacks
DtCallbackList< DtScenario & > myPreImportScenarioCallbacks
Definition: cgf.h:1650
DtVrfObjectManager
class DtVrfObjectManager:
Definition: vrfObjectManager.h:201
translatableStream.h
DtTranslatableStream.
DtCgf::myLoadedModelSets
std::set< DtFilename > myLoadedModelSets
Definition: cgf.h:1790
DtScenarioExtrasMgr
This class defines a manager whose job it is to read the extra scenario data in the ...
Definition: scenarioExtrasMgr.h:26
DtCgf::myPostScenarioRewindCallbacks
DtNoArgumentCallbackList myPostScenarioRewindCallbacks
Definition: cgf.h:1663
DtCgf::myAboutToLoadOrRewindScenario
bool myAboutToLoadOrRewindScenario
Definition: cgf.h:1753
DtCgf::myForceParameterDbReload
bool myForceParameterDbReload
Forces loadScenario to re-load the parameter database.
Definition: cgf.h:1580
DtAdminContent
DtAdminContent.
Definition: adminContent.h:24
DtSimulationModelSet
A simulation model set contains all the information that can be used to support a scenario either for...
Definition: simulationModelSet.h:31
DtAggregateSpatialModel
Functor class used to allow entity identifiers to be used as a key to a std::map. ...
Definition: aggregateSpatialModel.h:47
DtCgf::myMaxDrainInputTime
DtFloat64 myMaxDrainInputTime
Definition: cgf.h:1666
DtCgf::mySnapshotManager
DtSnapshotManager * mySnapshotManager
Definition: cgf.h:1766
DtCgf::myEngagementZonesManager
DtEngagementZonesManager * myEngagementZonesManager
Definition: cgf.h:1585
DtCgf::mySetDeadReckoningAlgorithmToStaticOnPause
bool mySetDeadReckoningAlgorithmToStaticOnPause
Definition: cgf.h:1756
DtCgf::myPublishZeroVelocityWhenPaused
bool myPublishZeroVelocityWhenPaused
Definition: cgf.h:1755
DtStealthCommandsManager
Definition: stealthCommandsManager.h:41
DtCgf::aboutToLoadOrRewindScenario
virtual bool aboutToLoadOrRewindScenario() const
Whether or not this cgf is about to rewind, rollback or load.
Definition: cgf.h:339
DtCgf::myMinDrainInputTime
DtFloat64 myMinDrainInputTime
Definition: cgf.h:1668
DtCgf::myPostImportScenarioCallbacks
DtCallbackList< const DtScenario & > myPostImportScenarioCallbacks
Definition: cgf.h:1651
DtSimTask
DtSimTask is an abstract base class from which real tasks can derive.
Definition: simTask.h:33
init
DT_DLL_DEBUGDRAWRENDERER void init(makVrv::DtDe &de)
Work function for the plugin initialization.
mode
const char int mode
Definition: ioapi.h:38
DtCgf::mySimTerrainRequestManager
DtSimTerrainRequestManager * mySimTerrainRequestManager
Definition: cgf.h:1528
DtCgf::myPostLoadScenarioCallbacks
DtCallbackList< const DtScenario & > myPostLoadScenarioCallbacks
Definition: cgf.h:1645
DtCgf::myReloadDelay
int myReloadDelay
Definition: cgf.h:1785
DtCgf::myVrfCreator
DtVrfCreator * myVrfCreator
Definition: cgf.h:1693
DtHlaExerciseClock
DtHlaClock is a clock that is capable of supporting HLA the time management concepts time-constrained...
Definition: hlaExerciseClock.h:44
DtCgf::myPreScenarioRewindCallbacks
DtNoArgumentCallbackList myPreScenarioRewindCallbacks
Definition: cgf.h:1662
DtCgf::canSimulate
virtual bool canSimulate() const
Whether or not the cgf is ready to simulate.
Definition: cgf.h:336
DtCgf::myCurrentParameterDatabaseFilename
DtFilename myCurrentParameterDatabaseFilename
Filename of currently loaded parameter database.
Definition: cgf.h:1635
DtSimManager
The simulation engine is controlled by a single,top-level class called the Simulation Manager...
Definition: simManager.h:102
DtSnapshotManager
Definition: snapshotManager.h:53
DtCgf::SimulationObjectGroupInformation::planArgs
DtlObjPtr planArgs
Definition: cgf.h:1772
DtCgf::myScenarioCapabilities
DtU32 myScenarioCapabilities
Definition: cgf.h:1787
DtCgf::myOwnVrfCreatorFlag
bool myOwnVrfCreatorFlag
These are essentially cached from the init call.
Definition: cgf.h:1692
DtCgf::scenarioStatus
DtIfScenarioStatus * scenarioStatus()
Returns the scenario status object.
Definition: cgf.h:247
DtCgf::myParameterDbLoaded
bool myParameterDbLoaded
Set to true if parameter database has been loaded via loadParameterDatabase call. ...
Definition: cgf.h:1632
DtCgf::myHostilityManager
DtHostilityManager * myHostilityManager
Definition: cgf.h:1584
DtGlobalPlanManager
The global plan manager maintains the list of &quot;Global Plans.&quot; These are plans that are not specific t...
Definition: globalPlanManager.h:37
DtCgf::mySpawnSinkManager
DtSpawnSinkManager * mySpawnSinkManager
Definition: cgf.h:1524
DtCgf::myExerciseConn
DtExerciseConn * myExerciseConn
The current exercise connection.
Definition: cgf.h:1531
DtCgf
An instance of DtCgf is an object representing a CGF (Computer Generated Forces). ...
Definition: cgf.h:115
DtCgf::myLuaObjectSerializer
DtLuaObjectSerializer * myLuaObjectSerializer
Definition: cgf.h:1559
DtCgf::myConsoleCommands
DtConsoleCommandOwner * myConsoleCommands
Definition: cgf.h:1741
DtCgf::myFireManager
DtFireManager * myFireManager
Definition: cgf.h:1557
DtRwActivities
A DtRwActivities list will contain a list of activities (key/value pair) by entity type that will sup...
Definition: rwActivities.h:20
DT_DLL_vrfcgf
#define DT_DLL_vrfcgf
This file is used to determine how to build.
Definition: vrfcgfDefines.h:25
DtCgf::myExerciseClockPtr
DtHlaExerciseClock * myExerciseClockPtr
Cache a pointer to the exercise clock (created by the DtSimManager) for convenience.
Definition: cgf.h:1711
DtCgf::myScriptedObjectsMovementManager
DtScriptedObjectsMovementManager * myScriptedObjectsMovementManager
Definition: cgf.h:1556
DtOrganizationManagerReadyCallbackInfo
Container used in callback lists.
Definition: organizationManager.h:27
DtCgf::myDebugDrawManager
DtDebugDrawManager * myDebugDrawManager
Pointer to the DtDebugDrawManagert.
Definition: cgf.h:1546
DtCgf::myPostScenarioReinitializeCallbacks
DtCallbackList< const DtScenario & > myPostScenarioReinitializeCallbacks
Definition: cgf.h:1647
DtDetonationManager
The DtDetonationManager class exists to centralize the processing of detonation interactions.
Definition: detonationManager.h:58
DtCgf::myFastForwardSettings
DtFastForwardSettings myFastForwardSettings
Definition: cgf.h:1716
DtCgf::myTerrainInterface
DtTerrainInterface * myTerrainInterface
The current terrain database.
Definition: cgf.h:1517
DtCgf::mySessionId
DtU32 mySessionId
Session Id.
Definition: cgf.h:1503
DtSimCommandDistributor
Contains the DtSimCommandDistributor class declaration.
Definition: simCommandDistributor.h:23
DtCgf::myDefaultTerrainDirectory
DtFilename myDefaultTerrainDirectory
Terrain database directory, initialized from VRF_defaultTerrainDatabasePath variable.
Definition: cgf.h:1607
DtCgf::myLoadPluginsIfVersionMismatch
bool myLoadPluginsIfVersionMismatch
Definition: cgf.h:1514
DtCgf::mySimulationAddress
DtSimulationAddress mySimulationAddress
Address for routing interface messages.
Definition: cgf.h:1500
DtScriptedObjectsMovementManager
The scripted objects movement manager contains a list of all objects that can be scheduled for script...
Definition: scriptedObjectsMovementManager.h:20
DtCgf::ActionCategories
std::map< std::string, ActionCategory > ActionCategories
Definition: cgf.h:1746
DtTaskVisualizationPublicationMode
DtTaskVisualizationPublicationMode
Defines how task visualizations will be published.
Definition: vrfObjectManager.h:182
DtCgf::myRollbackToId
int myRollbackToId
Definition: cgf.h:1781
DtCgf::myMsdlSidcMappingFile
DtFilename myMsdlSidcMappingFile
MSDL SDIC mapping file to load.
Definition: cgf.h:1622
DtDefaultSimulationModelSetValidatorManager
Default implementation that will add protocol and state data validators (contained in this header fil...
Definition: defaultSimulationModelSetValidatorManager.h:17
DtExerciseClock
Description: The Exercise Clock keeps track of current simulated time.
Definition: exerciseClock.h:44
Document ID: Generated on Thu Aug 27 10:56:05 EDT 2020 from SVN revision 217100
Copyright © 2005-2020 MAK Technologies. All Rights Reserved (www.mak.com)