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 
17 #include <vlutil/vlFilename.h>
18 #include <vlutil/vlTime.h>
19 #include <vector>
20 #include <vlutil/vlPrint.h>
21 #include <vrfobjcore/translatableStream.h>
22 #include <vrfobjcore/loadScenarioData.h>
23 #include <vrfcore/scenarioServiceInterface.h>
24 #include <readerWriter/noArgumentCallbackList.h>
25 #include "vrfcgf/snapshotManager.h"
26 #include "vrfutil/scenario.h"
27 #include "vrfutil/scenarioExplorer.h"
28 #include "vrfutil/outputLogger.h"
29 #include "vrfutil/rwActivities.h"
30 #include <boost/unordered_set.hpp>
31 #include <vrfutil/vrf4XAPI.h>
32 
33 struct DtLoadScenarioData;
34 class DtOrbatManager;
35 class DtObjectGeometricModelsManager;
36 class DtAdminContent;
37 class DtIfScenarioStatus;
38 class DtDebugDrawManager;
39 class DtCreateObjectServiceInterface;
40 class DtScenarioServiceInterface;
41 class DtSimulationModelSet;
42 class DtSimObjectManager;
43 class DtCommunicationManager;
44 class DtScenario;
45 class DtScenarioExplorer;
46 class DtPhysicalWorld;
47 class DtVrfNavAreaManager;
48 class DtLocalObjectManager;
49 class DtCommModelManager;
50 class DtTerrainInterface;
51 class DtVrfCreator;
52 struct DtInMemorySnapshot;
53 class DtSimManager;
54 class DtSimOperationsInProgressManager;
55 class DtObjectConsoleManager;
56 class DtScriptedTaskManager;
57 class DtScenarioEventManager;
58 class DtSimInternalCommunicationManager;
59 class DtHazardAreaManager;
60 class DtIntelCollectionAreaManager;
61 class DtCompressedFileTransporter;
62 class DtIfSaveScenario;
63 class DtSimulationServices;
64 class DtScriptedObjectsMovementManager;
65 class DtVrfStatusPublisher;
66 class DtEmbeddedEntityInfoManager;
67 class DtDetonationManager;
68 class DtAmmunitionManager;
69 class DtFireManager;
70 class DtVrfObjectPlanAdministrator;
71 class DtGlobalPlanManager;
72 class DtJoyDeviceManager;
73 class DtHostilityManager;
74 class DtEngagementZonesManager;
75 class DtScenarioExtrasMgr;
76 class DtCustomReportManager;
77 class DtStealthCommandsManager;
78 class DtFactoryManager;
79 class DtLoadOrderOfBattleHandler;
80 class DtObjectType;
81 class DtList;
82 class DtSimTask;
83 class DtSetDataRequest;
84 class DtPlan;
85 class DtPaperMapDatabase;
86 class DtMapDatum;
87 class DtVrfParameterDb;
88 class DtSimMessage;
89 class DtResourceMonitor;
90 class DtRadarCoverageMonitor;
91 class DtTerrainProfileRequestManager;
92 class DtVrfPlugin;
93 class DtVrfPluginManager;
94 class DtSimCommand;
95 class DtImportExportScenarioDescriptionManager;
96 class DtLuaObjectSerializer;
97 struct DtOrganizationManagerReadyCallbackInfo;
98 class DtConsoleCommandOwner;
99 class DtSimTerrainRequestManager;
100 class DtTimer;
101 class DtVrfSimOptionsInterface;
102 class DtSpawnSinkManager;
103 class DtSnapshotManager;
104 class DtSimCommandDistributor;
105 class DtApplicationSettings;
106 class DtNetworkInterfaceManager;
107 class DtScenarioLoadManager;
108 class DtManagedObjectListManager;
109 class DtDiGuyCharacterDataManager;
110 class DtSyncMatrixManager;
111 class DtAisDataManager;
112 class DtAdsbDataManager;
113 class DtInfluenceEventDispatcher;
114 struct DtCommunicationManagerPerformanceTimerInformation;
115 
116 namespace makVrfEvents
117 {
118  class DtEvent;
119  class DtEventManager;
120 }
121 
122 namespace makVrf
123 {
124  class DtStateDataManager;
125 }
126 
146 #include "vrfcgf/vrfcgfDefines.h"
147 class DT_DLL_vrfcgf DtCgf
148 {
149 public:
150 
157  DtCgf(const DtSimulationAddress& addr, const DtU32& capabilities = 0xffff);
158 
182  virtual bool init(DtCommunicationManager* conn, DtU32 sessionId = 1, DtVrfCreator* creator = 0, bool checkDataDir = true);
183 
185  virtual ~DtCgf();
186 
188  virtual const DtVrfSimOptionsInterface* simOptions() const;
189 
191  virtual void setSimOptions(const DtVrfSimOptionsInterface&);
192 
195  virtual void tick();
196 
199  virtual void sendFinalStatus(bool sendImmediately = false);
200 
204  virtual bool importScenarioDescriptionFile(const DtFilename& file, const DtString& format,
207  const std::map<std::string, std::string>& importData);
208 
212  virtual DtString exportScenarioDescriptionFile(const DtFilename& file, const DtString& format,
213  const std::map<std::string, std::string>& exportData);
214 
216  virtual void setAppDataDir(const DtString&);
217  virtual DtFilename appDataDir() const;
218 
220  virtual void setSimulationAddress(const DtSimulationAddress&);
221 
223  virtual void setUserDataDir(const DtString&);
224  virtual DtFilename userDataDir() const;
225 
227  virtual void setDataDir(const DtString&);
228  virtual DtFilename dataDir() const;
229 
233  virtual DtFilename sharedDataDir() const;
234  virtual void setSharedDataDir(const DtFilename& path);
235 
236  virtual DtFilename sharedDataRoot() const;
237  virtual void setSharedDataRoot(const DtFilename& path);
238 
239  virtual DtString sharedDataStem() const;
240  virtual void setSharedDataStem(const DtString& path);
241 
243  virtual void setAppIdRangeMax(int);
244  int appIdRangeMax() const;
245 
249  virtual bool loadScenario(const DtFilename& name, int scenarioRunId = 0,
250  bool isOrbatEnabled = false, bool createGlobalEnv = false,
251  bool createGlobalDynamicTerrain = false);
252 
259  virtual bool loadScenario(const DtScenario& scenario, int scenarioRunId = 0,
260  bool isOrbatEnabled = false, bool createGlobalEnv = false,
261  bool createGlobalDynamicTerrain = false);
262 
264  virtual void clearSimulationObjects();
265 
268  virtual bool importScenario(const DtScenario&);
269  virtual bool importScenario(const DtFilename&, int importScenarioFlags = DtDefaultScenarioImportFlags,
270  const DtString& deconflictingName = "");
271 
278  virtual bool newScenario(const DtFilename& dbname =
279  DtFilename::nullFilename(), const DtFilename& simulationModelSet =
280  DtFilename::nullFilename(), bool createGlobalEnv = false,
281  bool createGlobalDynamicTerrain = false);
282 
284  DtIfScenarioStatus* scenarioStatus() { return myScenarioStatus; };
285  const DtIfScenarioStatus* scenarioStatus() const { return myScenarioStatus; };
286 
287  virtual void sendScenarioStatusMessage();
288 
292  virtual bool saveScenario(const DtFilename& savename, bool saveAsSip = false);
293 
297  virtual DtInMemorySnapshotPtr takeSnapshot();
298 
300  virtual bool takeAndStoreSnapshot(bool makeBase);
301 
305  virtual void queueRollbackTo(DtInMemorySnapshotPtr snapshot, int scenarioRunId = 0);
306 
310  virtual void rollbackToSimTime(double simTime);
311 
315  virtual bool saveSimulationObjectGroup(DtFilename saveFolder, const DtString& groupName,
316  int flags, std::set<DtUUID>& uuidsSaved, bool& savAsZipFile);
317 
323  virtual bool createSimulationObjectGroup(const DtString& group, int flags, int force, const DtVector& geocentricLocation,
324  double offsetRotation, bool storedInZipFile = false);
325 
330  virtual void closeScenario(const DtFilename& terrainToOpen = "", bool forceCloseAll = false);
331 
336  virtual bool loadAdditionalObjectParameters(const DtFilename& paramsFileName,
337  const DtReaderWriter::SearchPaths& searchPaths, bool preloadParameters = false);
339 
342  virtual void run();
343 
345  virtual void pause();
346 
348  virtual std::string protocol() const;
349 
355  virtual void rewind(int scenarioRunId = 0);
356 
358  virtual void setRejectMismatchedScenarioMessages(bool);
359  virtual bool rejectMismatchedScenarioMessages() const;
360 
365 
366  virtual void setForceParameterDbReload(bool reload);
367  virtual bool forceParameterDbReload() const;
369 
373 
374  virtual void setEnableResourceMonitor(bool b);
375  virtual bool isResourceMonitorEnabled() const;
377 
379  virtual bool canSimulate() const { return myCanSimulate; };
380 
381  DtCommunicationManager* communicationManager() { return myCommunicationManager; };
382  virtual makVrfEvents::DtEventManager* eventManager();
383 
384  virtual bool canSleep() const;
385 
387  virtual bool aboutToLoadOrRewindScenario() const { return myAboutToLoadOrRewindScenario; };
388 
392  virtual void setSmsValidationEnabled(bool b);
393 
405 
406  virtual const DtFilename& defaultTerrainDirectory();
407  virtual void setDefaultTerrainDirectory(const DtFilename& directory);
409 
410  virtual bool logFrameRateStatistics() const;
411  virtual void setLogFrameRateStatistics(bool yesOrNo);
412 
414  virtual void sendServerLoadMessage(const DtString& error, int level = DtNlWarn);
415 
420 
421  virtual const DtFilename& defaultSimulationModelSetFilename();
422  virtual void setDefaultSimulationModelSetFilename(const DtFilename& filename);
424 
428 
429  virtual const DtFilename& diGuyAnimationsFilename();
430  virtual void setDIGuyAnimationsFilename(const DtFilename& filename);
432 
434 
435  void setClockMode(int clockMode);
437 
439 
440  virtual void setMsdlSidcMappingFile(const DtFilename&);
441  virtual const DtFilename& msdlSidcMappingFile() const;
443 
446  virtual void setCountryCodesMappingFile(const DtFilename&);
447  virtual const DtFilename& countryCodesMappingFile() const;
449 
452  virtual DtSimulationModelSet* defaultModelSet();
454 
458  virtual void deleteObject(const DtUUID& name, bool andRemoveFromOrbat = true) const;
462 
473  virtual DtLocalObject* createWaypoint(const DtVector& localPosition,
474  const DtString& uniqueName = DtString::nullString()) const;
475 
488  virtual DtLocalObject* createRoute(const DtList& vertices,
489  const DtString& uniqueName = DtString::nullString()) const;
490 
502  virtual DtLocalObject* createPhaseLine(
503  const DtVector& dbPoint1,
504  const DtVector& dbPoint2,
505  const DtString& uniqueName = DtString::nullString()) const;
506 
518  virtual DtLocalObject* createControlArea(
519  const DtList& vertices,
520  const DtString& uniqueName = DtString::nullString()) const;
521 
533  virtual DtLocalObject* createObstacle(
534  const DtList& vertices,
535  const DtString& uniqueName = DtString::nullString()) const;
536 
564  virtual DtLocalObject* 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 
604  virtual DtLocalObject* createAggregate(
605  const DtEntityType& aggregateType,
606  DtForceType force,
607  const DtVector& localPosition,
608  DtReal heading,
609  const std::vector<DtUUID>& subordinates = std::vector<DtUUID>(),
610  const DtString& aggregateName = DtString::nullString(),
611  bool addToOrbat = true) const;
612 
624  virtual DtLocalObject* createAggregate(
625  const DtEntityType& aggregateType,
626  DtForceType force,
627  const DtVector& localPosition,
628  DtReal heading,
629  bool createSubordinates,
630  const DtString& aggregateName = DtString::nullString(),
631  bool allowBlocking = true,
632  bool addToOrbat = true) const;
633 
645  virtual bool addSubordinate(DtLocalObject* subordinate,
646  DtLocalObject* aggregate);
647 
663  virtual bool removeSubordinate(DtLocalObject* subordinate,
664  DtLocalObject* aggregate);
666 
670  virtual void assignTask(const DtLocalObject* entity, const DtSimTask& task);
679 
688  virtual void sendSetDataRequest(const DtLocalObject* entity,
689  const DtSetDataRequest& request);
690 
692  virtual void assignPlanByUUID(const DtUUID&, const DtPlan& plan, bool sendPlan = false);
693 
698  virtual void abandonPlan(const DtLocalObject* entity);
699 
704  virtual void restartPlan(const DtLocalObject* entity);
706 
710  virtual void logObjectConsoleToFile(DtLocalObject* object,
715  DtFilename filename = DtFilename::nullFilename());
716 
718  virtual void stopLoggingObjectConsoleToFile(DtLocalObject* object);
719 
723  virtual void setObjectConsoleNotificationLevel(DtLocalObject* object,
724  DtNotifyLevelType level);
726 
733  virtual bool reuseEntityIdentifiersOnScenarioLoad() const;
734  virtual void setReuseEntityIdentifiersOnScenarioLoad(bool);
736 
740  virtual bool loadAllNavigationDataOnTerrainLoad() const;
741  virtual void setLoadAllNavigationDataOnTerrainLoad(bool);
743 
746  virtual void setTaskVisualizationPublicationMode(DtTaskVisualizationPublicationMode mode);
747  virtual DtTaskVisualizationPublicationMode taskVisualizationPublicationMode() const;
749 
753  virtual void setUseDrawControlForTaskVisualizations(bool);
754  virtual bool useDrawControlForTaskVisualizations() const;
756 
757 
758  //-------------------------------------------------------
760  //-------------------------------------------------------
761 
764  virtual DtSimManager* simManager() const;
765  virtual DtSimulationServices* simulationServices() const;
766 
768  virtual DtImportExportScenarioDescriptionManager* importExportScenarioDescriptionManager() const;
769 
772  virtual DtResourceMonitor* resourceMonitor() const;
773 
775  virtual DtRadarCoverageMonitor* radarCoverageMonitor() const;
776 
778  virtual DtTerrainProfileRequestManager* terrainProfileRequestManager() const;
779 
782  virtual DtFactoryManager* factoryManager() const;
783 
785  virtual DtSnapshotManager* snapshotManager() const;
786 
787  virtual DtAisDataManager* aisDataManager() const;
788  virtual DtAdsbDataManager* adsbDataManager() const;
789 
793  virtual DtLocalObjectManager* localObjectManager() const;
794 
797  virtual DtSimObjectManager* simObjectManager() const;
798 
801  virtual DtDebugDrawManager* debugDrawManager() const;
802 
804  virtual DtScriptedTaskManager* scriptedTaskManager() const;
805 
807  virtual DtScenarioEventManager* scenarioEventManager() const;
808 
810  virtual DtHazardAreaManager* hazardAreaManager() const;
811 
813  virtual DtIntelCollectionAreaManager* intelCollectionAreaManager() const;
814 
816  virtual DtScriptedObjectsMovementManager* ScriptedObjectsMovementManager() const;
817 
820  virtual DtDetonationManager* detonationManager() const;
821 
824  virtual DtAmmunitionManager* ammunitionManager() const;
825 
828  virtual DtFireManager* fireManager() const;
829 
834  virtual DtScenarioExtrasMgr* scenarioExtrasMgr() const;
835 
837  virtual DtVrfParameterDb* parameterDatabase() const;
838 
840  virtual DtGlobalPlanManager* globalPlanManager();
841 
843  virtual DtStealthCommandsManager* stealthCommandsManager();
844 
847 
848  virtual DtTerrainInterface* terrainInterface();
849  virtual const DtTerrainInterface* terrainInterface() const;
851 
854 
855  virtual DtPhysicalWorld* physicalWorld();
856  virtual const DtPhysicalWorld* physicalWorld() const;
858 
860  virtual void setPhysicalWorld(DtPhysicalWorld* newPhysicalWorld);
861 
862  virtual DtVrfNavAreaManager* vrfNavAreaManager();
863  virtual const DtVrfNavAreaManager* vrfNavAreaManager() const;
864 
865  virtual void setVrfNavAreaManager(DtVrfNavAreaManager* newVrfNavAreaManager);
866 
867  virtual DtSpawnSinkManager* spawnSinkManager();
868  virtual const DtSpawnSinkManager* spawnSinkManager() const;
869 
871 
872  virtual DtCommModelManager* commModelManager();
873  virtual const DtCommModelManager* commModelManager() const;
875 
876  virtual const DtDiGuyCharacterDataManager* diGuyCharacterManager() const;
877 
879 
880  virtual DtSimTerrainRequestManager* simTerrainRequestManager();
881  virtual const DtSimTerrainRequestManager* simTerrainRequestManager() const;
883 
885  virtual DtSimCommandDistributor* simCommandDistributor();
886 
888  virtual DtScenario* scenario() const;
889 
892  virtual const DtSimulationAddress& simulationAddress() const;
893 
899  virtual int sessionId() const;
900 
906 
907  virtual DtU32 scenarioCapabilities() const;
908  virtual void setScenarioCapabilities(DtU32 v);
909  virtual void setScenarioCapability(DtU32 v, bool);
911 
913  virtual void setTimeMultiplier(double);
914 
917 
918  virtual DtString applicationType() const;
919  virtual void setApplicationType(const DtString& type);
921 
924  virtual DtVrfStatusPublisher* statusPublisher() const;
925 
929  virtual void useMapDatum(const DtMapDatum& mapDatum);
930 
932  virtual void setParameterDbLoaded(bool flag);
933 
939  virtual void setDefaultParameterDbDirectory(const DtFilename& filename);
940 
942  virtual DtFilename objectGroupsRoot() const;
943 
948  virtual bool reinitializeScenario();
949 
950  virtual void setFullyLoadTerrain(bool yesOrNo);
951  virtual bool fullyLoadTerrain() const;
952 
956 
957  virtual void setAssertOnBlockingTerrainCalls(bool b);
958  virtual bool assertOnBlockingTerrainCalls() const;
960 
964 
965  virtual void setMetocEnable(bool b);
966  virtual bool metocEnable() const;
968 
969  //-------------------------------------------------------
971  //-------------------------------------------------------
972 
975  virtual void addPluginToLoad(const DtString&);
976 
979  virtual void setLoadPluginsIfVersionMismatch(bool);
980  virtual bool loadPluginsIfVersionMismatch() const;
981 
983  virtual bool createAndInitPluginManager(DtVrfCreator* creator);
984 
987  virtual void initializePluginCommandLineArguments(DtApplicationSettings& appInitializer);
988 
990 
991  DtVrfCreator* vrfCreator();
992  const DtVrfCreator* vrfCreator() const;
994 
998 
999  virtual void addPreLoadTerrainCallback(
1000  DtCallbackList<const DtFilename&>::DtCallbackFunctionType fcn, void* usrData);
1001  virtual void removePreLoadTerrainCallback(
1002  DtCallbackList<const DtFilename&>::DtCallbackFunctionType fcn, void* usrData);
1004 
1008 
1009  virtual void addPostLoadTerrainCallback(
1010  DtCallbackList<const DtFilename&>::DtCallbackFunctionType fcn, void* usrData);
1011  virtual void removePostLoadTerrainCallback(
1012  DtCallbackList<const DtFilename&>::DtCallbackFunctionType fcn, void* usrData);
1014 
1017  virtual void runForDuration(double);
1018 
1020  virtual void stopSimulationDurationTimer();
1021 
1023  static void runDurationCompleteCallback(void*);
1024  virtual void processRunDurationComplete();
1025 
1027  virtual void setPublishingGlobalEnvironment(bool);
1028 
1032 
1033  virtual void addPreLoadScenarioCallback(
1034  DtCallbackList<DtScenario&>::DtCallbackFunctionType fcn, void* usrData);
1035  virtual void removePreLoadScenarioCallback(
1036  DtCallbackList<DtScenario&>::DtCallbackFunctionType fcn, void* usrData);
1038 
1040 
1041  virtual void addPreScenarioReinitializeCallback(
1042  DtCallbackList<DtScenario&>::DtCallbackFunctionType fcn, void* usrData);
1043  virtual void removePreScenarioReinitializeCallback(
1044  DtCallbackList<DtScenario&>::DtCallbackFunctionType fcn, void* usrData);
1046 
1049 
1050  virtual void addPostScenarioReinitializeCallback(
1051  DtCallbackList<const DtScenario&>::DtCallbackFunctionType fcn, void* usrData);
1052  virtual void removePostScenarioReinitializeCallback(
1053  DtCallbackList<const DtScenario&>::DtCallbackFunctionType fcn, void* usrData);
1055 
1057 
1058  virtual void addPreCreateSimulationObjectGroupCallback(
1059  DtCallbackList<DtScenario&>::DtCallbackFunctionType fcn, void* usrData);
1060  virtual void removePreCreateSimulationObjectGroupCallback(
1061  DtCallbackList<DtScenario&>::DtCallbackFunctionType fcn, void* usrData);
1063 
1067 
1068  virtual void addPostLoadScenarioCallback(
1069  DtCallbackList<const DtScenario&>::DtCallbackFunctionType fcn, void* usrData);
1070  virtual void removePostLoadScenarioCallback(
1071  DtCallbackList<const DtScenario&>::DtCallbackFunctionType fcn, void* usrData);
1073 
1075 
1076  virtual void addPostCreateSimulationObjectGroupCallback(
1077  DtCallbackList<const DtScenario&>::DtCallbackFunctionType fcn, void* usrData);
1078  virtual void removePostCreateSimulationObjectGroupCallback(
1079  DtCallbackList<const DtScenario&>::DtCallbackFunctionType fcn, void* usrData);
1081 
1083 
1084  virtual void addPreImportScenarioCallback(
1085  DtCallbackList<DtScenario&>::DtCallbackFunctionType fcn, void* usrData);
1086  virtual void removePreImportScenarioCallback(
1087  DtCallbackList<DtScenario&>::DtCallbackFunctionType fcn, void* usrData);
1089 
1091 
1092  virtual void addPostImportScenarioCallback(
1093  DtCallbackList<const DtScenario&>::DtCallbackFunctionType fcn, void* usrData);
1094  virtual void removePostImportScenarioCallback(
1095  DtCallbackList<const DtScenario&>::DtCallbackFunctionType fcn, void* usrData);
1097 
1100 
1101  virtual void addPreSaveScenarioCallback(
1102  DtCallbackList<DtScenario&>::DtCallbackFunctionType fcn, void* usrData);
1103  virtual void removePreSaveScenarioCallback(
1104  DtCallbackList<DtScenario&>::DtCallbackFunctionType fcn, void* usrData);
1106 
1109 
1110  virtual void addPostSaveScenarioCallback(
1111  DtCallbackList<const DtScenario&>::DtCallbackFunctionType fcn, void* usrData);
1112  virtual void removePostSaveScenarioCallback(
1113  DtCallbackList<const DtScenario&>::DtCallbackFunctionType fcn, void* usrData);
1115 
1118 
1119  virtual void addPreCloseScenarioCallback(
1120  DtNoArgumentCallbackList::DtCallbackFunctionType fcn, void* usrData);
1121  virtual void removePreCloseScenarioCallback(
1122  DtNoArgumentCallbackList::DtCallbackFunctionType fcn, void* usrData);
1124 
1127 
1128  virtual void addCgfAboutToBeDestroyedCallback(
1129  DtNoArgumentCallbackList::DtCallbackFunctionType fcn, void* usrData);
1130  virtual void removeCgfAboutToBeDestroyedCallback(
1131  DtNoArgumentCallbackList::DtCallbackFunctionType fcn, void* usrData);
1133 
1136 
1137  virtual void addPostCloseScenarioCallback(
1138  DtNoArgumentCallbackList::DtCallbackFunctionType fcn, void* usrData);
1139  virtual void removePostCloseScenarioCallback(
1140  DtNoArgumentCallbackList::DtCallbackFunctionType fcn, void* usrData);
1142 
1144 
1145  virtual void addPreSaveSimulationObjectGroupsCallback(
1146  DtCallbackList<DtScenario&>::DtCallbackFunctionType fcn, void* usrData);
1147  virtual void removePreSaveSimulationObjectGroupsCallback(
1148  DtCallbackList<DtScenario&>::DtCallbackFunctionType fcn, void* usrData);
1150 
1152 
1153  virtual void addPostSaveSimulationObjectGroupsCallback(
1154  DtCallbackList<const DtScenario&>::DtCallbackFunctionType fcn, void* usrData);
1155  virtual void removePostSaveSimulationObjectGroupsCallback(
1156  DtCallbackList<const DtScenario&>::DtCallbackFunctionType fcn, void* usrData);
1158 
1161 
1162  virtual void addScenarioPauseCallback(
1163  DtNoArgumentCallbackList::DtCallbackFunctionType fcn, void* usrData);
1164  virtual void removeScenarioPauseCallback(
1165  DtNoArgumentCallbackList::DtCallbackFunctionType fcn, void* usrData);
1167 
1170 
1171  virtual void addScenarioRunCallback(
1172  DtNoArgumentCallbackList::DtCallbackFunctionType fcn, void* usrData);
1173  virtual void removeScenarioRunCallback(
1174  DtNoArgumentCallbackList::DtCallbackFunctionType fcn, void* usrData);
1176 
1181 
1182  virtual void addPreScenarioRewindCallback(
1183  DtNoArgumentCallbackList::DtCallbackFunctionType fcn, void* usrData);
1184  virtual void removePreScenarioRewindCallback(
1185  DtNoArgumentCallbackList::DtCallbackFunctionType fcn, void* usrData);
1187 
1190 
1191  virtual void addPostScenarioRewindCallback(
1192  DtNoArgumentCallbackList::DtCallbackFunctionType fcn, void* usrData);
1193  virtual void removePostScenarioRewindCallback(
1194  DtNoArgumentCallbackList::DtCallbackFunctionType fcn, void* usrData);
1196 
1199 
1200  virtual void addPostTickCallback(
1201  DtNoArgumentCallbackList::DtCallbackFunctionType fcn, void* usrData);
1202  virtual void removePostTickCallback(
1203  DtNoArgumentCallbackList::DtCallbackFunctionType fcn, void* usrData);
1205 
1207 
1208  virtual void setTimeToQuit(bool);
1209  virtual bool timeToQuit() const;
1211 
1223  virtual void setFrameRateMode(const DtString& mode, DtReal deltaTime = -1);
1224 
1228  virtual bool executeSimCommand(const DtSimCommand& simCommand);
1229 
1232  virtual void unloadTerrain();
1233 
1235  virtual bool isOrbatEnabled() const;
1236 
1238  virtual double timeScale() const;
1239 
1240  virtual void setRunInTimeManagementMode(bool);
1241 
1243  virtual DtSyncMatrixManager* syncMatrixManager();
1244 
1245 public:
1246 
1250  static void objectParametersOpCallback(DtSimMessage* msg, void* usr);
1251 
1252 protected:
1254  static void scenarioDescriptionCallback(DtSimMessage*, void* usr);
1255  virtual void processScenarioDescription(DtSimMessage*);
1256 
1258  static void setScenarioFilenameCallback(DtSimMessage*, void* usr);
1259  virtual void processSetScenarioFilename(DtSimMessage*);
1260 
1262  static void setRunDurationCallback(DtSimMessage*, void* usr);
1263  virtual void processSetRunDuration(DtSimMessage*);
1264 
1266  static void actionCategoriesRequestCallback(DtSimMessage* msg, void* usr);
1267  virtual void processActionCategoriesRequest(DtSimMessage* msg);
1268 
1270  static void scenarioStatusRequestCallback(DtSimMessage* msg, void* usr);
1271  virtual void processScenarioStatusRequest(DtSimMessage* msg);
1272 
1275  virtual bool beginFrame(DtCommunicationManagerPerformanceTimerInformation* info = nullptr);
1276  virtual bool advanceFrame();
1277 
1278 private:
1280  DtCgf(const DtCgf& original);
1282  DtCgf& operator=(const DtCgf& original);
1283 
1284 protected:
1287  virtual DtFilename spawnManagerTemplateFile(const DtScenarioExplorer&) const;
1288 
1290  virtual void loadAllPlugins();
1291 
1293  virtual bool loadComponentAttachmentTable(const DtFilename& filename);
1299  virtual bool loadTerrain(const DtFilename& filename);
1300 
1304  virtual DtFilename findTerrainFile(const DtFilename& startFile, const std::vector<DtFilename>& searchPaths,
1305  const std::string& extension) const;
1306 
1308  virtual bool loadOrderOfBattle(const DtScenario& scenario, DtLoadScenarioData&);
1309  virtual bool loadOrderOfBattle(const DtInMemorySnapshot::OOB&);
1310 
1312  virtual bool writeOrderOfBattle(const DtScenario& scenario) const;
1313  virtual bool writeOrderOfBattle(DtInMemorySnapshot::OOB&) const;
1314 
1316  virtual bool loadScenarioScripts(const DtFilename& filename);
1317  virtual bool loadScenarioScriptsFromZipFile(const DtFilename& scenarioZipFile, const DtFilename& filename);
1318  virtual bool loadScenarioScripts(const std::string& buffer);
1319 
1321  virtual bool loadOrbat(const DtFilename& filename, DtOrbatManager* intoOm = 0, bool clearBeforeLoading = true);
1322  virtual bool loadOrbatFromZipFile(const DtFilename& scenarioZipFile, const DtFilename& filename, DtOrbatManager* intoOm = 0, bool clearBeforeLoading = true);
1323  virtual bool loadOrbat(const std::string& buffer, DtOrbatManager* intoOm = 0, bool clearBeforeLoading = true);
1324 
1327  virtual void prepareForScenarioReinitialize();
1328 
1330  virtual bool isScenarioReinitializing() const;
1331 
1335  virtual bool loadParameterDb(const DtFilename& filename,
1336  const DtReaderWriter::SearchPaths& searchPaths, bool clearLoadedObjects = true, bool preloadParameters = false);
1337 
1340  virtual bool loadObjectParametersDBFile(const DtFilename& opdFile,
1341  const DtReaderWriter::SearchPaths& searchPaths, bool clearLoadedObjects = true, bool preloadParameters = false);
1342 
1346  virtual bool loadPhysicalWorldFile(const DtFilename& file, bool force = false);
1347 
1351  virtual bool loadDetonationParametersFile(const DtFilename& file, bool force = false);
1352 
1353  virtual bool loadTerrainDeformationParametersFile(const DtFilename& file, bool force = false);
1354 
1358  virtual bool loadAmmunitionParametersFile(const DtFilename& file, bool force = false);
1359 
1361  virtual bool loadPlans(const DtFilename& filename);
1362  virtual bool loadPlansFromZipFile(const DtFilename& scenarioZipFile, const DtFilename& filename);
1363  virtual bool loadPlans(const std::string& buffer);
1364 
1366  virtual bool loadGlobalPlans(const DtFilename& filename);
1367  virtual bool loadGlobalPlansFromZipFile(const DtFilename& scenarioZipFile, const DtFilename& filename);
1368 
1370  virtual void loadHostilityAndExtras(const DtScenarioExplorer& se);
1371  virtual void loadHostilityAndExtrasFromZipFile(const DtFilename& scenarioZipFile, const DtScenarioExplorer& se);
1372  virtual void loadHostilityAndExtras(const std::string& buffer);
1373 
1376  virtual void loadActivities(const DtScenarioExplorer&);
1377 
1380  virtual void loadModelSetFiles(const DtScenarioExplorer&);
1381 
1384  virtual void loadActionCategories(const DtFilename& f);
1385 
1386  virtual bool loadForceHostility(const DtFilename& filename, bool clear = true);
1387  virtual bool loadForceHostilityFromZipFile(const DtFilename& scenarioZipFile, const DtFilename& filename, bool clear = true);
1388 
1389  virtual bool loadScenarioExtras(const DtFilename& filename);
1390  virtual bool loadScenarioExtrasFromZipFile(const DtFilename&, const DtFilename& filename);
1391  virtual bool loadScenarioExtras(const std::string& buffer);
1392 
1395  virtual void processObjectParametersOp(DtSimMessage * msg);
1396 
1398  virtual void createAndInitScenarioLoadManager();
1399 
1402  virtual void emptyParametersDB();
1403 
1405  virtual void setAutoReorganization(bool onOff);
1406 
1410  virtual DtVrfPlugin* loadPlugin(const DtString&);
1411 
1414  virtual bool setupCommModelsForScenario(const DtScenarioExplorer& e);
1415 
1419  virtual void updateReadyStatus();
1420 
1423 
1424  static void simCommandCallback(DtSimMessage* msg, void* usr);
1425  virtual void processSimCommand(DtSimMessage* msg);
1427 
1431 
1432  static void deferredLoadScenarioCallback(void * data);
1433  virtual void processDeferredLoadScenario();
1434 
1437  virtual void processLoadScenario(const DtScenario* = 0, const DtInMemorySnapshotPtr = 0);
1439 
1441 
1442  static void deferredReinitializeScenarioCallback(void * data);
1443  virtual void processDeferredReinitializeScenario();
1445 
1450 
1451  static void deferredRollbackCallback(void * data);
1453  virtual bool processDeferredRollback(DtInMemorySnapshotPtr snapshot);
1455 
1457  virtual bool rollbackTo(DtInMemorySnapshotPtr chkp, int scenarioRunId = 0);
1458 
1462 
1463  static void deferredImportScenarioCallback(void * data);
1464  virtual void processDeferredImportScenario();
1466 
1470 
1471  static void deferredRewindCallback(void * data);
1472  virtual void processDeferredRewind();
1474 
1477  virtual void clearAllSimulationModelSetInformation();
1478 
1480  virtual void initializeCgfConsoleCommands();
1481 
1482  virtual void processCloseScenarioEvent(const makVrfEvents::DtEvent&);
1483  virtual void processLoadScenarioEvent(const makVrfEvents::DtEvent&);
1484 
1486  virtual bool createDIGuyCharacterManager(const DtFilename & diGuyAnimationsFile);
1487 
1488 protected:
1489  DtVrfSimOptionsInterface* mySimOptions;
1490 
1492  DtSimulationAddress mySimulationAddress;
1493 
1495  DtU32 mySessionId;
1496 
1498  bool myOK;
1499 
1501  bool myTimeToQuit;
1502 
1504  DtVrfPluginManager* myPluginManager;
1505  std::vector<DtString> myPluginsToLoad;
1506  bool myLoadPluginsIfVersionMismatch;
1507 
1509  DtTerrainInterface* myTerrainInterface;
1510 
1512  DtPhysicalWorld* myPhysicalWorld;
1513 
1514  DtVrfNavAreaManager* myVrfNavAreaManager;
1515 
1516  DtSpawnSinkManager* mySpawnSinkManager;
1517 
1518  DtCommModelManager* myCommModelManager;
1519 
1520  DtSimTerrainRequestManager* mySimTerrainRequestManager;
1521 
1523  DtCommunicationManager* myCommunicationManager;
1524 
1526  DtSimManager* mySimManager;
1527 
1529  DtCreateObjectServiceInterface* myCreateObjectService;
1530 
1532  DtScenarioServiceInterface* myScenarioService;
1533 
1535  DtScenario* myScenario;
1536 
1538  DtVrfStatusPublisher* myStatusPublisher;
1539 
1541  DtLocalObjectManager* myObjectManager;
1542 
1544  DtDebugDrawManager* myDebugDrawManager;
1545 
1546  DtDetonationManager* myDetonationManager;
1547  DtAmmunitionManager* myAmmunitionManager;
1548  DtScriptedTaskManager* myScriptedTaskManager;
1549  DtScenarioEventManager* myScenarioEventManager;
1550  DtHazardAreaManager* myHazardAreaManager;
1551  DtIntelCollectionAreaManager* myIntelCollectionAreaManager;
1552  DtScriptedObjectsMovementManager* myScriptedObjectsMovementManager;
1553  DtFireManager* myFireManager;
1554  DtObjectConsoleManager* myObjectConsoleManager;
1555  DtManagedObjectListManager* myFilteredObjectListManager;
1556  DtOrbatManager* myOrbatManager;
1557  DtObjectGeometricModelsManager* myObjectModelsManager;
1558  DtVrfObjectPlanAdministrator* myPlanAdministrator;
1559  DtSimInternalCommunicationManager* mySimInternalCommunicationManager;
1560  DtDiGuyCharacterDataManager * myCharacterMgr;
1561  DtAisDataManager* myAisDataManager;
1562  DtSimOperationsInProgressManager* mySimOperationsInProgressManager = nullptr;
1563  DtAdsbDataManager* myAdsbDataManager;
1564  bool myCreatedCharacterManager;
1565 
1566  DtLuaObjectSerializer* myLuaObjectSerializer;
1567 
1569  DtResourceMonitor* myResourceMonitor;
1570 
1572  DtRadarCoverageMonitor* myRadarCoverageMonitor;
1573 
1575  DtTerrainProfileRequestManager* myTerrainProfileRequestManager;
1576 
1578  DtVrfParameterDb* myParameterDatabase;
1579 
1581  DtEmbeddedEntityInfoManager* myEmbeddedEntityInfoManager;
1582 
1584  bool myForceParameterDbReload;
1585 
1586  DtGlobalPlanManager* myGlobalPlanManager;
1587 
1588  DtHostilityManager* myHostilityManager;
1589  DtEngagementZonesManager* myEngagementZonesManager;
1590 
1591  DtScenarioExtrasMgr* myScenarioExtrasManager;
1592 
1594  DtFactoryManager* myFactoryManager;
1595 
1597  DtStealthCommandsManager* myStealthCommandsManager;
1598 
1599  DtSimCommandDistributor* mySimCommandDistributor;
1600 
1605  DtFilename myVrfTerrainPathDirectory;
1606 
1610  DtFilename myDefaultTerrainDirectory;
1611 
1613  DtFilename myDefaultSimulationModelSetFilename;
1614 
1616  DtFilename myDIGuyAnimationsFilename;
1617 
1619  DtFilename myMsdlSidcMappingFile;
1620 
1622  DtFilename myCountryCodesMappingFile;
1623 
1626  bool myParameterDbLoaded;
1627 
1629  DtFilename myCurrentParameterDatabaseFilename;
1630 
1634  DtFilename myDefaultParameterDbDirectory;
1635 
1636  DtCallbackList<const DtFilename&> myPreLoadTerrainCallbacks;
1637  DtCallbackList<const DtFilename&> myPostLoadTerrainCallbacks;
1638  DtCallbackList<DtScenario&> myPreLoadScenarioCallbacks;
1639  DtCallbackList<const DtScenario&> myPostLoadScenarioCallbacks;
1640  DtCallbackList<DtScenario&> myPreScenarioReinitializeCallbacks;
1641  DtCallbackList<const DtScenario&> myPostScenarioReinitializeCallbacks;
1642  DtCallbackList<DtScenario&> myPreCreateSimulationObjectGroupCallbacks;
1643  DtCallbackList<const DtScenario&> myPostCreateSimulationObjectGroupCallbacks;
1644  DtCallbackList<DtScenario&> myPreImportScenarioCallbacks;
1645  DtCallbackList<const DtScenario&> myPostImportScenarioCallbacks;
1646  DtCallbackList<DtScenario&> myPreSaveScenarioCallbacks;
1647  DtCallbackList<const DtScenario&> myPostSaveScenarioCallbacks;
1648 
1649  DtCallbackList<DtScenario&> myPreSaveSimulationObjectGroupsCallbacks;
1650  DtCallbackList<const DtScenario&> myPostSaveSimulationObjectGroupsCallbacks;
1651 
1652  DtNoArgumentCallbackList myPreCloseScenarioCallbacks;
1653  DtNoArgumentCallbackList myPostCloseScenarioCallbacks;
1654  DtNoArgumentCallbackList myScenarioRunCallbacks;
1655  DtNoArgumentCallbackList myScenarioPauseCallbacks;
1656  DtNoArgumentCallbackList myPreScenarioRewindCallbacks;
1657  DtNoArgumentCallbackList myPostScenarioRewindCallbacks;
1658  DtNoArgumentCallbackList myPostTickCallbacks;
1659  DtNoArgumentCallbackList myCgfAboutToBeDestroyedCallbacks;
1660 
1661  DtSyncMatrixManager* mySyncMatrixManager;
1662  DtInfluenceEventDispatcher* myInfluenceEventDispatcher;
1663 
1668  void setVrfCreator(DtVrfCreator* creator);
1670 
1672 
1673  bool ownVrfCreator() const;
1674  void setOwnVrfCreator(bool yesOrNo);
1676 
1678  virtual bool differingModelSets(DtScenario*) const;
1679 
1680  virtual void simControlEvent(const makVrfEvents::DtEvent&);
1681 
1682  virtual void clearObjectsAwaitingDiscovery();
1683  virtual void processObjectsAwaitingDiscovery();
1684 
1685  virtual void terrainPaging(bool);
1686  virtual void jobQueueStatusChanged(bool);
1687 
1688 protected:
1691  bool myOwnVrfCreatorFlag;
1692  DtVrfCreator* myVrfCreator;
1693 
1695  bool myFullyLoadTerrain;
1696 
1700  bool myAssertOnBlockingTerrainCalls;
1701 
1704  DtSimulationModelSet* myDefaultModelSet;
1705 
1709  DtScenario myScenarioToLoad;
1710 
1711  bool myCreateGlobalEnvironment;
1712  bool myCreateGlobalDynamicTerrain;
1713  bool myCreatedGlobalEnvironment;
1714  bool myCreatedGlobalDynamicTerrain;
1715 
1720  bool myWasPaused;
1721 
1723  DtImportExportScenarioDescriptionManager* myImportScenarioDescriptionManager;
1724 
1725  DtConsoleCommandOwner* myConsoleCommands;
1726 
1729  typedef std::pair<std::string, bool> ActionCategory;
1730  typedef std::map<std::string, ActionCategory> ActionCategories;
1731  ActionCategories myActionCategories;
1732 
1734  DtIfScenarioStatus* myScenarioStatus;
1735 
1736  bool myPublishingGlobalEnvironment;
1737  bool myAboutToLoadOrRewindScenario;
1738  bool myReinitializingScenario;
1739 
1740  bool myMetocEnabled;
1741 
1742  DtTaskVisualizationPublicationMode myTaskVisualizationPublicationMode;
1743  bool myUseDrawControlForTaskVisualizations;
1744 
1745  bool myReuseEntityIdentifiersOnScenarioLoad;
1746 
1747  bool myLoadAllNavigationDataOnTerrainLoad;
1748 
1749  DtRwActivities myActivities;
1750  bool mySmsValidationEnabled;
1751  DtSnapshotManager* mySnapshotManager;
1752  DtSimObjectManager* mySimObjectManager;
1753 
1754  std::vector<DtFilename> myObjectGroupsRoot;
1755 
1756  struct SimulationObjectGroupInformation
1757  {
1758  DtlObjPtr planArgs;
1759  DtlObjPtr oobArgs;
1760  };
1761 
1762  typedef std::map<DtString, SimulationObjectGroupInformation> StoredSimulationObjectGroupInformation;
1763  StoredSimulationObjectGroupInformation myStoredSimulationObjectGroupInformation;
1764 
1765  bool myCanSimulate;
1766  bool myIsLoaded;
1767  bool myHasModelSetInformationLoadedAfterClose;
1768  int myReloadDelay;
1769  bool myRejectMismatchedScenarioMessages;
1770  DtU32 myScenarioCapabilities;
1771  int myAppIdRangeMax;
1772 
1773  std::set<DtFilename> myLoadedModelSets;
1774 
1775  DtInMemorySnapshotPtr myQueuedRollback;
1776  int myQueuedRollbackScenarioRunId;
1777 
1778  DtScenarioLoadManager* myScenarioLoadManager;
1779 
1780  typedef std::vector<DtLoadOrderOfBattleHandler*>SimulationObjectGroupsToBeCreated;
1781  SimulationObjectGroupsToBeCreated mySimulationObjectGroupsToBeCreated;
1782 
1783 public:
1786  VRF4API_METHOD DtLocalObjectManager* vrfObjectManager() { return myObjectManager; };
1787  VRF4API_METHOD DtCommunicationManager* exerciseConn() { return myCommunicationManager; };
1789 
1790 };
1791 
DtUUID
UUID is a unique ID wrapper class.
Definition: uuid.h:59
DtCgf::myObjectConsoleManager
DtObjectConsoleManager * myObjectConsoleManager
Definition: cgf.h:1554
DtCgf::myIsLoaded
bool myIsLoaded
Definition: cgf.h:1766
DtCgf::myObjectModelsManager
DtObjectGeometricModelsManager * myObjectModelsManager
Definition: cgf.h:1557
DtCgf::myCommunicationManager
DtCommunicationManager * myCommunicationManager
The current exercise connection.
Definition: cgf.h:1523
DtCgf::mySimManager
DtSimManager * mySimManager
Pointer to the DtSimManager.
Definition: cgf.h:1526
DtCgf::myCreateGlobalEnvironment
bool myCreateGlobalEnvironment
Definition: cgf.h:1711
DtCgf::myPublishingGlobalEnvironment
bool myPublishingGlobalEnvironment
Definition: cgf.h:1736
DtCgf::myScenarioStatus
DtIfScenarioStatus * myScenarioStatus
Scenario status message to be sent out upon request.
Definition: cgf.h:1734
DtLocalObjectManager
class DtLocalObjectManager:
Definition: localObjectManager.h:151
DtCgf::communicationManager
DtCommunicationManager * communicationManager()
Definition: cgf.h:381
DtSimTerrainRequestManager
Definition: simTerrainRequestManager.h:132
DtResourceMonitor
This class will be responsible for handling requests to return resources for a particular entity (or ...
Definition: resourceMonitor.h:54
DtCgf::myAmmunitionManager
DtAmmunitionManager * myAmmunitionManager
Definition: cgf.h:1547
DtCgf::myGlobalPlanManager
DtGlobalPlanManager * myGlobalPlanManager
Definition: cgf.h:1586
DtCgf::myUseDrawControlForTaskVisualizations
bool myUseDrawControlForTaskVisualizations
Definition: cgf.h:1743
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:1548
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:1563
DtCgf::myStealthCommandsManager
DtStealthCommandsManager * myStealthCommandsManager
Stealth commands manager.
Definition: cgf.h:1597
DtVrfParameterDb
Instances of DtVrfParameterDb are the database of DtVrfObjectParameters objects used in the construct...
Definition: vrfParameterDb.h:40
DtCgf::myScenarioPauseCallbacks
DtNoArgumentCallbackList myScenarioPauseCallbacks
Definition: cgf.h:1655
DtCgf::myPreLoadScenarioCallbacks
DtCallbackList< DtScenario & > myPreLoadScenarioCallbacks
Definition: cgf.h:1638
DtCgf::myCreateObjectService
DtCreateObjectServiceInterface * myCreateObjectService
Pointer to the create object service.
Definition: cgf.h:1529
DtCgf::myAisDataManager
DtAisDataManager * myAisDataManager
Definition: cgf.h:1561
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:1642
DtCgf::myOK
bool myOK
Flag indicating whether we have been successfully initialized.
Definition: cgf.h:1498
DtCgf::myPreCloseScenarioCallbacks
DtNoArgumentCallbackList myPreCloseScenarioCallbacks
Definition: cgf.h:1652
DtCgf::mySimCommandDistributor
DtSimCommandDistributor * mySimCommandDistributor
Definition: cgf.h:1599
DtCgf::myPhysicalWorld
DtPhysicalWorld * myPhysicalWorld
The current physical world.
Definition: cgf.h:1512
DtCgf::myDefaultSimulationModelSetFilename
DtFilename myDefaultSimulationModelSetFilename
Default simulation model set file to load.
Definition: cgf.h:1613
DtCgf::scenarioStatus
const DtIfScenarioStatus * scenarioStatus() const
Imports the specified scenario description file into the current scenario.
Definition: cgf.h:285
DtCgf::myFullyLoadTerrain
bool myFullyLoadTerrain
Flag indicating whether to fully load terrain subpages for paged terrain.
Definition: cgf.h:1695
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:1729
DtCgf::myPreScenarioReinitializeCallbacks
DtCallbackList< DtScenario & > myPreScenarioReinitializeCallbacks
Definition: cgf.h:1640
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:1591
DtScenarioExplorer
class DtScenarioExplorer:
Definition: scenarioExplorer.h:26
DtCgf::mySmsValidationEnabled
bool mySmsValidationEnabled
Definition: cgf.h:1750
DtCgf::myPostCreateSimulationObjectGroupCallbacks
DtCallbackList< const DtScenario & > myPostCreateSimulationObjectGroupCallbacks
Definition: cgf.h:1643
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:1535
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:1759
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:1754
DtRadarCoverageMonitor
Definition: radarCoverageMonitor.h:32
DtCgf::myVrfTerrainPathDirectory
DtFilename myVrfTerrainPathDirectory
Terrain data directory from environment variable VRF_TERRAIN_PATH. If specified, this is the 3rd plac...
Definition: cgf.h:1605
DtCgf::myTimeToQuit
bool myTimeToQuit
Flag indicating whether or not the app should quit.
Definition: cgf.h:1501
DtTerrainProfileRequestManager
Definition: terrainProfileRequestManager.h:31
DtCgf::myPostCloseScenarioCallbacks
DtNoArgumentCallbackList myPostCloseScenarioCallbacks
Definition: cgf.h:1653
DtCgf::myPostTickCallbacks
DtNoArgumentCallbackList myPostTickCallbacks
Definition: cgf.h:1658
DtAdsbDataManager
The DtAdsbDataManager loads and manages Automatic Dependent Surveillance - Broadcast (ADS-B) data...
Definition: adsbDataManager.h:40
DtCgf::myResourceMonitor
DtResourceMonitor * myResourceMonitor
Pointer to the DtResourceMonitor.
Definition: cgf.h:1569
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:1712
DtCgf::myCanSimulate
bool myCanSimulate
Definition: cgf.h:1765
DtCgf::myVrfNavAreaManager
DtVrfNavAreaManager * myVrfNavAreaManager
Definition: cgf.h:1514
DtScenarioServiceInterface
Service interface for checking and altering scenario wide properties.
Definition: scenarioServiceInterface.h:29
DtLuaObjectSerializer
Definition: luaObjectSerializer.h:24
DtCgf::SimulationObjectGroupsToBeCreated
std::vector< DtLoadOrderOfBattleHandler * > SimulationObjectGroupsToBeCreated
Definition: cgf.h:1780
DtCgf::myHasModelSetInformationLoadedAfterClose
bool myHasModelSetInformationLoadedAfterClose
Definition: cgf.h:1767
DtCgf::myQueuedRollback
DtInMemorySnapshotPtr myQueuedRollback
Definition: cgf.h:1775
DtCgf::myAppIdRangeMax
int myAppIdRangeMax
Definition: cgf.h:1771
DtInfluenceEventDispatcher
Definition: influenceEventDispatcher.h:25
DtFireManager
The DtFireManager class exists to centralize the process of sending and receiving of fire interaction...
Definition: fireManager.h:42
DtCgf::myCommModelManager
DtCommModelManager * myCommModelManager
Definition: cgf.h:1518
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:1714
DtIfScenarioStatus
Definition: ifScenarioStatus.h:28
DtCgf::mySimOptions
DtVrfSimOptionsInterface * mySimOptions
Definition: cgf.h:1489
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:37
DtCgf::myLoadAllNavigationDataOnTerrainLoad
bool myLoadAllNavigationDataOnTerrainLoad
Definition: cgf.h:1747
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:1745
DtCgf::myStatusPublisher
DtVrfStatusPublisher * myStatusPublisher
Pointer to the DtStatusPublisher.
Definition: cgf.h:1538
DtCgf::myTaskVisualizationPublicationMode
DtTaskVisualizationPublicationMode myTaskVisualizationPublicationMode
Definition: cgf.h:1742
DtCgf::myDIGuyAnimationsFilename
DtFilename myDIGuyAnimationsFilename
DI_Guy animation configuration file to load.
Definition: cgf.h:1616
DtCgf::myRejectMismatchedScenarioMessages
bool myRejectMismatchedScenarioMessages
Definition: cgf.h:1769
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:1787
DtCgf::myParameterDatabase
DtVrfParameterDb * myParameterDatabase
Pointer to the DtVrfParameterDb.
Definition: cgf.h:1578
DtCgf::myObjectManager
DtLocalObjectManager * myObjectManager
Pointer to the DtLocalObjectManager.
Definition: cgf.h:1541
DtCgf::myPreSaveScenarioCallbacks
DtCallbackList< DtScenario & > myPreSaveScenarioCallbacks
Definition: cgf.h:1646
DtObjectGeometricModelsManager
Manages loading and destruction of the geometric models for objects. Will reference the object parame...
Definition: objectGeometricModelsManager.h:30
DtCgf::myPreLoadTerrainCallbacks
DtCallbackList< const DtFilename & > myPreLoadTerrainCallbacks
Definition: cgf.h:1636
DtInMemorySnapshot::OOB
std::vector< std::string * > OOB
Definition: snapshotManager.h:44
DtCgf::StoredSimulationObjectGroupInformation
std::map< DtString, SimulationObjectGroupInformation > StoredSimulationObjectGroupInformation
Definition: cgf.h:1762
DtCommunicationManagerPerformanceTimerInformation
Definition: communicationManager.h:35
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:1581
DtCgf::myImportScenarioDescriptionManager
DtImportExportScenarioDescriptionManager * myImportScenarioDescriptionManager
The scenario description manager used to import scenario description files.
Definition: cgf.h:1723
DtCgf::myCreatedGlobalEnvironment
bool myCreatedGlobalEnvironment
Definition: cgf.h:1713
DtPhysicalWorld
The DtPhysicalWorld is the primary interface to and manager of all of the &quot;physical&quot; aspects of the s...
Definition: physicalWorld.h:102
DtCgf::myDetonationManager
DtDetonationManager * myDetonationManager
Definition: cgf.h:1546
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:1622
DtCgf::myDefaultParameterDbDirectory
DtFilename myDefaultParameterDbDirectory
Default parameter database directory to search in when parameter database being specified is not an a...
Definition: cgf.h:1634
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:1549
DtCgf::myScenarioService
DtScenarioServiceInterface * myScenarioService
Pointer to the scenario object service.
Definition: cgf.h:1532
DtCgf::myTerrainProfileRequestManager
DtTerrainProfileRequestManager * myTerrainProfileRequestManager
Pointer to the DtTerrainProfileRequestManager.
Definition: cgf.h:1575
DtVrfNavAreaManager
The DtVrfNavAreaManager manages all of the nav areas currently created in the sim.
Definition: vrfNavAreaManager.h:52
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:1786
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:51
DtCgf::myPostLoadTerrainCallbacks
DtCallbackList< const DtFilename & > myPostLoadTerrainCallbacks
Definition: cgf.h:1637
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:1763
DtCgf::myScenarioRunCallbacks
DtNoArgumentCallbackList myScenarioRunCallbacks
Definition: cgf.h:1654
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
dataDir
std::string dataDir()
DtCgf::myPluginManager
DtVrfPluginManager * myPluginManager
The current plugin manager.
Definition: cgf.h:1504
DtReaderWriter::SearchPaths
std::vector< DtFilename > SearchPaths
Definition: readerWriter.h:92
DtCgf::myQueuedRollbackScenarioRunId
int myQueuedRollbackScenarioRunId
Definition: cgf.h:1776
DtCgf::myCreatedCharacterManager
bool myCreatedCharacterManager
Definition: cgf.h:1564
DtCgf::mySimulationObjectGroupsToBeCreated
SimulationObjectGroupsToBeCreated mySimulationObjectGroupsToBeCreated
Definition: cgf.h:1781
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:1720
DtCallbackList
Definition: noArgumentCallbackList.h:90
DtCgf::myIntelCollectionAreaManager
DtIntelCollectionAreaManager * myIntelCollectionAreaManager
Definition: cgf.h:1551
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:1700
DtCgf::myPreSaveSimulationObjectGroupsCallbacks
DtCallbackList< DtScenario & > myPreSaveSimulationObjectGroupsCallbacks
Definition: cgf.h:1649
DtCgf::mySyncMatrixManager
DtSyncMatrixManager * mySyncMatrixManager
Definition: cgf.h:1661
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:1650
DtCgf::myDefaultModelSet
DtSimulationModelSet * myDefaultModelSet
Default simulation model set. This is created when the default simulation model set filename is set o...
Definition: cgf.h:1704
DtCgf::myActivities
DtRwActivities myActivities
Definition: cgf.h:1749
DtVrfPluginManager
Definition: vrfPluginManager.h:73
DtCgf::myScenarioLoadManager
DtScenarioLoadManager * myScenarioLoadManager
Definition: cgf.h:1778
DtCgf::myRadarCoverageMonitor
DtRadarCoverageMonitor * myRadarCoverageMonitor
Pointer to the DtRadarCoverageMonitor.
Definition: cgf.h:1572
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:74
DtTerrainInterface
DtTerrainInterface allows access to common terrain calls without having to know the terrain implement...
Definition: terrainInterface.h:100
DtCgf::myFactoryManager
DtFactoryManager * myFactoryManager
Pointer to the DtFactoryManager.
Definition: cgf.h:1594
DtCgf::myActionCategories
ActionCategories myActionCategories
Definition: cgf.h:1731
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:1709
DtCgf::myHazardAreaManager
DtHazardAreaManager * myHazardAreaManager
Definition: cgf.h:1550
DtCgf::myPluginsToLoad
std::vector< DtString > myPluginsToLoad
Definition: cgf.h:1505
DtCgf::myPostSaveScenarioCallbacks
DtCallbackList< const DtScenario & > myPostSaveScenarioCallbacks
Definition: cgf.h:1647
DtCgf::myReinitializingScenario
bool myReinitializingScenario
Definition: cgf.h:1738
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:1752
DtCgf::mySimInternalCommunicationManager
DtSimInternalCommunicationManager * mySimInternalCommunicationManager
Definition: cgf.h:1559
DtPlan
class DtPlan:
Definition: plan.h:92
DtCgf::myInfluenceEventDispatcher
DtInfluenceEventDispatcher * myInfluenceEventDispatcher
Definition: cgf.h:1662
DtCgf::myOrbatManager
DtOrbatManager * myOrbatManager
Definition: cgf.h:1556
DtCgf::myCgfAboutToBeDestroyedCallbacks
DtNoArgumentCallbackList myCgfAboutToBeDestroyedCallbacks
Definition: cgf.h:1659
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:1644
translatableStream.h
Contains the DtTranslatableStream class declaration.
DtCgf::myLoadedModelSets
std::set< DtFilename > myLoadedModelSets
Definition: cgf.h:1773
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:45
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:95
DtCgf::myPostScenarioRewindCallbacks
DtNoArgumentCallbackList myPostScenarioRewindCallbacks
Definition: cgf.h:1657
DtCgf::myAboutToLoadOrRewindScenario
bool myAboutToLoadOrRewindScenario
Definition: cgf.h:1737
DtSimObjectManager
This class is the central access point for all current-frame state of all objects in the simulation i...
Definition: simObjectManager.h:42
DtCgf::myForceParameterDbReload
bool myForceParameterDbReload
Forces loadScenario to re-load the parameter database.
Definition: cgf.h:1584
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:1751
DtCgf::myEngagementZonesManager
DtEngagementZonesManager * myEngagementZonesManager
Definition: cgf.h:1589
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:387
DtCgf::myPostImportScenarioCallbacks
DtCallbackList< const DtScenario & > myPostImportScenarioCallbacks
Definition: cgf.h:1645
DtCgf::myMetocEnabled
bool myMetocEnabled
Definition: cgf.h:1740
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:1558
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:1520
DtCgf::myPostLoadScenarioCallbacks
DtCallbackList< const DtScenario & > myPostLoadScenarioCallbacks
Definition: cgf.h:1639
DtCgf::myReloadDelay
int myReloadDelay
Definition: cgf.h:1768
DtCgf::myVrfCreator
DtVrfCreator * myVrfCreator
Definition: cgf.h:1692
DtCgf::myCharacterMgr
DtDiGuyCharacterDataManager * myCharacterMgr
Definition: cgf.h:1560
DtCgf::myPreScenarioRewindCallbacks
DtNoArgumentCallbackList myPreScenarioRewindCallbacks
Definition: cgf.h:1656
DtCgf::canSimulate
virtual bool canSimulate() const
Whether or not the cgf is ready to simulate.
Definition: cgf.h:379
DtCgf::myCurrentParameterDatabaseFilename
DtFilename myCurrentParameterDatabaseFilename
Filename of currently loaded parameter database.
Definition: cgf.h:1629
DtSimManager
The simulation engine is controlled by a single,top-level class called the Simulation Manager...
Definition: simManager.h:124
DtSnapshotManager
Definition: snapshotManager.h:57
DtCgf::myFilteredObjectListManager
DtManagedObjectListManager * myFilteredObjectListManager
Definition: cgf.h:1555
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:1758
DtCgf::myScenarioCapabilities
DtU32 myScenarioCapabilities
Definition: cgf.h:1770
DtCgf::myOwnVrfCreatorFlag
bool myOwnVrfCreatorFlag
These are essentially cached from the init call. This is necessary as the load terrain.
Definition: cgf.h:1691
DtCgf::scenarioStatus
DtIfScenarioStatus * scenarioStatus()
Returns the scenario status object.
Definition: cgf.h:284
DtCgf::myParameterDbLoaded
bool myParameterDbLoaded
Set to true if parameter database has been loaded via loadParameterDatabase call. If you load a param...
Definition: cgf.h:1626
DtCgf::myHostilityManager
DtHostilityManager * myHostilityManager
Definition: cgf.h:1588
DtGlobalPlanManager
The global plan manager maintains the list of &quot;Global Plans.&quot; These are plans that are not specific t...
Definition: globalPlanManager.h:45
DtCgf::mySpawnSinkManager
DtSpawnSinkManager * mySpawnSinkManager
Definition: cgf.h:1516
DtCgf
The top level class of a VR-Forces Simulation Engine, representing a Computer Generated Forces instan...
Definition: cgf.h:147
DtDefaultScenarioImportFlags
const int DtDefaultScenarioImportFlags
Default is not not import duplicate UUIDs. This will allow multiple scenarios that have the same base...
Definition: scenario.h:624
DtCgf::myLuaObjectSerializer
DtLuaObjectSerializer * myLuaObjectSerializer
Definition: cgf.h:1566
DtCgf::myConsoleCommands
DtConsoleCommandOwner * myConsoleCommands
Definition: cgf.h:1725
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:33
DtCgf::myFireManager
DtFireManager * myFireManager
Definition: cgf.h:1553
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:22
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:1552
DtCgf::myDebugDrawManager
DtDebugDrawManager * myDebugDrawManager
Pointer to the DtDebugDrawManagert.
Definition: cgf.h:1544
DtCgf::myPostScenarioReinitializeCallbacks
DtCallbackList< const DtScenario & > myPostScenarioReinitializeCallbacks
Definition: cgf.h:1641
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:1509
DtCgf::mySessionId
DtU32 mySessionId
Session Id.
Definition: cgf.h:1495
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:1610
DtCgf::myLoadPluginsIfVersionMismatch
bool myLoadPluginsIfVersionMismatch
Definition: cgf.h:1506
DtCgf::mySimulationAddress
DtSimulationAddress mySimulationAddress
Address for routing interface messages.
Definition: cgf.h:1492
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:1730
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. Holds all internal and external data for the object, and provides access to both the current frame and next frame state data for the object. All current frame data is read-only, and next-frame data can be written to. No thread safety guarantees are made on this object during the simulation frame and it should only be accessed by the thread that is simulating the object.
Definition: localObject.h:86
DtCgf::myMsdlSidcMappingFile
DtFilename myMsdlSidcMappingFile
MSDL SDIC mapping file to load.
Definition: cgf.h:1619
DtTaskVisualizationPublicationMode
DtTaskVisualizationPublicationMode
Defines how task visualizations will be published.
Definition: scenarioServiceInterface.h:21
Document ID: Generated on Tue Sep 24 19:28:17 EDT 2024 from SVN revision 269799
Copyright © 2005-2024 MAK Technologies. All Rights Reserved (www.mak.com)