VR-Forces 5.0.1 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 struct DtCommunicationManagerPerformanceTimerInformation;
111 
112 namespace makVrfEvents
113 {
114  class DtEvent;
115  class DtEventManager;
116 }
117 
118 namespace makVrf
119 {
120  class DtStateDataManager;
121 }
122 
142 #include "vrfcgf/vrfcgfDefines.h"
143 class DT_DLL_vrfcgf DtCgf
144 {
145 public:
146 
153  DtCgf(const DtSimulationAddress& addr, const DtU32& capabilities = 0xffff);
154 
178  virtual bool init(DtCommunicationManager* conn, DtU32 sessionId = 1, DtVrfCreator* creator = 0, bool checkDataDir = true);
179 
181  virtual ~DtCgf();
182 
184  virtual const DtVrfSimOptionsInterface* simOptions() const;
185 
187  virtual void setSimOptions(const DtVrfSimOptionsInterface&);
188 
191  virtual void tick();
192 
195  virtual void sendFinalStatus();
196 
200  virtual bool importScenarioDescriptionFile(const DtFilename& file, const DtString& format,
203  const std::map<std::string, std::string>& importData);
204 
208  virtual DtString exportScenarioDescriptionFile(const DtFilename& file, const DtString& format,
209  const std::map<std::string, std::string>& exportData);
210 
212  virtual void setAppDataDir(const DtString&);
213  virtual DtFilename appDataDir() const;
214 
216  virtual void setSimulationAddress(const DtSimulationAddress&);
217 
219  virtual void setUserDataDir(const DtString&);
220  virtual DtFilename userDataDir() const;
221 
223  virtual void setDataDir(const DtString&);
224  virtual DtFilename dataDir() const;
225 
229  virtual DtFilename sharedDataDir() const;
230  virtual void setSharedDataDir(const DtFilename& path);
231 
232  virtual DtFilename sharedDataRoot() const;
233  virtual void setSharedDataRoot(const DtFilename& path);
234 
235  virtual DtString sharedDataStem() const;
236  virtual void setSharedDataStem(const DtString& path);
237 
239  virtual void setAppIdRangeMax(int);
240  int appIdRangeMax() const;
241 
245  virtual bool loadScenario(const DtFilename& name, int scenarioRunId = 0,
246  bool isOrbatEnabled = false, bool createGlobalEnv = false,
247  bool createGlobalDynamicTerrain = false);
248 
255  virtual bool loadScenario(const DtScenario& scenario, int scenarioRunId = 0,
256  bool isOrbatEnabled = false, bool createGlobalEnv = false,
257  bool createGlobalDynamicTerrain = false);
258 
260  virtual void queueRollbackTo(DtInMemorySnapshot* chkp, int scenarioRunId = 0);
261 
263  virtual bool rollbackTo(DtInMemorySnapshot* chkp, int scenarioRunId = 0);
264 
266  virtual void clearSimulationObjects();
267 
270  virtual bool importScenario(const DtScenario&);
271  virtual bool importScenario(const DtFilename&);
272 
279  virtual bool newScenario(const DtFilename& dbname =
280  DtFilename::nullFilename(), const DtFilename& simulationModelSet =
281  DtFilename::nullFilename());
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 
295  virtual bool takeSnapshot(DtInMemorySnapshot*);
296 
299  virtual void rollbackToSimTime(double simTime);
300 
303  virtual void takeSnapshot(bool makeBase);
304 
307  virtual bool saveSnapshot(const DtFilename& saveFolder,
308  DtCompressedFileTransporter&, DtIfSaveScenario* msg, const DtSimulationAddress& requestor);
309 
313  virtual bool saveSimulationObjectGroup(DtFilename saveFolder, const DtString& groupName,
314  int flags, std::set<DtUUID>& uuidsSaved, bool& savAsZipFile);
315 
321  virtual bool createSimulationObjectGroup(const DtString& group, int flags, int force, const DtVector& geocentricLocation,
322  double offsetRotation, bool storedInZipFile = false);
323 
328  virtual void closeScenario(const DtFilename& terrainToOpen = "", bool forceCloseAll = false);
329 
334  virtual bool loadAdditionalObjectParameters(const DtFilename& paramsFileName,
335  const DtReaderWriter::SearchPaths& searchPaths, bool preloadParameters = false);
337 
340  virtual void run();
341 
343  virtual void pause();
344 
346  virtual std::string protocol() const;
347 
353  virtual void rewind(int scenarioRunId = 0);
354 
356  virtual void setRejectMismatchedScenarioMessages(bool);
357  virtual bool rejectMismatchedScenarioMessages() const;
358 
363 
364  virtual void setForceParameterDbReload(bool reload);
365  virtual bool forceParameterDbReload() const;
367 
371 
372  virtual void setEnableResourceMonitor(bool b);
373  virtual bool isResourceMonitorEnabled() const;
375 
377  virtual bool canSimulate() const { return myCanSimulate; };
378 
379  DtCommunicationManager* communicationManager() { return myCommunicationManager; };
380  virtual makVrfEvents::DtEventManager* eventManager();
381 
382  virtual bool canSleep() const;
383 
385  virtual bool aboutToLoadOrRewindScenario() const { return myAboutToLoadOrRewindScenario; };
386 
390  virtual void setSmsValidationEnabled(bool b);
391 
403 
404  virtual const DtFilename& defaultTerrainDirectory();
405  virtual void setDefaultTerrainDirectory(const DtFilename& directory);
407 
408  virtual bool logFrameRateStatistics() const;
409  virtual void setLogFrameRateStatistics(bool yesOrNo);
410 
412  virtual void sendServerLoadMessage(const DtString& error, int level = DtNlWarn);
413 
418 
419  virtual const DtFilename& defaultSimulationModelSetFilename();
420  virtual void setDefaultSimulationModelSetFilename(const DtFilename& filename);
422 
426 
427  virtual const DtFilename& diGuyAnimationsFilename();
428  virtual void setDIGuyAnimationsFilename(const DtFilename& filename);
430 
432 
433  void setClockMode(int clockMode);
435 
437 
438  virtual void setMsdlSidcMappingFile(const DtFilename&);
439  virtual const DtFilename& msdlSidcMappingFile() const;
441 
444  virtual void setCountryCodesMappingFile(const DtFilename&);
445  virtual const DtFilename& countryCodesMappingFile() const;
447 
450  virtual DtSimulationModelSet* defaultModelSet();
452 
456  virtual void deleteObject(const DtUUID& name, bool andRemoveFromOrbat = true) const;
460 
471  virtual DtLocalObject* createWaypoint(const DtVector& localPosition,
472  const DtString& uniqueName = DtString::nullString()) const;
473 
486  virtual DtLocalObject* createRoute(const DtList& vertices,
487  const DtString& uniqueName = DtString::nullString()) const;
488 
500  virtual DtLocalObject* createPhaseLine(
501  const DtVector& dbPoint1,
502  const DtVector& dbPoint2,
503  const DtString& uniqueName = DtString::nullString()) const;
504 
516  virtual DtLocalObject* createControlArea(
517  const DtList& vertices,
518  const DtString& uniqueName = DtString::nullString()) const;
519 
531  virtual DtLocalObject* createObstacle(
532  const DtList& vertices,
533  const DtString& uniqueName = DtString::nullString()) const;
534 
562  virtual DtLocalObject* createEntity(
563  const DtEntityType& entityType,
564  DtForceType force,
565  const DtVector& dbPosition,
566  DtReal heading,
567  const DtString& entityName = DtString::nullString(),
568  bool allowBlocking = true,
569  std::list<DtAdminContent*>* initialAdminContent = 0,
570  bool addToOrbat = true) const;
571 
572 
602  virtual DtLocalObject* createAggregate(
603  const DtEntityType& aggregateType,
604  DtForceType force,
605  const DtVector& localPosition,
606  DtReal heading,
607  const std::vector<DtUUID>& subordinates = std::vector<DtUUID>(),
608  const DtString& aggregateName = DtString::nullString(),
609  bool addToOrbat = true) const;
610 
622  virtual DtLocalObject* createAggregate(
623  const DtEntityType& aggregateType,
624  DtForceType force,
625  const DtVector& localPosition,
626  DtReal heading,
627  bool createSubordinates,
628  const DtString& aggregateName = DtString::nullString(),
629  bool allowBlocking = true,
630  bool addToOrbat = true) const;
631 
643  virtual bool addSubordinate(DtLocalObject* subordinate,
644  DtLocalObject* aggregate);
645 
661  virtual bool removeSubordinate(DtLocalObject* subordinate,
662  DtLocalObject* aggregate);
664 
668  virtual void assignTask(const DtLocalObject* entity, const DtSimTask& task);
677 
686  virtual void sendSetDataRequest(const DtLocalObject* entity,
687  const DtSetDataRequest& request);
688 
690  virtual void assignPlanByUUID(const DtUUID&, const DtPlan& plan);
691 
696  virtual void abandonPlan(const DtLocalObject* entity);
697 
702  virtual void restartPlan(const DtLocalObject* entity);
704 
708  virtual void logObjectConsoleToFile(DtLocalObject* object,
713  DtFilename filename = DtFilename::nullFilename());
714 
716  virtual void stopLoggingObjectConsoleToFile(DtLocalObject* object);
717 
721  virtual void setObjectConsoleNotificationLevel(DtLocalObject* object,
722  DtNotifyLevelType level);
724 
731  virtual bool reuseEntityIdentifiersOnScenarioLoad() const;
732  virtual void setReuseEntityIdentifiersOnScenarioLoad(bool);
734 
737  virtual void setTaskVisualizationPublicationMode(DtTaskVisualizationPublicationMode mode);
738  virtual DtTaskVisualizationPublicationMode taskVisualizationPublicationMode() const;
740 
744  virtual void setUseDrawControlForTaskVisualizations(bool);
745  virtual bool useDrawControlForTaskVisualizations() const;
747 
748 
749  //-------------------------------------------------------
751  //-------------------------------------------------------
752 
755  virtual DtSimManager* simManager() const;
756  virtual DtSimulationServices* simulationServices() const;
757 
759  virtual DtImportExportScenarioDescriptionManager* importExportScenarioDescriptionManager() const;
760 
763  virtual DtResourceMonitor* resourceMonitor() const;
764 
766  virtual DtRadarCoverageMonitor* radarCoverageMonitor() const;
767 
769  virtual DtTerrainProfileRequestManager* terrainProfileRequestManager() const;
770 
773  virtual DtFactoryManager* factoryManager() const;
774 
776  virtual DtSnapshotManager* snapshotManager() const;
777 
781  virtual DtLocalObjectManager* localObjectManager() const;
782 
785  virtual DtSimObjectManager* simObjectManager() const;
786 
789  virtual DtDebugDrawManager* debugDrawManager() const;
790 
792  virtual DtScriptedTaskManager* scriptedTaskManager() const;
793 
795  virtual DtScenarioEventManager* scenarioEventManager() const;
796 
798  virtual DtHazardAreaManager* hazardAreaManager() const;
799 
801  virtual DtIntelCollectionAreaManager* intelCollectionAreaManager() const;
802 
804  virtual DtScriptedObjectsMovementManager* ScriptedObjectsMovementManager() const;
805 
808  virtual DtDetonationManager* detonationManager() const;
809 
812  virtual DtAmmunitionManager* ammunitionManager() const;
813 
816  virtual DtFireManager* fireManager() const;
817 
822  virtual DtScenarioExtrasMgr* scenarioExtrasMgr() const;
823 
825  virtual DtVrfParameterDb* parameterDatabase() const;
826 
828  virtual DtGlobalPlanManager* globalPlanManager();
829 
831  virtual DtStealthCommandsManager* stealthCommandsManager();
832 
835 
836  virtual DtTerrainInterface* terrainInterface();
837  virtual const DtTerrainInterface* terrainInterface() const;
839 
842 
843  virtual DtPhysicalWorld* physicalWorld();
844  virtual const DtPhysicalWorld* physicalWorld() const;
846 
848  virtual void setPhysicalWorld(DtPhysicalWorld* newPhysicalWorld);
849 
850  virtual DtVrfNavAreaManager* vrfNavAreaManager();
851  virtual const DtVrfNavAreaManager* vrfNavAreaManager() const;
852 
853  virtual void setVrfNavAreaManager(DtVrfNavAreaManager* newVrfNavAreaManager);
854 
855  virtual DtSpawnSinkManager* spawnSinkManager();
856  virtual const DtSpawnSinkManager* spawnSinkManager() const;
857 
859 
860  virtual DtCommModelManager* commModelManager();
861  virtual const DtCommModelManager* commModelManager() const;
863 
864  virtual const DtDiGuyCharacterDataManager* diGuyCharacterManager() const;
865 
867 
868  virtual DtSimTerrainRequestManager* simTerrainRequestManager();
869  virtual const DtSimTerrainRequestManager* simTerrainRequestManager() const;
871 
873  virtual DtSimCommandDistributor* simCommandDistributor();
874 
876  virtual DtScenario* scenario() const;
877 
880  virtual const DtSimulationAddress& simulationAddress() const;
881 
887  virtual int sessionId() const;
888 
894 
895  virtual DtU32 scenarioCapabilities() const;
896  virtual void setScenarioCapabilities(DtU32 v);
897  virtual void setScenarioCapability(DtU32 v, bool);
899 
901  virtual void setTimeMultiplier(double);
902 
905 
906  virtual DtString applicationType() const;
907  virtual void setApplicationType(const DtString& type);
909 
912  virtual DtVrfStatusPublisher* statusPublisher() const;
913 
917  virtual void useMapDatum(const DtMapDatum& mapDatum);
918 
920  virtual void setParameterDbLoaded(bool flag);
921 
927  virtual void setDefaultParameterDbDirectory(const DtFilename& filename);
928 
930  virtual DtFilename objectGroupsRoot() const;
931 
936  virtual bool reinitializeScenario();
937 
938  virtual void setFullyLoadTerrain(bool yesOrNo);
939  virtual bool fullyLoadTerrain() const;
940 
944 
945  virtual void setAssertOnBlockingTerrainCalls(bool b);
946  virtual bool assertOnBlockingTerrainCalls() const;
948 
952 
953  virtual void setMetocEnable(bool b);
954  virtual bool metocEnable() const;
956 
957  //-------------------------------------------------------
959  //-------------------------------------------------------
960 
963  virtual void addPluginToLoad(const DtString&);
964 
967  virtual void setLoadPluginsIfVersionMismatch(bool);
968  virtual bool loadPluginsIfVersionMismatch() const;
969 
971  virtual bool createAndInitPluginManager(DtVrfCreator* creator);
972 
975  virtual void initializePluginCommandLineArguments(DtApplicationSettings& appInitializer);
976 
978 
979  DtVrfCreator* vrfCreator();
980  const DtVrfCreator* vrfCreator() const;
982 
986 
987  virtual void addPreLoadTerrainCallback(
988  DtCallbackList<const DtFilename&>::DtCallbackFunctionType fcn, void* usrData);
989  virtual void removePreLoadTerrainCallback(
990  DtCallbackList<const DtFilename&>::DtCallbackFunctionType fcn, void* usrData);
992 
996 
997  virtual void addPostLoadTerrainCallback(
998  DtCallbackList<const DtFilename&>::DtCallbackFunctionType fcn, void* usrData);
999  virtual void removePostLoadTerrainCallback(
1000  DtCallbackList<const DtFilename&>::DtCallbackFunctionType fcn, void* usrData);
1002 
1005  virtual void runForDuration(double);
1006 
1008  virtual void stopSimulationDurationTimer();
1009 
1011  static void runDurationCompleteCallback(void*);
1012  virtual void processRunDurationComplete();
1013 
1015  virtual void setPublishingGlobalEnvironment(bool);
1016 
1020 
1021  virtual void addPreLoadScenarioCallback(
1022  DtCallbackList<DtScenario&>::DtCallbackFunctionType fcn, void* usrData);
1023  virtual void removePreLoadScenarioCallback(
1024  DtCallbackList<DtScenario&>::DtCallbackFunctionType fcn, void* usrData);
1026 
1028 
1029  virtual void addPreScenarioReinitializeCallback(
1030  DtCallbackList<DtScenario&>::DtCallbackFunctionType fcn, void* usrData);
1031  virtual void removePreScenarioReinitializeCallback(
1032  DtCallbackList<DtScenario&>::DtCallbackFunctionType fcn, void* usrData);
1034 
1037 
1038  virtual void addPostScenarioReinitializeCallback(
1039  DtCallbackList<const DtScenario&>::DtCallbackFunctionType fcn, void* usrData);
1040  virtual void removePostScenarioReinitializeCallback(
1041  DtCallbackList<const DtScenario&>::DtCallbackFunctionType fcn, void* usrData);
1043 
1045 
1046  virtual void addPreCreateSimulationObjectGroupCallback(
1047  DtCallbackList<DtScenario&>::DtCallbackFunctionType fcn, void* usrData);
1048  virtual void removePreCreateSimulationObjectGroupCallback(
1049  DtCallbackList<DtScenario&>::DtCallbackFunctionType fcn, void* usrData);
1051 
1055 
1056  virtual void addPostLoadScenarioCallback(
1057  DtCallbackList<const DtScenario&>::DtCallbackFunctionType fcn, void* usrData);
1058  virtual void removePostLoadScenarioCallback(
1059  DtCallbackList<const DtScenario&>::DtCallbackFunctionType fcn, void* usrData);
1061 
1063 
1064  virtual void addPostCreateSimulationObjectGroupCallback(
1065  DtCallbackList<const DtScenario&>::DtCallbackFunctionType fcn, void* usrData);
1066  virtual void removePostCreateSimulationObjectGroupCallback(
1067  DtCallbackList<const DtScenario&>::DtCallbackFunctionType fcn, void* usrData);
1069 
1071 
1072  virtual void addPreImportScenarioCallback(
1073  DtCallbackList<DtScenario&>::DtCallbackFunctionType fcn, void* usrData);
1074  virtual void removePreImportScenarioCallback(
1075  DtCallbackList<DtScenario&>::DtCallbackFunctionType fcn, void* usrData);
1077 
1079 
1080  virtual void addPostImportScenarioCallback(
1081  DtCallbackList<const DtScenario&>::DtCallbackFunctionType fcn, void* usrData);
1082  virtual void removePostImportScenarioCallback(
1083  DtCallbackList<const DtScenario&>::DtCallbackFunctionType fcn, void* usrData);
1085 
1088 
1089  virtual void addPreSaveScenarioCallback(
1090  DtCallbackList<DtScenario&>::DtCallbackFunctionType fcn, void* usrData);
1091  virtual void removePreSaveScenarioCallback(
1092  DtCallbackList<DtScenario&>::DtCallbackFunctionType fcn, void* usrData);
1094 
1097 
1098  virtual void addPostSaveScenarioCallback(
1099  DtCallbackList<const DtScenario&>::DtCallbackFunctionType fcn, void* usrData);
1100  virtual void removePostSaveScenarioCallback(
1101  DtCallbackList<const DtScenario&>::DtCallbackFunctionType fcn, void* usrData);
1103 
1106 
1107  virtual void addPreCloseScenarioCallback(
1108  DtNoArgumentCallbackList::DtCallbackFunctionType fcn, void* usrData);
1109  virtual void removePreCloseScenarioCallback(
1110  DtNoArgumentCallbackList::DtCallbackFunctionType fcn, void* usrData);
1112 
1115 
1116  virtual void addPostCloseScenarioCallback(
1117  DtNoArgumentCallbackList::DtCallbackFunctionType fcn, void* usrData);
1118  virtual void removePostCloseScenarioCallback(
1119  DtNoArgumentCallbackList::DtCallbackFunctionType fcn, void* usrData);
1121 
1123 
1124  virtual void addPreSaveSimulationObjectGroupsCallback(
1125  DtCallbackList<DtScenario&>::DtCallbackFunctionType fcn, void* usrData);
1126  virtual void removePreSaveSimulationObjectGroupsCallback(
1127  DtCallbackList<DtScenario&>::DtCallbackFunctionType fcn, void* usrData);
1129 
1131 
1132  virtual void addPostSaveSimulationObjectGroupsCallback(
1133  DtCallbackList<const DtScenario&>::DtCallbackFunctionType fcn, void* usrData);
1134  virtual void removePostSaveSimulationObjectGroupsCallback(
1135  DtCallbackList<const DtScenario&>::DtCallbackFunctionType fcn, void* usrData);
1137 
1140 
1141  virtual void addScenarioPauseCallback(
1142  DtNoArgumentCallbackList::DtCallbackFunctionType fcn, void* usrData);
1143  virtual void removeScenarioPauseCallback(
1144  DtNoArgumentCallbackList::DtCallbackFunctionType fcn, void* usrData);
1146 
1149 
1150  virtual void addScenarioRunCallback(
1151  DtNoArgumentCallbackList::DtCallbackFunctionType fcn, void* usrData);
1152  virtual void removeScenarioRunCallback(
1153  DtNoArgumentCallbackList::DtCallbackFunctionType fcn, void* usrData);
1155 
1160 
1161  virtual void addPreScenarioRewindCallback(
1162  DtNoArgumentCallbackList::DtCallbackFunctionType fcn, void* usrData);
1163  virtual void removePreScenarioRewindCallback(
1164  DtNoArgumentCallbackList::DtCallbackFunctionType fcn, void* usrData);
1166 
1169 
1170  virtual void addPostScenarioRewindCallback(
1171  DtNoArgumentCallbackList::DtCallbackFunctionType fcn, void* usrData);
1172  virtual void removePostScenarioRewindCallback(
1173  DtNoArgumentCallbackList::DtCallbackFunctionType fcn, void* usrData);
1175 
1178 
1179  virtual void addPostTickCallback(
1180  DtNoArgumentCallbackList::DtCallbackFunctionType fcn, void* usrData);
1181  virtual void removePostTickCallback(
1182  DtNoArgumentCallbackList::DtCallbackFunctionType fcn, void* usrData);
1184 
1186 
1187  virtual void setTimeToQuit(bool);
1188  virtual bool timeToQuit() const;
1190 
1202  virtual void setFrameRateMode(const DtString& mode, DtReal deltaTime = -1);
1203 
1207  virtual bool executeSimCommand(const DtSimCommand& simCommand);
1208 
1211  virtual void unloadTerrain();
1212 
1214  virtual bool isOrbatEnabled() const;
1215 
1217  virtual double timeScale() const;
1218 
1219  virtual void setRunInTimeManagementMode(bool);
1220 
1222  virtual DtSyncMatrixManager* syncMatrixManager();
1223 
1224 public:
1225 
1229  static void objectParametersOpCallback(DtSimMessage* msg, void* usr);
1230 
1231 protected:
1233  static void scenarioDescriptionCallback(DtSimMessage*, void* usr);
1234  virtual void processScenarioDescription(DtSimMessage*);
1235 
1237  static void setScenarioFilenameCallback(DtSimMessage*, void* usr);
1238  virtual void processSetScenarioFilename(DtSimMessage*);
1239 
1241  static void setRunDurationCallback(DtSimMessage*, void* usr);
1242  virtual void processSetRunDuration(DtSimMessage*);
1243 
1245  static void actionCategoriesRequestCallback(DtSimMessage* msg, void* usr);
1246  virtual void processActionCategoriesRequest(DtSimMessage* msg);
1247 
1249  static void scenarioStatusRequestCallback(DtSimMessage* msg, void* usr);
1250  virtual void processScenarioStatusRequest(DtSimMessage* msg);
1251 
1254  virtual bool beginFrame();
1255  virtual bool advanceFrame();
1256 
1257 private:
1259  DtCgf(const DtCgf& original);
1261  DtCgf& operator=(const DtCgf& original);
1262 
1263 protected:
1266  virtual DtFilename spawnManagerTemplateFile(const DtScenarioExplorer&) const;
1267 
1269  virtual void loadAllPlugins();
1270 
1272  virtual bool loadComponentAttachmentTable(const DtFilename& filename);
1278  virtual bool loadTerrain(const DtFilename& filename);
1279 
1283  virtual DtFilename findTerrainFile(const DtFilename& startFile, const std::vector<DtFilename>& searchPaths,
1284  const std::string& extension) const;
1285 
1287  virtual bool loadOrderOfBattle(const DtScenario& scenario, DtLoadScenarioData&);
1288  virtual bool loadOrderOfBattle(const DtInMemorySnapshot::OOB&);
1289 
1291  virtual bool writeOrderOfBattle(const DtScenario& scenario) const;
1292  virtual bool writeOrderOfBattle(DtInMemorySnapshot::OOB&) const;
1293 
1295  virtual bool loadScenarioScripts(const DtFilename& filename);
1296  virtual bool loadScenarioScriptsFromZipFile(const DtFilename& scenarioZipFile, const DtFilename& filename);
1297  virtual bool loadScenarioScripts(const std::string& buffer);
1298 
1300  virtual bool loadOrbat(const DtFilename& filename, DtOrbatManager* intoOm = 0, bool clearBeforeLoading = true);
1301  virtual bool loadOrbatFromZipFile(const DtFilename& scenarioZipFile, const DtFilename& filename, DtOrbatManager* intoOm = 0, bool clearBeforeLoading = true);
1302  virtual bool loadOrbat(const std::string& buffer, DtOrbatManager* intoOm = 0, bool clearBeforeLoading = true);
1303 
1306  virtual void prepareForScenarioReinitialize();
1307 
1309  virtual bool isScenarioReinitializing() const;
1310 
1314  virtual bool loadParameterDb(const DtFilename& filename,
1315  const DtReaderWriter::SearchPaths& searchPaths, bool clearLoadedObjects = true, bool preloadParameters = false);
1316 
1319  virtual bool loadObjectParametersDBFile(const DtFilename& opdFile,
1320  const DtReaderWriter::SearchPaths& searchPaths, bool clearLoadedObjects = true, bool preloadParameters = false);
1321 
1325  virtual bool loadPhysicalWorldFile(const DtFilename& file, bool force = false);
1326 
1330  virtual bool loadDetonationParametersFile(const DtFilename& file, bool force = false);
1331 
1332  virtual bool loadTerrainDeformationParametersFile(const DtFilename& file, bool force = false);
1333 
1337  virtual bool loadAmmunitionParametersFile(const DtFilename& file, bool force = false);
1338 
1340  virtual bool loadPlans(const DtFilename& filename);
1341  virtual bool loadPlansFromZipFile(const DtFilename& scenarioZipFile, const DtFilename& filename);
1342  virtual bool loadPlans(const std::string& buffer);
1343 
1345  virtual bool loadGlobalPlans(const DtFilename& filename);
1346  virtual bool loadGlobalPlansFromZipFile(const DtFilename& scenarioZipFile, const DtFilename& filename);
1347 
1349  virtual void loadHostilityAndExtras(const DtScenarioExplorer& se);
1350  virtual void loadHostilityAndExtrasFromZipFile(const DtFilename& scenarioZipFile, const DtScenarioExplorer& se);
1351  virtual void loadHostilityAndExtras(const std::string& buffer);
1352 
1355  virtual void loadActivities(const DtScenarioExplorer&);
1356 
1359  virtual void loadModelSetFiles(const DtScenarioExplorer&);
1360 
1363  virtual void loadActionCategories(const DtFilename& f);
1364 
1365  virtual bool loadForceHostility(const DtFilename& filename, bool clear = true);
1366  virtual bool loadForceHostilityFromZipFile(const DtFilename& scenarioZipFile, const DtFilename& filename, bool clear = true);
1367 
1368  virtual bool loadScenarioExtras(const DtFilename& filename);
1369  virtual bool loadScenarioExtrasFromZipFile(const DtFilename&, const DtFilename& filename);
1370  virtual bool loadScenarioExtras(const std::string& buffer);
1371 
1374  virtual void processObjectParametersOp(DtSimMessage * msg);
1375 
1377  virtual void createAndInitScenarioLoadManager();
1378 
1381  virtual void emptyParametersDB();
1382 
1384  virtual void setAutoReorganization(bool onOff);
1385 
1389  virtual DtVrfPlugin* loadPlugin(const DtString&);
1390 
1393  virtual bool setupCommModelsForScenario(const DtScenarioExplorer& e);
1394 
1398  virtual void updateReadyStatus();
1399 
1402 
1403  static void simCommandCallback(DtSimMessage* msg, void* usr);
1404  virtual void processSimCommand(DtSimMessage* msg);
1406 
1410 
1411  static void deferredLoadScenarioCallback(void * data);
1412  virtual void processDeferredLoadScenario();
1413 
1416  virtual void processLoadScenario(const DtScenario* = 0, const DtInMemorySnapshot* = 0);
1418 
1420 
1421  static void deferredReinitializeScenarioCallback(void * data);
1422  virtual void processDeferredReinitializeScenario();
1424 
1429 
1430  static void deferredRollbackCallback(void * data);
1431  virtual void processDeferredRollback();
1433 
1437 
1438  static void deferredImportScenarioCallback(void * data);
1439  virtual void processDeferredImportScenario();
1441 
1445 
1446  static void deferredRewindCallback(void * data);
1447  virtual void processDeferredRewind();
1449 
1452  virtual void clearAllSimulationModelSetInformation();
1453 
1455  virtual void initializeCgfConsoleCommands();
1456 
1457  virtual void processCloseScenarioEvent(const makVrfEvents::DtEvent&);
1458  virtual void processLoadScenarioEvent(const makVrfEvents::DtEvent&);
1459 
1461  virtual bool createDIGuyCharacterManager(const DtFilename & diGuyAnimationsFile);
1462 
1463 protected:
1464  DtVrfSimOptionsInterface* mySimOptions;
1465 
1467  DtSimulationAddress mySimulationAddress;
1468 
1470  DtU32 mySessionId;
1471 
1473  bool myOK;
1474 
1476  bool myTimeToQuit;
1477 
1479  DtVrfPluginManager* myPluginManager;
1480  std::vector<DtString> myPluginsToLoad;
1481  bool myLoadPluginsIfVersionMismatch;
1482 
1484  DtTerrainInterface* myTerrainInterface;
1485 
1487  DtPhysicalWorld* myPhysicalWorld;
1488 
1489  DtVrfNavAreaManager* myVrfNavAreaManager;
1490 
1491  DtSpawnSinkManager* mySpawnSinkManager;
1492 
1493  DtCommModelManager* myCommModelManager;
1494 
1495  DtSimTerrainRequestManager* mySimTerrainRequestManager;
1496 
1498  DtCommunicationManager* myCommunicationManager;
1499 
1501  DtSimManager* mySimManager;
1502 
1504  DtCreateObjectServiceInterface* myCreateObjectService;
1505 
1507  DtScenarioServiceInterface* myScenarioService;
1508 
1510  DtScenario* myScenario;
1511 
1513  DtVrfStatusPublisher* myStatusPublisher;
1514 
1516  DtLocalObjectManager* myObjectManager;
1517 
1519  DtDebugDrawManager* myDebugDrawManager;
1520 
1521  DtDetonationManager* myDetonationManager;
1522  DtAmmunitionManager* myAmmunitionManager;
1523  DtScriptedTaskManager* myScriptedTaskManager;
1524  DtScenarioEventManager* myScenarioEventManager;
1525  DtHazardAreaManager* myHazardAreaManager;
1526  DtIntelCollectionAreaManager* myIntelCollectionAreaManager;
1527  DtScriptedObjectsMovementManager* myScriptedObjectsMovementManager;
1528  DtFireManager* myFireManager;
1529  DtObjectConsoleManager* myObjectConsoleManager;
1530  DtManagedObjectListManager* myFilteredObjectListManager;
1531  DtOrbatManager* myOrbatManager;
1532  DtObjectGeometricModelsManager* myObjectModelsManager;
1533  DtVrfObjectPlanAdministrator* myPlanAdministrator;
1534  DtSimInternalCommunicationManager* mySimInternalCommunicationManager;
1535  DtDiGuyCharacterDataManager * myCharacterMgr;
1536  bool myCreatedCharacterManager;
1537 
1538  DtLuaObjectSerializer* myLuaObjectSerializer;
1539 
1541  DtResourceMonitor* myResourceMonitor;
1542 
1544  DtRadarCoverageMonitor* myRadarCoverageMonitor;
1545 
1547  DtTerrainProfileRequestManager* myTerrainProfileRequestManager;
1548 
1550  DtVrfParameterDb* myParameterDatabase;
1551 
1553  DtEmbeddedEntityInfoManager* myEmbeddedEntityInfoManager;
1554 
1556  bool myForceParameterDbReload;
1557 
1558  DtGlobalPlanManager* myGlobalPlanManager;
1559 
1560  DtHostilityManager* myHostilityManager;
1561  DtEngagementZonesManager* myEngagementZonesManager;
1562 
1563  DtScenarioExtrasMgr* myScenarioExtrasManager;
1564 
1566  DtFactoryManager* myFactoryManager;
1567 
1569  DtStealthCommandsManager* myStealthCommandsManager;
1570 
1571  DtSimCommandDistributor* mySimCommandDistributor;
1572 
1577  DtFilename myVrfTerrainPathDirectory;
1578 
1582  DtFilename myDefaultTerrainDirectory;
1583 
1585  DtFilename myDefaultSimulationModelSetFilename;
1586 
1588  DtFilename myDIGuyAnimationsFilename;
1589 
1591  DtFilename myMsdlSidcMappingFile;
1592 
1594  DtFilename myCountryCodesMappingFile;
1595 
1598  bool myParameterDbLoaded;
1599 
1601  DtFilename myCurrentParameterDatabaseFilename;
1602 
1606  DtFilename myDefaultParameterDbDirectory;
1607 
1608  DtCallbackList<const DtFilename&> myPreLoadTerrainCallbacks;
1609  DtCallbackList<const DtFilename&> myPostLoadTerrainCallbacks;
1610  DtCallbackList<DtScenario&> myPreLoadScenarioCallbacks;
1611  DtCallbackList<const DtScenario&> myPostLoadScenarioCallbacks;
1612  DtCallbackList<DtScenario&> myPreScenarioReinitializeCallbacks;
1613  DtCallbackList<const DtScenario&> myPostScenarioReinitializeCallbacks;
1614  DtCallbackList<DtScenario&> myPreCreateSimulationObjectGroupCallbacks;
1615  DtCallbackList<const DtScenario&> myPostCreateSimulationObjectGroupCallbacks;
1616  DtCallbackList<DtScenario&> myPreImportScenarioCallbacks;
1617  DtCallbackList<const DtScenario&> myPostImportScenarioCallbacks;
1618  DtCallbackList<DtScenario&> myPreSaveScenarioCallbacks;
1619  DtCallbackList<const DtScenario&> myPostSaveScenarioCallbacks;
1620 
1621  DtCallbackList<DtScenario&> myPreSaveSimulationObjectGroupsCallbacks;
1622  DtCallbackList<const DtScenario&> myPostSaveSimulationObjectGroupsCallbacks;
1623 
1624  DtNoArgumentCallbackList myPreCloseScenarioCallbacks;
1625  DtNoArgumentCallbackList myPostCloseScenarioCallbacks;
1626  DtNoArgumentCallbackList myScenarioRunCallbacks;
1627  DtNoArgumentCallbackList myScenarioPauseCallbacks;
1628  DtNoArgumentCallbackList myPreScenarioRewindCallbacks;
1629  DtNoArgumentCallbackList myPostScenarioRewindCallbacks;
1630  DtNoArgumentCallbackList myPostTickCallbacks;
1631 
1632  DtSyncMatrixManager* mySyncMatrixManager;
1633 
1638  void setVrfCreator(DtVrfCreator* creator);
1640 
1642 
1643  bool ownVrfCreator() const;
1644  void setOwnVrfCreator(bool yesOrNo);
1646 
1648  virtual bool differingModelSets(DtScenario*) const;
1649 
1650  virtual void simControlEvent(const makVrfEvents::DtEvent&);
1651 
1652  virtual void clearObjectsAwaitingDiscovery();
1653  virtual void processObjectsAwaitingDiscovery();
1654 
1655 protected:
1658  bool myOwnVrfCreatorFlag;
1659  DtVrfCreator* myVrfCreator;
1660 
1662  bool myFullyLoadTerrain;
1663 
1667  bool myAssertOnBlockingTerrainCalls;
1668 
1671  DtSimulationModelSet* myDefaultModelSet;
1672 
1676  DtScenario myScenarioToLoad;
1677 
1678  bool myCreateGlobalEnvironment;
1679  bool myCreateGlobalDynamicTerrain;
1680  bool myCreatedGlobalEnvironment;
1681  bool myCreatedGlobalDynamicTerrain;
1682 
1687  bool myWasPaused;
1688 
1690  DtImportExportScenarioDescriptionManager* myImportScenarioDescriptionManager;
1691 
1692  DtConsoleCommandOwner* myConsoleCommands;
1693 
1696  typedef std::pair<std::string, bool> ActionCategory;
1697  typedef std::map<std::string, ActionCategory> ActionCategories;
1698  ActionCategories myActionCategories;
1699 
1701  DtIfScenarioStatus* myScenarioStatus;
1702 
1703  bool myPublishingGlobalEnvironment;
1704  bool myAboutToLoadOrRewindScenario;
1705  bool myReinitializingScenario;
1706 
1707  bool myMetocEnabled;
1708 
1709  DtTaskVisualizationPublicationMode myTaskVisualizationPublicationMode;
1710  bool myUseDrawControlForTaskVisualizations;
1711 
1712  bool myReuseEntityIdentifiersOnScenarioLoad;
1713 
1714  DtRwActivities myActivities;
1715  bool mySmsValidationEnabled;
1716  DtSnapshotManager* mySnapshotManager;
1717  DtSimObjectManager* mySimObjectManager;
1718 
1719  std::vector<DtFilename> myObjectGroupsRoot;
1720 
1721  struct SimulationObjectGroupInformation
1722  {
1723  DtlObjPtr planArgs;
1724  DtlObjPtr oobArgs;
1725  };
1726 
1727  typedef std::map<DtString, SimulationObjectGroupInformation> StoredSimulationObjectGroupInformation;
1728  StoredSimulationObjectGroupInformation myStoredSimulationObjectGroupInformation;
1729 
1730  int myRollbackToId;
1731  bool myCanSimulate;
1732  bool myIsLoaded;
1733  bool myHasModelSetInformationLoadedAfterClose;
1734  int myReloadDelay;
1735  bool myRejectMismatchedScenarioMessages;
1736  DtU32 myScenarioCapabilities;
1737  int myAppIdRangeMax;
1738 
1739  std::set<DtFilename> myLoadedModelSets;
1740 
1741  DtInMemorySnapshot* myQueuedRollback;
1742  int myQueuedRollbackScenarioRunId;
1743 
1744  DtScenarioLoadManager* myScenarioLoadManager;
1745 
1746  typedef std::vector<DtLoadOrderOfBattleHandler*>SimulationObjectGroupsToBeCreated;
1747  SimulationObjectGroupsToBeCreated mySimulationObjectGroupsToBeCreated;
1748 
1749 public:
1752  VRF4API_METHOD DtLocalObjectManager* vrfObjectManager() { return myObjectManager; };
1753  VRF4API_METHOD DtCommunicationManager* exerciseConn() { return myCommunicationManager; };
1755 
1756 };
1757 
DtUUID
UUID is a unique ID wrapper class.
Definition: rwUUID.h:226
DtCgf::myObjectConsoleManager
DtObjectConsoleManager * myObjectConsoleManager
Definition: cgf.h:1529
DtCgf::myIsLoaded
bool myIsLoaded
Definition: cgf.h:1732
DtCgf::myObjectModelsManager
DtObjectGeometricModelsManager * myObjectModelsManager
Definition: cgf.h:1532
DtCgf::myCommunicationManager
DtCommunicationManager * myCommunicationManager
The current exercise connection.
Definition: cgf.h:1498
DtCgf::mySimManager
DtSimManager * mySimManager
Pointer to the DtSimManager.
Definition: cgf.h:1501
DtCgf::myCreateGlobalEnvironment
bool myCreateGlobalEnvironment
Definition: cgf.h:1678
DtCgf::myPublishingGlobalEnvironment
bool myPublishingGlobalEnvironment
Definition: cgf.h:1703
DtCgf::myScenarioStatus
DtIfScenarioStatus * myScenarioStatus
Scenario status message to be sent out upon request.
Definition: cgf.h:1701
DtLocalObjectManager
class DtLocalObjectManager:
Definition: localObjectManager.h:151
DtCgf::communicationManager
DtCommunicationManager * communicationManager()
Definition: cgf.h:379
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:1522
DtCgf::myGlobalPlanManager
DtGlobalPlanManager * myGlobalPlanManager
Definition: cgf.h:1558
DtCgf::myUseDrawControlForTaskVisualizations
bool myUseDrawControlForTaskVisualizations
Definition: cgf.h:1710
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:1523
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:1569
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:1627
DtCgf::myPreLoadScenarioCallbacks
DtCallbackList< DtScenario & > myPreLoadScenarioCallbacks
Definition: cgf.h:1610
DtCgf::myCreateObjectService
DtCreateObjectServiceInterface * myCreateObjectService
Pointer to the create object service.
Definition: cgf.h:1504
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:1614
DtCgf::myOK
bool myOK
Flag indicating whether we have been successfully initialized.
Definition: cgf.h:1473
DtCgf::myPreCloseScenarioCallbacks
DtNoArgumentCallbackList myPreCloseScenarioCallbacks
Definition: cgf.h:1624
DtCgf::mySimCommandDistributor
DtSimCommandDistributor * mySimCommandDistributor
Definition: cgf.h:1571
DtCgf::myPhysicalWorld
DtPhysicalWorld * myPhysicalWorld
The current physical world.
Definition: cgf.h:1487
DtCgf::myDefaultSimulationModelSetFilename
DtFilename myDefaultSimulationModelSetFilename
Default simulation model set file to load.
Definition: cgf.h:1585
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:1662
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:1696
DtCgf::myPreScenarioReinitializeCallbacks
DtCallbackList< DtScenario & > myPreScenarioReinitializeCallbacks
Definition: cgf.h:1612
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:1563
DtScenarioExplorer
class DtScenarioExplorer:
Definition: scenarioExplorer.h:26
DtCgf::mySmsValidationEnabled
bool mySmsValidationEnabled
Definition: cgf.h:1715
DtCgf::myPostCreateSimulationObjectGroupCallbacks
DtCallbackList< const DtScenario & > myPostCreateSimulationObjectGroupCallbacks
Definition: cgf.h:1615
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:1510
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:1724
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:1719
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:1577
DtCgf::myTimeToQuit
bool myTimeToQuit
Flag indicating whether or not the app should quit.
Definition: cgf.h:1476
DtTerrainProfileRequestManager
Definition: terrainProfileRequestManager.h:31
DtCgf::myPostCloseScenarioCallbacks
DtNoArgumentCallbackList myPostCloseScenarioCallbacks
Definition: cgf.h:1625
DtCgf::myPostTickCallbacks
DtNoArgumentCallbackList myPostTickCallbacks
Definition: cgf.h:1630
DtCgf::myResourceMonitor
DtResourceMonitor * myResourceMonitor
Pointer to the DtResourceMonitor.
Definition: cgf.h:1541
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:1679
DtCgf::myCanSimulate
bool myCanSimulate
Definition: cgf.h:1731
DtCgf::myVrfNavAreaManager
DtVrfNavAreaManager * myVrfNavAreaManager
Definition: cgf.h:1489
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:1746
DtCgf::myHasModelSetInformationLoadedAfterClose
bool myHasModelSetInformationLoadedAfterClose
Definition: cgf.h:1733
DtCgf::myAppIdRangeMax
int myAppIdRangeMax
Definition: cgf.h:1737
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:1741
DtCgf::myCommModelManager
DtCommModelManager * myCommModelManager
Definition: cgf.h:1493
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:1681
DtIfScenarioStatus
Definition: ifScenarioStatus.h:28
DtCgf::mySimOptions
DtVrfSimOptionsInterface * mySimOptions
Definition: cgf.h:1464
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:1712
DtCgf::myStatusPublisher
DtVrfStatusPublisher * myStatusPublisher
Pointer to the DtStatusPublisher.
Definition: cgf.h:1513
DtCgf::myTaskVisualizationPublicationMode
DtTaskVisualizationPublicationMode myTaskVisualizationPublicationMode
Definition: cgf.h:1709
DtCgf::myDIGuyAnimationsFilename
DtFilename myDIGuyAnimationsFilename
DI_Guy animation configuration file to load.
Definition: cgf.h:1588
DtObjectType
Definition: objectType.h:27
DtCgf::myRejectMismatchedScenarioMessages
bool myRejectMismatchedScenarioMessages
Definition: cgf.h:1735
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:1753
DtCgf::myParameterDatabase
DtVrfParameterDb * myParameterDatabase
Pointer to the DtVrfParameterDb.
Definition: cgf.h:1550
DtCgf::myObjectManager
DtLocalObjectManager * myObjectManager
Pointer to the DtLocalObjectManager.
Definition: cgf.h:1516
DtCgf::myPreSaveScenarioCallbacks
DtCallbackList< DtScenario & > myPreSaveScenarioCallbacks
Definition: cgf.h:1618
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:1608
DtInMemorySnapshot::OOB
std::vector< std::string * > OOB
Definition: snapshotManager.h:44
DtCgf::StoredSimulationObjectGroupInformation
std::map< DtString, SimulationObjectGroupInformation > StoredSimulationObjectGroupInformation
Definition: cgf.h:1727
DtCommunicationManagerPerformanceTimerInformation
Definition: communicationManager.h:36
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:1553
DtCgf::myImportScenarioDescriptionManager
DtImportExportScenarioDescriptionManager * myImportScenarioDescriptionManager
The scenario description manager used to import scenario description files.
Definition: cgf.h:1690
DtCgf::myCreatedGlobalEnvironment
bool myCreatedGlobalEnvironment
Definition: cgf.h:1680
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:1521
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:1594
DtCgf::myDefaultParameterDbDirectory
DtFilename myDefaultParameterDbDirectory
Default parameter database directory to search in when parameter database being specified is not an a...
Definition: cgf.h:1606
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:1524
DtCgf::myScenarioService
DtScenarioServiceInterface * myScenarioService
Pointer to the scenario object service.
Definition: cgf.h:1507
DtCgf::myTerrainProfileRequestManager
DtTerrainProfileRequestManager * myTerrainProfileRequestManager
Pointer to the DtTerrainProfileRequestManager.
Definition: cgf.h:1547
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:1752
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:1609
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:1728
DtCgf::myScenarioRunCallbacks
DtNoArgumentCallbackList myScenarioRunCallbacks
Definition: cgf.h:1626
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:1479
DtReaderWriter::SearchPaths
std::vector< DtFilename > SearchPaths
Definition: readerWriter.h:92
DtCgf::myQueuedRollbackScenarioRunId
int myQueuedRollbackScenarioRunId
Definition: cgf.h:1742
DtCgf::myCreatedCharacterManager
bool myCreatedCharacterManager
Definition: cgf.h:1536
DtCgf::mySimulationObjectGroupsToBeCreated
SimulationObjectGroupsToBeCreated mySimulationObjectGroupsToBeCreated
Definition: cgf.h:1747
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:1687
DtCallbackList
Definition: noArgumentCallbackList.h:91
DtCgf::myIntelCollectionAreaManager
DtIntelCollectionAreaManager * myIntelCollectionAreaManager
Definition: cgf.h:1526
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:1667
DtCgf::myPreSaveSimulationObjectGroupsCallbacks
DtCallbackList< DtScenario & > myPreSaveSimulationObjectGroupsCallbacks
Definition: cgf.h:1621
DtCgf::mySyncMatrixManager
DtSyncMatrixManager * mySyncMatrixManager
Definition: cgf.h:1632
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:1622
DtCgf::myDefaultModelSet
DtSimulationModelSet * myDefaultModelSet
Default simulation model set. This is created when the default simulation model set filename is set o...
Definition: cgf.h:1671
DtCgf::myActivities
DtRwActivities myActivities
Definition: cgf.h:1714
DtVrfPluginManager
Definition: vrfPluginManager.h:73
DtCgf::myScenarioLoadManager
DtScenarioLoadManager * myScenarioLoadManager
Definition: cgf.h:1744
DtCgf::myRadarCoverageMonitor
DtRadarCoverageMonitor * myRadarCoverageMonitor
Pointer to the DtRadarCoverageMonitor.
Definition: cgf.h:1544
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:1566
DtCgf::myActionCategories
ActionCategories myActionCategories
Definition: cgf.h:1698
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:1676
DtCgf::myHazardAreaManager
DtHazardAreaManager * myHazardAreaManager
Definition: cgf.h:1525
DtCgf::myPluginsToLoad
std::vector< DtString > myPluginsToLoad
Definition: cgf.h:1480
DtCgf::myPostSaveScenarioCallbacks
DtCallbackList< const DtScenario & > myPostSaveScenarioCallbacks
Definition: cgf.h:1619
DtCgf::myReinitializingScenario
bool myReinitializingScenario
Definition: cgf.h:1705
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:274
DtCgf::mySimObjectManager
DtSimObjectManager * mySimObjectManager
Definition: cgf.h:1717
DtCgf::mySimInternalCommunicationManager
DtSimInternalCommunicationManager * mySimInternalCommunicationManager
Definition: cgf.h:1534
DtPlan
class DtPlan:
Definition: plan.h:92
DtCgf::myOrbatManager
DtOrbatManager * myOrbatManager
Definition: cgf.h:1531
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:1616
translatableStream.h
Contains the DtTranslatableStream class declaration.
DtCgf::myLoadedModelSets
std::set< DtFilename > myLoadedModelSets
Definition: cgf.h:1739
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:44
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:89
DtCgf::myPostScenarioRewindCallbacks
DtNoArgumentCallbackList myPostScenarioRewindCallbacks
Definition: cgf.h:1629
DtCgf::myAboutToLoadOrRewindScenario
bool myAboutToLoadOrRewindScenario
Definition: cgf.h:1704
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:1556
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:1716
DtCgf::myEngagementZonesManager
DtEngagementZonesManager * myEngagementZonesManager
Definition: cgf.h:1561
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:385
DtCgf::myPostImportScenarioCallbacks
DtCallbackList< const DtScenario & > myPostImportScenarioCallbacks
Definition: cgf.h:1617
DtCgf::myMetocEnabled
bool myMetocEnabled
Definition: cgf.h:1707
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:1533
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:1495
DtCgf::myPostLoadScenarioCallbacks
DtCallbackList< const DtScenario & > myPostLoadScenarioCallbacks
Definition: cgf.h:1611
DtCgf::myReloadDelay
int myReloadDelay
Definition: cgf.h:1734
DtCgf::myVrfCreator
DtVrfCreator * myVrfCreator
Definition: cgf.h:1659
DtCgf::myCharacterMgr
DtDiGuyCharacterDataManager * myCharacterMgr
Definition: cgf.h:1535
DtCgf::myPreScenarioRewindCallbacks
DtNoArgumentCallbackList myPreScenarioRewindCallbacks
Definition: cgf.h:1628
DtCgf::canSimulate
virtual bool canSimulate() const
Whether or not the cgf is ready to simulate.
Definition: cgf.h:377
DtCgf::myCurrentParameterDatabaseFilename
DtFilename myCurrentParameterDatabaseFilename
Filename of currently loaded parameter database.
Definition: cgf.h:1601
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:1530
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:1723
DtCgf::myScenarioCapabilities
DtU32 myScenarioCapabilities
Definition: cgf.h:1736
DtCgf::myOwnVrfCreatorFlag
bool myOwnVrfCreatorFlag
These are essentially cached from the init call. This is necessary as the load terrain.
Definition: cgf.h:1658
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:1598
DtCgf::myHostilityManager
DtHostilityManager * myHostilityManager
Definition: cgf.h:1560
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:1491
DtCgf
The top level class of a VR-Forces Simulation Engine, representing a Computer Generated Forces instan...
Definition: cgf.h:143
DtCgf::myLuaObjectSerializer
DtLuaObjectSerializer * myLuaObjectSerializer
Definition: cgf.h:1538
DtCgf::myConsoleCommands
DtConsoleCommandOwner * myConsoleCommands
Definition: cgf.h:1692
DtCgf::myFireManager
DtFireManager * myFireManager
Definition: cgf.h:1528
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:1527
DtCgf::myDebugDrawManager
DtDebugDrawManager * myDebugDrawManager
Pointer to the DtDebugDrawManagert.
Definition: cgf.h:1519
DtCgf::myPostScenarioReinitializeCallbacks
DtCallbackList< const DtScenario & > myPostScenarioReinitializeCallbacks
Definition: cgf.h:1613
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:1484
DtCgf::mySessionId
DtU32 mySessionId
Session Id.
Definition: cgf.h:1470
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:1582
DtCgf::myLoadPluginsIfVersionMismatch
bool myLoadPluginsIfVersionMismatch
Definition: cgf.h:1481
DtCgf::mySimulationAddress
DtSimulationAddress mySimulationAddress
Address for routing interface messages.
Definition: cgf.h:1467
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:1697
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:1730
DtCgf::myMsdlSidcMappingFile
DtFilename myMsdlSidcMappingFile
MSDL SDIC mapping file to load.
Definition: cgf.h:1591
DtTaskVisualizationPublicationMode
DtTaskVisualizationPublicationMode
Defines how task visualizations will be published.
Definition: scenarioServiceInterface.h:21
Document ID: Generated on Mon Jun 20 00:38:30 EDT 2022 from SVN revision 244029
Copyright © 2005-2021 MAK Technologies. All Rights Reserved (www.mak.com)