VR-Forces 5.0.3 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 DtObjectConsoleManager;
55 class DtScriptedTaskManager;
56 class DtScenarioEventManager;
57 class DtSimInternalCommunicationManager;
58 class DtHazardAreaManager;
59 class DtIntelCollectionAreaManager;
60 class DtCompressedFileTransporter;
61 class DtIfSaveScenario;
62 class DtSimulationServices;
63 class DtScriptedObjectsMovementManager;
64 class DtVrfStatusPublisher;
65 class DtEmbeddedEntityInfoManager;
66 class DtDetonationManager;
67 class DtAmmunitionManager;
68 class DtFireManager;
69 class DtVrfObjectPlanAdministrator;
70 class DtGlobalPlanManager;
71 class DtJoyDeviceManager;
72 class DtHostilityManager;
73 class DtEngagementZonesManager;
74 class DtScenarioExtrasMgr;
75 class DtCustomReportManager;
76 class DtStealthCommandsManager;
77 class DtFactoryManager;
78 class DtLoadOrderOfBattleHandler;
79 class DtObjectType;
80 class DtList;
81 class DtSimTask;
82 class DtSetDataRequest;
83 class DtPlan;
84 class DtPaperMapDatabase;
85 class DtMapDatum;
86 class DtVrfParameterDb;
87 class DtSimMessage;
88 class DtResourceMonitor;
89 class DtRadarCoverageMonitor;
90 class DtTerrainProfileRequestManager;
91 class DtVrfPlugin;
92 class DtVrfPluginManager;
93 class DtSimCommand;
94 class DtImportExportScenarioDescriptionManager;
95 class DtLuaObjectSerializer;
96 struct DtOrganizationManagerReadyCallbackInfo;
97 class DtConsoleCommandOwner;
98 class DtSimTerrainRequestManager;
99 class DtTimer;
100 class DtVrfSimOptionsInterface;
101 class DtSpawnSinkManager;
102 class DtSnapshotManager;
103 class DtSimCommandDistributor;
104 class DtApplicationSettings;
105 class DtNetworkInterfaceManager;
106 class DtScenarioLoadManager;
107 class DtManagedObjectListManager;
108 class DtDiGuyCharacterDataManager;
109 class DtSyncMatrixManager;
110 class DtInfluenceEventDispatcher;
111 struct DtCommunicationManagerPerformanceTimerInformation;
112 
113 namespace makVrfEvents
114 {
115  class DtEvent;
116  class DtEventManager;
117 }
118 
119 namespace makVrf
120 {
121  class DtStateDataManager;
122 }
123 
143 #include "vrfcgf/vrfcgfDefines.h"
144 class DT_DLL_vrfcgf DtCgf
145 {
146 public:
147 
154  DtCgf(const DtSimulationAddress& addr, const DtU32& capabilities = 0xffff);
155 
179  virtual bool init(DtCommunicationManager* conn, DtU32 sessionId = 1, DtVrfCreator* creator = 0, bool checkDataDir = true);
180 
182  virtual ~DtCgf();
183 
185  virtual const DtVrfSimOptionsInterface* simOptions() const;
186 
188  virtual void setSimOptions(const DtVrfSimOptionsInterface&);
189 
192  virtual void tick();
193 
196  virtual void sendFinalStatus();
197 
201  virtual bool importScenarioDescriptionFile(const DtFilename& file, const DtString& format,
204  const std::map<std::string, std::string>& importData);
205 
209  virtual DtString exportScenarioDescriptionFile(const DtFilename& file, const DtString& format,
210  const std::map<std::string, std::string>& exportData);
211 
213  virtual void setAppDataDir(const DtString&);
214  virtual DtFilename appDataDir() const;
215 
217  virtual void setSimulationAddress(const DtSimulationAddress&);
218 
220  virtual void setUserDataDir(const DtString&);
221  virtual DtFilename userDataDir() const;
222 
224  virtual void setDataDir(const DtString&);
225  virtual DtFilename dataDir() const;
226 
230  virtual DtFilename sharedDataDir() const;
231  virtual void setSharedDataDir(const DtFilename& path);
232 
233  virtual DtFilename sharedDataRoot() const;
234  virtual void setSharedDataRoot(const DtFilename& path);
235 
236  virtual DtString sharedDataStem() const;
237  virtual void setSharedDataStem(const DtString& path);
238 
240  virtual void setAppIdRangeMax(int);
241  int appIdRangeMax() const;
242 
246  virtual bool loadScenario(const DtFilename& name, int scenarioRunId = 0,
247  bool isOrbatEnabled = false, bool createGlobalEnv = false,
248  bool createGlobalDynamicTerrain = false);
249 
256  virtual bool loadScenario(const DtScenario& scenario, int scenarioRunId = 0,
257  bool isOrbatEnabled = false, bool createGlobalEnv = false,
258  bool createGlobalDynamicTerrain = false);
259 
261  virtual void queueRollbackTo(DtInMemorySnapshot* chkp, int scenarioRunId = 0);
262 
264  virtual bool rollbackTo(DtInMemorySnapshot* chkp, int scenarioRunId = 0);
265 
267  virtual void clearSimulationObjects();
268 
271  virtual bool importScenario(const DtScenario&);
272  virtual bool importScenario(const DtFilename&);
273 
280  virtual bool newScenario(const DtFilename& dbname =
281  DtFilename::nullFilename(), const DtFilename& simulationModelSet =
282  DtFilename::nullFilename());
283 
285  DtIfScenarioStatus* scenarioStatus() { return myScenarioStatus; };
286  const DtIfScenarioStatus* scenarioStatus() const { return myScenarioStatus; };
287 
288  virtual void sendScenarioStatusMessage();
289 
293  virtual bool saveScenario(const DtFilename& savename, bool saveAsSip = false);
294 
296  virtual bool takeSnapshot(DtInMemorySnapshot*);
297 
300  virtual void rollbackToSimTime(double simTime);
301 
304  virtual void takeSnapshot(bool makeBase);
305 
308  virtual bool saveSnapshot(const DtFilename& saveFolder,
309  DtCompressedFileTransporter&, DtIfSaveScenario* msg, const DtSimulationAddress& requestor);
310 
314  virtual bool saveSimulationObjectGroup(DtFilename saveFolder, const DtString& groupName,
315  int flags, std::set<DtUUID>& uuidsSaved, bool& savAsZipFile);
316 
322  virtual bool createSimulationObjectGroup(const DtString& group, int flags, int force, const DtVector& geocentricLocation,
323  double offsetRotation, bool storedInZipFile = false);
324 
329  virtual void closeScenario(const DtFilename& terrainToOpen = "", bool forceCloseAll = false);
330 
335  virtual bool loadAdditionalObjectParameters(const DtFilename& paramsFileName,
336  const DtReaderWriter::SearchPaths& searchPaths, bool preloadParameters = false);
338 
341  virtual void run();
342 
344  virtual void pause();
345 
347  virtual std::string protocol() const;
348 
354  virtual void rewind(int scenarioRunId = 0);
355 
357  virtual void setRejectMismatchedScenarioMessages(bool);
358  virtual bool rejectMismatchedScenarioMessages() const;
359 
364 
365  virtual void setForceParameterDbReload(bool reload);
366  virtual bool forceParameterDbReload() const;
368 
372 
373  virtual void setEnableResourceMonitor(bool b);
374  virtual bool isResourceMonitorEnabled() const;
376 
378  virtual bool canSimulate() const { return myCanSimulate; };
379 
380  DtCommunicationManager* communicationManager() { return myCommunicationManager; };
381  virtual makVrfEvents::DtEventManager* eventManager();
382 
383  virtual bool canSleep() const;
384 
386  virtual bool aboutToLoadOrRewindScenario() const { return myAboutToLoadOrRewindScenario; };
387 
391  virtual void setSmsValidationEnabled(bool b);
392 
404 
405  virtual const DtFilename& defaultTerrainDirectory();
406  virtual void setDefaultTerrainDirectory(const DtFilename& directory);
408 
409  virtual bool logFrameRateStatistics() const;
410  virtual void setLogFrameRateStatistics(bool yesOrNo);
411 
413  virtual void sendServerLoadMessage(const DtString& error, int level = DtNlWarn);
414 
419 
420  virtual const DtFilename& defaultSimulationModelSetFilename();
421  virtual void setDefaultSimulationModelSetFilename(const DtFilename& filename);
423 
427 
428  virtual const DtFilename& diGuyAnimationsFilename();
429  virtual void setDIGuyAnimationsFilename(const DtFilename& filename);
431 
433 
434  void setClockMode(int clockMode);
436 
438 
439  virtual void setMsdlSidcMappingFile(const DtFilename&);
440  virtual const DtFilename& msdlSidcMappingFile() const;
442 
445  virtual void setCountryCodesMappingFile(const DtFilename&);
446  virtual const DtFilename& countryCodesMappingFile() const;
448 
451  virtual DtSimulationModelSet* defaultModelSet();
453 
457  virtual void deleteObject(const DtUUID& name, bool andRemoveFromOrbat = true) const;
461 
472  virtual DtLocalObject* createWaypoint(const DtVector& localPosition,
473  const DtString& uniqueName = DtString::nullString()) const;
474 
487  virtual DtLocalObject* createRoute(const DtList& vertices,
488  const DtString& uniqueName = DtString::nullString()) const;
489 
501  virtual DtLocalObject* createPhaseLine(
502  const DtVector& dbPoint1,
503  const DtVector& dbPoint2,
504  const DtString& uniqueName = DtString::nullString()) const;
505 
517  virtual DtLocalObject* createControlArea(
518  const DtList& vertices,
519  const DtString& uniqueName = DtString::nullString()) const;
520 
532  virtual DtLocalObject* createObstacle(
533  const DtList& vertices,
534  const DtString& uniqueName = DtString::nullString()) const;
535 
563  virtual DtLocalObject* createEntity(
564  const DtEntityType& entityType,
565  DtForceType force,
566  const DtVector& dbPosition,
567  DtReal heading,
568  const DtString& entityName = DtString::nullString(),
569  bool allowBlocking = true,
570  std::list<DtAdminContent*>* initialAdminContent = 0,
571  bool addToOrbat = true) const;
572 
573 
603  virtual DtLocalObject* createAggregate(
604  const DtEntityType& aggregateType,
605  DtForceType force,
606  const DtVector& localPosition,
607  DtReal heading,
608  const std::vector<DtUUID>& subordinates = std::vector<DtUUID>(),
609  const DtString& aggregateName = DtString::nullString(),
610  bool addToOrbat = true) const;
611 
623  virtual DtLocalObject* createAggregate(
624  const DtEntityType& aggregateType,
625  DtForceType force,
626  const DtVector& localPosition,
627  DtReal heading,
628  bool createSubordinates,
629  const DtString& aggregateName = DtString::nullString(),
630  bool allowBlocking = true,
631  bool addToOrbat = true) const;
632 
644  virtual bool addSubordinate(DtLocalObject* subordinate,
645  DtLocalObject* aggregate);
646 
662  virtual bool removeSubordinate(DtLocalObject* subordinate,
663  DtLocalObject* aggregate);
665 
669  virtual void assignTask(const DtLocalObject* entity, const DtSimTask& task);
678 
687  virtual void sendSetDataRequest(const DtLocalObject* entity,
688  const DtSetDataRequest& request);
689 
691  virtual void assignPlanByUUID(const DtUUID&, const DtPlan& plan);
692 
697  virtual void abandonPlan(const DtLocalObject* entity);
698 
703  virtual void restartPlan(const DtLocalObject* entity);
705 
709  virtual void logObjectConsoleToFile(DtLocalObject* object,
714  DtFilename filename = DtFilename::nullFilename());
715 
717  virtual void stopLoggingObjectConsoleToFile(DtLocalObject* object);
718 
722  virtual void setObjectConsoleNotificationLevel(DtLocalObject* object,
723  DtNotifyLevelType level);
725 
732  virtual bool reuseEntityIdentifiersOnScenarioLoad() const;
733  virtual void setReuseEntityIdentifiersOnScenarioLoad(bool);
735 
738  virtual void setTaskVisualizationPublicationMode(DtTaskVisualizationPublicationMode mode);
739  virtual DtTaskVisualizationPublicationMode taskVisualizationPublicationMode() const;
741 
745  virtual void setUseDrawControlForTaskVisualizations(bool);
746  virtual bool useDrawControlForTaskVisualizations() const;
748 
749 
750  //-------------------------------------------------------
752  //-------------------------------------------------------
753 
756  virtual DtSimManager* simManager() const;
757  virtual DtSimulationServices* simulationServices() const;
758 
760  virtual DtImportExportScenarioDescriptionManager* importExportScenarioDescriptionManager() const;
761 
764  virtual DtResourceMonitor* resourceMonitor() const;
765 
767  virtual DtRadarCoverageMonitor* radarCoverageMonitor() const;
768 
770  virtual DtTerrainProfileRequestManager* terrainProfileRequestManager() const;
771 
774  virtual DtFactoryManager* factoryManager() const;
775 
777  virtual DtSnapshotManager* snapshotManager() const;
778 
782  virtual DtLocalObjectManager* localObjectManager() const;
783 
786  virtual DtSimObjectManager* simObjectManager() const;
787 
790  virtual DtDebugDrawManager* debugDrawManager() const;
791 
793  virtual DtScriptedTaskManager* scriptedTaskManager() const;
794 
796  virtual DtScenarioEventManager* scenarioEventManager() const;
797 
799  virtual DtHazardAreaManager* hazardAreaManager() const;
800 
802  virtual DtIntelCollectionAreaManager* intelCollectionAreaManager() const;
803 
805  virtual DtScriptedObjectsMovementManager* ScriptedObjectsMovementManager() const;
806 
809  virtual DtDetonationManager* detonationManager() const;
810 
813  virtual DtAmmunitionManager* ammunitionManager() const;
814 
817  virtual DtFireManager* fireManager() const;
818 
823  virtual DtScenarioExtrasMgr* scenarioExtrasMgr() const;
824 
826  virtual DtVrfParameterDb* parameterDatabase() const;
827 
829  virtual DtGlobalPlanManager* globalPlanManager();
830 
832  virtual DtStealthCommandsManager* stealthCommandsManager();
833 
836 
837  virtual DtTerrainInterface* terrainInterface();
838  virtual const DtTerrainInterface* terrainInterface() const;
840 
843 
844  virtual DtPhysicalWorld* physicalWorld();
845  virtual const DtPhysicalWorld* physicalWorld() const;
847 
849  virtual void setPhysicalWorld(DtPhysicalWorld* newPhysicalWorld);
850 
851  virtual DtVrfNavAreaManager* vrfNavAreaManager();
852  virtual const DtVrfNavAreaManager* vrfNavAreaManager() const;
853 
854  virtual void setVrfNavAreaManager(DtVrfNavAreaManager* newVrfNavAreaManager);
855 
856  virtual DtSpawnSinkManager* spawnSinkManager();
857  virtual const DtSpawnSinkManager* spawnSinkManager() const;
858 
860 
861  virtual DtCommModelManager* commModelManager();
862  virtual const DtCommModelManager* commModelManager() const;
864 
865  virtual const DtDiGuyCharacterDataManager* diGuyCharacterManager() const;
866 
868 
869  virtual DtSimTerrainRequestManager* simTerrainRequestManager();
870  virtual const DtSimTerrainRequestManager* simTerrainRequestManager() const;
872 
874  virtual DtSimCommandDistributor* simCommandDistributor();
875 
877  virtual DtScenario* scenario() const;
878 
881  virtual const DtSimulationAddress& simulationAddress() const;
882 
888  virtual int sessionId() const;
889 
895 
896  virtual DtU32 scenarioCapabilities() const;
897  virtual void setScenarioCapabilities(DtU32 v);
898  virtual void setScenarioCapability(DtU32 v, bool);
900 
902  virtual void setTimeMultiplier(double);
903 
906 
907  virtual DtString applicationType() const;
908  virtual void setApplicationType(const DtString& type);
910 
913  virtual DtVrfStatusPublisher* statusPublisher() const;
914 
918  virtual void useMapDatum(const DtMapDatum& mapDatum);
919 
921  virtual void setParameterDbLoaded(bool flag);
922 
928  virtual void setDefaultParameterDbDirectory(const DtFilename& filename);
929 
931  virtual DtFilename objectGroupsRoot() const;
932 
937  virtual bool reinitializeScenario();
938 
939  virtual void setFullyLoadTerrain(bool yesOrNo);
940  virtual bool fullyLoadTerrain() const;
941 
945 
946  virtual void setAssertOnBlockingTerrainCalls(bool b);
947  virtual bool assertOnBlockingTerrainCalls() const;
949 
953 
954  virtual void setMetocEnable(bool b);
955  virtual bool metocEnable() const;
957 
958  //-------------------------------------------------------
960  //-------------------------------------------------------
961 
964  virtual void addPluginToLoad(const DtString&);
965 
968  virtual void setLoadPluginsIfVersionMismatch(bool);
969  virtual bool loadPluginsIfVersionMismatch() const;
970 
972  virtual bool createAndInitPluginManager(DtVrfCreator* creator);
973 
976  virtual void initializePluginCommandLineArguments(DtApplicationSettings& appInitializer);
977 
979 
980  DtVrfCreator* vrfCreator();
981  const DtVrfCreator* vrfCreator() const;
983 
987 
988  virtual void addPreLoadTerrainCallback(
989  DtCallbackList<const DtFilename&>::DtCallbackFunctionType fcn, void* usrData);
990  virtual void removePreLoadTerrainCallback(
991  DtCallbackList<const DtFilename&>::DtCallbackFunctionType fcn, void* usrData);
993 
997 
998  virtual void addPostLoadTerrainCallback(
999  DtCallbackList<const DtFilename&>::DtCallbackFunctionType fcn, void* usrData);
1000  virtual void removePostLoadTerrainCallback(
1001  DtCallbackList<const DtFilename&>::DtCallbackFunctionType fcn, void* usrData);
1003 
1006  virtual void runForDuration(double);
1007 
1009  virtual void stopSimulationDurationTimer();
1010 
1012  static void runDurationCompleteCallback(void*);
1013  virtual void processRunDurationComplete();
1014 
1016  virtual void setPublishingGlobalEnvironment(bool);
1017 
1021 
1022  virtual void addPreLoadScenarioCallback(
1023  DtCallbackList<DtScenario&>::DtCallbackFunctionType fcn, void* usrData);
1024  virtual void removePreLoadScenarioCallback(
1025  DtCallbackList<DtScenario&>::DtCallbackFunctionType fcn, void* usrData);
1027 
1029 
1030  virtual void addPreScenarioReinitializeCallback(
1031  DtCallbackList<DtScenario&>::DtCallbackFunctionType fcn, void* usrData);
1032  virtual void removePreScenarioReinitializeCallback(
1033  DtCallbackList<DtScenario&>::DtCallbackFunctionType fcn, void* usrData);
1035 
1038 
1039  virtual void addPostScenarioReinitializeCallback(
1040  DtCallbackList<const DtScenario&>::DtCallbackFunctionType fcn, void* usrData);
1041  virtual void removePostScenarioReinitializeCallback(
1042  DtCallbackList<const DtScenario&>::DtCallbackFunctionType fcn, void* usrData);
1044 
1046 
1047  virtual void addPreCreateSimulationObjectGroupCallback(
1048  DtCallbackList<DtScenario&>::DtCallbackFunctionType fcn, void* usrData);
1049  virtual void removePreCreateSimulationObjectGroupCallback(
1050  DtCallbackList<DtScenario&>::DtCallbackFunctionType fcn, void* usrData);
1052 
1056 
1057  virtual void addPostLoadScenarioCallback(
1058  DtCallbackList<const DtScenario&>::DtCallbackFunctionType fcn, void* usrData);
1059  virtual void removePostLoadScenarioCallback(
1060  DtCallbackList<const DtScenario&>::DtCallbackFunctionType fcn, void* usrData);
1062 
1064 
1065  virtual void addPostCreateSimulationObjectGroupCallback(
1066  DtCallbackList<const DtScenario&>::DtCallbackFunctionType fcn, void* usrData);
1067  virtual void removePostCreateSimulationObjectGroupCallback(
1068  DtCallbackList<const DtScenario&>::DtCallbackFunctionType fcn, void* usrData);
1070 
1072 
1073  virtual void addPreImportScenarioCallback(
1074  DtCallbackList<DtScenario&>::DtCallbackFunctionType fcn, void* usrData);
1075  virtual void removePreImportScenarioCallback(
1076  DtCallbackList<DtScenario&>::DtCallbackFunctionType fcn, void* usrData);
1078 
1080 
1081  virtual void addPostImportScenarioCallback(
1082  DtCallbackList<const DtScenario&>::DtCallbackFunctionType fcn, void* usrData);
1083  virtual void removePostImportScenarioCallback(
1084  DtCallbackList<const DtScenario&>::DtCallbackFunctionType fcn, void* usrData);
1086 
1089 
1090  virtual void addPreSaveScenarioCallback(
1091  DtCallbackList<DtScenario&>::DtCallbackFunctionType fcn, void* usrData);
1092  virtual void removePreSaveScenarioCallback(
1093  DtCallbackList<DtScenario&>::DtCallbackFunctionType fcn, void* usrData);
1095 
1098 
1099  virtual void addPostSaveScenarioCallback(
1100  DtCallbackList<const DtScenario&>::DtCallbackFunctionType fcn, void* usrData);
1101  virtual void removePostSaveScenarioCallback(
1102  DtCallbackList<const DtScenario&>::DtCallbackFunctionType fcn, void* usrData);
1104 
1107 
1108  virtual void addPreCloseScenarioCallback(
1109  DtNoArgumentCallbackList::DtCallbackFunctionType fcn, void* usrData);
1110  virtual void removePreCloseScenarioCallback(
1111  DtNoArgumentCallbackList::DtCallbackFunctionType fcn, void* usrData);
1113 
1116 
1117  virtual void addPostCloseScenarioCallback(
1118  DtNoArgumentCallbackList::DtCallbackFunctionType fcn, void* usrData);
1119  virtual void removePostCloseScenarioCallback(
1120  DtNoArgumentCallbackList::DtCallbackFunctionType fcn, void* usrData);
1122 
1124 
1125  virtual void addPreSaveSimulationObjectGroupsCallback(
1126  DtCallbackList<DtScenario&>::DtCallbackFunctionType fcn, void* usrData);
1127  virtual void removePreSaveSimulationObjectGroupsCallback(
1128  DtCallbackList<DtScenario&>::DtCallbackFunctionType fcn, void* usrData);
1130 
1132 
1133  virtual void addPostSaveSimulationObjectGroupsCallback(
1134  DtCallbackList<const DtScenario&>::DtCallbackFunctionType fcn, void* usrData);
1135  virtual void removePostSaveSimulationObjectGroupsCallback(
1136  DtCallbackList<const DtScenario&>::DtCallbackFunctionType fcn, void* usrData);
1138 
1141 
1142  virtual void addScenarioPauseCallback(
1143  DtNoArgumentCallbackList::DtCallbackFunctionType fcn, void* usrData);
1144  virtual void removeScenarioPauseCallback(
1145  DtNoArgumentCallbackList::DtCallbackFunctionType fcn, void* usrData);
1147 
1150 
1151  virtual void addScenarioRunCallback(
1152  DtNoArgumentCallbackList::DtCallbackFunctionType fcn, void* usrData);
1153  virtual void removeScenarioRunCallback(
1154  DtNoArgumentCallbackList::DtCallbackFunctionType fcn, void* usrData);
1156 
1161 
1162  virtual void addPreScenarioRewindCallback(
1163  DtNoArgumentCallbackList::DtCallbackFunctionType fcn, void* usrData);
1164  virtual void removePreScenarioRewindCallback(
1165  DtNoArgumentCallbackList::DtCallbackFunctionType fcn, void* usrData);
1167 
1170 
1171  virtual void addPostScenarioRewindCallback(
1172  DtNoArgumentCallbackList::DtCallbackFunctionType fcn, void* usrData);
1173  virtual void removePostScenarioRewindCallback(
1174  DtNoArgumentCallbackList::DtCallbackFunctionType fcn, void* usrData);
1176 
1179 
1180  virtual void addPostTickCallback(
1181  DtNoArgumentCallbackList::DtCallbackFunctionType fcn, void* usrData);
1182  virtual void removePostTickCallback(
1183  DtNoArgumentCallbackList::DtCallbackFunctionType fcn, void* usrData);
1185 
1187 
1188  virtual void setTimeToQuit(bool);
1189  virtual bool timeToQuit() const;
1191 
1203  virtual void setFrameRateMode(const DtString& mode, DtReal deltaTime = -1);
1204 
1208  virtual bool executeSimCommand(const DtSimCommand& simCommand);
1209 
1212  virtual void unloadTerrain();
1213 
1215  virtual bool isOrbatEnabled() const;
1216 
1218  virtual double timeScale() const;
1219 
1220  virtual void setRunInTimeManagementMode(bool);
1221 
1223  virtual DtSyncMatrixManager* syncMatrixManager();
1224 
1225 public:
1226 
1230  static void objectParametersOpCallback(DtSimMessage* msg, void* usr);
1231 
1232 protected:
1234  static void scenarioDescriptionCallback(DtSimMessage*, void* usr);
1235  virtual void processScenarioDescription(DtSimMessage*);
1236 
1238  static void setScenarioFilenameCallback(DtSimMessage*, void* usr);
1239  virtual void processSetScenarioFilename(DtSimMessage*);
1240 
1242  static void setRunDurationCallback(DtSimMessage*, void* usr);
1243  virtual void processSetRunDuration(DtSimMessage*);
1244 
1246  static void actionCategoriesRequestCallback(DtSimMessage* msg, void* usr);
1247  virtual void processActionCategoriesRequest(DtSimMessage* msg);
1248 
1250  static void scenarioStatusRequestCallback(DtSimMessage* msg, void* usr);
1251  virtual void processScenarioStatusRequest(DtSimMessage* msg);
1252 
1255  virtual bool beginFrame(DtCommunicationManagerPerformanceTimerInformation* info = nullptr);
1256  virtual bool advanceFrame();
1257 
1258 private:
1260  DtCgf(const DtCgf& original);
1262  DtCgf& operator=(const DtCgf& original);
1263 
1264 protected:
1267  virtual DtFilename spawnManagerTemplateFile(const DtScenarioExplorer&) const;
1268 
1270  virtual void loadAllPlugins();
1271 
1273  virtual bool loadComponentAttachmentTable(const DtFilename& filename);
1279  virtual bool loadTerrain(const DtFilename& filename);
1280 
1284  virtual DtFilename findTerrainFile(const DtFilename& startFile, const std::vector<DtFilename>& searchPaths,
1285  const std::string& extension) const;
1286 
1288  virtual bool loadOrderOfBattle(const DtScenario& scenario, DtLoadScenarioData&);
1289  virtual bool loadOrderOfBattle(const DtInMemorySnapshot::OOB&);
1290 
1292  virtual bool writeOrderOfBattle(const DtScenario& scenario) const;
1293  virtual bool writeOrderOfBattle(DtInMemorySnapshot::OOB&) const;
1294 
1296  virtual bool loadScenarioScripts(const DtFilename& filename);
1297  virtual bool loadScenarioScriptsFromZipFile(const DtFilename& scenarioZipFile, const DtFilename& filename);
1298  virtual bool loadScenarioScripts(const std::string& buffer);
1299 
1301  virtual bool loadOrbat(const DtFilename& filename, DtOrbatManager* intoOm = 0, bool clearBeforeLoading = true);
1302  virtual bool loadOrbatFromZipFile(const DtFilename& scenarioZipFile, const DtFilename& filename, DtOrbatManager* intoOm = 0, bool clearBeforeLoading = true);
1303  virtual bool loadOrbat(const std::string& buffer, DtOrbatManager* intoOm = 0, bool clearBeforeLoading = true);
1304 
1307  virtual void prepareForScenarioReinitialize();
1308 
1310  virtual bool isScenarioReinitializing() const;
1311 
1315  virtual bool loadParameterDb(const DtFilename& filename,
1316  const DtReaderWriter::SearchPaths& searchPaths, bool clearLoadedObjects = true, bool preloadParameters = false);
1317 
1320  virtual bool loadObjectParametersDBFile(const DtFilename& opdFile,
1321  const DtReaderWriter::SearchPaths& searchPaths, bool clearLoadedObjects = true, bool preloadParameters = false);
1322 
1326  virtual bool loadPhysicalWorldFile(const DtFilename& file, bool force = false);
1327 
1331  virtual bool loadDetonationParametersFile(const DtFilename& file, bool force = false);
1332 
1333  virtual bool loadTerrainDeformationParametersFile(const DtFilename& file, bool force = false);
1334 
1338  virtual bool loadAmmunitionParametersFile(const DtFilename& file, bool force = false);
1339 
1341  virtual bool loadPlans(const DtFilename& filename);
1342  virtual bool loadPlansFromZipFile(const DtFilename& scenarioZipFile, const DtFilename& filename);
1343  virtual bool loadPlans(const std::string& buffer);
1344 
1346  virtual bool loadGlobalPlans(const DtFilename& filename);
1347  virtual bool loadGlobalPlansFromZipFile(const DtFilename& scenarioZipFile, const DtFilename& filename);
1348 
1350  virtual void loadHostilityAndExtras(const DtScenarioExplorer& se);
1351  virtual void loadHostilityAndExtrasFromZipFile(const DtFilename& scenarioZipFile, const DtScenarioExplorer& se);
1352  virtual void loadHostilityAndExtras(const std::string& buffer);
1353 
1356  virtual void loadActivities(const DtScenarioExplorer&);
1357 
1360  virtual void loadModelSetFiles(const DtScenarioExplorer&);
1361 
1364  virtual void loadActionCategories(const DtFilename& f);
1365 
1366  virtual bool loadForceHostility(const DtFilename& filename, bool clear = true);
1367  virtual bool loadForceHostilityFromZipFile(const DtFilename& scenarioZipFile, const DtFilename& filename, bool clear = true);
1368 
1369  virtual bool loadScenarioExtras(const DtFilename& filename);
1370  virtual bool loadScenarioExtrasFromZipFile(const DtFilename&, const DtFilename& filename);
1371  virtual bool loadScenarioExtras(const std::string& buffer);
1372 
1375  virtual void processObjectParametersOp(DtSimMessage * msg);
1376 
1378  virtual void createAndInitScenarioLoadManager();
1379 
1382  virtual void emptyParametersDB();
1383 
1385  virtual void setAutoReorganization(bool onOff);
1386 
1390  virtual DtVrfPlugin* loadPlugin(const DtString&);
1391 
1394  virtual bool setupCommModelsForScenario(const DtScenarioExplorer& e);
1395 
1399  virtual void updateReadyStatus();
1400 
1403 
1404  static void simCommandCallback(DtSimMessage* msg, void* usr);
1405  virtual void processSimCommand(DtSimMessage* msg);
1407 
1411 
1412  static void deferredLoadScenarioCallback(void * data);
1413  virtual void processDeferredLoadScenario();
1414 
1417  virtual void processLoadScenario(const DtScenario* = 0, const DtInMemorySnapshot* = 0);
1419 
1421 
1422  static void deferredReinitializeScenarioCallback(void * data);
1423  virtual void processDeferredReinitializeScenario();
1425 
1430 
1431  static void deferredRollbackCallback(void * data);
1432  virtual void processDeferredRollback();
1434 
1438 
1439  static void deferredImportScenarioCallback(void * data);
1440  virtual void processDeferredImportScenario();
1442 
1446 
1447  static void deferredRewindCallback(void * data);
1448  virtual void processDeferredRewind();
1450 
1453  virtual void clearAllSimulationModelSetInformation();
1454 
1456  virtual void initializeCgfConsoleCommands();
1457 
1458  virtual void processCloseScenarioEvent(const makVrfEvents::DtEvent&);
1459  virtual void processLoadScenarioEvent(const makVrfEvents::DtEvent&);
1460 
1462  virtual bool createDIGuyCharacterManager(const DtFilename & diGuyAnimationsFile);
1463 
1464 protected:
1465  DtVrfSimOptionsInterface* mySimOptions;
1466 
1468  DtSimulationAddress mySimulationAddress;
1469 
1471  DtU32 mySessionId;
1472 
1474  bool myOK;
1475 
1477  bool myTimeToQuit;
1478 
1480  DtVrfPluginManager* myPluginManager;
1481  std::vector<DtString> myPluginsToLoad;
1482  bool myLoadPluginsIfVersionMismatch;
1483 
1485  DtTerrainInterface* myTerrainInterface;
1486 
1488  DtPhysicalWorld* myPhysicalWorld;
1489 
1490  DtVrfNavAreaManager* myVrfNavAreaManager;
1491 
1492  DtSpawnSinkManager* mySpawnSinkManager;
1493 
1494  DtCommModelManager* myCommModelManager;
1495 
1496  DtSimTerrainRequestManager* mySimTerrainRequestManager;
1497 
1499  DtCommunicationManager* myCommunicationManager;
1500 
1502  DtSimManager* mySimManager;
1503 
1505  DtCreateObjectServiceInterface* myCreateObjectService;
1506 
1508  DtScenarioServiceInterface* myScenarioService;
1509 
1511  DtScenario* myScenario;
1512 
1514  DtVrfStatusPublisher* myStatusPublisher;
1515 
1517  DtLocalObjectManager* myObjectManager;
1518 
1520  DtDebugDrawManager* myDebugDrawManager;
1521 
1522  DtDetonationManager* myDetonationManager;
1523  DtAmmunitionManager* myAmmunitionManager;
1524  DtScriptedTaskManager* myScriptedTaskManager;
1525  DtScenarioEventManager* myScenarioEventManager;
1526  DtHazardAreaManager* myHazardAreaManager;
1527  DtIntelCollectionAreaManager* myIntelCollectionAreaManager;
1528  DtScriptedObjectsMovementManager* myScriptedObjectsMovementManager;
1529  DtFireManager* myFireManager;
1530  DtObjectConsoleManager* myObjectConsoleManager;
1531  DtManagedObjectListManager* myFilteredObjectListManager;
1532  DtOrbatManager* myOrbatManager;
1533  DtObjectGeometricModelsManager* myObjectModelsManager;
1534  DtVrfObjectPlanAdministrator* myPlanAdministrator;
1535  DtSimInternalCommunicationManager* mySimInternalCommunicationManager;
1536  DtDiGuyCharacterDataManager * myCharacterMgr;
1537  bool myCreatedCharacterManager;
1538 
1539  DtLuaObjectSerializer* myLuaObjectSerializer;
1540 
1542  DtResourceMonitor* myResourceMonitor;
1543 
1545  DtRadarCoverageMonitor* myRadarCoverageMonitor;
1546 
1548  DtTerrainProfileRequestManager* myTerrainProfileRequestManager;
1549 
1551  DtVrfParameterDb* myParameterDatabase;
1552 
1554  DtEmbeddedEntityInfoManager* myEmbeddedEntityInfoManager;
1555 
1557  bool myForceParameterDbReload;
1558 
1559  DtGlobalPlanManager* myGlobalPlanManager;
1560 
1561  DtHostilityManager* myHostilityManager;
1562  DtEngagementZonesManager* myEngagementZonesManager;
1563 
1564  DtScenarioExtrasMgr* myScenarioExtrasManager;
1565 
1567  DtFactoryManager* myFactoryManager;
1568 
1570  DtStealthCommandsManager* myStealthCommandsManager;
1571 
1572  DtSimCommandDistributor* mySimCommandDistributor;
1573 
1578  DtFilename myVrfTerrainPathDirectory;
1579 
1583  DtFilename myDefaultTerrainDirectory;
1584 
1586  DtFilename myDefaultSimulationModelSetFilename;
1587 
1589  DtFilename myDIGuyAnimationsFilename;
1590 
1592  DtFilename myMsdlSidcMappingFile;
1593 
1595  DtFilename myCountryCodesMappingFile;
1596 
1599  bool myParameterDbLoaded;
1600 
1602  DtFilename myCurrentParameterDatabaseFilename;
1603 
1607  DtFilename myDefaultParameterDbDirectory;
1608 
1609  DtCallbackList<const DtFilename&> myPreLoadTerrainCallbacks;
1610  DtCallbackList<const DtFilename&> myPostLoadTerrainCallbacks;
1611  DtCallbackList<DtScenario&> myPreLoadScenarioCallbacks;
1612  DtCallbackList<const DtScenario&> myPostLoadScenarioCallbacks;
1613  DtCallbackList<DtScenario&> myPreScenarioReinitializeCallbacks;
1614  DtCallbackList<const DtScenario&> myPostScenarioReinitializeCallbacks;
1615  DtCallbackList<DtScenario&> myPreCreateSimulationObjectGroupCallbacks;
1616  DtCallbackList<const DtScenario&> myPostCreateSimulationObjectGroupCallbacks;
1617  DtCallbackList<DtScenario&> myPreImportScenarioCallbacks;
1618  DtCallbackList<const DtScenario&> myPostImportScenarioCallbacks;
1619  DtCallbackList<DtScenario&> myPreSaveScenarioCallbacks;
1620  DtCallbackList<const DtScenario&> myPostSaveScenarioCallbacks;
1621 
1622  DtCallbackList<DtScenario&> myPreSaveSimulationObjectGroupsCallbacks;
1623  DtCallbackList<const DtScenario&> myPostSaveSimulationObjectGroupsCallbacks;
1624 
1625  DtNoArgumentCallbackList myPreCloseScenarioCallbacks;
1626  DtNoArgumentCallbackList myPostCloseScenarioCallbacks;
1627  DtNoArgumentCallbackList myScenarioRunCallbacks;
1628  DtNoArgumentCallbackList myScenarioPauseCallbacks;
1629  DtNoArgumentCallbackList myPreScenarioRewindCallbacks;
1630  DtNoArgumentCallbackList myPostScenarioRewindCallbacks;
1631  DtNoArgumentCallbackList myPostTickCallbacks;
1632 
1633  DtSyncMatrixManager* mySyncMatrixManager;
1634  DtInfluenceEventDispatcher* myInfluenceEventDispatcher;
1635 
1640  void setVrfCreator(DtVrfCreator* creator);
1642 
1644 
1645  bool ownVrfCreator() const;
1646  void setOwnVrfCreator(bool yesOrNo);
1648 
1650  virtual bool differingModelSets(DtScenario*) const;
1651 
1652  virtual void simControlEvent(const makVrfEvents::DtEvent&);
1653 
1654  virtual void clearObjectsAwaitingDiscovery();
1655  virtual void processObjectsAwaitingDiscovery();
1656 
1657 protected:
1660  bool myOwnVrfCreatorFlag;
1661  DtVrfCreator* myVrfCreator;
1662 
1664  bool myFullyLoadTerrain;
1665 
1669  bool myAssertOnBlockingTerrainCalls;
1670 
1673  DtSimulationModelSet* myDefaultModelSet;
1674 
1678  DtScenario myScenarioToLoad;
1679 
1680  bool myCreateGlobalEnvironment;
1681  bool myCreateGlobalDynamicTerrain;
1682  bool myCreatedGlobalEnvironment;
1683  bool myCreatedGlobalDynamicTerrain;
1684 
1689  bool myWasPaused;
1690 
1692  DtImportExportScenarioDescriptionManager* myImportScenarioDescriptionManager;
1693 
1694  DtConsoleCommandOwner* myConsoleCommands;
1695 
1698  typedef std::pair<std::string, bool> ActionCategory;
1699  typedef std::map<std::string, ActionCategory> ActionCategories;
1700  ActionCategories myActionCategories;
1701 
1703  DtIfScenarioStatus* myScenarioStatus;
1704 
1705  bool myPublishingGlobalEnvironment;
1706  bool myAboutToLoadOrRewindScenario;
1707  bool myReinitializingScenario;
1708 
1709  bool myMetocEnabled;
1710 
1711  DtTaskVisualizationPublicationMode myTaskVisualizationPublicationMode;
1712  bool myUseDrawControlForTaskVisualizations;
1713 
1714  bool myReuseEntityIdentifiersOnScenarioLoad;
1715 
1716  DtRwActivities myActivities;
1717  bool mySmsValidationEnabled;
1718  DtSnapshotManager* mySnapshotManager;
1719  DtSimObjectManager* mySimObjectManager;
1720 
1721  std::vector<DtFilename> myObjectGroupsRoot;
1722 
1723  struct SimulationObjectGroupInformation
1724  {
1725  DtlObjPtr planArgs;
1726  DtlObjPtr oobArgs;
1727  };
1728 
1729  typedef std::map<DtString, SimulationObjectGroupInformation> StoredSimulationObjectGroupInformation;
1730  StoredSimulationObjectGroupInformation myStoredSimulationObjectGroupInformation;
1731 
1732  int myRollbackToId;
1733  bool myCanSimulate;
1734  bool myIsLoaded;
1735  bool myHasModelSetInformationLoadedAfterClose;
1736  int myReloadDelay;
1737  bool myRejectMismatchedScenarioMessages;
1738  DtU32 myScenarioCapabilities;
1739  int myAppIdRangeMax;
1740 
1741  std::set<DtFilename> myLoadedModelSets;
1742 
1743  DtInMemorySnapshot* myQueuedRollback;
1744  int myQueuedRollbackScenarioRunId;
1745 
1746  DtScenarioLoadManager* myScenarioLoadManager;
1747 
1748  typedef std::vector<DtLoadOrderOfBattleHandler*>SimulationObjectGroupsToBeCreated;
1749  SimulationObjectGroupsToBeCreated mySimulationObjectGroupsToBeCreated;
1750 
1751 public:
1754  VRF4API_METHOD DtLocalObjectManager* vrfObjectManager() { return myObjectManager; };
1755  VRF4API_METHOD DtCommunicationManager* exerciseConn() { return myCommunicationManager; };
1757 
1758 };
1759 
DtUUID
UUID is a unique ID wrapper class.
Definition: rwUUID.h:229
DtCgf::myObjectConsoleManager
DtObjectConsoleManager * myObjectConsoleManager
Definition: cgf.h:1530
DtCgf::myIsLoaded
bool myIsLoaded
Definition: cgf.h:1734
DtCgf::myObjectModelsManager
DtObjectGeometricModelsManager * myObjectModelsManager
Definition: cgf.h:1533
DtCgf::myCommunicationManager
DtCommunicationManager * myCommunicationManager
The current exercise connection.
Definition: cgf.h:1499
DtCgf::mySimManager
DtSimManager * mySimManager
Pointer to the DtSimManager.
Definition: cgf.h:1502
DtCgf::myCreateGlobalEnvironment
bool myCreateGlobalEnvironment
Definition: cgf.h:1680
DtCgf::myPublishingGlobalEnvironment
bool myPublishingGlobalEnvironment
Definition: cgf.h:1705
DtCgf::myScenarioStatus
DtIfScenarioStatus * myScenarioStatus
Scenario status message to be sent out upon request.
Definition: cgf.h:1703
DtLocalObjectManager
class DtLocalObjectManager:
Definition: localObjectManager.h:151
DtCgf::communicationManager
DtCommunicationManager * communicationManager()
Definition: cgf.h:380
DtSimTerrainRequestManager
Definition: simTerrainRequestManager.h:34
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:1523
DtCgf::myGlobalPlanManager
DtGlobalPlanManager * myGlobalPlanManager
Definition: cgf.h:1559
DtCgf::myUseDrawControlForTaskVisualizations
bool myUseDrawControlForTaskVisualizations
Definition: cgf.h:1712
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:1524
DtTimer
Instances of DtTimer are used to maintain the information needed to represent some kind of scheduled ...
Definition: timer.h:38
DtCgf::myStealthCommandsManager
DtStealthCommandsManager * myStealthCommandsManager
Stealth commands manager.
Definition: cgf.h:1570
DtVrfParameterDb
Instances of DtVrfParameterDb are the database of DtVrfObjectParameters objects used in the construct...
Definition: vrfParameterDb.h:38
DtCgf::myScenarioPauseCallbacks
DtNoArgumentCallbackList myScenarioPauseCallbacks
Definition: cgf.h:1628
DtCgf::myPreLoadScenarioCallbacks
DtCallbackList< DtScenario & > myPreLoadScenarioCallbacks
Definition: cgf.h:1611
DtCgf::myCreateObjectService
DtCreateObjectServiceInterface * myCreateObjectService
Pointer to the create object service.
Definition: cgf.h:1505
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 orgainization hie...
Definition: createObjectServiceInterface.h:35
DtCgf::myPreCreateSimulationObjectGroupCallbacks
DtCallbackList< DtScenario & > myPreCreateSimulationObjectGroupCallbacks
Definition: cgf.h:1615
DtCgf::myOK
bool myOK
Flag indicating whether we have been successfully initialized.
Definition: cgf.h:1474
DtCgf::myPreCloseScenarioCallbacks
DtNoArgumentCallbackList myPreCloseScenarioCallbacks
Definition: cgf.h:1625
DtCgf::mySimCommandDistributor
DtSimCommandDistributor * mySimCommandDistributor
Definition: cgf.h:1572
DtCgf::myPhysicalWorld
DtPhysicalWorld * myPhysicalWorld
The current physical world.
Definition: cgf.h:1488
DtCgf::myDefaultSimulationModelSetFilename
DtFilename myDefaultSimulationModelSetFilename
Default simulation model set file to load.
Definition: cgf.h:1586
DtCgf::scenarioStatus
const DtIfScenarioStatus * scenarioStatus() const
Imports the specified scenario description file into the current scenario.
Definition: cgf.h:286
DtCgf::myFullyLoadTerrain
bool myFullyLoadTerrain
Flag indicating whether to fully load terrain subpages for paged terrain.
Definition: cgf.h:1664
DtNoArgumentCallbackList::DtCallbackFunctionType
void(* DtCallbackFunctionType)(void *)
The function signature of the callback function.
Definition: noArgumentCallbackList.h:156
DtCgf::ActionCategory
std::pair< std::string, bool > ActionCategory
Map of ID and screen string for action categories. Only used by the front-end Not currently set up fo...
Definition: cgf.h:1698
DtCgf::myPreScenarioReinitializeCallbacks
DtCallbackList< DtScenario & > myPreScenarioReinitializeCallbacks
Definition: cgf.h:1613
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:1564
DtScenarioExplorer
class DtScenarioExplorer:
Definition: scenarioExplorer.h:26
DtCgf::mySmsValidationEnabled
bool mySmsValidationEnabled
Definition: cgf.h:1717
DtCgf::myPostCreateSimulationObjectGroupCallbacks
DtCallbackList< const DtScenario & > myPostCreateSimulationObjectGroupCallbacks
Definition: cgf.h:1616
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:23
DtIfSaveScenario
class DtIfSaveScenario:
Definition: ifSaveScenario.h:23
DtCgf::myScenario
DtScenario * myScenario
The current scenario.
Definition: cgf.h:1511
DtSimInternalCommunicationManager
The manager for SimInternal messages on a single simulation engine. This class manages the passing of...
Definition: simInternalCommunicationManager.h:27
DtCgf::SimulationObjectGroupInformation::oobArgs
DtlObjPtr oobArgs
Definition: cgf.h:1726
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:1721
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:1578
DtCgf::myTimeToQuit
bool myTimeToQuit
Flag indicating whether or not the app should quit.
Definition: cgf.h:1477
DtTerrainProfileRequestManager
Definition: terrainProfileRequestManager.h:31
DtCgf::myPostCloseScenarioCallbacks
DtNoArgumentCallbackList myPostCloseScenarioCallbacks
Definition: cgf.h:1626
DtCgf::myPostTickCallbacks
DtNoArgumentCallbackList myPostTickCallbacks
Definition: cgf.h:1631
DtCgf::myResourceMonitor
DtResourceMonitor * myResourceMonitor
Pointer to the DtResourceMonitor.
Definition: cgf.h:1542
DtOrbatManager
This class handles all requests as they pertain to viewing or modifying the ORBAT.
Definition: orbatManager.h:28
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:21
DtCgf::myCreateGlobalDynamicTerrain
bool myCreateGlobalDynamicTerrain
Definition: cgf.h:1681
DtCgf::myCanSimulate
bool myCanSimulate
Definition: cgf.h:1733
DtCgf::myVrfNavAreaManager
DtVrfNavAreaManager * myVrfNavAreaManager
Definition: cgf.h:1490
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:1748
DtCgf::myHasModelSetInformationLoadedAfterClose
bool myHasModelSetInformationLoadedAfterClose
Definition: cgf.h:1735
DtCgf::myAppIdRangeMax
int myAppIdRangeMax
Definition: cgf.h:1739
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::myQueuedRollback
DtInMemorySnapshot * myQueuedRollback
Definition: cgf.h:1743
DtCgf::myCommModelManager
DtCommModelManager * myCommModelManager
Definition: cgf.h:1494
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:1683
DtIfScenarioStatus
Definition: ifScenarioStatus.h:28
DtCgf::mySimOptions
DtVrfSimOptionsInterface * mySimOptions
Definition: cgf.h:1465
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
DtObjectConsoleManager
This class represents a collection of object consoles that will be used to manage streams for individ...
Definition: objectConsoleManager.h:29
DtScenarioLoadManager
Definition: scenarioLoadManager.h:80
DtCgf::myReuseEntityIdentifiersOnScenarioLoad
bool myReuseEntityIdentifiersOnScenarioLoad
Definition: cgf.h:1714
DtCgf::myStatusPublisher
DtVrfStatusPublisher * myStatusPublisher
Pointer to the DtStatusPublisher.
Definition: cgf.h:1514
DtCgf::myTaskVisualizationPublicationMode
DtTaskVisualizationPublicationMode myTaskVisualizationPublicationMode
Definition: cgf.h:1711
DtCgf::myDIGuyAnimationsFilename
DtFilename myDIGuyAnimationsFilename
DI_Guy animation configuration file to load.
Definition: cgf.h:1589
DtObjectType
Definition: objectType.h:27
DtCgf::myRejectMismatchedScenarioMessages
bool myRejectMismatchedScenarioMessages
Definition: cgf.h:1737
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:1755
DtCgf::myParameterDatabase
DtVrfParameterDb * myParameterDatabase
Pointer to the DtVrfParameterDb.
Definition: cgf.h:1551
DtCgf::myObjectManager
DtLocalObjectManager * myObjectManager
Pointer to the DtLocalObjectManager.
Definition: cgf.h:1517
DtCgf::myPreSaveScenarioCallbacks
DtCallbackList< DtScenario & > myPreSaveScenarioCallbacks
Definition: cgf.h:1619
DtObjectGeometricModelsManager
Manages loading and destruction of the geometric models for objects. Will reference the object parame...
Definition: objectGeometricModelsManager.h:29
DtCgf::myPreLoadTerrainCallbacks
DtCallbackList< const DtFilename & > myPreLoadTerrainCallbacks
Definition: cgf.h:1609
DtInMemorySnapshot::OOB
std::vector< std::string * > OOB
Definition: snapshotManager.h:44
DtCgf::StoredSimulationObjectGroupInformation
std::map< DtString, SimulationObjectGroupInformation > StoredSimulationObjectGroupInformation
Definition: cgf.h:1729
DtCommunicationManagerPerformanceTimerInformation
Definition: communicationManager.h:35
DtScenarioEventManager
The scenario event manager will keep track of all scenario event objects and their state...
Definition: scenarioEventManager.h:33
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:1554
DtCgf::myImportScenarioDescriptionManager
DtImportExportScenarioDescriptionManager * myImportScenarioDescriptionManager
The scenario description manager used to import scenario description files.
Definition: cgf.h:1692
DtCgf::myCreatedGlobalEnvironment
bool myCreatedGlobalEnvironment
Definition: cgf.h:1682
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:1522
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:1595
DtCgf::myDefaultParameterDbDirectory
DtFilename myDefaultParameterDbDirectory
Default parameter database directory to search in when parameter database being specified is not an a...
Definition: cgf.h:1607
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:1525
DtCgf::myScenarioService
DtScenarioServiceInterface * myScenarioService
Pointer to the scenario object service.
Definition: cgf.h:1508
DtCgf::myTerrainProfileRequestManager
DtTerrainProfileRequestManager * myTerrainProfileRequestManager
Pointer to the DtTerrainProfileRequestManager.
Definition: cgf.h:1548
DtVrfNavAreaManager
The DtVrfNavAreaManager manages all of the nav areas currently created in the sim.
Definition: vrfNavAreaManager.h:50
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:1754
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:1610
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:1730
DtCgf::myScenarioRunCallbacks
DtNoArgumentCallbackList myScenarioRunCallbacks
Definition: cgf.h:1627
DtNoArgumentCallbackList
This class works just as DtCalllbackTable, but manages callbacks that have no arguments, and therefore don&#39;t fit in the template defined by DtCallbackList.
Definition: noArgumentCallbackList.h:152
dataDir
std::string dataDir()
DtCgf::myPluginManager
DtVrfPluginManager * myPluginManager
The current plugin manager.
Definition: cgf.h:1480
DtReaderWriter::SearchPaths
std::vector< DtFilename > SearchPaths
Definition: readerWriter.h:92
DtCgf::myQueuedRollbackScenarioRunId
int myQueuedRollbackScenarioRunId
Definition: cgf.h:1744
DtCgf::myCreatedCharacterManager
bool myCreatedCharacterManager
Definition: cgf.h:1537
DtCgf::mySimulationObjectGroupsToBeCreated
SimulationObjectGroupsToBeCreated mySimulationObjectGroupsToBeCreated
Definition: cgf.h:1749
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:1689
DtCallbackList
Definition: noArgumentCallbackList.h:91
DtCgf::myIntelCollectionAreaManager
DtIntelCollectionAreaManager * myIntelCollectionAreaManager
Definition: cgf.h:1527
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:1669
DtCgf::myPreSaveSimulationObjectGroupsCallbacks
DtCallbackList< DtScenario & > myPreSaveSimulationObjectGroupsCallbacks
Definition: cgf.h:1622
DtCgf::mySyncMatrixManager
DtSyncMatrixManager * mySyncMatrixManager
Definition: cgf.h:1633
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:1623
DtCgf::myDefaultModelSet
DtSimulationModelSet * myDefaultModelSet
Default simulation model set. This is created when the default simulation model set filename is set o...
Definition: cgf.h:1673
DtCgf::myActivities
DtRwActivities myActivities
Definition: cgf.h:1716
DtVrfPluginManager
Definition: vrfPluginManager.h:73
DtCgf::myScenarioLoadManager
DtScenarioLoadManager * myScenarioLoadManager
Definition: cgf.h:1746
DtCgf::myRadarCoverageMonitor
DtRadarCoverageMonitor * myRadarCoverageMonitor
Pointer to the DtRadarCoverageMonitor.
Definition: cgf.h:1545
DtConsoleCommandOwner
A utility class for use with DtConsoleCommandManager. This class takes ownership of an arbitrary numb...
Definition: consoleCommandManager.h:166
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:99
DtCgf::myFactoryManager
DtFactoryManager * myFactoryManager
Pointer to the DtFactoryManager.
Definition: cgf.h:1567
DtCgf::myActionCategories
ActionCategories myActionCategories
Definition: cgf.h:1700
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:1678
DtCgf::myHazardAreaManager
DtHazardAreaManager * myHazardAreaManager
Definition: cgf.h:1526
DtCgf::myPluginsToLoad
std::vector< DtString > myPluginsToLoad
Definition: cgf.h:1481
DtCgf::myPostSaveScenarioCallbacks
DtCallbackList< const DtScenario & > myPostSaveScenarioCallbacks
Definition: cgf.h:1620
DtCgf::myReinitializingScenario
bool myReinitializingScenario
Definition: cgf.h:1707
error
Definition: asyncJobServer.h:39
DtVrfCreator
Instances of DtVrfCreator are responsible for creating all of the objects needed to create and manage...
Definition: vrfCreator.h:276
DtCgf::mySimObjectManager
DtSimObjectManager * mySimObjectManager
Definition: cgf.h:1719
DtCgf::mySimInternalCommunicationManager
DtSimInternalCommunicationManager * mySimInternalCommunicationManager
Definition: cgf.h:1535
DtPlan
class DtPlan:
Definition: plan.h:92
DtCgf::myInfluenceEventDispatcher
DtInfluenceEventDispatcher * myInfluenceEventDispatcher
Definition: cgf.h:1634
DtCgf::myOrbatManager
DtOrbatManager * myOrbatManager
Definition: cgf.h:1532
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:1617
translatableStream.h
Contains the DtTranslatableStream class declaration.
DtCgf::myLoadedModelSets
std::set< DtFilename > myLoadedModelSets
Definition: cgf.h:1741
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:90
DtCgf::myPostScenarioRewindCallbacks
DtNoArgumentCallbackList myPostScenarioRewindCallbacks
Definition: cgf.h:1630
DtCgf::myAboutToLoadOrRewindScenario
bool myAboutToLoadOrRewindScenario
Definition: cgf.h:1706
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:1557
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:1718
DtCgf::myEngagementZonesManager
DtEngagementZonesManager * myEngagementZonesManager
Definition: cgf.h:1562
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:386
DtCgf::myPostImportScenarioCallbacks
DtCallbackList< const DtScenario & > myPostImportScenarioCallbacks
Definition: cgf.h:1618
DtCgf::myMetocEnabled
bool myMetocEnabled
Definition: cgf.h:1709
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:1534
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:1496
DtCgf::myPostLoadScenarioCallbacks
DtCallbackList< const DtScenario & > myPostLoadScenarioCallbacks
Definition: cgf.h:1612
DtCgf::myReloadDelay
int myReloadDelay
Definition: cgf.h:1736
DtCgf::myVrfCreator
DtVrfCreator * myVrfCreator
Definition: cgf.h:1661
DtCgf::myCharacterMgr
DtDiGuyCharacterDataManager * myCharacterMgr
Definition: cgf.h:1536
DtCgf::myPreScenarioRewindCallbacks
DtNoArgumentCallbackList myPreScenarioRewindCallbacks
Definition: cgf.h:1629
DtCgf::canSimulate
virtual bool canSimulate() const
Whether or not the cgf is ready to simulate.
Definition: cgf.h:378
DtCgf::myCurrentParameterDatabaseFilename
DtFilename myCurrentParameterDatabaseFilename
Filename of currently loaded parameter database.
Definition: cgf.h:1602
DtSimManager
The simulation engine is controlled by a single,top-level class called the Simulation Manager...
Definition: simManager.h:121
DtSnapshotManager
Definition: snapshotManager.h:55
DtCgf::myFilteredObjectListManager
DtManagedObjectListManager * myFilteredObjectListManager
Definition: cgf.h:1531
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:1725
DtCgf::myScenarioCapabilities
DtU32 myScenarioCapabilities
Definition: cgf.h:1738
DtCgf::myOwnVrfCreatorFlag
bool myOwnVrfCreatorFlag
These are essentially cached from the init call. This is necessary as the load terrain.
Definition: cgf.h:1660
DtCgf::scenarioStatus
DtIfScenarioStatus * scenarioStatus()
Returns the scenario status object.
Definition: cgf.h:285
DtCgf::myParameterDbLoaded
bool myParameterDbLoaded
Set to true if parameter database has been loaded via loadParameterDatabase call. If you load a param...
Definition: cgf.h:1599
DtCgf::myHostilityManager
DtHostilityManager * myHostilityManager
Definition: cgf.h:1561
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:1492
DtCgf
The top level class of a VR-Forces Simulation Engine, representing a Computer Generated Forces instan...
Definition: cgf.h:144
DtCgf::myLuaObjectSerializer
DtLuaObjectSerializer * myLuaObjectSerializer
Definition: cgf.h:1539
DtCgf::myConsoleCommands
DtConsoleCommandOwner * myConsoleCommands
Definition: cgf.h:1694
DtCgf::myFireManager
DtFireManager * myFireManager
Definition: cgf.h:1529
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:1528
DtCgf::myDebugDrawManager
DtDebugDrawManager * myDebugDrawManager
Pointer to the DtDebugDrawManagert.
Definition: cgf.h:1520
DtCgf::myPostScenarioReinitializeCallbacks
DtCallbackList< const DtScenario & > myPostScenarioReinitializeCallbacks
Definition: cgf.h:1614
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:1485
DtCgf::mySessionId
DtU32 mySessionId
Session Id.
Definition: cgf.h:1471
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:1583
DtCgf::myLoadPluginsIfVersionMismatch
bool myLoadPluginsIfVersionMismatch
Definition: cgf.h:1482
DtCgf::mySimulationAddress
DtSimulationAddress mySimulationAddress
Address for routing interface messages.
Definition: cgf.h:1468
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:1699
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::myRollbackToId
int myRollbackToId
Definition: cgf.h:1732
DtCgf::myMsdlSidcMappingFile
DtFilename myMsdlSidcMappingFile
MSDL SDIC mapping file to load.
Definition: cgf.h:1592
DtTaskVisualizationPublicationMode
DtTaskVisualizationPublicationMode
Defines how task visualizations will be published.
Definition: scenarioServiceInterface.h:21
Document ID: Generated on Thu Jun 1 17:58:13 EDT 2023 from SVN revision 255404
Copyright © 2005-2021 MAK Technologies. All Rights Reserved (www.mak.com)