VR-Forces Developer's Guide
 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 
18 #include <vrfcgf/snapshotManager.h>
19 #include <vrfcore/scenarioServiceInterface.h>
20 #include <vrfobjcore/loadScenarioData.h>
21 #include <vrfobjcore/translatableStream.h>
22 #include <vrfutil/outputLogger.h>
23 #include <vrfutil/rwActivities.h>
24 #include <vrfutil/scenario.h>
25 #include <vrfutil/scenarioExplorer.h>
26 #include <vrfutil/vrf4XAPI.h>
27 
29 #include <vlutil/vlFilename.h>
30 #include <vlutil/vlPrint.h>
31 #include <vlutil/vlTime.h>
32 
34 #include <readerWriter/noArgumentCallbackList.h>
35 
37 #include <vector>
38 
39 
40 struct DtLoadScenarioData;
41 class DtOrbatManager;
42 class DtObjectGeometricModelsManager;
43 class DtAdminContent;
44 class DtIfScenarioStatus;
45 class DtDebugDrawManager;
46 class DtCreateObjectServiceInterface;
47 class DtScenarioServiceInterface;
48 class DtSimulationModelSet;
49 class DtSimObjectManager;
50 class DtCommunicationManager;
51 class DtScenario;
52 class DtScenarioExplorer;
53 class DtPhysicalWorld;
54 class DtVrfNavAreaManager;
55 class DtLocalObjectManager;
56 class DtCommModelManager;
57 class DtTerrainInterface;
58 class DtVrfCreator;
59 struct DtInMemorySnapshot;
60 class DtSimManager;
61 class DtSimOperationsInProgressManager;
62 class DtObjectConsoleManager;
63 class DtScriptedTaskManager;
64 class DtScenarioEventManager;
65 class DtSimInternalCommunicationManager;
66 class DtHazardAreaManager;
67 class DtIntelCollectionAreaManager;
68 class DtCompressedFileTransporter;
69 class DtIfSaveScenario;
70 class DtSimulationServices;
71 class DtScriptedObjectsMovementManager;
72 class DtVrfStatusPublisher;
73 class DtEmbeddedEntityInfoManager;
74 class DtDetonationManager;
75 class DtAmmunitionManager;
76 class DtFireManager;
77 class DtVrfObjectPlanAdministrator;
78 class DtGlobalPlanManager;
79 class DtJoyDeviceManager;
80 class DtHostilityManager;
81 class DtEngagementZonesManager;
82 class DtScenarioExtrasMgr;
83 class DtCustomReportManager;
84 class DtStealthCommandsManager;
85 class DtFactoryManager;
86 class DtLoadOrderOfBattleHandler;
87 class DtList;
88 class DtSimTask;
89 class DtSetDataRequest;
90 class DtPlan;
91 class DtPaperMapDatabase;
92 class DtMapDatum;
93 class DtVrfParameterDb;
94 class DtSimMessage;
95 class DtResourceMonitor;
96 class DtRadarCoverageMonitor;
97 class DtTerrainProfileRequestManager;
98 class DtVrfPlugin;
99 class DtVrfPluginManager;
100 class DtSimCommand;
101 class DtImportExportScenarioDescriptionManager;
102 class DtLuaObjectSerializer;
103 struct DtOrganizationManagerReadyCallbackInfo;
104 class DtConsoleCommandOwner;
105 class DtSimTerrainRequestManager;
106 class DtTimer;
107 class DtVrfSimOptionsInterface;
108 class DtSpawnSinkManager;
109 class DtSnapshotManager;
110 class DtSimCommandDistributor;
111 class DtApplicationSettings;
112 class DtNetworkInterfaceManager;
113 class DtScenarioLoadManager;
114 class DtManagedObjectListManager;
115 class DtDiGuyCharacterDataManager;
116 class DtSyncMatrixManager;
117 class DtAisDataManager;
118 class DtAdsbDataManager;
119 class DtInfluenceEventDispatcher;
120 class DtDynamicFeaturesManager;
121 struct DtCommunicationManagerPerformanceTimerInformation;
122 
123 namespace makVrfEvents
124 {
125  class DtEvent;
126  class DtEventManager;
127 }
128 
129 namespace makVrf
130 {
131  class DtStateDataManager;
132 }
133 
155 #include "vrfcgf/vrfcgfDefines.h"
156 class DT_DLL_vrfcgf DtCgf
157 {
158 public:
159 
166  DtCgf(const DtSimulationAddress& addr, const DtU32& capabilities = 0xffff);
167 
191  virtual bool init(DtCommunicationManager* conn, DtU32 sessionId = 1, DtVrfCreator* creator = 0, bool checkDataDir = true);
192 
194  virtual ~DtCgf();
195 
197  virtual const DtVrfSimOptionsInterface* simOptions() const;
198 
200  virtual void setSimOptions(const DtVrfSimOptionsInterface&);
201 
204  virtual void tick();
205 
208  virtual void sendFinalStatus(bool sendImmediately = false);
209 
213  virtual bool importScenarioDescriptionFile(const DtFilename& file, const DtString& format,
216  const std::map<std::string, std::string>& importData);
217 
221  virtual DtString exportScenarioDescriptionFile(const DtFilename& file, const DtString& format,
222  const std::map<std::string, std::string>& exportData);
223 
225  virtual void setAppDataDir(const DtString&);
226  virtual DtFilename appDataDir() const;
227 
229  virtual void setSimulationAddress(const DtSimulationAddress&);
230 
232  virtual void setUserDataDir(const DtString&);
233  virtual DtFilename userDataDir() const;
234 
236  virtual void setDataDir(const DtString&);
237  virtual DtFilename dataDir() const;
238 
242  virtual DtFilename sharedDataDir() const;
243  virtual void setSharedDataDir(const DtFilename& path);
244 
245  virtual DtFilename sharedDataRoot() const;
246  virtual void setSharedDataRoot(const DtFilename& path);
247 
248  virtual DtString sharedDataStem() const;
249  virtual void setSharedDataStem(const DtString& path);
250 
252  virtual void setAppIdRangeMax(int);
253  int appIdRangeMax() const;
254 
258  virtual bool loadScenario(const DtFilename& name, int scenarioRunId = 0,
259  bool isOrbatEnabled = false, bool createGlobalEnv = false,
260  bool createGlobalDynamicTerrain = false);
261 
268  virtual bool loadScenario(const DtScenario& scenario, int scenarioRunId = 0,
269  bool isOrbatEnabled = false, bool createGlobalEnv = false,
270  bool createGlobalDynamicTerrain = false);
271 
273  virtual void clearSimulationObjects(const std::set<DtUUID>& except = std::set<DtUUID>());
274 
277  virtual bool importScenario(const DtScenario&);
278  virtual bool importScenario(const DtFilename&, int importScenarioFlags = DtDefaultScenarioImportFlags,
279  const DtString& deconflictingName = "");
280 
287  virtual bool newScenario(const DtFilename& dbname =
288  DtFilename::nullFilename(), const DtFilename& simulationModelSet =
289  DtFilename::nullFilename(), bool createGlobalEnv = false,
290  bool createGlobalDynamicTerrain = false);
291 
293  DtIfScenarioStatus* scenarioStatus() { return myScenarioStatus; };
294  const DtIfScenarioStatus* scenarioStatus() const { return myScenarioStatus; };
295 
296  virtual void sendScenarioStatusMessage();
297 
303  virtual bool saveScenario(const DtFilename& savename, bool saveAsSip = false);
304 
308  virtual DtInMemorySnapshotPtr takeSnapshot();
309 
311  virtual bool takeAndStoreSnapshot(bool makeBase);
312 
316  virtual void queueRollbackTo(DtInMemorySnapshotPtr snapshot, int scenarioRunId = 0);
317 
321  virtual void rollbackToSimTime(double simTime);
322 
326  virtual bool saveSimulationObjectGroup(DtFilename saveFolder, const DtString& groupName,
327  int flags, std::set<DtUUID>& uuidsSaved, bool& savAsZipFile);
328 
334  virtual bool createSimulationObjectGroup(const DtString& group, int flags, int force, const DtVector& geocentricLocation,
335  double offsetRotation, bool storedInZipFile = false);
336 
341  virtual void closeScenario(const DtFilename& terrainToOpen = "", bool forceCloseAll = false);
342 
347  virtual bool loadAdditionalObjectParameters(const DtFilename& paramsFileName,
348  const DtReaderWriter::SearchPaths& searchPaths, bool preloadParameters = false);
350 
353  virtual void run();
354 
356  virtual void pause();
357 
359  virtual std::string protocol() const;
360 
362  virtual void setRejectMismatchedScenarioMessages(bool);
363  virtual bool rejectMismatchedScenarioMessages() const;
364 
369 
370  virtual void setForceParameterDbReload(bool reload);
371  virtual bool forceParameterDbReload() const;
373 
377 
378  virtual void setEnableResourceMonitor(bool b);
379  virtual bool isResourceMonitorEnabled() const;
381 
383  virtual bool canSimulate() const { return myCanSimulate; };
384 
385  DtCommunicationManager* communicationManager() { return myCommunicationManager; };
386  virtual makVrfEvents::DtEventManager* eventManager();
387 
388  virtual bool canSleep() const;
389 
391  virtual bool aboutToLoadOrRewindScenario() const { return myAboutToLoadOrRewindScenario; };
392 
396  virtual void setSmsValidationEnabled(bool b);
397 
409 
410  virtual const DtFilename& defaultTerrainDirectory();
411  virtual void setDefaultTerrainDirectory(const DtFilename& directory);
413 
414  virtual bool logFrameRateStatistics() const;
415  virtual void setLogFrameRateStatistics(bool yesOrNo);
416 
418  virtual void sendServerLoadMessage(const DtString& error, int level = DtNlWarn);
419 
424 
425  virtual const DtFilename& defaultSimulationModelSetFilename();
426  virtual void setDefaultSimulationModelSetFilename(const DtFilename& filename);
428 
432 
433  virtual const DtFilename& diGuyAnimationsFilename();
434  virtual void setDIGuyAnimationsFilename(const DtFilename& filename);
436 
438 
439  void setClockMode(int clockMode);
441 
443 
444  virtual void setMsdlSidcMappingFile(const DtFilename&);
445  virtual const DtFilename& msdlSidcMappingFile() const;
447 
450  virtual void setCountryCodesMappingFile(const DtFilename&);
451  virtual const DtFilename& countryCodesMappingFile() const;
453 
456  virtual DtSimulationModelSet* defaultModelSet();
458 
462  virtual void deleteObject(const DtUUID& name, bool andRemoveFromOrbat = true) const;
466 
477  virtual DtLocalObject* createWaypoint(const DtVector& localPosition,
478  const DtString& uniqueName = DtString::nullString()) const;
479 
492  virtual DtLocalObject* createRoute(const DtList& vertices,
493  const DtString& uniqueName = DtString::nullString()) const;
494 
506  virtual DtLocalObject* createPhaseLine(
507  const DtVector& dbPoint1,
508  const DtVector& dbPoint2,
509  const DtString& uniqueName = DtString::nullString()) const;
510 
522  virtual DtLocalObject* createControlArea(
523  const DtList& vertices,
524  const DtString& uniqueName = DtString::nullString()) const;
525 
537  virtual DtLocalObject* createObstacle(
538  const DtList& vertices,
539  const DtString& uniqueName = DtString::nullString()) const;
540 
568  virtual DtLocalObject* createEntity(
569  const DtEntityType& entityType,
570  DtForceType force,
571  const DtVector& dbPosition,
572  DtReal heading,
573  const DtString& entityName = DtString::nullString(),
574  bool allowBlocking = true,
575  std::list<DtAdminContent*>* initialAdminContent = 0,
576  bool addToOrbat = true) const;
577 
578 
608  virtual DtLocalObject* createAggregate(
609  const DtEntityType& aggregateType,
610  DtForceType force,
611  const DtVector& localPosition,
612  DtReal heading,
613  const std::vector<DtUUID>& subordinates = std::vector<DtUUID>(),
614  const DtString& aggregateName = DtString::nullString(),
615  bool addToOrbat = true) const;
616 
628  virtual DtLocalObject* createAggregate(
629  const DtEntityType& aggregateType,
630  DtForceType force,
631  const DtVector& localPosition,
632  DtReal heading,
633  bool createSubordinates,
634  const DtString& aggregateName = DtString::nullString(),
635  bool allowBlocking = true,
636  bool addToOrbat = true) const;
637 
649  virtual bool addSubordinate(DtLocalObject* subordinate,
650  DtLocalObject* aggregate);
651 
667  virtual bool removeSubordinate(DtLocalObject* subordinate,
668  DtLocalObject* aggregate);
670 
674  virtual void assignTask(const DtLocalObject* entity, const DtSimTask& task);
683 
692  virtual void sendSetDataRequest(const DtLocalObject* entity,
693  const DtSetDataRequest& request);
694 
696  virtual void assignPlanByUUID(const DtUUID&, const DtPlan& plan, bool sendPlan = false);
697 
702  virtual void abandonPlan(const DtLocalObject* entity);
703 
708  virtual void restartPlan(const DtLocalObject* entity);
710 
714  virtual void logObjectConsoleToFile(DtLocalObject* object,
719  DtFilename filename = DtFilename::nullFilename());
720 
722  virtual void stopLoggingObjectConsoleToFile(DtLocalObject* object);
723 
727  virtual void setObjectConsoleNotificationLevel(DtLocalObject* object,
728  DtNotifyLevelType level);
730 
737  virtual bool reuseEntityIdentifiersOnScenarioLoad() const;
738  virtual void setReuseEntityIdentifiersOnScenarioLoad(bool);
740 
744  virtual bool loadAllNavigationDataOnTerrainLoad() const;
745  virtual void setLoadAllNavigationDataOnTerrainLoad(bool);
747 
750  virtual void setTaskVisualizationPublicationMode(DtTaskVisualizationPublicationMode mode);
751  virtual DtTaskVisualizationPublicationMode taskVisualizationPublicationMode() const;
753 
757  virtual void setUseDrawControlForTaskVisualizations(bool);
758  virtual bool useDrawControlForTaskVisualizations() const;
760 
761 
762  //-------------------------------------------------------
764  //-------------------------------------------------------
765 
768  virtual DtSimManager* simManager() const;
769  virtual DtSimulationServices* simulationServices() const;
770 
772  virtual DtImportExportScenarioDescriptionManager* importExportScenarioDescriptionManager() const;
773 
776  virtual DtResourceMonitor* resourceMonitor() const;
777 
779  virtual DtRadarCoverageMonitor* radarCoverageMonitor() const;
780 
782  virtual DtTerrainProfileRequestManager* terrainProfileRequestManager() const;
783 
786  virtual DtFactoryManager* factoryManager() const;
787 
789  virtual DtSnapshotManager* snapshotManager() const;
790 
791  virtual DtAisDataManager* aisDataManager() const;
792  virtual DtAdsbDataManager* adsbDataManager() const;
793 
797  virtual DtLocalObjectManager* localObjectManager() const;
798 
801  virtual DtSimObjectManager* simObjectManager() const;
802 
804  virtual DtDynamicFeaturesManager* aggregateDynamicFeaturesManager() const;
805 
808  virtual DtDebugDrawManager* debugDrawManager() const;
809 
811  virtual DtScriptedTaskManager* scriptedTaskManager() const;
812 
814  virtual DtScenarioEventManager* scenarioEventManager() const;
815 
817  virtual DtHazardAreaManager* hazardAreaManager() const;
818 
820  virtual DtIntelCollectionAreaManager* intelCollectionAreaManager() const;
821 
823  virtual DtScriptedObjectsMovementManager* ScriptedObjectsMovementManager() const;
824 
827  virtual DtDetonationManager* detonationManager() const;
828 
831  virtual DtAmmunitionManager* ammunitionManager() const;
832 
835  virtual DtFireManager* fireManager() const;
836 
841  virtual DtScenarioExtrasMgr* scenarioExtrasMgr() const;
842 
844  virtual DtVrfParameterDb* parameterDatabase() const;
845 
847  virtual DtGlobalPlanManager* globalPlanManager();
848 
850  virtual DtStealthCommandsManager* stealthCommandsManager();
851 
854 
855  virtual DtTerrainInterface* terrainInterface();
856  virtual const DtTerrainInterface* terrainInterface() const;
858 
861 
862  virtual DtPhysicalWorld* physicalWorld();
863  virtual const DtPhysicalWorld* physicalWorld() const;
865 
867  virtual void setPhysicalWorld(DtPhysicalWorld* newPhysicalWorld);
868 
869  virtual DtVrfNavAreaManager* vrfNavAreaManager();
870  virtual const DtVrfNavAreaManager* vrfNavAreaManager() const;
871 
872  virtual void setVrfNavAreaManager(DtVrfNavAreaManager* newVrfNavAreaManager);
873 
874  virtual DtSpawnSinkManager* spawnSinkManager();
875  virtual const DtSpawnSinkManager* spawnSinkManager() const;
876 
878 
879  virtual DtCommModelManager* commModelManager();
880  virtual const DtCommModelManager* commModelManager() const;
882 
883  virtual const DtDiGuyCharacterDataManager* diGuyCharacterManager() const;
884 
886 
887  virtual DtSimTerrainRequestManager* simTerrainRequestManager();
888  virtual const DtSimTerrainRequestManager* simTerrainRequestManager() const;
890 
892  virtual DtSimCommandDistributor* simCommandDistributor();
893 
895  virtual DtScenario* scenario() const;
896 
899  virtual const DtSimulationAddress& simulationAddress() const;
900 
906  virtual int sessionId() const;
907 
913 
914  virtual DtU32 scenarioCapabilities() const;
915  virtual void setScenarioCapabilities(DtU32 v);
916  virtual void setScenarioCapability(DtU32 v, bool);
918 
920  virtual void setTimeMultiplier(double);
921 
924 
925  virtual DtString applicationType() const;
926  virtual void setApplicationType(const DtString& type);
928 
931  virtual DtVrfStatusPublisher* statusPublisher() const;
932 
936  virtual void useMapDatum(const DtMapDatum& mapDatum);
937 
939  virtual void setParameterDbLoaded(bool flag);
940 
946  virtual void setDefaultParameterDbDirectory(const DtFilename& filename);
947 
949  virtual DtFilename objectGroupsRoot() const;
950 
955  virtual bool reinitializeScenario();
956 
958  virtual void reinitializeObjects(const std::vector<DtUUID>&);
959 
960  virtual void setFullyLoadTerrain(bool yesOrNo);
961  virtual bool fullyLoadTerrain() const;
962 
966 
967  virtual void setAssertOnBlockingTerrainCalls(bool b);
968  virtual bool assertOnBlockingTerrainCalls() const;
970 
971  //-------------------------------------------------------
973  //-------------------------------------------------------
974 
977  virtual void addPluginToLoad(const DtString&);
978 
981  virtual void setLoadPluginsIfVersionMismatch(bool);
982  virtual bool loadPluginsIfVersionMismatch() const;
983 
985  virtual bool createAndInitPluginManager(DtVrfCreator* creator);
986 
989  virtual void initializePluginCommandLineArguments(DtApplicationSettings& appInitializer);
990 
992 
993  DtVrfCreator* vrfCreator();
994  const DtVrfCreator* vrfCreator() const;
996 
1000 
1001  virtual void addPreLoadTerrainCallback(
1002  DtCallbackList<const DtFilename&>::DtCallbackFunctionType fcn, void* usrData);
1003  virtual void removePreLoadTerrainCallback(
1004  DtCallbackList<const DtFilename&>::DtCallbackFunctionType fcn, void* usrData);
1006 
1010 
1011  virtual void addPostLoadTerrainCallback(
1012  DtCallbackList<const DtFilename&>::DtCallbackFunctionType fcn, void* usrData);
1013  virtual void removePostLoadTerrainCallback(
1014  DtCallbackList<const DtFilename&>::DtCallbackFunctionType fcn, void* usrData);
1016 
1019  virtual void runForDuration(double);
1020 
1022  virtual void stopSimulationDurationTimer();
1023 
1025  static void runDurationCompleteCallback(void*);
1026  virtual void processRunDurationComplete();
1027 
1029  virtual void setPublishingGlobalEnvironment(bool);
1030 
1034 
1035  virtual void addPreLoadScenarioCallback(
1036  DtCallbackList<DtScenario&>::DtCallbackFunctionType fcn, void* usrData);
1037  virtual void removePreLoadScenarioCallback(
1038  DtCallbackList<DtScenario&>::DtCallbackFunctionType fcn, void* usrData);
1040 
1042 
1043  virtual void addPreScenarioReinitializeCallback(
1044  DtCallbackList<DtScenario&>::DtCallbackFunctionType fcn, void* usrData);
1045  virtual void removePreScenarioReinitializeCallback(
1046  DtCallbackList<DtScenario&>::DtCallbackFunctionType fcn, void* usrData);
1048 
1051 
1052  virtual void addPostScenarioReinitializeCallback(
1053  DtCallbackList<const DtScenario&>::DtCallbackFunctionType fcn, void* usrData);
1054  virtual void removePostScenarioReinitializeCallback(
1055  DtCallbackList<const DtScenario&>::DtCallbackFunctionType fcn, void* usrData);
1057 
1059 
1060  virtual void addPreCreateSimulationObjectGroupCallback(
1061  DtCallbackList<DtScenario&>::DtCallbackFunctionType fcn, void* usrData);
1062  virtual void removePreCreateSimulationObjectGroupCallback(
1063  DtCallbackList<DtScenario&>::DtCallbackFunctionType fcn, void* usrData);
1065 
1069 
1070  virtual void addPostLoadScenarioCallback(
1071  DtCallbackList<const DtScenario&>::DtCallbackFunctionType fcn, void* usrData);
1072  virtual void removePostLoadScenarioCallback(
1073  DtCallbackList<const DtScenario&>::DtCallbackFunctionType fcn, void* usrData);
1075 
1077 
1078  virtual void addPostCreateSimulationObjectGroupCallback(
1079  DtCallbackList<const DtScenario&>::DtCallbackFunctionType fcn, void* usrData);
1080  virtual void removePostCreateSimulationObjectGroupCallback(
1081  DtCallbackList<const DtScenario&>::DtCallbackFunctionType fcn, void* usrData);
1083 
1085 
1086  virtual void addPreImportScenarioCallback(
1087  DtCallbackList<DtScenario&>::DtCallbackFunctionType fcn, void* usrData);
1088  virtual void removePreImportScenarioCallback(
1089  DtCallbackList<DtScenario&>::DtCallbackFunctionType fcn, void* usrData);
1091 
1093 
1094  virtual void addPostImportScenarioCallback(
1095  DtCallbackList<const DtScenario&>::DtCallbackFunctionType fcn, void* usrData);
1096  virtual void removePostImportScenarioCallback(
1097  DtCallbackList<const DtScenario&>::DtCallbackFunctionType fcn, void* usrData);
1099 
1102 
1103  virtual void addPreSaveScenarioCallback(
1104  DtCallbackList<DtScenario&>::DtCallbackFunctionType fcn, void* usrData);
1105  virtual void removePreSaveScenarioCallback(
1106  DtCallbackList<DtScenario&>::DtCallbackFunctionType fcn, void* usrData);
1108 
1111 
1112  virtual void addPostSaveScenarioCallback(
1113  DtCallbackList<const DtScenario&>::DtCallbackFunctionType fcn, void* usrData);
1114  virtual void removePostSaveScenarioCallback(
1115  DtCallbackList<const DtScenario&>::DtCallbackFunctionType fcn, void* usrData);
1117 
1120 
1121  virtual void addPreCloseScenarioCallback(
1122  DtNoArgumentCallbackList::DtCallbackFunctionType fcn, void* usrData);
1123  virtual void removePreCloseScenarioCallback(
1124  DtNoArgumentCallbackList::DtCallbackFunctionType fcn, void* usrData);
1126 
1129 
1130  virtual void addPostParameterDatabaseLoadedCallback(
1131  DtNoArgumentCallbackList::DtCallbackFunctionType fcn, void* usrData);
1132  virtual void removePostParameterDatabaseLoadedCallback(
1133  DtNoArgumentCallbackList::DtCallbackFunctionType fcn, void* usrData);
1135 
1138 
1139  virtual void addCgfAboutToBeDestroyedCallback(
1140  DtNoArgumentCallbackList::DtCallbackFunctionType fcn, void* usrData);
1141  virtual void removeCgfAboutToBeDestroyedCallback(
1142  DtNoArgumentCallbackList::DtCallbackFunctionType fcn, void* usrData);
1144 
1147 
1148  virtual void addPostCloseScenarioCallback(
1149  DtNoArgumentCallbackList::DtCallbackFunctionType fcn, void* usrData);
1150  virtual void removePostCloseScenarioCallback(
1151  DtNoArgumentCallbackList::DtCallbackFunctionType fcn, void* usrData);
1153 
1155 
1156  virtual void addPreSaveSimulationObjectGroupsCallback(
1157  DtCallbackList<DtScenario&>::DtCallbackFunctionType fcn, void* usrData);
1158  virtual void removePreSaveSimulationObjectGroupsCallback(
1159  DtCallbackList<DtScenario&>::DtCallbackFunctionType fcn, void* usrData);
1161 
1163 
1164  virtual void addPostSaveSimulationObjectGroupsCallback(
1165  DtCallbackList<const DtScenario&>::DtCallbackFunctionType fcn, void* usrData);
1166  virtual void removePostSaveSimulationObjectGroupsCallback(
1167  DtCallbackList<const DtScenario&>::DtCallbackFunctionType fcn, void* usrData);
1169 
1172 
1173  virtual void addScenarioPauseCallback(
1174  DtNoArgumentCallbackList::DtCallbackFunctionType fcn, void* usrData);
1175  virtual void removeScenarioPauseCallback(
1176  DtNoArgumentCallbackList::DtCallbackFunctionType fcn, void* usrData);
1178 
1181 
1182  virtual void addScenarioRunCallback(
1183  DtNoArgumentCallbackList::DtCallbackFunctionType fcn, void* usrData);
1184  virtual void removeScenarioRunCallback(
1185  DtNoArgumentCallbackList::DtCallbackFunctionType fcn, void* usrData);
1187 
1192 
1193  virtual void addPreScenarioRollbackCallback(
1194  DtNoArgumentCallbackList::DtCallbackFunctionType fcn, void* usrData);
1195  virtual void removePreScenarioRollbackCallback(
1196  DtNoArgumentCallbackList::DtCallbackFunctionType fcn, void* usrData);
1198 
1201 
1202  virtual void addPostScenarioRollbackCallback(
1203  DtNoArgumentCallbackList::DtCallbackFunctionType fcn, void* usrData);
1204  virtual void removePostScenarioRollbackCallback(
1205  DtNoArgumentCallbackList::DtCallbackFunctionType fcn, void* usrData);
1207 
1210 
1211  virtual void addPostTickCallback(
1212  DtNoArgumentCallbackList::DtCallbackFunctionType fcn, void* usrData);
1213  virtual void removePostTickCallback(
1214  DtNoArgumentCallbackList::DtCallbackFunctionType fcn, void* usrData);
1216 
1218 
1219  virtual void setTimeToQuit(bool);
1220  virtual bool timeToQuit() const;
1222 
1234  virtual void setFrameRateMode(const DtString& mode, DtReal deltaTime = -1);
1235 
1239  virtual bool executeSimCommand(const DtSimCommand& simCommand);
1240 
1243  virtual void unloadTerrain();
1244 
1246  virtual bool isOrbatEnabled() const;
1247 
1249  virtual double timeScale() const;
1250 
1251  virtual void setRunInTimeManagementMode(bool);
1252 
1254  virtual DtSyncMatrixManager* syncMatrixManager();
1255 
1256  virtual void setAutomaticallyCreateGlobalEnvironment(bool param1);
1257 
1258  virtual void setMaxAsynchronousTerrainThreads(int threads);
1259 
1260 public:
1261 
1265  static void objectParametersOpCallback(DtSimMessage* msg, void* usr);
1266 
1267 protected:
1268  static void BadLoadScenarioClose(void* usr);
1269  virtual void handleBadScenarioLoad();
1270 
1272  static void scenarioDescriptionCallback(DtSimMessage*, void* usr);
1273  virtual void processScenarioDescription(DtSimMessage*);
1274 
1276  static void setScenarioFilenameCallback(DtSimMessage*, void* usr);
1277  virtual void processSetScenarioFilename(DtSimMessage*);
1278 
1280  static void setRunDurationCallback(DtSimMessage*, void* usr);
1281  virtual void processSetRunDuration(DtSimMessage*);
1282 
1284  static void actionCategoriesRequestCallback(DtSimMessage* msg, void* usr);
1285  virtual void processActionCategoriesRequest(DtSimMessage* msg);
1286 
1288  static void scenarioStatusRequestCallback(DtSimMessage* msg, void* usr);
1289  virtual void processScenarioStatusRequest(DtSimMessage* msg);
1290 
1293  virtual bool beginFrame(DtCommunicationManagerPerformanceTimerInformation* info = nullptr);
1294  virtual bool advanceFrame();
1295 
1296 private:
1298  DtCgf(const DtCgf& original);
1300  DtCgf& operator=(const DtCgf& original);
1301 
1302 protected:
1305  virtual DtFilename spawnManagerTemplateFile(const DtScenarioExplorer&) const;
1306 
1308  virtual void loadAllPlugins();
1309 
1311  virtual bool loadComponentAttachmentTable(const DtFilename& filename);
1317  virtual bool loadTerrain(const DtFilename& filename);
1318 
1322  virtual DtFilename findTerrainFile(const DtFilename& startFile, const std::vector<DtFilename>& searchPaths,
1323  const std::string& extension) const;
1324 
1326  virtual bool loadOrderOfBattle(const DtScenario& scenario, DtLoadScenarioData&);
1327  virtual bool loadOrderOfBattle(const DtInMemorySnapshot::OOB&);
1328 
1330  virtual bool writeOrderOfBattle(const DtScenario& scenario) const;
1331  virtual bool writeOrderOfBattle(DtInMemorySnapshot::OOB&) const;
1332 
1334  virtual bool loadScenarioScripts(const DtFilename& filename);
1335  virtual bool loadScenarioScriptsFromZipFile(const DtFilename& scenarioZipFile, const DtFilename& filename);
1336  virtual bool loadScenarioScripts(const std::string& buffer);
1337 
1339  virtual bool loadOrbat(const DtFilename& filename, DtOrbatManager* intoOm = 0, bool clearBeforeLoading = true);
1340  virtual bool loadOrbatFromZipFile(const DtFilename& scenarioZipFile, const DtFilename& filename, DtOrbatManager* intoOm = 0, bool clearBeforeLoading = true);
1341  virtual bool loadOrbat(const std::string& buffer, DtOrbatManager* intoOm = 0, bool clearBeforeLoading = true);
1342 
1345  virtual void prepareForScenarioReinitialize();
1346 
1348  virtual bool isScenarioReinitializing() const;
1349 
1353  virtual bool loadParameterDb(const DtFilename& filename,
1354  const DtReaderWriter::SearchPaths& searchPaths, bool clearLoadedObjects = true, bool preloadParameters = false);
1355 
1358  virtual bool loadObjectParametersDBFile(const DtFilename& opdFile,
1359  const DtReaderWriter::SearchPaths& searchPaths, bool clearLoadedObjects = true, bool preloadParameters = false);
1360 
1364  virtual bool loadPhysicalWorldFile(const DtFilename& file, bool force = false);
1365 
1369  virtual bool loadDetonationParametersFile(const DtFilename& file, bool force = false);
1370 
1371  virtual bool loadTerrainDeformationParametersFile(const DtFilename& file, bool force = false);
1372 
1376  virtual bool loadAmmunitionParametersFile(const DtFilename& file, bool force = false);
1377 
1379  virtual bool loadPlans(const DtFilename& filename);
1380  virtual bool loadPlansFromZipFile(const DtFilename& scenarioZipFile, const DtFilename& filename);
1381  virtual bool loadPlans(const std::string& buffer);
1382 
1384  virtual bool loadGlobalPlans(const DtFilename& filename);
1385  virtual bool loadGlobalPlansFromZipFile(const DtFilename& scenarioZipFile, const DtFilename& filename);
1386 
1388  virtual void loadHostilityAndExtras(const DtScenarioExplorer& se);
1389  virtual void loadHostilityAndExtrasFromZipFile(const DtFilename& scenarioZipFile, const DtScenarioExplorer& se);
1390  virtual void loadHostilityAndExtras(const std::string& buffer);
1391 
1394  virtual void loadActivities(const DtScenarioExplorer&);
1395 
1398  virtual void loadModelSetFiles(const DtScenarioExplorer&);
1399 
1402  virtual void loadActionCategories(const DtFilename& f);
1403 
1404  virtual bool loadForceHostility(const DtFilename& filename, bool clear = true);
1405  virtual bool loadForceHostilityFromZipFile(const DtFilename& scenarioZipFile, const DtFilename& filename, bool clear = true);
1406 
1407  virtual bool loadScenarioExtras(const DtFilename& filename);
1408  virtual bool loadScenarioExtrasFromZipFile(const DtFilename&, const DtFilename& filename);
1409  virtual bool loadScenarioExtras(const std::string& buffer);
1410 
1413  virtual void processObjectParametersOp(DtSimMessage * msg);
1414 
1416  virtual void createAndInitScenarioLoadManager();
1417 
1420  virtual void emptyParametersDB();
1421 
1423  virtual void setAutoReorganization(bool onOff);
1424 
1428  virtual DtVrfPlugin* loadPlugin(const DtString&);
1429 
1432  virtual bool setupCommModelsForScenario(const DtScenarioExplorer& e);
1433 
1437  virtual void updateReadyStatus();
1438 
1441 
1442  static void simCommandCallback(DtSimMessage* msg, void* usr);
1443  virtual void processSimCommand(DtSimMessage* msg);
1445 
1449 
1450  static void deferredLoadScenarioCallback(void * data);
1451  virtual void processDeferredLoadScenario();
1452 
1455  virtual void processLoadScenario(const DtScenario* = 0, const DtInMemorySnapshotPtr = 0);
1457 
1459 
1460  static void deferredReinitializeScenarioCallback(void * data);
1461  virtual void processDeferredReinitializeScenario();
1463 
1468 
1469  static void deferredRollbackCallback(void * data);
1471  virtual bool processDeferredRollback(DtInMemorySnapshotPtr snapshot);
1473 
1475  virtual bool rollbackTo(DtInMemorySnapshotPtr chkp, int scenarioRunId = 0);
1476 
1480 
1481  static void deferredImportScenarioCallback(void * data);
1482  virtual void processDeferredImportScenario();
1484 
1487  virtual void clearAllSimulationModelSetInformation();
1488 
1490  virtual void initializeCgfConsoleCommands();
1491 
1492  virtual void processCloseScenarioEvent(const makVrfEvents::DtEvent&);
1493  virtual void processLoadScenarioEvent(const makVrfEvents::DtEvent&);
1494 
1496  virtual bool createDIGuyCharacterManager(const DtFilename & diGuyAnimationsFile);
1497 
1498 protected:
1499  DtVrfSimOptionsInterface* mySimOptions;
1500 
1502  DtSimulationAddress mySimulationAddress;
1503 
1505  DtU32 mySessionId;
1506 
1508  bool myOK;
1509 
1511  bool myTimeToQuit;
1512 
1514  DtVrfPluginManager* myPluginManager;
1515  std::vector<DtString> myPluginsToLoad;
1516  bool myLoadPluginsIfVersionMismatch;
1517 
1519  DtTerrainInterface* myTerrainInterface;
1520 
1522  DtPhysicalWorld* myPhysicalWorld;
1523 
1524  DtVrfNavAreaManager* myVrfNavAreaManager;
1525 
1526  DtSpawnSinkManager* mySpawnSinkManager;
1527 
1528  DtCommModelManager* myCommModelManager;
1529 
1530  DtSimTerrainRequestManager* mySimTerrainRequestManager;
1531 
1533  DtCommunicationManager* myCommunicationManager;
1534 
1536  DtSimManager* mySimManager;
1537 
1539  DtCreateObjectServiceInterface* myCreateObjectService;
1540 
1542  DtScenarioServiceInterface* myScenarioService;
1543 
1545  DtScenario* myScenario;
1546 
1548  DtVrfStatusPublisher* myStatusPublisher;
1549 
1551  DtLocalObjectManager* myObjectManager;
1552 
1554  DtDebugDrawManager* myDebugDrawManager;
1555 
1556  DtDetonationManager* myDetonationManager;
1557  DtAmmunitionManager* myAmmunitionManager;
1558  DtScriptedTaskManager* myScriptedTaskManager;
1559  DtScenarioEventManager* myScenarioEventManager;
1560  DtHazardAreaManager* myHazardAreaManager;
1561  DtIntelCollectionAreaManager* myIntelCollectionAreaManager;
1562  DtScriptedObjectsMovementManager* myScriptedObjectsMovementManager;
1563  DtFireManager* myFireManager;
1564  DtObjectConsoleManager* myObjectConsoleManager;
1565  DtManagedObjectListManager* myFilteredObjectListManager;
1566  DtOrbatManager* myOrbatManager;
1567  DtObjectGeometricModelsManager* myObjectModelsManager;
1568  DtVrfObjectPlanAdministrator* myPlanAdministrator;
1569  DtSimInternalCommunicationManager* mySimInternalCommunicationManager;
1570  DtDiGuyCharacterDataManager * myCharacterMgr;
1571  DtAisDataManager* myAisDataManager;
1572  DtSimOperationsInProgressManager* mySimOperationsInProgressManager = nullptr;
1573  DtAdsbDataManager* myAdsbDataManager;
1574  bool myCreatedCharacterManager;
1575 
1576  DtLuaObjectSerializer* myLuaObjectSerializer;
1577 
1579  DtResourceMonitor* myResourceMonitor;
1580 
1582  DtRadarCoverageMonitor* myRadarCoverageMonitor;
1583 
1585  DtTerrainProfileRequestManager* myTerrainProfileRequestManager;
1586 
1588  DtVrfParameterDb* myParameterDatabase;
1589 
1591  DtEmbeddedEntityInfoManager* myEmbeddedEntityInfoManager;
1592 
1594  bool myForceParameterDbReload;
1595 
1596  DtGlobalPlanManager* myGlobalPlanManager;
1597 
1598  DtHostilityManager* myHostilityManager;
1599  DtEngagementZonesManager* myEngagementZonesManager;
1600 
1601  DtScenarioExtrasMgr* myScenarioExtrasManager;
1602 
1604  DtFactoryManager* myFactoryManager;
1605 
1607  DtStealthCommandsManager* myStealthCommandsManager;
1608 
1609  DtSimCommandDistributor* mySimCommandDistributor;
1610 
1615  DtFilename myVrfTerrainPathDirectory;
1616 
1620  DtFilename myDefaultTerrainDirectory;
1621 
1623  DtFilename myDefaultSimulationModelSetFilename;
1624 
1626  DtFilename myDIGuyAnimationsFilename;
1627 
1629  DtFilename myMsdlSidcMappingFile;
1630 
1632  DtFilename myCountryCodesMappingFile;
1633 
1636  bool myParameterDbLoaded;
1637 
1639  DtFilename myCurrentParameterDatabaseFilename;
1640 
1644  DtFilename myDefaultParameterDbDirectory;
1645 
1646  DtCallbackList<const DtFilename&> myPreLoadTerrainCallbacks;
1647  DtCallbackList<const DtFilename&> myPostLoadTerrainCallbacks;
1648  DtCallbackList<DtScenario&> myPreLoadScenarioCallbacks;
1649  DtCallbackList<const DtScenario&> myPostLoadScenarioCallbacks;
1650  DtCallbackList<DtScenario&> myPreScenarioReinitializeCallbacks;
1651  DtCallbackList<const DtScenario&> myPostScenarioReinitializeCallbacks;
1652  DtCallbackList<DtScenario&> myPreCreateSimulationObjectGroupCallbacks;
1653  DtCallbackList<const DtScenario&> myPostCreateSimulationObjectGroupCallbacks;
1654  DtCallbackList<DtScenario&> myPreImportScenarioCallbacks;
1655  DtCallbackList<const DtScenario&> myPostImportScenarioCallbacks;
1656  DtCallbackList<DtScenario&> myPreSaveScenarioCallbacks;
1657  DtCallbackList<const DtScenario&> myPostSaveScenarioCallbacks;
1658 
1659  DtCallbackList<DtScenario&> myPreSaveSimulationObjectGroupsCallbacks;
1660  DtCallbackList<const DtScenario&> myPostSaveSimulationObjectGroupsCallbacks;
1661 
1662  DtNoArgumentCallbackList myPostParameterDatabaseLoadedCallbacks;
1663  DtNoArgumentCallbackList myPreCloseScenarioCallbacks;
1664  DtNoArgumentCallbackList myPostCloseScenarioCallbacks;
1665  DtNoArgumentCallbackList myScenarioRunCallbacks;
1666  DtNoArgumentCallbackList myScenarioPauseCallbacks;
1667  DtNoArgumentCallbackList myPreScenarioRollbackCallbacks;
1668  DtNoArgumentCallbackList myPostScenarioRollbackCallbacks;
1669  DtNoArgumentCallbackList myPostTickCallbacks;
1670  DtNoArgumentCallbackList myCgfAboutToBeDestroyedCallbacks;
1671 
1672  DtSyncMatrixManager* mySyncMatrixManager;
1673  DtInfluenceEventDispatcher* myInfluenceEventDispatcher;
1674  DtDynamicFeaturesManager* myDynamicFeaturesManager;
1675 
1680  void setVrfCreator(DtVrfCreator* creator);
1682 
1684 
1685  bool ownVrfCreator() const;
1686  void setOwnVrfCreator(bool yesOrNo);
1688 
1690  virtual bool differingModelSets(DtScenario*) const;
1691 
1692  virtual void simControlEvent(const makVrfEvents::DtEvent&);
1693 
1694  virtual void clearObjectsAwaitingDiscovery();
1695  virtual void processObjectsAwaitingDiscovery();
1696 
1697  virtual void terrainPaging(bool);
1698  virtual void jobQueueStatusChanged(bool);
1699 
1700 protected:
1703  bool myOwnVrfCreatorFlag;
1704  DtVrfCreator* myVrfCreator;
1705 
1707  bool myFullyLoadTerrain;
1708 
1712  bool myAssertOnBlockingTerrainCalls;
1713 
1716  DtSimulationModelSet* myDefaultModelSet;
1717 
1721  DtScenario myScenarioToLoad;
1722 
1723  bool myCreateGlobalEnvironment;
1724  bool myCreateGlobalDynamicTerrain;
1725  bool myCreatedGlobalEnvironment;
1726  bool myCreatedGlobalDynamicTerrain;
1727 
1728  bool myAutomaticallyCreateGlobalEnvironment;
1729 
1730  int myMaxAsynchronousTerrainThreads;
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 
1756  DtTaskVisualizationPublicationMode myTaskVisualizationPublicationMode;
1757  bool myUseDrawControlForTaskVisualizations;
1758 
1759  bool myReuseEntityIdentifiersOnScenarioLoad;
1760 
1761  bool myLoadAllNavigationDataOnTerrainLoad;
1762 
1763  DtRwActivities myActivities;
1764  bool mySmsValidationEnabled;
1765  DtSnapshotManager* mySnapshotManager;
1766  DtSimObjectManager* mySimObjectManager;
1767 
1768  std::vector<DtFilename> myObjectGroupsRoot;
1769 
1770  struct SimulationObjectGroupInformation
1771  {
1772  DtlObjPtr planArgs;
1773  DtlObjPtr oobArgs;
1774  };
1775 
1776  typedef std::map<DtString, SimulationObjectGroupInformation> StoredSimulationObjectGroupInformation;
1777  StoredSimulationObjectGroupInformation myStoredSimulationObjectGroupInformation;
1778 
1779  bool myCanSimulate;
1780  bool myIsLoaded;
1781  bool myHasModelSetInformationLoadedAfterClose;
1782  int myReloadDelay;
1783  bool myRejectMismatchedScenarioMessages;
1784  DtU32 myScenarioCapabilities;
1785  int myAppIdRangeMax;
1786 
1787  std::set<DtFilename> myLoadedModelSets;
1788 
1789  DtInMemorySnapshotPtr myQueuedRollback;
1790  int myQueuedRollbackScenarioRunId;
1791 
1792  DtScenarioLoadManager* myScenarioLoadManager;
1793 
1794  typedef std::vector<DtLoadOrderOfBattleHandler*>SimulationObjectGroupsToBeCreated;
1795  SimulationObjectGroupsToBeCreated mySimulationObjectGroupsToBeCreated;
1796 
1797 public:
1800  VRF4API_METHOD DtLocalObjectManager* vrfObjectManager() { return myObjectManager; };
1801  VRF4API_METHOD DtCommunicationManager* exerciseConn() { return myCommunicationManager; };
1803 };
1804 
DtUUID
UUID is a unique ID wrapper class.
Definition: uuid.h:59
DtCgf::myObjectConsoleManager
DtObjectConsoleManager * myObjectConsoleManager
Definition: cgf.h:1564
DtCgf::myIsLoaded
bool myIsLoaded
Definition: cgf.h:1780
DtCgf::myObjectModelsManager
DtObjectGeometricModelsManager * myObjectModelsManager
Definition: cgf.h:1567
DtCgf::myCommunicationManager
DtCommunicationManager * myCommunicationManager
The current exercise connection.
Definition: cgf.h:1533
DtCgf::mySimManager
DtSimManager * mySimManager
Pointer to the DtSimManager.
Definition: cgf.h:1536
DtCgf::myCreateGlobalEnvironment
bool myCreateGlobalEnvironment
Definition: cgf.h:1723
DtCgf::myPublishingGlobalEnvironment
bool myPublishingGlobalEnvironment
Definition: cgf.h:1752
DtCgf::myScenarioStatus
DtIfScenarioStatus * myScenarioStatus
Scenario status message to be sent out upon request.
Definition: cgf.h:1750
DtLocalObjectManager
class DtLocalObjectManager:
Definition: localObjectManager.h:157
DtCgf::communicationManager
DtCommunicationManager * communicationManager()
Definition: cgf.h:385
DtSimTerrainRequestManager
Definition: simTerrainRequestManager.h:137
DtResourceMonitor
This class will be responsible for handling requests to return resources for a particular entity (or ...
Definition: resourceMonitor.h:60
DtCgf::myAmmunitionManager
DtAmmunitionManager * myAmmunitionManager
Definition: cgf.h:1557
DtCgf::myGlobalPlanManager
DtGlobalPlanManager * myGlobalPlanManager
Definition: cgf.h:1596
DtCgf::myUseDrawControlForTaskVisualizations
bool myUseDrawControlForTaskVisualizations
Definition: cgf.h:1757
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:1558
DtTimer
Instances of DtTimer are used to maintain the information needed to represent some kind of scheduled ...
Definition: timer.h:38
DtCgf::myAdsbDataManager
DtAdsbDataManager * myAdsbDataManager
Definition: cgf.h:1573
DtCgf::myStealthCommandsManager
DtStealthCommandsManager * myStealthCommandsManager
Stealth commands manager.
Definition: cgf.h:1607
DtVrfParameterDb
Instances of DtVrfParameterDb are the database of DtVrfObjectParameters objects used in the construct...
Definition: vrfParameterDb.h:41
DtCgf::myScenarioPauseCallbacks
DtNoArgumentCallbackList myScenarioPauseCallbacks
Definition: cgf.h:1666
DtCgf::myPreLoadScenarioCallbacks
DtCallbackList< DtScenario & > myPreLoadScenarioCallbacks
Definition: cgf.h:1648
DtCgf::myCreateObjectService
DtCreateObjectServiceInterface * myCreateObjectService
Pointer to the create object service.
Definition: cgf.h:1539
DtCgf::myAisDataManager
DtAisDataManager * myAisDataManager
Definition: cgf.h:1571
DtInMemorySnapshot
Structure holds a complete single-backend snapshot state in memory.
Definition: snapshotManager.h:31
DtScenario
Definition: scenario.h:52
DtCreateObjectServiceInterface
Service interface for creating and removing simulation objects as well as adjusting organization hier...
Definition: createObjectServiceInterface.h:36
DtCgf::myPreCreateSimulationObjectGroupCallbacks
DtCallbackList< DtScenario & > myPreCreateSimulationObjectGroupCallbacks
Definition: cgf.h:1652
DtCgf::myOK
bool myOK
Flag indicating whether we have been successfully initialized.
Definition: cgf.h:1508
DtCgf::myPreCloseScenarioCallbacks
DtNoArgumentCallbackList myPreCloseScenarioCallbacks
Definition: cgf.h:1663
DtCgf::mySimCommandDistributor
DtSimCommandDistributor * mySimCommandDistributor
Definition: cgf.h:1609
DtCgf::myPhysicalWorld
DtPhysicalWorld * myPhysicalWorld
The current physical world.
Definition: cgf.h:1522
DtCgf::myDefaultSimulationModelSetFilename
DtFilename myDefaultSimulationModelSetFilename
Default simulation model set file to load.
Definition: cgf.h:1623
DtCgf::scenarioStatus
const DtIfScenarioStatus * scenarioStatus() const
Imports the specified scenario description file into the current scenario.
Definition: cgf.h:294
DtCgf::myFullyLoadTerrain
bool myFullyLoadTerrain
Flag indicating whether to fully load terrain subpages for paged terrain.
Definition: cgf.h:1707
DtNoArgumentCallbackList::DtCallbackFunctionType
void(* DtCallbackFunctionType)(void *)
The function signature of the callback function.
Definition: noArgumentCallbackList.h:155
DtCgf::ActionCategory
std::pair< std::string, bool > ActionCategory
Map of ID and screen string for action categories. Only used by the front-end Not currently set up fo...
Definition: cgf.h:1745
DtCgf::myPreScenarioReinitializeCallbacks
DtCallbackList< DtScenario & > myPreScenarioReinitializeCallbacks
Definition: cgf.h:1650
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:1601
DtScenarioExplorer
class DtScenarioExplorer:
Definition: scenarioExplorer.h:26
DtCgf::mySmsValidationEnabled
bool mySmsValidationEnabled
Definition: cgf.h:1764
DtCgf::myPostCreateSimulationObjectGroupCallbacks
DtCallbackList< const DtScenario & > myPostCreateSimulationObjectGroupCallbacks
Definition: cgf.h:1653
DtScriptedTaskManager
Manage scripted tasks (primarily Lua tasks) known by VR-Forces.
Definition: scriptedTaskManager.h:76
DtCommModelManager
Holds all radio networks (comm models, implemented by DtCommModel) for the current exercise...
Definition: commModelManager.h:26
makVrfEvents::DtEventManager
The DtEventManager handles the sending and receipt of system events (fire, detonate, command, etc). It provides a thread-safe way for the sim engine to send and receive such events, between both components within this sim engine and other remote applications.
Definition: eventManager.h:33
DtVrfSimOptionsInterface
Options for the configuring the sim.
Definition: vrfSimOptionsInterface.h:20
DtSpawnSinkManager
Manages all of the spawn points, sink points, and spawn templates in the current scenario.
Definition: spawnSinkManager.h:24
DtIfSaveScenario
class DtIfSaveScenario:
Definition: ifSaveScenario.h:23
DtCgf::myScenario
DtScenario * myScenario
The current scenario.
Definition: cgf.h:1545
DtSimInternalCommunicationManager
The manager for SimInternal messages on a single simulation engine. This class manages the passing of...
Definition: simInternalCommunicationManager.h:28
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:20
DtCgf::myObjectGroupsRoot
std::vector< DtFilename > myObjectGroupsRoot
Definition: cgf.h:1768
DtRadarCoverageMonitor
Definition: radarCoverageMonitor.h:30
DtCgf::myVrfTerrainPathDirectory
DtFilename myVrfTerrainPathDirectory
Terrain data directory from environment variable VRF_TERRAIN_PATH. If specified, this is the 3rd plac...
Definition: cgf.h:1615
DtCgf::myTimeToQuit
bool myTimeToQuit
Flag indicating whether or not the app should quit.
Definition: cgf.h:1511
DtTerrainProfileRequestManager
Definition: terrainProfileRequestManager.h:31
DtCgf::myPostCloseScenarioCallbacks
DtNoArgumentCallbackList myPostCloseScenarioCallbacks
Definition: cgf.h:1664
DtCgf::myPostTickCallbacks
DtNoArgumentCallbackList myPostTickCallbacks
Definition: cgf.h:1669
DtAdsbDataManager
The DtAdsbDataManager loads and manages Automatic Dependent Surveillance - Broadcast (ADS-B) data...
Definition: adsbDataManager.h:41
DtCgf::myResourceMonitor
DtResourceMonitor * myResourceMonitor
Pointer to the DtResourceMonitor.
Definition: cgf.h:1579
DtOrbatManager
This class handles all requests as they pertain to viewing or modifying the ORBAT.
Definition: orbatManager.h:30
DtHazardAreaManager
The DtHazardAreaManager will keep track of all hazard area objects and their state. Hazard areas are predefined as part of this class. Call the add/remove methods to add or remove areas to watch.
Definition: hazardAreaManager.h:22
DtCgf::myCreateGlobalDynamicTerrain
bool myCreateGlobalDynamicTerrain
Definition: cgf.h:1724
DtCgf::myCanSimulate
bool myCanSimulate
Definition: cgf.h:1779
DtCgf::myVrfNavAreaManager
DtVrfNavAreaManager * myVrfNavAreaManager
Definition: cgf.h:1524
DtScenarioServiceInterface
Service interface for checking and altering scenario wide properties.
Definition: scenarioServiceInterface.h:30
DtLuaObjectSerializer
Definition: luaObjectSerializer.h:24
DtCgf::SimulationObjectGroupsToBeCreated
std::vector< DtLoadOrderOfBattleHandler * > SimulationObjectGroupsToBeCreated
Definition: cgf.h:1794
DtCgf::myHasModelSetInformationLoadedAfterClose
bool myHasModelSetInformationLoadedAfterClose
Definition: cgf.h:1781
DtCgf::myQueuedRollback
DtInMemorySnapshotPtr myQueuedRollback
Definition: cgf.h:1789
DtCgf::myAppIdRangeMax
int myAppIdRangeMax
Definition: cgf.h:1785
DtInfluenceEventDispatcher
Definition: influenceEventDispatcher.h:25
DtFireManager
The DtFireManager class exists to centralize the process of sending and receiving of fire interaction...
Definition: fireManager.h:43
DtCgf::myCommModelManager
DtCommModelManager * myCommModelManager
Definition: cgf.h:1528
DtSyncMatrixManager
The synchronization matrix manager maintains the list of synchronization matrices. These are locally simulated objects that manage a list of phases where during each phase, scenario entities can be assigned with plans.
Definition: syncMatrixManager.h:40
DtCgf::myCreatedGlobalDynamicTerrain
bool myCreatedGlobalDynamicTerrain
Definition: cgf.h:1726
DtIfScenarioStatus
Definition: ifScenarioStatus.h:28
DtCgf::mySimOptions
DtVrfSimOptionsInterface * mySimOptions
Definition: cgf.h:1499
DtHostilityManager
This class keeps track of which forces are hostile to which other forces in the simulation. It maintains state for each force type, and which other forces types are considered hostile by that force. It can be queried for this data any time during the simulation. Supports force enumerations from 0 to 255.
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:39
DtCgf::myLoadAllNavigationDataOnTerrainLoad
bool myLoadAllNavigationDataOnTerrainLoad
Definition: cgf.h:1761
DtObjectConsoleManager
This class represents a collection of object consoles that will be used to manage streams for individ...
Definition: objectConsoleManager.h:31
DtScenarioLoadManager
Definition: scenarioLoadManager.h:80
DtCgf::myReuseEntityIdentifiersOnScenarioLoad
bool myReuseEntityIdentifiersOnScenarioLoad
Definition: cgf.h:1759
DtCgf::myStatusPublisher
DtVrfStatusPublisher * myStatusPublisher
Pointer to the DtStatusPublisher.
Definition: cgf.h:1548
DtCgf::myTaskVisualizationPublicationMode
DtTaskVisualizationPublicationMode myTaskVisualizationPublicationMode
Definition: cgf.h:1756
DtCgf::myDIGuyAnimationsFilename
DtFilename myDIGuyAnimationsFilename
DI_Guy animation configuration file to load.
Definition: cgf.h:1626
DtCgf::myRejectMismatchedScenarioMessages
bool myRejectMismatchedScenarioMessages
Definition: cgf.h:1783
DtCgf::myMaxAsynchronousTerrainThreads
int myMaxAsynchronousTerrainThreads
Definition: cgf.h:1730
DtCgf::exerciseConn
VRF4API_METHOD DtCommunicationManager * exerciseConn()
These are backwards compatible methods that can be used if you define ALLOW_VRF4API in your header fi...
Definition: cgf.h:1801
DtCgf::myParameterDatabase
DtVrfParameterDb * myParameterDatabase
Pointer to the DtVrfParameterDb.
Definition: cgf.h:1588
DtCgf::myObjectManager
DtLocalObjectManager * myObjectManager
Pointer to the DtLocalObjectManager.
Definition: cgf.h:1551
DtCgf::myPreSaveScenarioCallbacks
DtCallbackList< DtScenario & > myPreSaveScenarioCallbacks
Definition: cgf.h:1656
DtObjectGeometricModelsManager
Manages loading and destruction of the geometric models for objects. Will reference the object parame...
Definition: objectGeometricModelsManager.h:34
DtCgf::myPreLoadTerrainCallbacks
DtCallbackList< const DtFilename & > myPreLoadTerrainCallbacks
Definition: cgf.h:1646
DtInMemorySnapshot::OOB
std::vector< std::string * > OOB
Definition: snapshotManager.h:44
DtCgf::StoredSimulationObjectGroupInformation
std::map< DtString, SimulationObjectGroupInformation > StoredSimulationObjectGroupInformation
Definition: cgf.h:1776
DtCommunicationManagerPerformanceTimerInformation
Definition: communicationManager.h:38
DtScenarioEventManager
The scenario event manager will keep track of all scenario event objects and their state...
Definition: scenarioEventManager.h:36
DtSetDataRequest
DtSetDataRequest is an abstract base class from which real setDataRequests can derive. It manages the read/write capability; derived classes need only use and register read/writatble data types for derived information.
Definition: setDataRequest.h:41
DtCgf::myEmbeddedEntityInfoManager
DtEmbeddedEntityInfoManager * myEmbeddedEntityInfoManager
Pointer to the DtEmbeddedEntityInfoManager.
Definition: cgf.h:1591
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:1725
DtPhysicalWorld
The DtPhysicalWorld is the primary interface to and manager of all of the &quot;physical&quot; aspects of the s...
Definition: physicalWorld.h:112
DtCgf::myDetonationManager
DtDetonationManager * myDetonationManager
Definition: cgf.h:1556
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:1632
DtCgf::myDefaultParameterDbDirectory
DtFilename myDefaultParameterDbDirectory
Default parameter database directory to search in when parameter database being specified is not an a...
Definition: cgf.h:1644
makVrfEvents::DtEvent
Definition: event.h:13
DtEmbeddedEntityInfoManager
DtEmbeddedEntityInfoManager is the central point for information about embedded entities and their ca...
Definition: embeddedEntityInfoManager.h:36
DtCgf::myScenarioEventManager
DtScenarioEventManager * myScenarioEventManager
Definition: cgf.h:1559
DtCgf::myScenarioService
DtScenarioServiceInterface * myScenarioService
Pointer to the scenario object service.
Definition: cgf.h:1542
DtCgf::myTerrainProfileRequestManager
DtTerrainProfileRequestManager * myTerrainProfileRequestManager
Pointer to the DtTerrainProfileRequestManager.
Definition: cgf.h:1585
DtVrfNavAreaManager
The DtVrfNavAreaManager manages all of the nav areas currently created in the sim.
Definition: vrfNavAreaManager.h:65
DtInMemorySnapshotPtr
std::shared_ptr< DtInMemorySnapshot > DtInMemorySnapshotPtr
Definition: snapshotManager.h:53
DtCgf::vrfObjectManager
VRF4API_METHOD DtLocalObjectManager * vrfObjectManager()
These are backwards compatible methods that can be used if you define ALLOW_VRF4API in your header fi...
Definition: cgf.h:1800
DtImportExportScenarioDescriptionManager
Definition: importExportScenarioDescriptionManager.h:32
DtPaperMapDatabase
Definition: paperMapDatabase.h:20
DtCommunicationManager
The DtCommunicationManager class is a convenience class that will create both the DtNetworkInterfaceM...
Definition: communicationManager.h:54
DtCgf::myDynamicFeaturesManager
DtDynamicFeaturesManager * myDynamicFeaturesManager
Definition: cgf.h:1674
DtCgf::myPostLoadTerrainCallbacks
DtCallbackList< const DtFilename & > myPostLoadTerrainCallbacks
Definition: cgf.h:1647
DtSimMessage
File: simMsg.h.
Definition: simMessage.h:35
DtDiGuyCharacterDataManager
Contains data describing the available attributes and animations for each DI-Guy character type...
Definition: diGuyCharacterDataManager.h:33
DtCgf::myStoredSimulationObjectGroupInformation
StoredSimulationObjectGroupInformation myStoredSimulationObjectGroupInformation
Definition: cgf.h:1777
DtCgf::myScenarioRunCallbacks
DtNoArgumentCallbackList myScenarioRunCallbacks
Definition: cgf.h:1665
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:151
DtCgf::myPluginManager
DtVrfPluginManager * myPluginManager
The current plugin manager.
Definition: cgf.h:1514
DtReaderWriter::SearchPaths
std::vector< DtFilename > SearchPaths
Definition: readerWriter.h:92
DtCgf::myQueuedRollbackScenarioRunId
int myQueuedRollbackScenarioRunId
Definition: cgf.h:1790
DtCgf::myCreatedCharacterManager
bool myCreatedCharacterManager
Definition: cgf.h:1574
DtCgf::mySimulationObjectGroupsToBeCreated
SimulationObjectGroupsToBeCreated mySimulationObjectGroupsToBeCreated
Definition: cgf.h:1795
DtCompressedFileTransporter
Definition: compressedFileTransporter.h:24
DtLoadScenarioData
This is a two way structure. It will contain read data (import) and output dat objects created...
Definition: loadScenarioData.h:39
DtCgf::myWasPaused
bool myWasPaused
Used to hold the paused state during a rewindScenario operation. The act of rewinding a scenario star...
Definition: cgf.h:1736
DtCallbackList
Definition: noArgumentCallbackList.h:90
DtCgf::myIntelCollectionAreaManager
DtIntelCollectionAreaManager * myIntelCollectionAreaManager
Definition: cgf.h:1561
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:1712
DtCgf::myPreSaveSimulationObjectGroupsCallbacks
DtCallbackList< DtScenario & > myPreSaveSimulationObjectGroupsCallbacks
Definition: cgf.h:1659
DtCgf::mySyncMatrixManager
DtSyncMatrixManager * mySyncMatrixManager
Definition: cgf.h:1672
DtVrfStatusPublisher
Instances of DtVrfStatusPublisher are used to send information about a VR-Forces simulation engine to...
Definition: vrfStatusPublisher.h:30
DtCgf::myPostSaveSimulationObjectGroupsCallbacks
DtCallbackList< const DtScenario & > myPostSaveSimulationObjectGroupsCallbacks
Definition: cgf.h:1660
DtCgf::myDefaultModelSet
DtSimulationModelSet * myDefaultModelSet
Default simulation model set. This is created when the default simulation model set filename is set o...
Definition: cgf.h:1716
DtCgf::myPostScenarioRollbackCallbacks
DtNoArgumentCallbackList myPostScenarioRollbackCallbacks
Definition: cgf.h:1668
DtCgf::myActivities
DtRwActivities myActivities
Definition: cgf.h:1763
DtVrfPluginManager
Definition: vrfPluginManager.h:73
DtCgf::myScenarioLoadManager
DtScenarioLoadManager * myScenarioLoadManager
Definition: cgf.h:1792
DtCgf::myRadarCoverageMonitor
DtRadarCoverageMonitor * myRadarCoverageMonitor
Pointer to the DtRadarCoverageMonitor.
Definition: cgf.h:1582
DtConsoleCommandOwner
A utility class for use with DtConsoleCommandManager. This class takes ownership of an arbitrary numb...
Definition: consoleCommandManager.h:168
DtFactoryManager
Instances of DtFactoryManager are responsible for maintaining all the factories.
Definition: factoryManager.h:73
DtTerrainInterface
DtTerrainInterface allows access to common terrain calls without having to know the terrain implement...
Definition: terrainInterface.h:93
DtCgf::myFactoryManager
DtFactoryManager * myFactoryManager
Pointer to the DtFactoryManager.
Definition: cgf.h:1604
DtCgf::myActionCategories
ActionCategories myActionCategories
Definition: cgf.h:1747
DtSimCommand
DtSimCommand is an abstract base class from which commands can derive. It manages the read/write capa...
Definition: simCommand.h:32
DtCgf::myScenarioToLoad
DtScenario myScenarioToLoad
Used to contain the scenario we want to during loadScenario operation. The act of loading a scenario ...
Definition: cgf.h:1721
DtCgf::myHazardAreaManager
DtHazardAreaManager * myHazardAreaManager
Definition: cgf.h:1560
DtCgf::myPluginsToLoad
std::vector< DtString > myPluginsToLoad
Definition: cgf.h:1515
DtCgf::myPostSaveScenarioCallbacks
DtCallbackList< const DtScenario & > myPostSaveScenarioCallbacks
Definition: cgf.h:1657
DtCgf::myReinitializingScenario
bool myReinitializingScenario
Definition: cgf.h:1754
error
Definition: asyncJobServer.h:39
DtSimOperationsInProgressManager
The DtSimOperationsInProgressManager can be used to keep track (by count) of sim services in operatio...
Definition: simOperationsInProgressManager.h:17
DtVrfCreator
Instances of DtVrfCreator are responsible for creating all of the objects needed to create and manage...
Definition: vrfCreator.h:284
DtCgf::mySimObjectManager
DtSimObjectManager * mySimObjectManager
Definition: cgf.h:1766
DtCgf::mySimInternalCommunicationManager
DtSimInternalCommunicationManager * mySimInternalCommunicationManager
Definition: cgf.h:1569
DtPlan
class DtPlan:
Definition: plan.h:92
DtCgf::myInfluenceEventDispatcher
DtInfluenceEventDispatcher * myInfluenceEventDispatcher
Definition: cgf.h:1673
DtCgf::myOrbatManager
DtOrbatManager * myOrbatManager
Definition: cgf.h:1566
DtCgf::myCgfAboutToBeDestroyedCallbacks
DtNoArgumentCallbackList myCgfAboutToBeDestroyedCallbacks
Definition: cgf.h:1670
DtIntelCollectionAreaManager
The intel collection area manager will keep track of all Intel Collection area objects and their stat...
Definition: intelCollectionAreaManager.h:20
DtVrfObjectPlanAdministrator
The DtVrfObjectPlanAdministrator performs plan-related tasks that must be done in a centralized manne...
Definition: vrfObjectPlanAdministrator.h:44
DtCgf::myPreImportScenarioCallbacks
DtCallbackList< DtScenario & > myPreImportScenarioCallbacks
Definition: cgf.h:1654
translatableStream.h
Contains the DtTranslatableStream class declaration.
DtCgf::myLoadedModelSets
std::set< DtFilename > myLoadedModelSets
Definition: cgf.h:1787
DtNetworkInterfaceManager
The DtNetworkInterfaceManager manages all network interfaces utilized by the sim engine. Often there is only one, but it is possible for there to be multiple. Each network interface is an instance of a subclass of DtNetworkManagerInterface. As state data is created or removed, the DtNetworkInterfaceManager will notify each of its network interfaces, so that they may create object network interfaces to output required state data to the network.
Definition: networkInterfaceManager.h:47
DtScenarioExtrasMgr
This class defines a manager whose job it is to read the extra scenario data in the ...
Definition: scenarioExtrasMgr.h:26
DtSimulationServices
Central access point of all non-object-specific the services and managers that are available for use ...
Definition: simulationServices.h:96
DtCgf::myAboutToLoadOrRewindScenario
bool myAboutToLoadOrRewindScenario
Definition: cgf.h:1753
DtSimObjectManager
This class is the central access point for all current-frame state of all objects in the simulation i...
Definition: simObjectManager.h:32
DtCgf::myForceParameterDbReload
bool myForceParameterDbReload
Forces loadScenario to re-load the parameter database.
Definition: cgf.h:1594
DtAdminContent
DtAdminContent.
Definition: adminContent.h:23
DtSimulationModelSet
A simulation model set contains all the information that can be used to support a scenario either for...
Definition: simulationModelSet.h:31
DtCgf::mySnapshotManager
DtSnapshotManager * mySnapshotManager
Definition: cgf.h:1765
DtCgf::myEngagementZonesManager
DtEngagementZonesManager * myEngagementZonesManager
Definition: cgf.h:1599
DtStealthCommandsManager
Responsible for maintaining and executing stealth commands. The stealth commands are of the format (i...
Definition: stealthCommandsManager.h:35
DtCgf::aboutToLoadOrRewindScenario
virtual bool aboutToLoadOrRewindScenario() const
Whether or not this cgf is about to rewind, rollback or load.
Definition: cgf.h:391
DtDynamicFeaturesManager
Definition: dynamicFeaturesManager.h:18
DtCgf::myPostImportScenarioCallbacks
DtCallbackList< const DtScenario & > myPostImportScenarioCallbacks
Definition: cgf.h:1655
DtCgf::myPostParameterDatabaseLoadedCallbacks
DtNoArgumentCallbackList myPostParameterDatabaseLoadedCallbacks
Definition: cgf.h:1662
DtSimTask
DtSimTask is an abstract base class from which real tasks can derive. It manages the read/write capab...
Definition: simTask.h:30
DtCgf::myPlanAdministrator
DtVrfObjectPlanAdministrator * myPlanAdministrator
Definition: cgf.h:1568
init
DT_DLL_DEBUGDRAWRENDERER void init(makVrv::DtDe &de)
Work function for the plugin initialization.
DtCgf::myAutomaticallyCreateGlobalEnvironment
bool myAutomaticallyCreateGlobalEnvironment
Definition: cgf.h:1728
mode
const char int mode
Definition: ioapi.h:38
DtCgf::mySimTerrainRequestManager
DtSimTerrainRequestManager * mySimTerrainRequestManager
Definition: cgf.h:1530
DtCgf::myPostLoadScenarioCallbacks
DtCallbackList< const DtScenario & > myPostLoadScenarioCallbacks
Definition: cgf.h:1649
DtCgf::myReloadDelay
int myReloadDelay
Definition: cgf.h:1782
DtCgf::myVrfCreator
DtVrfCreator * myVrfCreator
Definition: cgf.h:1704
DtCgf::myCharacterMgr
DtDiGuyCharacterDataManager * myCharacterMgr
Definition: cgf.h:1570
DtCgf::canSimulate
virtual bool canSimulate() const
Whether or not the cgf is ready to simulate.
Definition: cgf.h:383
DtCgf::myCurrentParameterDatabaseFilename
DtFilename myCurrentParameterDatabaseFilename
Filename of currently loaded parameter database.
Definition: cgf.h:1639
DtSimManager
The simulation engine is controlled by a single,top-level class called the Simulation Manager...
Definition: simManager.h:137
DtSnapshotManager
Definition: snapshotManager.h:57
DtCgf::myFilteredObjectListManager
DtManagedObjectListManager * myFilteredObjectListManager
Definition: cgf.h:1565
DtManagedObjectListManager
Service which provides managed lists of simulation objects that are filtered based on a given predica...
Definition: managedObjectListManager.h:22
DtCgf::SimulationObjectGroupInformation::planArgs
DtlObjPtr planArgs
Definition: cgf.h:1772
DtCgf::myScenarioCapabilities
DtU32 myScenarioCapabilities
Definition: cgf.h:1784
DtCgf::myOwnVrfCreatorFlag
bool myOwnVrfCreatorFlag
These are essentially cached from the init call. This is necessary as the load terrain.
Definition: cgf.h:1703
DtCgf::scenarioStatus
DtIfScenarioStatus * scenarioStatus()
Returns the scenario status object.
Definition: cgf.h:293
DtCgf::myParameterDbLoaded
bool myParameterDbLoaded
Set to true if parameter database has been loaded via loadParameterDatabase call. If you load a param...
Definition: cgf.h:1636
DtCgf::myHostilityManager
DtHostilityManager * myHostilityManager
Definition: cgf.h:1598
DtCgf::myPreScenarioRollbackCallbacks
DtNoArgumentCallbackList myPreScenarioRollbackCallbacks
Definition: cgf.h:1667
DtGlobalPlanManager
The global plan manager maintains the list of &quot;Global Plans.&quot; These are plans that are not specific t...
Definition: globalPlanManager.h:53
DtCgf::mySpawnSinkManager
DtSpawnSinkManager * mySpawnSinkManager
Definition: cgf.h:1526
DtCgf
The top level class of a VR-Forces Simulation Engine, representing a Computer Generated Forces instan...
Definition: cgf.h:156
DtDefaultScenarioImportFlags
const int DtDefaultScenarioImportFlags
Default is not not import duplicate UUIDs. This will allow multiple scenarios that have the same base...
Definition: scenario.h:625
DtCgf::myLuaObjectSerializer
DtLuaObjectSerializer * myLuaObjectSerializer
Definition: cgf.h:1576
DtCgf::myConsoleCommands
DtConsoleCommandOwner * myConsoleCommands
Definition: cgf.h:1741
DtAisDataManager
The DtAisDataManager loads and manages Automatic Identification System (AIS) data, which is used to track and monitor real world ships. This data can be used to create and simulate clutter entities in a simulation.
Definition: aisDataManager.h:34
DtCgf::myFireManager
DtFireManager * myFireManager
Definition: cgf.h:1563
VRF4API_METHOD
#define VRF4API_METHOD
Include this header file to allow for the definition/usage of the ability to mark something as deprec...
Definition: vrf4XAPI.h:23
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::myScriptedObjectsMovementManager
DtScriptedObjectsMovementManager * myScriptedObjectsMovementManager
Definition: cgf.h:1562
DtCgf::myDebugDrawManager
DtDebugDrawManager * myDebugDrawManager
Pointer to the DtDebugDrawManagert.
Definition: cgf.h:1554
DtCgf::myPostScenarioReinitializeCallbacks
DtCallbackList< const DtScenario & > myPostScenarioReinitializeCallbacks
Definition: cgf.h:1651
DtDetonationManager
The DtDetonationManager class exists to centralize the processing of detonation interactions. Components register with the detonation manager, providing a pointer to a DtSimObject as well as the objects global designator, and a damage adjudication function to call when the detonation affects the registered sim object. The detonation manager determines the entity or entities the detonation affects, and notifies them and only them through the supplied callback functions.
Definition: detonationManager.h:50
DtCgf::myTerrainInterface
DtTerrainInterface * myTerrainInterface
The current terrain database.
Definition: cgf.h:1519
DtCgf::mySessionId
DtU32 mySessionId
Session Id.
Definition: cgf.h:1505
DtSimCommandDistributor
Contains the DtSimCommandDistributor class declaration.
Definition: simCommandDistributor.h:24
DtCgf::myDefaultTerrainDirectory
DtFilename myDefaultTerrainDirectory
Terrain database directory, initialized from VRF_defaultTerrainDatabasePath variable. This is the second place to look for a terrain database specified in a scenario file, if we can&#39;t locate it relative to the application path.
Definition: cgf.h:1620
DtCgf::myLoadPluginsIfVersionMismatch
bool myLoadPluginsIfVersionMismatch
Definition: cgf.h:1516
DtCgf::mySimulationAddress
DtSimulationAddress mySimulationAddress
Address for routing interface messages.
Definition: cgf.h:1502
DtScriptedObjectsMovementManager
The scripted objects movement manager contains a list of all scripted movement objects that can be us...
Definition: scriptedObjectsMovementManager.h:22
DtCgf::ActionCategories
std::map< std::string, ActionCategory > ActionCategories
Definition: cgf.h:1746
DtLoadOrderOfBattleHandler
The DtLoadOrderOfBattleHandler will load an order of battle file (oob) and create all the local objec...
Definition: loadOrderOfBattleHandler.h:26
DtLocalObject
A locally simulated VRF object.
Definition: localObject.h:98
DtCgf::myMsdlSidcMappingFile
DtFilename myMsdlSidcMappingFile
MSDL SDIC mapping file to load.
Definition: cgf.h:1629
DtTaskVisualizationPublicationMode
DtTaskVisualizationPublicationMode
Defines how task visualizations will be published.
Definition: scenarioServiceInterface.h:22
Document ID: Generated on Thu Oct 23 22:29:17 EDT 2025 from SVN revision 280951
Copyright © 2005-2024 MAK Technologies. All Rights Reserved (www.mak.com)