VR-Forces 4.10 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 
990 
991  virtual void setMetocEnable(bool b);
992  virtual bool metocEnable() const;
994 
995  //-------------------------------------------------------
997  //-------------------------------------------------------
998 
1001  virtual void addPluginToLoad(const DtString&);
1002 
1005  virtual void setLoadPluginsIfVersionMismatch(bool);
1006  virtual bool loadPluginsIfVersionMismatch() const;
1007 
1009  virtual bool createAndInitPluginManager(DtVrfCreator* creator);
1010 
1013  virtual void initializePluginCommandLineArguments(DtApplicationSettings& appInitializer);
1014 
1016 
1017  DtVrfCreator* vrfCreator();
1018  const DtVrfCreator* vrfCreator() const;
1020 
1024 
1025  virtual void addPreLoadTerrainCallback(
1026  DtCallbackList<const DtFilename&>::DtCallbackFunctionType fcn, void* usrData);
1027  virtual void removePreLoadTerrainCallback(
1028  DtCallbackList<const DtFilename&>::DtCallbackFunctionType fcn, void* usrData);
1030 
1034 
1035  virtual void addPostLoadTerrainCallback(
1036  DtCallbackList<const DtFilename&>::DtCallbackFunctionType fcn, void* usrData);
1037  virtual void removePostLoadTerrainCallback(
1038  DtCallbackList<const DtFilename&>::DtCallbackFunctionType fcn, void* usrData);
1040 
1043  virtual void runForDuration(double);
1044 
1046  virtual void stopSimulationDurationTimer();
1047 
1049  static void runDurationCompleteCallback(void*);
1050  virtual void processRunDurationComplete();
1051 
1053  virtual void setPublishingGlobalEnvironment(bool);
1054 
1058 
1059  virtual void addPreLoadScenarioCallback(
1060  DtCallbackList<DtScenario&>::DtCallbackFunctionType fcn, void* usrData);
1061  virtual void removePreLoadScenarioCallback(
1062  DtCallbackList<DtScenario&>::DtCallbackFunctionType fcn, void* usrData);
1064 
1066 
1067  virtual void addPreScenarioReinitializeCallback(
1068  DtCallbackList<DtScenario&>::DtCallbackFunctionType fcn, void* usrData);
1069  virtual void removePreScenarioReinitializeCallback(
1070  DtCallbackList<DtScenario&>::DtCallbackFunctionType fcn, void* usrData);
1072 
1075 
1076  virtual void addPostScenarioReinitializeCallback(
1077  DtCallbackList<const DtScenario&>::DtCallbackFunctionType fcn, void* usrData);
1078  virtual void removePostScenarioReinitializeCallback(
1079  DtCallbackList<const DtScenario&>::DtCallbackFunctionType fcn, void* usrData);
1081 
1083 
1084  virtual void addPreCreateSimulationObjectGroupCallback(
1085  DtCallbackList<DtScenario&>::DtCallbackFunctionType fcn, void* usrData);
1086  virtual void removePreCreateSimulationObjectGroupCallback(
1087  DtCallbackList<DtScenario&>::DtCallbackFunctionType fcn, void* usrData);
1089 
1093 
1094  virtual void addPostLoadScenarioCallback(
1095  DtCallbackList<const DtScenario&>::DtCallbackFunctionType fcn, void* usrData);
1096  virtual void removePostLoadScenarioCallback(
1097  DtCallbackList<const DtScenario&>::DtCallbackFunctionType fcn, void* usrData);
1099 
1101 
1102  virtual void addPostCreateSimulationObjectGroupCallback(
1103  DtCallbackList<const DtScenario&>::DtCallbackFunctionType fcn, void* usrData);
1104  virtual void removePostCreateSimulationObjectGroupCallback(
1105  DtCallbackList<const DtScenario&>::DtCallbackFunctionType fcn, void* usrData);
1107 
1109 
1110  virtual void addPreImportScenarioCallback(
1111  DtCallbackList<DtScenario&>::DtCallbackFunctionType fcn, void* usrData);
1112  virtual void removePreImportScenarioCallback(
1113  DtCallbackList<DtScenario&>::DtCallbackFunctionType fcn, void* usrData);
1115 
1117 
1118  virtual void addPostImportScenarioCallback(
1119  DtCallbackList<const DtScenario&>::DtCallbackFunctionType fcn, void* usrData);
1120  virtual void removePostImportScenarioCallback(
1121  DtCallbackList<const DtScenario&>::DtCallbackFunctionType fcn, void* usrData);
1123 
1126 
1127  virtual void addPreSaveScenarioCallback(
1128  DtCallbackList<DtScenario&>::DtCallbackFunctionType fcn, void* usrData);
1129  virtual void removePreSaveScenarioCallback(
1130  DtCallbackList<DtScenario&>::DtCallbackFunctionType fcn, void* usrData);
1132 
1135 
1136  virtual void addPostSaveScenarioCallback(
1137  DtCallbackList<const DtScenario&>::DtCallbackFunctionType fcn, void* usrData);
1138  virtual void removePostSaveScenarioCallback(
1139  DtCallbackList<const DtScenario&>::DtCallbackFunctionType fcn, void* usrData);
1141 
1144 
1145  virtual void addPreCloseScenarioCallback(
1146  DtNoArgumentCallbackList::DtCallbackFunctionType fcn, void* usrData);
1147  virtual void removePreCloseScenarioCallback(
1148  DtNoArgumentCallbackList::DtCallbackFunctionType fcn, void* usrData);
1150 
1153 
1154  virtual void addPostCloseScenarioCallback(
1155  DtNoArgumentCallbackList::DtCallbackFunctionType fcn, void* usrData);
1156  virtual void removePostCloseScenarioCallback(
1157  DtNoArgumentCallbackList::DtCallbackFunctionType fcn, void* usrData);
1159 
1161 
1162  virtual void addPreSaveSimulationObjectGroupsCallback(
1163  DtCallbackList<DtScenario&>::DtCallbackFunctionType fcn, void* usrData);
1164  virtual void removePreSaveSimulationObjectGroupsCallback(
1165  DtCallbackList<DtScenario&>::DtCallbackFunctionType fcn, void* usrData);
1167 
1169 
1170  virtual void addPostSaveSimulationObjectGroupsCallback(
1171  DtCallbackList<const DtScenario&>::DtCallbackFunctionType fcn, void* usrData);
1172  virtual void removePostSaveSimulationObjectGroupsCallback(
1173  DtCallbackList<const DtScenario&>::DtCallbackFunctionType fcn, void* usrData);
1175 
1178 
1179  virtual void addScenarioPauseCallback(
1180  DtNoArgumentCallbackList::DtCallbackFunctionType fcn, void* usrData);
1181  virtual void removeScenarioPauseCallback(
1182  DtNoArgumentCallbackList::DtCallbackFunctionType fcn, void* usrData);
1184 
1187 
1188  virtual void addScenarioRunCallback(
1189  DtNoArgumentCallbackList::DtCallbackFunctionType fcn, void* usrData);
1190  virtual void removeScenarioRunCallback(
1191  DtNoArgumentCallbackList::DtCallbackFunctionType fcn, void* usrData);
1193 
1198 
1199  virtual void addPreScenarioRewindCallback(
1200  DtNoArgumentCallbackList::DtCallbackFunctionType fcn, void* usrData);
1201  virtual void removePreScenarioRewindCallback(
1202  DtNoArgumentCallbackList::DtCallbackFunctionType fcn, void* usrData);
1204 
1207 
1208  virtual void addPostScenarioRewindCallback(
1209  DtNoArgumentCallbackList::DtCallbackFunctionType fcn, void* usrData);
1210  virtual void removePostScenarioRewindCallback(
1211  DtNoArgumentCallbackList::DtCallbackFunctionType fcn, void* usrData);
1213 
1216 
1217  virtual void addPostTickCallback(
1218  DtNoArgumentCallbackList::DtCallbackFunctionType fcn, void* usrData);
1219  virtual void removePostTickCallback(
1220  DtNoArgumentCallbackList::DtCallbackFunctionType fcn, void* usrData);
1222 
1224 
1225  virtual void setTimeToQuit(bool);
1226  virtual bool timeToQuit() const;
1228 
1232  virtual bool executeSimCommand(const DtSimCommand& simCommand);
1233 
1236  virtual void unloadTerrain();
1237 
1239  virtual bool isOrbatEnabled() const;
1240 
1242  virtual bool canSleep() const;
1244  virtual double timeScale() const;
1245 
1246 public:
1247 
1251  static void objectParametersOpCallback(DtSimMessage* msg, void* usr);
1252 
1253 protected:
1255  static void scenarioDescriptionCallback(DtSimMessage*, void* usr);
1256  virtual void processScenarioDescription(DtSimMessage*);
1257 
1259  static void setScenarioFilenameCallback(DtSimMessage*, void* usr);
1260  virtual void processSetScenarioFilename(DtSimMessage*);
1261 
1263  static void setRunDurationCallback(DtSimMessage*, void* usr);
1264  virtual void processSetRunDuration(DtSimMessage*);
1265 
1267  static void actionCategoriesRequestCallback(DtSimMessage* msg, void* usr);
1268  virtual void processActionCategoriesRequest(DtSimMessage* msg);
1269 
1271  static void scenarioStatusRequestCallback(DtSimMessage* msg, void* usr);
1272  virtual void processScenarioStatusRequest(DtSimMessage* msg);
1273 
1275  static void adjustSettingsForTimeMultiplierCallback(DtFloat64 timeMult, void* usr);
1276 
1277 private:
1279  DtCgf(const DtCgf& original);
1281  DtCgf& operator=(const DtCgf& original);
1282 
1283 protected:
1286  virtual DtFilename spawnManagerTemplateFile(const DtScenarioExplorer&) const;
1287 
1289  virtual void loadAllPlugins();
1290 
1292  virtual bool loadComponentAttachmentTable(const DtFilename& filename);
1298  virtual bool loadTerrain(const DtFilename& filename);
1299 
1303  virtual DtFilename findTerrainFile(const DtFilename& startFile, const std::vector<DtFilename>& searchPaths,
1304  const std::string& extension) const;
1305 
1307  virtual bool loadOrderOfBattle(const DtFilename& filename);
1308  virtual bool loadOrderOfBattleFromZipFile(const DtFilename& scenarioZipFile, const DtFilename& filename);
1309  virtual bool loadOrderOfBattle(const DtInMemorySnapshot::OOB&);
1310 
1312  virtual bool loadScenarioScripts(const DtFilename& filename);
1313  virtual bool loadScenarioScriptsFromZipFile(const DtFilename& scenarioZipFile, const DtFilename& filename);
1314  virtual bool loadScenarioScripts(const std::string& buffer);
1315 
1317  virtual bool loadOrbat(const DtFilename& filename, DtOrbatManager* intoOm = 0, bool clearBeforeLoading = true);
1318  virtual bool loadOrbatFromZipFile(const DtFilename& scenarioZipFile, const DtFilename& filename, DtOrbatManager* intoOm = 0, bool clearBeforeLoading = true);
1319  virtual bool loadOrbat(const std::string& buffer, DtOrbatManager* intoOm = 0, bool clearBeforeLoading = true);
1320 
1323  virtual void prepareForScenarioReinitialize();
1324 
1326  virtual bool isScenarioReinitializing() const;
1327 
1331  virtual bool loadParameterDb(const DtFilename& filename,
1332  const DtReaderWriter::SearchPaths& searchPaths, bool clearLoadedObjects = true, bool preloadParameters = false);
1333 
1336  virtual bool loadObjectParametersDBFile(const DtFilename& opdFile,
1337  const DtReaderWriter::SearchPaths& searchPaths, bool clearLoadedObjects = true, bool preloadParameters = false);
1338 
1342  virtual bool loadPhysicalWorldFile(const DtFilename& file, bool force = false);
1343 
1347  virtual bool loadDetonationParametersFile(const DtFilename& file, bool force = false);
1348 
1349  virtual bool loadTerrainDeformationParametersFile(const DtFilename& file, bool force = false);
1350 
1354  virtual bool loadAmmunitionParametersFile(const DtFilename& file, bool force = false);
1355 
1357  virtual bool loadPlans(const DtFilename& filename);
1358  virtual bool loadPlansFromZipFile(const DtFilename& scenarioZipFile, const DtFilename& filename);
1359  virtual bool loadPlans(const std::string& buffer);
1360 
1362  virtual bool loadGlobalPlans(const DtFilename& filename);
1363  virtual bool loadGlobalPlansFromZipFile(const DtFilename& scenarioZipFile, const DtFilename& filename);
1364 
1366  virtual void loadHostilityAndExtras(const DtScenarioExplorer& se);
1367  virtual void loadHostilityAndExtrasFromZipFile(const DtFilename& scenarioZipFile, const DtScenarioExplorer& se);
1368  virtual void loadHostilityAndExtras(const std::string& buffer);
1369 
1372  virtual void loadActivities(const DtScenarioExplorer&);
1373 
1376  virtual void loadModelSetFiles(const DtScenarioExplorer&);
1377 
1380  virtual void loadActionCategories(const DtFilename& f);
1381 
1382  virtual bool loadForceHostility(const DtFilename& filename, bool clear = true);
1383  virtual bool loadForceHostilityFromZipFile(const DtFilename& scenarioZipFile, const DtFilename& filename, bool clear = true);
1384 
1385  virtual bool loadScenarioExtras(const DtFilename& filename);
1386  virtual bool loadScenarioExtrasFromZipFile(const DtFilename&, const DtFilename& filename);
1387  virtual bool loadScenarioExtras(const std::string& buffer);
1388 
1391  virtual void processObjectParametersOp(DtSimMessage * msg);
1392 
1393 
1396  virtual void emptyParametersDB();
1397 
1408  virtual void setFrameRateMode(const DtString& mode, DtReal deltaTime);
1409 
1411  virtual void setAutoReorganization(bool onOff);
1412 
1415  virtual void drainInput();
1416 
1420  virtual DtVrfPlugin* loadPlugin(const DtString&);
1421 
1426 #if DtHLA
1427  DtHlaExerciseClock* exerciseClock() const;
1428 #else
1429  DtExerciseClock* exerciseClock() const;
1430 #endif
1431 
1434  virtual bool setupCommModelsForScenario(const DtScenarioExplorer& e);
1435 
1439  virtual void updateReadyStatus();
1440 
1442  virtual void processOrganizationManagerReady(const DtOrganizationManagerReadyCallbackInfo&);
1443  static void organizationManagerReadyCallback(const DtOrganizationManagerReadyCallbackInfo&, void* usr);
1444 
1447 
1448  static void simCommandCallback(DtSimMessage* msg, void* usr);
1449  virtual void processSimCommand(DtSimMessage* msg);
1451 
1455 
1456  static void deferredLoadScenarioCallback(void * data);
1457  virtual void processDeferredLoadScenario();
1458 
1461  virtual void processLoadScenario(const DtScenario* = 0, const DtInMemorySnapshot* = 0);
1463 
1465 
1466  static void deferredReinitializeScenarioCallback(void * data);
1467  virtual void processDeferredReinitializeScenario();
1469 
1474 
1475  static void deferredRollbackCallback(void * data);
1476  virtual void processDeferredRollback();
1478 
1482 
1483  static void deferredImportScenarioCallback(void * data);
1484  virtual void processDeferredImportScenario();
1486 
1490 
1491  static void deferredRewindCallback(void * data);
1492  virtual void processDeferredRewind();
1494 
1497  virtual void clearAllSimulationModelSetInformation();
1498 
1499  virtual void adjustSettingsForTimeMultiplier(double timeMultiplier);
1500 
1502  virtual void initializeCgfConsoleCommands();
1503 
1504 protected:
1505  DtVrfSimOptionsInterface* mySimOptions;
1506 
1508  DtSimulationAddress mySimulationAddress;
1509 
1511  DtU32 mySessionId;
1512 
1514  bool myOK;
1515 
1517  bool myTimeToQuit;
1518 
1520  DtVrfPluginManager* myPluginManager;
1521  std::vector<DtString> myPluginsToLoad;
1522  bool myLoadPluginsIfVersionMismatch;
1523 
1525  DtTerrainInterface* myTerrainInterface;
1526 
1528  DtPhysicalWorld* myPhysicalWorld;
1529 
1530  DtVrfNavAreaManager* myVrfNavAreaManager;
1531 
1532  DtSpawnSinkManager* mySpawnSinkManager;
1533 
1534  DtCommModelManager* myCommModelManager;
1535 
1536  DtSimTerrainRequestManager* mySimTerrainRequestManager;
1537 
1539  DtExerciseConn* myExerciseConn;
1540 
1542  DtSimManager* mySimManager;
1543 
1545  DtScenario* myScenario;
1546 
1548  DtVrfStatusPublisher* myStatusPublisher;
1549 
1551  DtVrfObjectManager* myVrfObjectManager;
1552 
1554  DtDebugDrawManager* myDebugDrawManager;
1555 
1556  DtAggregateSpatialModel* myAggregateSpatialModel;
1557 
1558  DtDetonationManager* myDetonationManager;
1559  DtAmmunitionManager* myAmmunitionManager;
1560  DtScriptedTaskManager* myScriptedTaskManager;
1561  DtScenarioEventManager* myScenarioEventManager;
1562  DtHazardAreaManager* myHazardAreaManager;
1563  DtIntelCollectionAreaManager* myIntelCollectionAreaManager;
1564  DtScriptedObjectsMovementManager* myScriptedObjectsMovementManager;
1565  DtFireManager* myFireManager;
1566 
1567  DtLuaObjectSerializer* myLuaObjectSerializer;
1568 
1570  DtResourceMonitor* myResourceMonitor;
1571 
1573  DtRadarCoverageMonitor* myRadarCoverageMonitor;
1574 
1576  DtTerrainProfileRequestManager* myTerrainProfileRequestManager;
1577 
1579  DtVrfObjectIdGenerator* myVrfObjectIdGenerator;
1580 
1582  DtVrfParameterDb* myParameterDatabase;
1583 
1585  DtEmbeddedEntityInfoManager* myEmbeddedEntityInfoManager;
1586 
1588  bool myForceParameterDbReload;
1589 
1590  DtGlobalPlanManager* myGlobalPlanManager;
1591 
1592  DtHostilityManager* myHostilityManager;
1593  DtEngagementZonesManager* myEngagementZonesManager;
1594 
1595  DtScenarioExtrasMgr* myScenarioExtrasManager;
1596 
1598  DtFactoryManager* myFactoryManager;
1599 
1601  DtStealthCommandsManager* myStealthCommandsManager;
1602 
1603  DtSimCommandDistributor* mySimCommandDistributor;
1604  DtEventManager* myEventManager;
1605 
1610  DtFilename myVrfTerrainPathDirectory;
1611 
1615  DtFilename myDefaultTerrainDirectory;
1616 
1618  DtFilename myDefaultSimulationModelSetFilename;
1619 
1621  bool myUseDIGuy;
1622 
1624  DtFilename myDIGuyAnimationsFilename;
1625 
1627  int myClockMode;
1628 
1630  DtFilename myMsdlSidcMappingFile;
1631 
1633  DtFilename myCountryCodesMappingFile;
1634 
1636  DtFilename myFastForwardSettingsFile;
1637 
1640  bool myParameterDbLoaded;
1641 
1643  DtFilename myCurrentParameterDatabaseFilename;
1644 
1648  DtFilename myDefaultParameterDbDirectory;
1649 
1650  DtCallbackList<const DtFilename&> myPreLoadTerrainCallbacks;
1651  DtCallbackList<const DtFilename&> myPostLoadTerrainCallbacks;
1652  DtCallbackList<DtScenario&> myPreLoadScenarioCallbacks;
1653  DtCallbackList<const DtScenario&> myPostLoadScenarioCallbacks;
1654  DtCallbackList<DtScenario&> myPreScenarioReinitializeCallbacks;
1655  DtCallbackList<const DtScenario&> myPostScenarioReinitializeCallbacks;
1656  DtCallbackList<DtScenario&> myPreCreateSimulationObjectGroupCallbacks;
1657  DtCallbackList<const DtScenario&> myPostCreateSimulationObjectGroupCallbacks;
1658  DtCallbackList<DtScenario&> myPreImportScenarioCallbacks;
1659  DtCallbackList<const DtScenario&> myPostImportScenarioCallbacks;
1660  DtCallbackList<DtScenario&> myPreSaveScenarioCallbacks;
1661  DtCallbackList<const DtScenario&> myPostSaveScenarioCallbacks;
1662 
1663  DtCallbackList<DtScenario&> myPreSaveSimulationObjectGroupsCallbacks;
1664  DtCallbackList<const DtScenario&> myPostSaveSimulationObjectGroupsCallbacks;
1665 
1666  DtNoArgumentCallbackList myPreCloseScenarioCallbacks;
1667  DtNoArgumentCallbackList myPostCloseScenarioCallbacks;
1668  DtNoArgumentCallbackList myScenarioRunCallbacks;
1669  DtNoArgumentCallbackList myScenarioPauseCallbacks;
1670  DtNoArgumentCallbackList myPreScenarioRewindCallbacks;
1671  DtNoArgumentCallbackList myPostScenarioRewindCallbacks;
1672  DtNoArgumentCallbackList myPostTickCallbacks;
1673 
1674  DtFloat64 myMaxDrainInputTime;
1675 #if DtHLA
1676  DtFloat64 myMinDrainInputTime;
1677 #else
1678  int myMaxDrainInputReads;
1679 #endif
1680 
1685  void setVrfCreator(DtVrfCreator* creator);
1687 
1689 
1690  bool ownVrfCreator() const;
1691  void setOwnVrfCreator(bool yesOrNo);
1693 
1695  virtual bool differingModelSets(DtScenario*) const;
1696 
1697 protected:
1700  bool myOwnVrfCreatorFlag;
1701  DtVrfCreator* myVrfCreator;
1702 
1703 #if DtHLA
1704  bool myRunInTimeManagementMode;
1705 #endif
1706 
1708  bool myFullyLoadTerrain;
1709 
1713  bool myAssertOnBlockingTerrainCalls;
1714 
1718 #if DtHLA
1719  DtHlaExerciseClock* myExerciseClockPtr;
1720 #else
1721  DtExerciseClock* myExerciseClockPtr;
1722 #endif
1723 
1724  DtFastForwardSettings myFastForwardSettings;
1725 
1728  DtSimulationModelSet* myDefaultModelSet;
1729 
1733  DtScenario myScenarioToLoad;
1734 
1735  bool myCreateGlobalEnvironment;
1736  bool myCreateGlobalDynamicTerrain;
1737  bool myCreatedGlobalEnvironment;
1738  bool myCreatedGlobalDynamicTerrain;
1739 
1744  bool myWasPaused;
1745 
1747  DtImportExportScenarioDescriptionManager* myImportScenarioDescriptionManager;
1748 
1749  DtConsoleCommandOwner* myConsoleCommands;
1750 
1753  typedef std::pair<std::string, bool> ActionCategory;
1754  typedef std::map<std::string, ActionCategory> ActionCategories;
1755  ActionCategories myActionCategories;
1756 
1758  DtIfScenarioStatus* myScenarioStatus;
1759 
1760  bool myPublishingGlobalEnvironment;
1761  bool myAboutToLoadOrRewindScenario;
1762  bool myReinitializingScenario;
1763  bool myPublishZeroVelocityWhenPaused;
1764  bool mySetDeadReckoningAlgorithmToStaticOnPause;
1765 
1766  bool myMetocEnabled;
1767 
1768  DtTaskVisualizationPublicationMode myTaskVisualizationPublicationMode;
1769  bool myUseDrawControlForTaskVisualizations;
1770 
1771  bool myReuseEntityIdentifiersOnScenarioLoad;
1772 
1773  DtRwActivities myActivities;
1774  bool mySmsValidationEnabled;
1775  DtDefaultSimulationModelSetValidatorManager mySimulationModelSetValidator;
1776  DtSnapshotManager* mySnapshotManager;
1777 
1778  std::vector<DtFilename> myObjectGroupsRoot;
1779 
1780  struct SimulationObjectGroupInformation
1781  {
1782  DtlObjPtr planArgs;
1783  DtlObjPtr oobArgs;
1784  };
1785 
1786  std::set<DtGlobalObjectDesignator> myRemoteObjectGlobalIds;
1787 
1788  typedef std::map<DtString, SimulationObjectGroupInformation> StoredSimulationObjectGroupInformation;
1789  StoredSimulationObjectGroupInformation myStoredSimulationObjectGroupInformation;
1790 
1791  int myRollbackToId;
1792  bool myCanSimulate;
1793  bool myIsLoaded;
1794  bool myHasModelSetInformationLoadedAfterClose;
1795  int myReloadDelay;
1796  bool myRejectMismatchedScenarioMessages;
1797  DtU32 myScenarioCapabilities;
1798  int myAppIdRangeMax;
1799 
1800  std::set<DtFilename> myLoadedModelSets;
1801 
1802  DtInMemorySnapshot* myQueuedRollback;
1803  int myQueuedRollbackScenarioRunId;
1804 };
1805 
DtUUID
UUID is a unique ID wrapper class.
Definition: rwUUID.h:222
DtCgf::myIsLoaded
bool myIsLoaded
Definition: cgf.h:1793
DtCgf::mySimManager
DtSimManager * mySimManager
Pointer to the DtSimManager.
Definition: cgf.h:1542
DtCgf::myCreateGlobalEnvironment
bool myCreateGlobalEnvironment
Definition: cgf.h:1735
DtCgf::myPublishingGlobalEnvironment
bool myPublishingGlobalEnvironment
Definition: cgf.h:1760
DtCgf::myUseDIGuy
bool myUseDIGuy
Set true to use DI-Guy Characters in Vr-forces.
Definition: cgf.h:1621
DtCgf::myScenarioStatus
DtIfScenarioStatus * myScenarioStatus
Scenario status message to be sent out upon request.
Definition: cgf.h:1758
DtCgf::myFastForwardSettingsFile
DtFilename myFastForwardSettingsFile
Fast forward settings file.
Definition: cgf.h:1636
DtSimTerrainRequestManager
Definition: simTerrainRequestManager.h:34
DtResourceMonitor
Class: DtResourceMonitor.
Definition: resourceMonitor.h:58
DtCgf::myAmmunitionManager
DtAmmunitionManager * myAmmunitionManager
Definition: cgf.h:1559
DtCgf::myGlobalPlanManager
DtGlobalPlanManager * myGlobalPlanManager
Definition: cgf.h:1590
DtCgf::myUseDrawControlForTaskVisualizations
bool myUseDrawControlForTaskVisualizations
Definition: cgf.h:1769
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:1560
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:1704
DtCgf::myStealthCommandsManager
DtStealthCommandsManager * myStealthCommandsManager
Stealth commands manager.
Definition: cgf.h:1601
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:1669
DtCgf::myPreLoadScenarioCallbacks
DtCallbackList< DtScenario & > myPreLoadScenarioCallbacks
Definition: cgf.h:1652
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:1656
DtCgf::myOK
bool myOK
Flag indicating whether we have been successfully initialized.
Definition: cgf.h:1514
DtCgf::myEventManager
DtEventManager * myEventManager
Definition: cgf.h:1604
DtCgf::myPreCloseScenarioCallbacks
DtNoArgumentCallbackList myPreCloseScenarioCallbacks
Definition: cgf.h:1666
DtCgf::mySimCommandDistributor
DtSimCommandDistributor * mySimCommandDistributor
Definition: cgf.h:1603
DtCgf::myPhysicalWorld
DtPhysicalWorld * myPhysicalWorld
The current physical world.
Definition: cgf.h:1528
DtCgf::myDefaultSimulationModelSetFilename
DtFilename myDefaultSimulationModelSetFilename
Default simulation model set file to load.
Definition: cgf.h:1618
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:1708
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:1753
DtCgf::myPreScenarioReinitializeCallbacks
DtCallbackList< DtScenario & > myPreScenarioReinitializeCallbacks
Definition: cgf.h:1654
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:1595
DtScenarioExplorer
class DtScenarioExplorer:
Definition: scenarioExplorer.h:26
DtCgf::mySmsValidationEnabled
bool mySmsValidationEnabled
Definition: cgf.h:1774
DtCgf::myPostCreateSimulationObjectGroupCallbacks
DtCallbackList< const DtScenario & > myPostCreateSimulationObjectGroupCallbacks
Definition: cgf.h:1657
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:1579
DtVrfSimOptionsInterface
Options for the configuring the sim.
Definition: vrfSimOptionsInterface.h:20
DtSpawnSinkManager
Definition: spawnSinkManager.h:22
DtIfSaveScenario
class DtIfSaveScenario:
Definition: ifSaveScenario.h:23
DtCgf::myScenario
DtScenario * myScenario
The current scenario.
Definition: cgf.h:1545
DtCgf::SimulationObjectGroupInformation::oobArgs
DtlObjPtr oobArgs
Definition: cgf.h:1783
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:1778
DtRadarCoverageMonitor
Definition: radarCoverageMonitor.h:32
DtCgf::myVrfTerrainPathDirectory
DtFilename myVrfTerrainPathDirectory
Terrain data directory from environment variable VRF_TERRAIN_PATH.
Definition: cgf.h:1610
DtCgf::myTimeToQuit
bool myTimeToQuit
Flag indicating whether or not the app should quit.
Definition: cgf.h:1517
DtTerrainProfileRequestManager
Definition: terrainProfileRequestManager.h:31
DtCgf::myPostCloseScenarioCallbacks
DtNoArgumentCallbackList myPostCloseScenarioCallbacks
Definition: cgf.h:1667
DtFastForwardSettings
Definition: fastForwardSettings.h:12
DtCgf::myPostTickCallbacks
DtNoArgumentCallbackList myPostTickCallbacks
Definition: cgf.h:1672
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:1570
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:1736
DtCgf::myCanSimulate
bool myCanSimulate
Definition: cgf.h:1792
DtCgf::myVrfNavAreaManager
DtVrfNavAreaManager * myVrfNavAreaManager
Definition: cgf.h:1530
DtLuaObjectSerializer
Definition: luaObjectSerializer.h:22
DtCgf::myHasModelSetInformationLoadedAfterClose
bool myHasModelSetInformationLoadedAfterClose
Definition: cgf.h:1794
DtCgf::myAppIdRangeMax
int myAppIdRangeMax
Definition: cgf.h:1798
DtFireManager
The DtFireManager class exists to centralize the processing of fire interactions. ...
Definition: fireManager.h:42
DtCgf::myQueuedRollback
DtInMemorySnapshot * myQueuedRollback
Definition: cgf.h:1802
DtCgf::myCommModelManager
DtCommModelManager * myCommModelManager
Definition: cgf.h:1534
DtCgf::myCreatedGlobalDynamicTerrain
bool myCreatedGlobalDynamicTerrain
Definition: cgf.h:1738
DtIfScenarioStatus
Definition: ifScenarioStatus.h:28
DtCgf::mySimOptions
DtVrfSimOptionsInterface * mySimOptions
Definition: cgf.h:1505
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:1627
DtCgf::mySimulationModelSetValidator
DtDefaultSimulationModelSetValidatorManager mySimulationModelSetValidator
Definition: cgf.h:1775
DtCgf::myReuseEntityIdentifiersOnScenarioLoad
bool myReuseEntityIdentifiersOnScenarioLoad
Definition: cgf.h:1771
DtCgf::myStatusPublisher
DtVrfStatusPublisher * myStatusPublisher
Pointer to the DtStatusPublisher.
Definition: cgf.h:1548
DtCgf::myRemoteObjectGlobalIds
std::set< DtGlobalObjectDesignator > myRemoteObjectGlobalIds
Definition: cgf.h:1786
DtCgf::myTaskVisualizationPublicationMode
DtTaskVisualizationPublicationMode myTaskVisualizationPublicationMode
Definition: cgf.h:1768
DtCgf::myDIGuyAnimationsFilename
DtFilename myDIGuyAnimationsFilename
DI_Guy animation configuration file to load.
Definition: cgf.h:1624
DtObjectType
Definition: objectType.h:27
DtCgf::myRejectMismatchedScenarioMessages
bool myRejectMismatchedScenarioMessages
Definition: cgf.h:1796
DtCgf::myParameterDatabase
DtVrfParameterDb * myParameterDatabase
Pointer to the DtVrfParameterDb.
Definition: cgf.h:1582
DtCgf::myPreSaveScenarioCallbacks
DtCallbackList< DtScenario & > myPreSaveScenarioCallbacks
Definition: cgf.h:1660
DtCgf::myPreLoadTerrainCallbacks
DtCallbackList< const DtFilename & > myPreLoadTerrainCallbacks
Definition: cgf.h:1650
DtInMemorySnapshot::OOB
std::vector< std::string * > OOB
Definition: snapshotManager.h:44
DtCgf::StoredSimulationObjectGroupInformation
std::map< DtString, SimulationObjectGroupInformation > StoredSimulationObjectGroupInformation
Definition: cgf.h:1788
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:1585
DtCgf::myImportScenarioDescriptionManager
DtImportExportScenarioDescriptionManager * myImportScenarioDescriptionManager
The scenario description manager used to import scenario description files.
Definition: cgf.h:1747
DtCgf::myCreatedGlobalEnvironment
bool myCreatedGlobalEnvironment
Definition: cgf.h:1737
DtPhysicalWorld
The DtPhysicalWorld is the primary interface to and manager of all of the &quot;physical&quot; aspects of the s...
Definition: physicalWorld.h:88
DtCgf::myDetonationManager
DtDetonationManager * myDetonationManager
Definition: cgf.h:1558
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:1633
DtCgf::myDefaultParameterDbDirectory
DtFilename myDefaultParameterDbDirectory
Default parameter database directory to search in when parameter database being specified is not an a...
Definition: cgf.h:1648
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:1561
DtCgf::myTerrainProfileRequestManager
DtTerrainProfileRequestManager * myTerrainProfileRequestManager
Pointer to the DtTerrainProfileRequestManager.
Definition: cgf.h:1576
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:1651
DtSimMessage
File: simMsg.h.
Definition: simMessage.h:35
DtCgf::myStoredSimulationObjectGroupInformation
StoredSimulationObjectGroupInformation myStoredSimulationObjectGroupInformation
Definition: cgf.h:1789
DtCgf::myVrfObjectManager
DtVrfObjectManager * myVrfObjectManager
Pointer to the DtVrfObjectManager.
Definition: cgf.h:1551
DtCgf::myScenarioRunCallbacks
DtNoArgumentCallbackList myScenarioRunCallbacks
Definition: cgf.h:1668
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:1520
DtReaderWriter::SearchPaths
std::vector< DtFilename > SearchPaths
Definition: readerWriter.h:92
DtCgf::myQueuedRollbackScenarioRunId
int myQueuedRollbackScenarioRunId
Definition: cgf.h:1803
DtCompressedFileTransporter
Definition: compressedFileTransporter.h:24
DtCgf::myWasPaused
bool myWasPaused
Used to hold the paused state during a rewindScenario operation.
Definition: cgf.h:1744
DtCallbackList
Definition: noArgumentCallbackList.h:91
DtCgf::myIntelCollectionAreaManager
DtIntelCollectionAreaManager * myIntelCollectionAreaManager
Definition: cgf.h:1563
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:1713
DtCgf::myPreSaveSimulationObjectGroupsCallbacks
DtCallbackList< DtScenario & > myPreSaveSimulationObjectGroupsCallbacks
Definition: cgf.h:1663
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:1664
DtCgf::myDefaultModelSet
DtSimulationModelSet * myDefaultModelSet
Default simulation model set.
Definition: cgf.h:1728
DtCgf::myActivities
DtRwActivities myActivities
Definition: cgf.h:1773
DtVrfPluginManager
Definition: vrfPluginManager.h:73
DtCgf::myRadarCoverageMonitor
DtRadarCoverageMonitor * myRadarCoverageMonitor
Pointer to the DtRadarCoverageMonitor.
Definition: cgf.h:1573
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:75
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:88
DtCgf::myFactoryManager
DtFactoryManager * myFactoryManager
Pointer to the DtFactoryManager.
Definition: cgf.h:1598
DtCgf::myActionCategories
ActionCategories myActionCategories
Definition: cgf.h:1755
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:1733
DtCgf::myHazardAreaManager
DtHazardAreaManager * myHazardAreaManager
Definition: cgf.h:1562
DtCgf::myAggregateSpatialModel
DtAggregateSpatialModel * myAggregateSpatialModel
Definition: cgf.h:1556
DtCgf::myPluginsToLoad
std::vector< DtString > myPluginsToLoad
Definition: cgf.h:1521
DtCgf::myPostSaveScenarioCallbacks
DtCallbackList< const DtScenario & > myPostSaveScenarioCallbacks
Definition: cgf.h:1661
DtCgf::myReinitializingScenario
bool myReinitializingScenario
Definition: cgf.h:1762
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:256
DtPlan
class DtPlan:
Definition: plan.h:91
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:1658
DtVrfObjectManager
class DtVrfObjectManager:
Definition: vrfObjectManager.h:202
translatableStream.h
DtTranslatableStream.
DtCgf::myLoadedModelSets
std::set< DtFilename > myLoadedModelSets
Definition: cgf.h:1800
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:1671
DtCgf::myAboutToLoadOrRewindScenario
bool myAboutToLoadOrRewindScenario
Definition: cgf.h:1761
DtCgf::myForceParameterDbReload
bool myForceParameterDbReload
Forces loadScenario to re-load the parameter database.
Definition: cgf.h:1588
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:1674
DtCgf::mySnapshotManager
DtSnapshotManager * mySnapshotManager
Definition: cgf.h:1776
DtCgf::myEngagementZonesManager
DtEngagementZonesManager * myEngagementZonesManager
Definition: cgf.h:1593
DtCgf::mySetDeadReckoningAlgorithmToStaticOnPause
bool mySetDeadReckoningAlgorithmToStaticOnPause
Definition: cgf.h:1764
DtCgf::myPublishZeroVelocityWhenPaused
bool myPublishZeroVelocityWhenPaused
Definition: cgf.h:1763
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:1676
DtCgf::myPostImportScenarioCallbacks
DtCallbackList< const DtScenario & > myPostImportScenarioCallbacks
Definition: cgf.h:1659
DtCgf::myMetocEnabled
bool myMetocEnabled
Definition: cgf.h:1766
DtSimTask
DtSimTask is an abstract base class from which real tasks can derive.
Definition: simTask.h:31
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:1536
DtCgf::myPostLoadScenarioCallbacks
DtCallbackList< const DtScenario & > myPostLoadScenarioCallbacks
Definition: cgf.h:1653
DtCgf::myReloadDelay
int myReloadDelay
Definition: cgf.h:1795
DtCgf::myVrfCreator
DtVrfCreator * myVrfCreator
Definition: cgf.h:1701
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:1670
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:1643
DtSimManager
The simulation engine is controlled by a single,top-level class called the Simulation Manager...
Definition: simManager.h:103
DtSnapshotManager
Definition: snapshotManager.h:56
DtCgf::SimulationObjectGroupInformation::planArgs
DtlObjPtr planArgs
Definition: cgf.h:1782
DtCgf::myScenarioCapabilities
DtU32 myScenarioCapabilities
Definition: cgf.h:1797
DtCgf::myOwnVrfCreatorFlag
bool myOwnVrfCreatorFlag
These are essentially cached from the init call.
Definition: cgf.h:1700
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:1640
DtCgf::myHostilityManager
DtHostilityManager * myHostilityManager
Definition: cgf.h:1592
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:1532
DtCgf::myExerciseConn
DtExerciseConn * myExerciseConn
The current exercise connection.
Definition: cgf.h:1539
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:1567
DtCgf::myConsoleCommands
DtConsoleCommandOwner * myConsoleCommands
Definition: cgf.h:1749
DtCgf::myFireManager
DtFireManager * myFireManager
Definition: cgf.h:1565
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:1719
DtCgf::myScriptedObjectsMovementManager
DtScriptedObjectsMovementManager * myScriptedObjectsMovementManager
Definition: cgf.h:1564
DtOrganizationManagerReadyCallbackInfo
Container used in callback lists.
Definition: organizationManager.h:27
DtCgf::myDebugDrawManager
DtDebugDrawManager * myDebugDrawManager
Pointer to the DtDebugDrawManagert.
Definition: cgf.h:1554
DtCgf::myPostScenarioReinitializeCallbacks
DtCallbackList< const DtScenario & > myPostScenarioReinitializeCallbacks
Definition: cgf.h:1655
DtDetonationManager
The DtDetonationManager class exists to centralize the processing of detonation interactions.
Definition: detonationManager.h:58
DtCgf::myFastForwardSettings
DtFastForwardSettings myFastForwardSettings
Definition: cgf.h:1724
DtCgf::myTerrainInterface
DtTerrainInterface * myTerrainInterface
The current terrain database.
Definition: cgf.h:1525
DtCgf::mySessionId
DtU32 mySessionId
Session Id.
Definition: cgf.h:1511
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:1615
DtCgf::myLoadPluginsIfVersionMismatch
bool myLoadPluginsIfVersionMismatch
Definition: cgf.h:1522
DtCgf::mySimulationAddress
DtSimulationAddress mySimulationAddress
Address for routing interface messages.
Definition: cgf.h:1508
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:1754
DtTaskVisualizationPublicationMode
DtTaskVisualizationPublicationMode
Defines how task visualizations will be published.
Definition: vrfObjectManager.h:183
DtCgf::myRollbackToId
int myRollbackToId
Definition: cgf.h:1791
DtCgf::myMsdlSidcMappingFile
DtFilename myMsdlSidcMappingFile
MSDL SDIC mapping file to load.
Definition: cgf.h:1630
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 Tue Sep 21 17:42:52 EDT 2021 from SVN revision 234861
Copyright © 2005-2021 MAK Technologies. All Rights Reserved (www.mak.com)