VR-Forces Developer's Guide
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Groups Pages
cgf.h
Go to the documentation of this file.
1 /*******************************************************************************
2 ** Copyright (c) 2019 MAK Technologies, Inc.
3 ** All rights reserved.
4 *******************************************************************************/
5 
6 #pragma once
7 
10 
12 
13 #ifdef WIN32
14 #include <winsock2.h>
15 #endif
16 
17 #include <vlutil/vlFilename.h>
18 #include <vlutil/vlTime.h>
19 #include <vector>
20 #include <vlutil/vlPrint.h>
21 #include <vrfobjcore/translatableStream.h>
22 #include <vrfobjcore/loadScenarioData.h>
23 #include <vrfcore/scenarioServiceInterface.h>
24 #include <readerWriter/noArgumentCallbackList.h>
25 #include "vrfcgf/snapshotManager.h"
26 #include "vrfutil/scenario.h"
27 #include "vrfutil/scenarioExplorer.h"
28 #include "vrfutil/outputLogger.h"
29 #include "vrfutil/rwActivities.h"
30 #include <boost/unordered_set.hpp>
31 #include <vrfutil/vrf4XAPI.h>
32 
33 struct DtLoadScenarioData;
34 class DtOrbatManager;
35 class DtObjectGeometricModelsManager;
36 class DtAdminContent;
37 class DtIfScenarioStatus;
38 class DtDebugDrawManager;
39 class DtCreateObjectServiceInterface;
40 class DtScenarioServiceInterface;
41 class DtSimulationModelSet;
42 class DtSimObjectManager;
43 class DtCommunicationManager;
44 class DtScenario;
45 class DtScenarioExplorer;
46 class DtPhysicalWorld;
47 class DtVrfNavAreaManager;
48 class DtLocalObjectManager;
49 class DtCommModelManager;
50 class DtTerrainInterface;
51 class DtVrfCreator;
52 struct DtInMemorySnapshot;
53 class DtSimManager;
54 class DtSimOperationsInProgressManager;
55 class DtObjectConsoleManager;
56 class DtScriptedTaskManager;
57 class DtScenarioEventManager;
58 class DtSimInternalCommunicationManager;
59 class DtHazardAreaManager;
60 class DtIntelCollectionAreaManager;
61 class DtCompressedFileTransporter;
62 class DtIfSaveScenario;
63 class DtSimulationServices;
64 class DtScriptedObjectsMovementManager;
65 class DtVrfStatusPublisher;
66 class DtEmbeddedEntityInfoManager;
67 class DtDetonationManager;
68 class DtAmmunitionManager;
69 class DtFireManager;
70 class DtVrfObjectPlanAdministrator;
71 class DtGlobalPlanManager;
72 class DtJoyDeviceManager;
73 class DtHostilityManager;
74 class DtEngagementZonesManager;
75 class DtScenarioExtrasMgr;
76 class DtCustomReportManager;
77 class DtStealthCommandsManager;
78 class DtFactoryManager;
79 class DtLoadOrderOfBattleHandler;
80 class DtObjectType;
81 class DtList;
82 class DtSimTask;
83 class DtSetDataRequest;
84 class DtPlan;
85 class DtPaperMapDatabase;
86 class DtMapDatum;
87 class DtVrfParameterDb;
88 class DtSimMessage;
89 class DtResourceMonitor;
90 class DtRadarCoverageMonitor;
91 class DtTerrainProfileRequestManager;
92 class DtVrfPlugin;
93 class DtVrfPluginManager;
94 class DtSimCommand;
95 class DtImportExportScenarioDescriptionManager;
96 class DtLuaObjectSerializer;
97 struct DtOrganizationManagerReadyCallbackInfo;
98 class DtConsoleCommandOwner;
99 class DtSimTerrainRequestManager;
100 class DtTimer;
101 class DtVrfSimOptionsInterface;
102 class DtSpawnSinkManager;
103 class DtSnapshotManager;
104 class DtSimCommandDistributor;
105 class DtApplicationSettings;
106 class DtNetworkInterfaceManager;
107 class DtScenarioLoadManager;
108 class DtManagedObjectListManager;
109 class DtDiGuyCharacterDataManager;
110 class DtSyncMatrixManager;
111 class DtAisDataManager;
112 class DtAdsbDataManager;
113 class DtInfluenceEventDispatcher;
114 struct DtCommunicationManagerPerformanceTimerInformation;
115 
116 namespace makVrfEvents
117 {
118  class DtEvent;
119  class DtEventManager;
120 }
121 
122 namespace makVrf
123 {
124  class DtStateDataManager;
125 }
126 
146 #include "vrfcgf/vrfcgfDefines.h"
147 class DT_DLL_vrfcgf DtCgf
148 {
149 public:
150 
157  DtCgf(const DtSimulationAddress& addr, const DtU32& capabilities = 0xffff);
158 
182  virtual bool init(DtCommunicationManager* conn, DtU32 sessionId = 1, DtVrfCreator* creator = 0, bool checkDataDir = true);
183 
185  virtual ~DtCgf();
186 
188  virtual const DtVrfSimOptionsInterface* simOptions() const;
189 
191  virtual void setSimOptions(const DtVrfSimOptionsInterface&);
192 
195  virtual void tick();
196 
199  virtual void sendFinalStatus(bool sendImmediately = false);
200 
204  virtual bool importScenarioDescriptionFile(const DtFilename& file, const DtString& format,
207  const std::map<std::string, std::string>& importData);
208 
212  virtual DtString exportScenarioDescriptionFile(const DtFilename& file, const DtString& format,
213  const std::map<std::string, std::string>& exportData);
214 
216  virtual void setAppDataDir(const DtString&);
217  virtual DtFilename appDataDir() const;
218 
220  virtual void setSimulationAddress(const DtSimulationAddress&);
221 
223  virtual void setUserDataDir(const DtString&);
224  virtual DtFilename userDataDir() const;
225 
227  virtual void setDataDir(const DtString&);
228  virtual DtFilename dataDir() const;
229 
233  virtual DtFilename sharedDataDir() const;
234  virtual void setSharedDataDir(const DtFilename& path);
235 
236  virtual DtFilename sharedDataRoot() const;
237  virtual void setSharedDataRoot(const DtFilename& path);
238 
239  virtual DtString sharedDataStem() const;
240  virtual void setSharedDataStem(const DtString& path);
241 
243  virtual void setAppIdRangeMax(int);
244  int appIdRangeMax() const;
245 
249  virtual bool loadScenario(const DtFilename& name, int scenarioRunId = 0,
250  bool isOrbatEnabled = false, bool createGlobalEnv = false,
251  bool createGlobalDynamicTerrain = false);
252 
259  virtual bool loadScenario(const DtScenario& scenario, int scenarioRunId = 0,
260  bool isOrbatEnabled = false, bool createGlobalEnv = false,
261  bool createGlobalDynamicTerrain = false);
262 
264  virtual void queueRollbackTo(DtInMemorySnapshot* chkp, int scenarioRunId = 0);
265 
267  virtual bool rollbackTo(DtInMemorySnapshot* chkp, int scenarioRunId = 0);
268 
270  virtual void clearSimulationObjects();
271 
274  virtual bool importScenario(const DtScenario&);
275  virtual bool importScenario(const DtFilename&, int importScenarioFlags = DtDefaultScenarioImportFlags,
276  const DtString& deconflictingName = "");
277 
284  virtual bool newScenario(const DtFilename& dbname =
285  DtFilename::nullFilename(), const DtFilename& simulationModelSet =
286  DtFilename::nullFilename(), bool createGlobalEnv = false,
287  bool createGlobalDynamicTerrain = false);
288 
290  DtIfScenarioStatus* scenarioStatus() { return myScenarioStatus; };
291  const DtIfScenarioStatus* scenarioStatus() const { return myScenarioStatus; };
292 
293  virtual void sendScenarioStatusMessage();
294 
298  virtual bool saveScenario(const DtFilename& savename, bool saveAsSip = false);
299 
301  virtual bool takeSnapshot(DtInMemorySnapshot*);
302 
305  virtual void rollbackToSimTime(double simTime);
306 
309  virtual void takeSnapshot(bool makeBase);
310 
313  virtual bool saveSnapshot(const DtFilename& saveFolder,
314  DtCompressedFileTransporter&, DtIfSaveScenario* msg, const DtSimulationAddress& requestor);
315 
319  virtual bool saveSimulationObjectGroup(DtFilename saveFolder, const DtString& groupName,
320  int flags, std::set<DtUUID>& uuidsSaved, bool& savAsZipFile);
321 
327  virtual bool createSimulationObjectGroup(const DtString& group, int flags, int force, const DtVector& geocentricLocation,
328  double offsetRotation, bool storedInZipFile = false);
329 
334  virtual void closeScenario(const DtFilename& terrainToOpen = "", bool forceCloseAll = false);
335 
340  virtual bool loadAdditionalObjectParameters(const DtFilename& paramsFileName,
341  const DtReaderWriter::SearchPaths& searchPaths, bool preloadParameters = false);
343 
346  virtual void run();
347 
349  virtual void pause();
350 
352  virtual std::string protocol() const;
353 
359  virtual void rewind(int scenarioRunId = 0);
360 
362  virtual void setRejectMismatchedScenarioMessages(bool);
363  virtual bool rejectMismatchedScenarioMessages() const;
364 
369 
370  virtual void setForceParameterDbReload(bool reload);
371  virtual bool forceParameterDbReload() const;
373 
377 
378  virtual void setEnableResourceMonitor(bool b);
379  virtual bool isResourceMonitorEnabled() const;
381 
383  virtual bool canSimulate() const { return myCanSimulate; };
384 
385  DtCommunicationManager* communicationManager() { return myCommunicationManager; };
386  virtual makVrfEvents::DtEventManager* eventManager();
387 
388  virtual bool canSleep() const;
389 
391  virtual bool aboutToLoadOrRewindScenario() const { return myAboutToLoadOrRewindScenario; };
392 
396  virtual void setSmsValidationEnabled(bool b);
397 
409 
410  virtual const DtFilename& defaultTerrainDirectory();
411  virtual void setDefaultTerrainDirectory(const DtFilename& directory);
413 
414  virtual bool logFrameRateStatistics() const;
415  virtual void setLogFrameRateStatistics(bool yesOrNo);
416 
418  virtual void sendServerLoadMessage(const DtString& error, int level = DtNlWarn);
419 
424 
425  virtual const DtFilename& defaultSimulationModelSetFilename();
426  virtual void setDefaultSimulationModelSetFilename(const DtFilename& filename);
428 
432 
433  virtual const DtFilename& diGuyAnimationsFilename();
434  virtual void setDIGuyAnimationsFilename(const DtFilename& filename);
436 
438 
439  void setClockMode(int clockMode);
441 
443 
444  virtual void setMsdlSidcMappingFile(const DtFilename&);
445  virtual const DtFilename& msdlSidcMappingFile() const;
447 
450  virtual void setCountryCodesMappingFile(const DtFilename&);
451  virtual const DtFilename& countryCodesMappingFile() const;
453 
456  virtual DtSimulationModelSet* defaultModelSet();
458 
462  virtual void deleteObject(const DtUUID& name, bool andRemoveFromOrbat = true) const;
466 
477  virtual DtLocalObject* createWaypoint(const DtVector& localPosition,
478  const DtString& uniqueName = DtString::nullString()) const;
479 
492  virtual DtLocalObject* createRoute(const DtList& vertices,
493  const DtString& uniqueName = DtString::nullString()) const;
494 
506  virtual DtLocalObject* createPhaseLine(
507  const DtVector& dbPoint1,
508  const DtVector& dbPoint2,
509  const DtString& uniqueName = DtString::nullString()) const;
510 
522  virtual DtLocalObject* createControlArea(
523  const DtList& vertices,
524  const DtString& uniqueName = DtString::nullString()) const;
525 
537  virtual DtLocalObject* createObstacle(
538  const DtList& vertices,
539  const DtString& uniqueName = DtString::nullString()) const;
540 
568  virtual DtLocalObject* createEntity(
569  const DtEntityType& entityType,
570  DtForceType force,
571  const DtVector& dbPosition,
572  DtReal heading,
573  const DtString& entityName = DtString::nullString(),
574  bool allowBlocking = true,
575  std::list<DtAdminContent*>* initialAdminContent = 0,
576  bool addToOrbat = true) const;
577 
578 
608  virtual DtLocalObject* createAggregate(
609  const DtEntityType& aggregateType,
610  DtForceType force,
611  const DtVector& localPosition,
612  DtReal heading,
613  const std::vector<DtUUID>& subordinates = std::vector<DtUUID>(),
614  const DtString& aggregateName = DtString::nullString(),
615  bool addToOrbat = true) const;
616 
628  virtual DtLocalObject* createAggregate(
629  const DtEntityType& aggregateType,
630  DtForceType force,
631  const DtVector& localPosition,
632  DtReal heading,
633  bool createSubordinates,
634  const DtString& aggregateName = DtString::nullString(),
635  bool allowBlocking = true,
636  bool addToOrbat = true) const;
637 
649  virtual bool addSubordinate(DtLocalObject* subordinate,
650  DtLocalObject* aggregate);
651 
667  virtual bool removeSubordinate(DtLocalObject* subordinate,
668  DtLocalObject* aggregate);
670 
674  virtual void assignTask(const DtLocalObject* entity, const DtSimTask& task);
683 
692  virtual void sendSetDataRequest(const DtLocalObject* entity,
693  const DtSetDataRequest& request);
694 
696  virtual void assignPlanByUUID(const DtUUID&, const DtPlan& plan, bool sendPlan = false);
697 
702  virtual void abandonPlan(const DtLocalObject* entity);
703 
708  virtual void restartPlan(const DtLocalObject* entity);
710 
714  virtual void logObjectConsoleToFile(DtLocalObject* object,
719  DtFilename filename = DtFilename::nullFilename());
720 
722  virtual void stopLoggingObjectConsoleToFile(DtLocalObject* object);
723 
727  virtual void setObjectConsoleNotificationLevel(DtLocalObject* object,
728  DtNotifyLevelType level);
730 
737  virtual bool reuseEntityIdentifiersOnScenarioLoad() const;
738  virtual void setReuseEntityIdentifiersOnScenarioLoad(bool);
740 
743  virtual void setTaskVisualizationPublicationMode(DtTaskVisualizationPublicationMode mode);
744  virtual DtTaskVisualizationPublicationMode taskVisualizationPublicationMode() const;
746 
750  virtual void setUseDrawControlForTaskVisualizations(bool);
751  virtual bool useDrawControlForTaskVisualizations() const;
753 
754 
755  //-------------------------------------------------------
757  //-------------------------------------------------------
758 
761  virtual DtSimManager* simManager() const;
762  virtual DtSimulationServices* simulationServices() const;
763 
765  virtual DtImportExportScenarioDescriptionManager* importExportScenarioDescriptionManager() const;
766 
769  virtual DtResourceMonitor* resourceMonitor() const;
770 
772  virtual DtRadarCoverageMonitor* radarCoverageMonitor() const;
773 
775  virtual DtTerrainProfileRequestManager* terrainProfileRequestManager() const;
776 
779  virtual DtFactoryManager* factoryManager() const;
780 
782  virtual DtSnapshotManager* snapshotManager() const;
783 
784  virtual DtAisDataManager* aisDataManager() const;
785  virtual DtAdsbDataManager* adsbDataManager() const;
786 
790  virtual DtLocalObjectManager* localObjectManager() const;
791 
794  virtual DtSimObjectManager* simObjectManager() const;
795 
798  virtual DtDebugDrawManager* debugDrawManager() const;
799 
801  virtual DtScriptedTaskManager* scriptedTaskManager() const;
802 
804  virtual DtScenarioEventManager* scenarioEventManager() const;
805 
807  virtual DtHazardAreaManager* hazardAreaManager() const;
808 
810  virtual DtIntelCollectionAreaManager* intelCollectionAreaManager() const;
811 
813  virtual DtScriptedObjectsMovementManager* ScriptedObjectsMovementManager() const;
814 
817  virtual DtDetonationManager* detonationManager() const;
818 
821  virtual DtAmmunitionManager* ammunitionManager() const;
822 
825  virtual DtFireManager* fireManager() const;
826 
831  virtual DtScenarioExtrasMgr* scenarioExtrasMgr() const;
832 
834  virtual DtVrfParameterDb* parameterDatabase() const;
835 
837  virtual DtGlobalPlanManager* globalPlanManager();
838 
840  virtual DtStealthCommandsManager* stealthCommandsManager();
841 
844 
845  virtual DtTerrainInterface* terrainInterface();
846  virtual const DtTerrainInterface* terrainInterface() const;
848 
851 
852  virtual DtPhysicalWorld* physicalWorld();
853  virtual const DtPhysicalWorld* physicalWorld() const;
855 
857  virtual void setPhysicalWorld(DtPhysicalWorld* newPhysicalWorld);
858 
859  virtual DtVrfNavAreaManager* vrfNavAreaManager();
860  virtual const DtVrfNavAreaManager* vrfNavAreaManager() const;
861 
862  virtual void setVrfNavAreaManager(DtVrfNavAreaManager* newVrfNavAreaManager);
863 
864  virtual DtSpawnSinkManager* spawnSinkManager();
865  virtual const DtSpawnSinkManager* spawnSinkManager() const;
866 
868 
869  virtual DtCommModelManager* commModelManager();
870  virtual const DtCommModelManager* commModelManager() const;
872 
873  virtual const DtDiGuyCharacterDataManager* diGuyCharacterManager() const;
874 
876 
877  virtual DtSimTerrainRequestManager* simTerrainRequestManager();
878  virtual const DtSimTerrainRequestManager* simTerrainRequestManager() const;
880 
882  virtual DtSimCommandDistributor* simCommandDistributor();
883 
885  virtual DtScenario* scenario() const;
886 
889  virtual const DtSimulationAddress& simulationAddress() const;
890 
896  virtual int sessionId() const;
897 
903 
904  virtual DtU32 scenarioCapabilities() const;
905  virtual void setScenarioCapabilities(DtU32 v);
906  virtual void setScenarioCapability(DtU32 v, bool);
908 
910  virtual void setTimeMultiplier(double);
911 
914 
915  virtual DtString applicationType() const;
916  virtual void setApplicationType(const DtString& type);
918 
921  virtual DtVrfStatusPublisher* statusPublisher() const;
922 
926  virtual void useMapDatum(const DtMapDatum& mapDatum);
927 
929  virtual void setParameterDbLoaded(bool flag);
930 
936  virtual void setDefaultParameterDbDirectory(const DtFilename& filename);
937 
939  virtual DtFilename objectGroupsRoot() const;
940 
945  virtual bool reinitializeScenario();
946 
947  virtual void setFullyLoadTerrain(bool yesOrNo);
948  virtual bool fullyLoadTerrain() const;
949 
953 
954  virtual void setAssertOnBlockingTerrainCalls(bool b);
955  virtual bool assertOnBlockingTerrainCalls() const;
957 
961 
962  virtual void setMetocEnable(bool b);
963  virtual bool metocEnable() const;
965 
966  //-------------------------------------------------------
968  //-------------------------------------------------------
969 
972  virtual void addPluginToLoad(const DtString&);
973 
976  virtual void setLoadPluginsIfVersionMismatch(bool);
977  virtual bool loadPluginsIfVersionMismatch() const;
978 
980  virtual bool createAndInitPluginManager(DtVrfCreator* creator);
981 
984  virtual void initializePluginCommandLineArguments(DtApplicationSettings& appInitializer);
985 
987 
988  DtVrfCreator* vrfCreator();
989  const DtVrfCreator* vrfCreator() const;
991 
995 
996  virtual void addPreLoadTerrainCallback(
997  DtCallbackList<const DtFilename&>::DtCallbackFunctionType fcn, void* usrData);
998  virtual void removePreLoadTerrainCallback(
999  DtCallbackList<const DtFilename&>::DtCallbackFunctionType fcn, void* usrData);
1001 
1005 
1006  virtual void addPostLoadTerrainCallback(
1007  DtCallbackList<const DtFilename&>::DtCallbackFunctionType fcn, void* usrData);
1008  virtual void removePostLoadTerrainCallback(
1009  DtCallbackList<const DtFilename&>::DtCallbackFunctionType fcn, void* usrData);
1011 
1014  virtual void runForDuration(double);
1015 
1017  virtual void stopSimulationDurationTimer();
1018 
1020  static void runDurationCompleteCallback(void*);
1021  virtual void processRunDurationComplete();
1022 
1024  virtual void setPublishingGlobalEnvironment(bool);
1025 
1029 
1030  virtual void addPreLoadScenarioCallback(
1031  DtCallbackList<DtScenario&>::DtCallbackFunctionType fcn, void* usrData);
1032  virtual void removePreLoadScenarioCallback(
1033  DtCallbackList<DtScenario&>::DtCallbackFunctionType fcn, void* usrData);
1035 
1037 
1038  virtual void addPreScenarioReinitializeCallback(
1039  DtCallbackList<DtScenario&>::DtCallbackFunctionType fcn, void* usrData);
1040  virtual void removePreScenarioReinitializeCallback(
1041  DtCallbackList<DtScenario&>::DtCallbackFunctionType fcn, void* usrData);
1043 
1046 
1047  virtual void addPostScenarioReinitializeCallback(
1048  DtCallbackList<const DtScenario&>::DtCallbackFunctionType fcn, void* usrData);
1049  virtual void removePostScenarioReinitializeCallback(
1050  DtCallbackList<const DtScenario&>::DtCallbackFunctionType fcn, void* usrData);
1052 
1054 
1055  virtual void addPreCreateSimulationObjectGroupCallback(
1056  DtCallbackList<DtScenario&>::DtCallbackFunctionType fcn, void* usrData);
1057  virtual void removePreCreateSimulationObjectGroupCallback(
1058  DtCallbackList<DtScenario&>::DtCallbackFunctionType fcn, void* usrData);
1060 
1064 
1065  virtual void addPostLoadScenarioCallback(
1066  DtCallbackList<const DtScenario&>::DtCallbackFunctionType fcn, void* usrData);
1067  virtual void removePostLoadScenarioCallback(
1068  DtCallbackList<const DtScenario&>::DtCallbackFunctionType fcn, void* usrData);
1070 
1072 
1073  virtual void addPostCreateSimulationObjectGroupCallback(
1074  DtCallbackList<const DtScenario&>::DtCallbackFunctionType fcn, void* usrData);
1075  virtual void removePostCreateSimulationObjectGroupCallback(
1076  DtCallbackList<const DtScenario&>::DtCallbackFunctionType fcn, void* usrData);
1078 
1080 
1081  virtual void addPreImportScenarioCallback(
1082  DtCallbackList<DtScenario&>::DtCallbackFunctionType fcn, void* usrData);
1083  virtual void removePreImportScenarioCallback(
1084  DtCallbackList<DtScenario&>::DtCallbackFunctionType fcn, void* usrData);
1086 
1088 
1089  virtual void addPostImportScenarioCallback(
1090  DtCallbackList<const DtScenario&>::DtCallbackFunctionType fcn, void* usrData);
1091  virtual void removePostImportScenarioCallback(
1092  DtCallbackList<const DtScenario&>::DtCallbackFunctionType fcn, void* usrData);
1094 
1097 
1098  virtual void addPreSaveScenarioCallback(
1099  DtCallbackList<DtScenario&>::DtCallbackFunctionType fcn, void* usrData);
1100  virtual void removePreSaveScenarioCallback(
1101  DtCallbackList<DtScenario&>::DtCallbackFunctionType fcn, void* usrData);
1103 
1106 
1107  virtual void addPostSaveScenarioCallback(
1108  DtCallbackList<const DtScenario&>::DtCallbackFunctionType fcn, void* usrData);
1109  virtual void removePostSaveScenarioCallback(
1110  DtCallbackList<const DtScenario&>::DtCallbackFunctionType fcn, void* usrData);
1112 
1115 
1116  virtual void addPreCloseScenarioCallback(
1117  DtNoArgumentCallbackList::DtCallbackFunctionType fcn, void* usrData);
1118  virtual void removePreCloseScenarioCallback(
1119  DtNoArgumentCallbackList::DtCallbackFunctionType fcn, void* usrData);
1121 
1124 
1125  virtual void addCgfAboutToBeDestroyedCallback(
1126  DtNoArgumentCallbackList::DtCallbackFunctionType fcn, void* usrData);
1127  virtual void removeCgfAboutToBeDestroyedCallback(
1128  DtNoArgumentCallbackList::DtCallbackFunctionType fcn, void* usrData);
1130 
1133 
1134  virtual void addPostCloseScenarioCallback(
1135  DtNoArgumentCallbackList::DtCallbackFunctionType fcn, void* usrData);
1136  virtual void removePostCloseScenarioCallback(
1137  DtNoArgumentCallbackList::DtCallbackFunctionType fcn, void* usrData);
1139 
1141 
1142  virtual void addPreSaveSimulationObjectGroupsCallback(
1143  DtCallbackList<DtScenario&>::DtCallbackFunctionType fcn, void* usrData);
1144  virtual void removePreSaveSimulationObjectGroupsCallback(
1145  DtCallbackList<DtScenario&>::DtCallbackFunctionType fcn, void* usrData);
1147 
1149 
1150  virtual void addPostSaveSimulationObjectGroupsCallback(
1151  DtCallbackList<const DtScenario&>::DtCallbackFunctionType fcn, void* usrData);
1152  virtual void removePostSaveSimulationObjectGroupsCallback(
1153  DtCallbackList<const DtScenario&>::DtCallbackFunctionType fcn, void* usrData);
1155 
1158 
1159  virtual void addScenarioPauseCallback(
1160  DtNoArgumentCallbackList::DtCallbackFunctionType fcn, void* usrData);
1161  virtual void removeScenarioPauseCallback(
1162  DtNoArgumentCallbackList::DtCallbackFunctionType fcn, void* usrData);
1164 
1167 
1168  virtual void addScenarioRunCallback(
1169  DtNoArgumentCallbackList::DtCallbackFunctionType fcn, void* usrData);
1170  virtual void removeScenarioRunCallback(
1171  DtNoArgumentCallbackList::DtCallbackFunctionType fcn, void* usrData);
1173 
1178 
1179  virtual void addPreScenarioRewindCallback(
1180  DtNoArgumentCallbackList::DtCallbackFunctionType fcn, void* usrData);
1181  virtual void removePreScenarioRewindCallback(
1182  DtNoArgumentCallbackList::DtCallbackFunctionType fcn, void* usrData);
1184 
1187 
1188  virtual void addPostScenarioRewindCallback(
1189  DtNoArgumentCallbackList::DtCallbackFunctionType fcn, void* usrData);
1190  virtual void removePostScenarioRewindCallback(
1191  DtNoArgumentCallbackList::DtCallbackFunctionType fcn, void* usrData);
1193 
1196 
1197  virtual void addPostTickCallback(
1198  DtNoArgumentCallbackList::DtCallbackFunctionType fcn, void* usrData);
1199  virtual void removePostTickCallback(
1200  DtNoArgumentCallbackList::DtCallbackFunctionType fcn, void* usrData);
1202 
1204 
1205  virtual void setTimeToQuit(bool);
1206  virtual bool timeToQuit() const;
1208 
1220  virtual void setFrameRateMode(const DtString& mode, DtReal deltaTime = -1);
1221 
1225  virtual bool executeSimCommand(const DtSimCommand& simCommand);
1226 
1229  virtual void unloadTerrain();
1230 
1232  virtual bool isOrbatEnabled() const;
1233 
1235  virtual double timeScale() const;
1236 
1237  virtual void setRunInTimeManagementMode(bool);
1238 
1240  virtual DtSyncMatrixManager* syncMatrixManager();
1241 
1242 public:
1243 
1247  static void objectParametersOpCallback(DtSimMessage* msg, void* usr);
1248 
1249 protected:
1251  static void scenarioDescriptionCallback(DtSimMessage*, void* usr);
1252  virtual void processScenarioDescription(DtSimMessage*);
1253 
1255  static void setScenarioFilenameCallback(DtSimMessage*, void* usr);
1256  virtual void processSetScenarioFilename(DtSimMessage*);
1257 
1259  static void setRunDurationCallback(DtSimMessage*, void* usr);
1260  virtual void processSetRunDuration(DtSimMessage*);
1261 
1263  static void actionCategoriesRequestCallback(DtSimMessage* msg, void* usr);
1264  virtual void processActionCategoriesRequest(DtSimMessage* msg);
1265 
1267  static void scenarioStatusRequestCallback(DtSimMessage* msg, void* usr);
1268  virtual void processScenarioStatusRequest(DtSimMessage* msg);
1269 
1272  virtual bool beginFrame(DtCommunicationManagerPerformanceTimerInformation* info = nullptr);
1273  virtual bool advanceFrame();
1274 
1275 private:
1277  DtCgf(const DtCgf& original);
1279  DtCgf& operator=(const DtCgf& original);
1280 
1281 protected:
1284  virtual DtFilename spawnManagerTemplateFile(const DtScenarioExplorer&) const;
1285 
1287  virtual void loadAllPlugins();
1288 
1290  virtual bool loadComponentAttachmentTable(const DtFilename& filename);
1296  virtual bool loadTerrain(const DtFilename& filename);
1297 
1301  virtual DtFilename findTerrainFile(const DtFilename& startFile, const std::vector<DtFilename>& searchPaths,
1302  const std::string& extension) const;
1303 
1305  virtual bool loadOrderOfBattle(const DtScenario& scenario, DtLoadScenarioData&);
1306  virtual bool loadOrderOfBattle(const DtInMemorySnapshot::OOB&);
1307 
1309  virtual bool writeOrderOfBattle(const DtScenario& scenario) const;
1310  virtual bool writeOrderOfBattle(DtInMemorySnapshot::OOB&) const;
1311 
1313  virtual bool loadScenarioScripts(const DtFilename& filename);
1314  virtual bool loadScenarioScriptsFromZipFile(const DtFilename& scenarioZipFile, const DtFilename& filename);
1315  virtual bool loadScenarioScripts(const std::string& buffer);
1316 
1318  virtual bool loadOrbat(const DtFilename& filename, DtOrbatManager* intoOm = 0, bool clearBeforeLoading = true);
1319  virtual bool loadOrbatFromZipFile(const DtFilename& scenarioZipFile, const DtFilename& filename, DtOrbatManager* intoOm = 0, bool clearBeforeLoading = true);
1320  virtual bool loadOrbat(const std::string& buffer, DtOrbatManager* intoOm = 0, bool clearBeforeLoading = true);
1321 
1324  virtual void prepareForScenarioReinitialize();
1325 
1327  virtual bool isScenarioReinitializing() const;
1328 
1332  virtual bool loadParameterDb(const DtFilename& filename,
1333  const DtReaderWriter::SearchPaths& searchPaths, bool clearLoadedObjects = true, bool preloadParameters = false);
1334 
1337  virtual bool loadObjectParametersDBFile(const DtFilename& opdFile,
1338  const DtReaderWriter::SearchPaths& searchPaths, bool clearLoadedObjects = true, bool preloadParameters = false);
1339 
1343  virtual bool loadPhysicalWorldFile(const DtFilename& file, bool force = false);
1344 
1348  virtual bool loadDetonationParametersFile(const DtFilename& file, bool force = false);
1349 
1350  virtual bool loadTerrainDeformationParametersFile(const DtFilename& file, bool force = false);
1351 
1355  virtual bool loadAmmunitionParametersFile(const DtFilename& file, bool force = false);
1356 
1358  virtual bool loadPlans(const DtFilename& filename);
1359  virtual bool loadPlansFromZipFile(const DtFilename& scenarioZipFile, const DtFilename& filename);
1360  virtual bool loadPlans(const std::string& buffer);
1361 
1363  virtual bool loadGlobalPlans(const DtFilename& filename);
1364  virtual bool loadGlobalPlansFromZipFile(const DtFilename& scenarioZipFile, const DtFilename& filename);
1365 
1367  virtual void loadHostilityAndExtras(const DtScenarioExplorer& se);
1368  virtual void loadHostilityAndExtrasFromZipFile(const DtFilename& scenarioZipFile, const DtScenarioExplorer& se);
1369  virtual void loadHostilityAndExtras(const std::string& buffer);
1370 
1373  virtual void loadActivities(const DtScenarioExplorer&);
1374 
1377  virtual void loadModelSetFiles(const DtScenarioExplorer&);
1378 
1381  virtual void loadActionCategories(const DtFilename& f);
1382 
1383  virtual bool loadForceHostility(const DtFilename& filename, bool clear = true);
1384  virtual bool loadForceHostilityFromZipFile(const DtFilename& scenarioZipFile, const DtFilename& filename, bool clear = true);
1385 
1386  virtual bool loadScenarioExtras(const DtFilename& filename);
1387  virtual bool loadScenarioExtrasFromZipFile(const DtFilename&, const DtFilename& filename);
1388  virtual bool loadScenarioExtras(const std::string& buffer);
1389 
1392  virtual void processObjectParametersOp(DtSimMessage * msg);
1393 
1395  virtual void createAndInitScenarioLoadManager();
1396 
1399  virtual void emptyParametersDB();
1400 
1402  virtual void setAutoReorganization(bool onOff);
1403 
1407  virtual DtVrfPlugin* loadPlugin(const DtString&);
1408 
1411  virtual bool setupCommModelsForScenario(const DtScenarioExplorer& e);
1412 
1416  virtual void updateReadyStatus();
1417 
1420 
1421  static void simCommandCallback(DtSimMessage* msg, void* usr);
1422  virtual void processSimCommand(DtSimMessage* msg);
1424 
1428 
1429  static void deferredLoadScenarioCallback(void * data);
1430  virtual void processDeferredLoadScenario();
1431 
1434  virtual void processLoadScenario(const DtScenario* = 0, const DtInMemorySnapshot* = 0);
1436 
1438 
1439  static void deferredReinitializeScenarioCallback(void * data);
1440  virtual void processDeferredReinitializeScenario();
1442 
1447 
1448  static void deferredRollbackCallback(void * data);
1449  virtual void processDeferredRollback();
1451 
1455 
1456  static void deferredImportScenarioCallback(void * data);
1457  virtual void processDeferredImportScenario();
1459 
1463 
1464  static void deferredRewindCallback(void * data);
1465  virtual void processDeferredRewind();
1467 
1470  virtual void clearAllSimulationModelSetInformation();
1471 
1473  virtual void initializeCgfConsoleCommands();
1474 
1475  virtual void processCloseScenarioEvent(const makVrfEvents::DtEvent&);
1476  virtual void processLoadScenarioEvent(const makVrfEvents::DtEvent&);
1477 
1479  virtual bool createDIGuyCharacterManager(const DtFilename & diGuyAnimationsFile);
1480 
1481 protected:
1482  DtVrfSimOptionsInterface* mySimOptions;
1483 
1485  DtSimulationAddress mySimulationAddress;
1486 
1488  DtU32 mySessionId;
1489 
1491  bool myOK;
1492 
1494  bool myTimeToQuit;
1495 
1497  DtVrfPluginManager* myPluginManager;
1498  std::vector<DtString> myPluginsToLoad;
1499  bool myLoadPluginsIfVersionMismatch;
1500 
1502  DtTerrainInterface* myTerrainInterface;
1503 
1505  DtPhysicalWorld* myPhysicalWorld;
1506 
1507  DtVrfNavAreaManager* myVrfNavAreaManager;
1508 
1509  DtSpawnSinkManager* mySpawnSinkManager;
1510 
1511  DtCommModelManager* myCommModelManager;
1512 
1513  DtSimTerrainRequestManager* mySimTerrainRequestManager;
1514 
1516  DtCommunicationManager* myCommunicationManager;
1517 
1519  DtSimManager* mySimManager;
1520 
1522  DtCreateObjectServiceInterface* myCreateObjectService;
1523 
1525  DtScenarioServiceInterface* myScenarioService;
1526 
1528  DtScenario* myScenario;
1529 
1531  DtVrfStatusPublisher* myStatusPublisher;
1532 
1534  DtLocalObjectManager* myObjectManager;
1535 
1537  DtDebugDrawManager* myDebugDrawManager;
1538 
1539  DtDetonationManager* myDetonationManager;
1540  DtAmmunitionManager* myAmmunitionManager;
1541  DtScriptedTaskManager* myScriptedTaskManager;
1542  DtScenarioEventManager* myScenarioEventManager;
1543  DtHazardAreaManager* myHazardAreaManager;
1544  DtIntelCollectionAreaManager* myIntelCollectionAreaManager;
1545  DtScriptedObjectsMovementManager* myScriptedObjectsMovementManager;
1546  DtFireManager* myFireManager;
1547  DtObjectConsoleManager* myObjectConsoleManager;
1548  DtManagedObjectListManager* myFilteredObjectListManager;
1549  DtOrbatManager* myOrbatManager;
1550  DtObjectGeometricModelsManager* myObjectModelsManager;
1551  DtVrfObjectPlanAdministrator* myPlanAdministrator;
1552  DtSimInternalCommunicationManager* mySimInternalCommunicationManager;
1553  DtDiGuyCharacterDataManager * myCharacterMgr;
1554  DtAisDataManager* myAisDataManager;
1555  DtSimOperationsInProgressManager* mySimOperationsInProgressManager = nullptr;
1556  DtAdsbDataManager* myAdsbDataManager;
1557  bool myCreatedCharacterManager;
1558 
1559  DtLuaObjectSerializer* myLuaObjectSerializer;
1560 
1562  DtResourceMonitor* myResourceMonitor;
1563 
1565  DtRadarCoverageMonitor* myRadarCoverageMonitor;
1566 
1568  DtTerrainProfileRequestManager* myTerrainProfileRequestManager;
1569 
1571  DtVrfParameterDb* myParameterDatabase;
1572 
1574  DtEmbeddedEntityInfoManager* myEmbeddedEntityInfoManager;
1575 
1577  bool myForceParameterDbReload;
1578 
1579  DtGlobalPlanManager* myGlobalPlanManager;
1580 
1581  DtHostilityManager* myHostilityManager;
1582  DtEngagementZonesManager* myEngagementZonesManager;
1583 
1584  DtScenarioExtrasMgr* myScenarioExtrasManager;
1585 
1587  DtFactoryManager* myFactoryManager;
1588 
1590  DtStealthCommandsManager* myStealthCommandsManager;
1591 
1592  DtSimCommandDistributor* mySimCommandDistributor;
1593 
1598  DtFilename myVrfTerrainPathDirectory;
1599 
1603  DtFilename myDefaultTerrainDirectory;
1604 
1606  DtFilename myDefaultSimulationModelSetFilename;
1607 
1609  DtFilename myDIGuyAnimationsFilename;
1610 
1612  DtFilename myMsdlSidcMappingFile;
1613 
1615  DtFilename myCountryCodesMappingFile;
1616 
1619  bool myParameterDbLoaded;
1620 
1622  DtFilename myCurrentParameterDatabaseFilename;
1623 
1627  DtFilename myDefaultParameterDbDirectory;
1628 
1629  DtCallbackList<const DtFilename&> myPreLoadTerrainCallbacks;
1630  DtCallbackList<const DtFilename&> myPostLoadTerrainCallbacks;
1631  DtCallbackList<DtScenario&> myPreLoadScenarioCallbacks;
1632  DtCallbackList<const DtScenario&> myPostLoadScenarioCallbacks;
1633  DtCallbackList<DtScenario&> myPreScenarioReinitializeCallbacks;
1634  DtCallbackList<const DtScenario&> myPostScenarioReinitializeCallbacks;
1635  DtCallbackList<DtScenario&> myPreCreateSimulationObjectGroupCallbacks;
1636  DtCallbackList<const DtScenario&> myPostCreateSimulationObjectGroupCallbacks;
1637  DtCallbackList<DtScenario&> myPreImportScenarioCallbacks;
1638  DtCallbackList<const DtScenario&> myPostImportScenarioCallbacks;
1639  DtCallbackList<DtScenario&> myPreSaveScenarioCallbacks;
1640  DtCallbackList<const DtScenario&> myPostSaveScenarioCallbacks;
1641 
1642  DtCallbackList<DtScenario&> myPreSaveSimulationObjectGroupsCallbacks;
1643  DtCallbackList<const DtScenario&> myPostSaveSimulationObjectGroupsCallbacks;
1644 
1645  DtNoArgumentCallbackList myPreCloseScenarioCallbacks;
1646  DtNoArgumentCallbackList myPostCloseScenarioCallbacks;
1647  DtNoArgumentCallbackList myScenarioRunCallbacks;
1648  DtNoArgumentCallbackList myScenarioPauseCallbacks;
1649  DtNoArgumentCallbackList myPreScenarioRewindCallbacks;
1650  DtNoArgumentCallbackList myPostScenarioRewindCallbacks;
1651  DtNoArgumentCallbackList myPostTickCallbacks;
1652  DtNoArgumentCallbackList myCgfAboutToBeDestroyedCallbacks;
1653 
1654  DtSyncMatrixManager* mySyncMatrixManager;
1655  DtInfluenceEventDispatcher* myInfluenceEventDispatcher;
1656 
1661  void setVrfCreator(DtVrfCreator* creator);
1663 
1665 
1666  bool ownVrfCreator() const;
1667  void setOwnVrfCreator(bool yesOrNo);
1669 
1671  virtual bool differingModelSets(DtScenario*) const;
1672 
1673  virtual void simControlEvent(const makVrfEvents::DtEvent&);
1674 
1675  virtual void clearObjectsAwaitingDiscovery();
1676  virtual void processObjectsAwaitingDiscovery();
1677 
1678  virtual void terrainPaging(bool);
1679  virtual void jobQueueStatusChanged(bool);
1680 
1681 protected:
1684  bool myOwnVrfCreatorFlag;
1685  DtVrfCreator* myVrfCreator;
1686 
1688  bool myFullyLoadTerrain;
1689 
1693  bool myAssertOnBlockingTerrainCalls;
1694 
1697  DtSimulationModelSet* myDefaultModelSet;
1698 
1702  DtScenario myScenarioToLoad;
1703 
1704  bool myCreateGlobalEnvironment;
1705  bool myCreateGlobalDynamicTerrain;
1706  bool myCreatedGlobalEnvironment;
1707  bool myCreatedGlobalDynamicTerrain;
1708 
1713  bool myWasPaused;
1714 
1716  DtImportExportScenarioDescriptionManager* myImportScenarioDescriptionManager;
1717 
1718  DtConsoleCommandOwner* myConsoleCommands;
1719 
1722  typedef std::pair<std::string, bool> ActionCategory;
1723  typedef std::map<std::string, ActionCategory> ActionCategories;
1724  ActionCategories myActionCategories;
1725 
1727  DtIfScenarioStatus* myScenarioStatus;
1728 
1729  bool myPublishingGlobalEnvironment;
1730  bool myAboutToLoadOrRewindScenario;
1731  bool myReinitializingScenario;
1732 
1733  bool myMetocEnabled;
1734 
1735  DtTaskVisualizationPublicationMode myTaskVisualizationPublicationMode;
1736  bool myUseDrawControlForTaskVisualizations;
1737 
1738  bool myReuseEntityIdentifiersOnScenarioLoad;
1739 
1740  DtRwActivities myActivities;
1741  bool mySmsValidationEnabled;
1742  DtSnapshotManager* mySnapshotManager;
1743  DtSimObjectManager* mySimObjectManager;
1744 
1745  std::vector<DtFilename> myObjectGroupsRoot;
1746 
1747  struct SimulationObjectGroupInformation
1748  {
1749  DtlObjPtr planArgs;
1750  DtlObjPtr oobArgs;
1751  };
1752 
1753  typedef std::map<DtString, SimulationObjectGroupInformation> StoredSimulationObjectGroupInformation;
1754  StoredSimulationObjectGroupInformation myStoredSimulationObjectGroupInformation;
1755 
1756  int myRollbackToId;
1757  bool myCanSimulate;
1758  bool myIsLoaded;
1759  bool myHasModelSetInformationLoadedAfterClose;
1760  int myReloadDelay;
1761  bool myRejectMismatchedScenarioMessages;
1762  DtU32 myScenarioCapabilities;
1763  int myAppIdRangeMax;
1764 
1765  std::set<DtFilename> myLoadedModelSets;
1766 
1767  DtInMemorySnapshot* myQueuedRollback;
1768  int myQueuedRollbackScenarioRunId;
1769 
1770  DtScenarioLoadManager* myScenarioLoadManager;
1771 
1772  typedef std::vector<DtLoadOrderOfBattleHandler*>SimulationObjectGroupsToBeCreated;
1773  SimulationObjectGroupsToBeCreated mySimulationObjectGroupsToBeCreated;
1774 
1775 public:
1778  VRF4API_METHOD DtLocalObjectManager* vrfObjectManager() { return myObjectManager; };
1779  VRF4API_METHOD DtCommunicationManager* exerciseConn() { return myCommunicationManager; };
1781 
1782 };
1783 
DtUUID
UUID is a unique ID wrapper class.
Definition: uuid.h:59
DtCgf::myObjectConsoleManager
DtObjectConsoleManager * myObjectConsoleManager
Definition: cgf.h:1547
DtCgf::myIsLoaded
bool myIsLoaded
Definition: cgf.h:1758
DtCgf::myObjectModelsManager
DtObjectGeometricModelsManager * myObjectModelsManager
Definition: cgf.h:1550
DtCgf::myCommunicationManager
DtCommunicationManager * myCommunicationManager
The current exercise connection.
Definition: cgf.h:1516
DtCgf::mySimManager
DtSimManager * mySimManager
Pointer to the DtSimManager.
Definition: cgf.h:1519
DtCgf::myCreateGlobalEnvironment
bool myCreateGlobalEnvironment
Definition: cgf.h:1704
DtCgf::myPublishingGlobalEnvironment
bool myPublishingGlobalEnvironment
Definition: cgf.h:1729
DtCgf::myScenarioStatus
DtIfScenarioStatus * myScenarioStatus
Scenario status message to be sent out upon request.
Definition: cgf.h:1727
DtLocalObjectManager
class DtLocalObjectManager:
Definition: localObjectManager.h:151
DtCgf::communicationManager
DtCommunicationManager * communicationManager()
Definition: cgf.h:385
DtSimTerrainRequestManager
Definition: simTerrainRequestManager.h:132
DtResourceMonitor
This class will be responsible for handling requests to return resources for a particular entity (or ...
Definition: resourceMonitor.h:54
DtCgf::myAmmunitionManager
DtAmmunitionManager * myAmmunitionManager
Definition: cgf.h:1540
DtCgf::myGlobalPlanManager
DtGlobalPlanManager * myGlobalPlanManager
Definition: cgf.h:1579
DtCgf::myUseDrawControlForTaskVisualizations
bool myUseDrawControlForTaskVisualizations
Definition: cgf.h:1736
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:1541
DtTimer
Instances of DtTimer are used to maintain the information needed to represent some kind of scheduled ...
Definition: timer.h:38
DtCgf::myAdsbDataManager
DtAdsbDataManager * myAdsbDataManager
Definition: cgf.h:1556
DtCgf::myStealthCommandsManager
DtStealthCommandsManager * myStealthCommandsManager
Stealth commands manager.
Definition: cgf.h:1590
DtVrfParameterDb
Instances of DtVrfParameterDb are the database of DtVrfObjectParameters objects used in the construct...
Definition: vrfParameterDb.h:40
DtCgf::myScenarioPauseCallbacks
DtNoArgumentCallbackList myScenarioPauseCallbacks
Definition: cgf.h:1648
DtCgf::myPreLoadScenarioCallbacks
DtCallbackList< DtScenario & > myPreLoadScenarioCallbacks
Definition: cgf.h:1631
DtCgf::myCreateObjectService
DtCreateObjectServiceInterface * myCreateObjectService
Pointer to the create object service.
Definition: cgf.h:1522
DtCgf::myAisDataManager
DtAisDataManager * myAisDataManager
Definition: cgf.h:1554
DtInMemorySnapshot
Structure holds a complete single-backend snapshot state in memory.
Definition: snapshotManager.h:31
DtScenario
Definition: scenario.h:52
DtCreateObjectServiceInterface
Service interface for creating and removing simulation objects as well as adjusting organization hier...
Definition: createObjectServiceInterface.h:36
DtCgf::myPreCreateSimulationObjectGroupCallbacks
DtCallbackList< DtScenario & > myPreCreateSimulationObjectGroupCallbacks
Definition: cgf.h:1635
DtCgf::myOK
bool myOK
Flag indicating whether we have been successfully initialized.
Definition: cgf.h:1491
DtCgf::myPreCloseScenarioCallbacks
DtNoArgumentCallbackList myPreCloseScenarioCallbacks
Definition: cgf.h:1645
DtCgf::mySimCommandDistributor
DtSimCommandDistributor * mySimCommandDistributor
Definition: cgf.h:1592
DtCgf::myPhysicalWorld
DtPhysicalWorld * myPhysicalWorld
The current physical world.
Definition: cgf.h:1505
DtCgf::myDefaultSimulationModelSetFilename
DtFilename myDefaultSimulationModelSetFilename
Default simulation model set file to load.
Definition: cgf.h:1606
DtCgf::scenarioStatus
const DtIfScenarioStatus * scenarioStatus() const
Imports the specified scenario description file into the current scenario.
Definition: cgf.h:291
DtCgf::myFullyLoadTerrain
bool myFullyLoadTerrain
Flag indicating whether to fully load terrain subpages for paged terrain.
Definition: cgf.h:1688
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:1722
DtCgf::myPreScenarioReinitializeCallbacks
DtCallbackList< DtScenario & > myPreScenarioReinitializeCallbacks
Definition: cgf.h:1633
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:1584
DtScenarioExplorer
class DtScenarioExplorer:
Definition: scenarioExplorer.h:26
DtCgf::mySmsValidationEnabled
bool mySmsValidationEnabled
Definition: cgf.h:1741
DtCgf::myPostCreateSimulationObjectGroupCallbacks
DtCallbackList< const DtScenario & > myPostCreateSimulationObjectGroupCallbacks
Definition: cgf.h:1636
DtScriptedTaskManager
Manage scripted tasks (primarily Lua tasks) known by VR-Forces.
Definition: scriptedTaskManager.h:76
DtCommModelManager
Holds all radio networks (comm models, implemented by DtCommModel) for the current exercise...
Definition: commModelManager.h:26
makVrfEvents::DtEventManager
The DtEventManager handles the sending and receipt of system events (fire, detonate, command, etc). It provides a thread-safe way for the sim engine to send and receive such events, between both components within this sim engine and other remote applications.
Definition: eventManager.h:33
DtVrfSimOptionsInterface
Options for the configuring the sim.
Definition: vrfSimOptionsInterface.h:20
DtSpawnSinkManager
Manages all of the spawn points, sink points, and spawn templates in the current scenario.
Definition: spawnSinkManager.h:24
DtIfSaveScenario
class DtIfSaveScenario:
Definition: ifSaveScenario.h:23
DtCgf::myScenario
DtScenario * myScenario
The current scenario.
Definition: cgf.h:1528
DtSimInternalCommunicationManager
The manager for SimInternal messages on a single simulation engine. This class manages the passing of...
Definition: simInternalCommunicationManager.h:28
DtCgf::SimulationObjectGroupInformation::oobArgs
DtlObjPtr oobArgs
Definition: cgf.h:1750
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:1745
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:1598
DtCgf::myTimeToQuit
bool myTimeToQuit
Flag indicating whether or not the app should quit.
Definition: cgf.h:1494
DtTerrainProfileRequestManager
Definition: terrainProfileRequestManager.h:31
DtCgf::myPostCloseScenarioCallbacks
DtNoArgumentCallbackList myPostCloseScenarioCallbacks
Definition: cgf.h:1646
DtCgf::myPostTickCallbacks
DtNoArgumentCallbackList myPostTickCallbacks
Definition: cgf.h:1651
DtAdsbDataManager
The DtAdsbDataManager loads and manages Automatic Dependent Surveillance - Broadcast (ADS-B) data...
Definition: adsbDataManager.h:40
DtCgf::myResourceMonitor
DtResourceMonitor * myResourceMonitor
Pointer to the DtResourceMonitor.
Definition: cgf.h:1562
DtOrbatManager
This class handles all requests as they pertain to viewing or modifying the ORBAT.
Definition: orbatManager.h:30
DtHazardAreaManager
The DtHazardAreaManager will keep track of all hazard area objects and their state. Hazard areas are predefined as part of this class. Call the add/remove methods to add or remove areas to watch.
Definition: hazardAreaManager.h:22
DtCgf::myCreateGlobalDynamicTerrain
bool myCreateGlobalDynamicTerrain
Definition: cgf.h:1705
DtCgf::myCanSimulate
bool myCanSimulate
Definition: cgf.h:1757
DtCgf::myVrfNavAreaManager
DtVrfNavAreaManager * myVrfNavAreaManager
Definition: cgf.h:1507
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:1772
DtCgf::myHasModelSetInformationLoadedAfterClose
bool myHasModelSetInformationLoadedAfterClose
Definition: cgf.h:1759
DtCgf::myAppIdRangeMax
int myAppIdRangeMax
Definition: cgf.h:1763
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:1767
DtCgf::myCommModelManager
DtCommModelManager * myCommModelManager
Definition: cgf.h:1511
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:1707
DtIfScenarioStatus
Definition: ifScenarioStatus.h:28
DtCgf::mySimOptions
DtVrfSimOptionsInterface * mySimOptions
Definition: cgf.h:1482
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:31
DtScenarioLoadManager
Definition: scenarioLoadManager.h:80
DtCgf::myReuseEntityIdentifiersOnScenarioLoad
bool myReuseEntityIdentifiersOnScenarioLoad
Definition: cgf.h:1738
DtCgf::myStatusPublisher
DtVrfStatusPublisher * myStatusPublisher
Pointer to the DtStatusPublisher.
Definition: cgf.h:1531
DtCgf::myTaskVisualizationPublicationMode
DtTaskVisualizationPublicationMode myTaskVisualizationPublicationMode
Definition: cgf.h:1735
DtCgf::myDIGuyAnimationsFilename
DtFilename myDIGuyAnimationsFilename
DI_Guy animation configuration file to load.
Definition: cgf.h:1609
DtObjectType
Definition: objectType.h:27
DtCgf::myRejectMismatchedScenarioMessages
bool myRejectMismatchedScenarioMessages
Definition: cgf.h:1761
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:1779
DtCgf::myParameterDatabase
DtVrfParameterDb * myParameterDatabase
Pointer to the DtVrfParameterDb.
Definition: cgf.h:1571
DtCgf::myObjectManager
DtLocalObjectManager * myObjectManager
Pointer to the DtLocalObjectManager.
Definition: cgf.h:1534
DtCgf::myPreSaveScenarioCallbacks
DtCallbackList< DtScenario & > myPreSaveScenarioCallbacks
Definition: cgf.h:1639
DtObjectGeometricModelsManager
Manages loading and destruction of the geometric models for objects. Will reference the object parame...
Definition: objectGeometricModelsManager.h:30
DtCgf::myPreLoadTerrainCallbacks
DtCallbackList< const DtFilename & > myPreLoadTerrainCallbacks
Definition: cgf.h:1629
DtInMemorySnapshot::OOB
std::vector< std::string * > OOB
Definition: snapshotManager.h:44
DtCgf::StoredSimulationObjectGroupInformation
std::map< DtString, SimulationObjectGroupInformation > StoredSimulationObjectGroupInformation
Definition: cgf.h:1753
DtCommunicationManagerPerformanceTimerInformation
Definition: communicationManager.h:35
DtScenarioEventManager
The scenario event manager will keep track of all scenario event objects and their state...
Definition: scenarioEventManager.h:36
DtSetDataRequest
DtSetDataRequest is an abstract base class from which real setDataRequests can derive. It manages the read/write capability; derived classes need only use and register read/writatble data types for derived information.
Definition: setDataRequest.h:41
DtCgf::myEmbeddedEntityInfoManager
DtEmbeddedEntityInfoManager * myEmbeddedEntityInfoManager
Pointer to the DtEmbeddedEntityInfoManager.
Definition: cgf.h:1574
DtCgf::myImportScenarioDescriptionManager
DtImportExportScenarioDescriptionManager * myImportScenarioDescriptionManager
The scenario description manager used to import scenario description files.
Definition: cgf.h:1716
DtCgf::myCreatedGlobalEnvironment
bool myCreatedGlobalEnvironment
Definition: cgf.h:1706
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:1539
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:1615
DtCgf::myDefaultParameterDbDirectory
DtFilename myDefaultParameterDbDirectory
Default parameter database directory to search in when parameter database being specified is not an a...
Definition: cgf.h:1627
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:1542
DtCgf::myScenarioService
DtScenarioServiceInterface * myScenarioService
Pointer to the scenario object service.
Definition: cgf.h:1525
DtCgf::myTerrainProfileRequestManager
DtTerrainProfileRequestManager * myTerrainProfileRequestManager
Pointer to the DtTerrainProfileRequestManager.
Definition: cgf.h:1568
DtVrfNavAreaManager
The DtVrfNavAreaManager manages all of the nav areas currently created in the sim.
Definition: vrfNavAreaManager.h:52
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:1778
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:1630
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:1754
DtCgf::myScenarioRunCallbacks
DtNoArgumentCallbackList myScenarioRunCallbacks
Definition: cgf.h:1647
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:1497
DtReaderWriter::SearchPaths
std::vector< DtFilename > SearchPaths
Definition: readerWriter.h:92
DtCgf::myQueuedRollbackScenarioRunId
int myQueuedRollbackScenarioRunId
Definition: cgf.h:1768
DtCgf::myCreatedCharacterManager
bool myCreatedCharacterManager
Definition: cgf.h:1557
DtCgf::mySimulationObjectGroupsToBeCreated
SimulationObjectGroupsToBeCreated mySimulationObjectGroupsToBeCreated
Definition: cgf.h:1773
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:1713
DtCallbackList
Definition: noArgumentCallbackList.h:91
DtCgf::myIntelCollectionAreaManager
DtIntelCollectionAreaManager * myIntelCollectionAreaManager
Definition: cgf.h:1544
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:1693
DtCgf::myPreSaveSimulationObjectGroupsCallbacks
DtCallbackList< DtScenario & > myPreSaveSimulationObjectGroupsCallbacks
Definition: cgf.h:1642
DtCgf::mySyncMatrixManager
DtSyncMatrixManager * mySyncMatrixManager
Definition: cgf.h:1654
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:1643
DtCgf::myDefaultModelSet
DtSimulationModelSet * myDefaultModelSet
Default simulation model set. This is created when the default simulation model set filename is set o...
Definition: cgf.h:1697
DtCgf::myActivities
DtRwActivities myActivities
Definition: cgf.h:1740
DtVrfPluginManager
Definition: vrfPluginManager.h:73
DtCgf::myScenarioLoadManager
DtScenarioLoadManager * myScenarioLoadManager
Definition: cgf.h:1770
DtCgf::myRadarCoverageMonitor
DtRadarCoverageMonitor * myRadarCoverageMonitor
Pointer to the DtRadarCoverageMonitor.
Definition: cgf.h:1565
DtConsoleCommandOwner
A utility class for use with DtConsoleCommandManager. This class takes ownership of an arbitrary numb...
Definition: consoleCommandManager.h:168
DtFactoryManager
Instances of DtFactoryManager are responsible for maintaining all the factories.
Definition: factoryManager.h:74
DtTerrainInterface
DtTerrainInterface allows access to common terrain calls without having to know the terrain implement...
Definition: terrainInterface.h:100
DtCgf::myFactoryManager
DtFactoryManager * myFactoryManager
Pointer to the DtFactoryManager.
Definition: cgf.h:1587
DtCgf::myActionCategories
ActionCategories myActionCategories
Definition: cgf.h:1724
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:1702
DtCgf::myHazardAreaManager
DtHazardAreaManager * myHazardAreaManager
Definition: cgf.h:1543
DtCgf::myPluginsToLoad
std::vector< DtString > myPluginsToLoad
Definition: cgf.h:1498
DtCgf::myPostSaveScenarioCallbacks
DtCallbackList< const DtScenario & > myPostSaveScenarioCallbacks
Definition: cgf.h:1640
DtCgf::myReinitializingScenario
bool myReinitializingScenario
Definition: cgf.h:1731
error
Definition: asyncJobServer.h:39
DtSimOperationsInProgressManager
The DtSimOperationsInProgressManager can be used to keep track (by count) of sim services in operatio...
Definition: simOperationsInProgressManager.h:17
DtVrfCreator
Instances of DtVrfCreator are responsible for creating all of the objects needed to create and manage...
Definition: vrfCreator.h:284
DtCgf::mySimObjectManager
DtSimObjectManager * mySimObjectManager
Definition: cgf.h:1743
DtCgf::mySimInternalCommunicationManager
DtSimInternalCommunicationManager * mySimInternalCommunicationManager
Definition: cgf.h:1552
DtPlan
class DtPlan:
Definition: plan.h:92
DtCgf::myInfluenceEventDispatcher
DtInfluenceEventDispatcher * myInfluenceEventDispatcher
Definition: cgf.h:1655
DtCgf::myOrbatManager
DtOrbatManager * myOrbatManager
Definition: cgf.h:1549
DtCgf::myCgfAboutToBeDestroyedCallbacks
DtNoArgumentCallbackList myCgfAboutToBeDestroyedCallbacks
Definition: cgf.h:1652
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:1637
translatableStream.h
Contains the DtTranslatableStream class declaration.
DtCgf::myLoadedModelSets
std::set< DtFilename > myLoadedModelSets
Definition: cgf.h:1765
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:94
DtCgf::myPostScenarioRewindCallbacks
DtNoArgumentCallbackList myPostScenarioRewindCallbacks
Definition: cgf.h:1650
DtCgf::myAboutToLoadOrRewindScenario
bool myAboutToLoadOrRewindScenario
Definition: cgf.h:1730
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:1577
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:1742
DtCgf::myEngagementZonesManager
DtEngagementZonesManager * myEngagementZonesManager
Definition: cgf.h:1582
DtStealthCommandsManager
Responsible for maintaining and executing stealth commands. The stealth commands are of the format (i...
Definition: stealthCommandsManager.h:35
DtCgf::aboutToLoadOrRewindScenario
virtual bool aboutToLoadOrRewindScenario() const
Whether or not this cgf is about to rewind, rollback or load.
Definition: cgf.h:391
DtCgf::myPostImportScenarioCallbacks
DtCallbackList< const DtScenario & > myPostImportScenarioCallbacks
Definition: cgf.h:1638
DtCgf::myMetocEnabled
bool myMetocEnabled
Definition: cgf.h:1733
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:1551
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:1513
DtCgf::myPostLoadScenarioCallbacks
DtCallbackList< const DtScenario & > myPostLoadScenarioCallbacks
Definition: cgf.h:1632
DtCgf::myReloadDelay
int myReloadDelay
Definition: cgf.h:1760
DtCgf::myVrfCreator
DtVrfCreator * myVrfCreator
Definition: cgf.h:1685
DtCgf::myCharacterMgr
DtDiGuyCharacterDataManager * myCharacterMgr
Definition: cgf.h:1553
DtCgf::myPreScenarioRewindCallbacks
DtNoArgumentCallbackList myPreScenarioRewindCallbacks
Definition: cgf.h:1649
DtCgf::canSimulate
virtual bool canSimulate() const
Whether or not the cgf is ready to simulate.
Definition: cgf.h:383
DtCgf::myCurrentParameterDatabaseFilename
DtFilename myCurrentParameterDatabaseFilename
Filename of currently loaded parameter database.
Definition: cgf.h:1622
DtSimManager
The simulation engine is controlled by a single,top-level class called the Simulation Manager...
Definition: simManager.h:123
DtSnapshotManager
Definition: snapshotManager.h:55
DtCgf::myFilteredObjectListManager
DtManagedObjectListManager * myFilteredObjectListManager
Definition: cgf.h:1548
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:1749
DtCgf::myScenarioCapabilities
DtU32 myScenarioCapabilities
Definition: cgf.h:1762
DtCgf::myOwnVrfCreatorFlag
bool myOwnVrfCreatorFlag
These are essentially cached from the init call. This is necessary as the load terrain.
Definition: cgf.h:1684
DtCgf::scenarioStatus
DtIfScenarioStatus * scenarioStatus()
Returns the scenario status object.
Definition: cgf.h:290
DtCgf::myParameterDbLoaded
bool myParameterDbLoaded
Set to true if parameter database has been loaded via loadParameterDatabase call. If you load a param...
Definition: cgf.h:1619
DtCgf::myHostilityManager
DtHostilityManager * myHostilityManager
Definition: cgf.h:1581
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:1509
DtCgf
The top level class of a VR-Forces Simulation Engine, representing a Computer Generated Forces instan...
Definition: cgf.h:147
DtDefaultScenarioImportFlags
const int DtDefaultScenarioImportFlags
Default is not not import duplicate UUIDs. This will allow multiple scenarios that have the same base...
Definition: scenario.h:624
DtCgf::myLuaObjectSerializer
DtLuaObjectSerializer * myLuaObjectSerializer
Definition: cgf.h:1559
DtCgf::myConsoleCommands
DtConsoleCommandOwner * myConsoleCommands
Definition: cgf.h:1718
DtAisDataManager
The DtAisDataManager loads and manages Automatic Identification System (AIS) data, which is used to track and monitor real world ships. This data can be used to create and simulate clutter entities in a simulation.
Definition: aisDataManager.h:33
DtCgf::myFireManager
DtFireManager * myFireManager
Definition: cgf.h:1546
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:1545
DtCgf::myDebugDrawManager
DtDebugDrawManager * myDebugDrawManager
Pointer to the DtDebugDrawManagert.
Definition: cgf.h:1537
DtCgf::myPostScenarioReinitializeCallbacks
DtCallbackList< const DtScenario & > myPostScenarioReinitializeCallbacks
Definition: cgf.h:1634
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:1502
DtCgf::mySessionId
DtU32 mySessionId
Session Id.
Definition: cgf.h:1488
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:1603
DtCgf::myLoadPluginsIfVersionMismatch
bool myLoadPluginsIfVersionMismatch
Definition: cgf.h:1499
DtCgf::mySimulationAddress
DtSimulationAddress mySimulationAddress
Address for routing interface messages.
Definition: cgf.h:1485
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:1723
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:1756
DtCgf::myMsdlSidcMappingFile
DtFilename myMsdlSidcMappingFile
MSDL SDIC mapping file to load.
Definition: cgf.h:1612
DtTaskVisualizationPublicationMode
DtTaskVisualizationPublicationMode
Defines how task visualizations will be published.
Definition: scenarioServiceInterface.h:21
Document ID: Generated on Wed Mar 27 22:49:11 EDT 2024 from SVN revision 264633
Copyright © 2005-2024 MAK Technologies. All Rights Reserved (www.mak.com)