cgf.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2013 MAK Technologies, Inc.
** All rights reserved.
*******************************************************************************/

#pragma once



#ifdef WIN32
#include <winsock2.h>
#endif


#include <vlutil/vlFilename.h>
#include <vlutil/vlTime.h>
#include <vl/hostStructs.h>
#include <vector>
#include <vlutil/vlPrint.h>
#include "vrfutil/callbackList.h"
#include "vrfutil/scenario.h"
#include "vrfutil/scenarioExplorer.h"
#include "vrfutil/outputLogger.h" 

class DtAdminContent;
class DtSimulationModelSet;
class DtExerciseConn;
class DtScenario;
class DtScenarioExplorer;
class DtPhysicalWorld;
class DtCommModelManager;
class DtTerrainInterface;
class DtVrfCreator;
class DtSimManager;
class DtScriptedTaskManager;
class DtScriptedObjectsMovementManager;
class DtVrfStatusPublisher;
class DtVrfObjectManager;
class DtAggregateSpatialModel;
class DtDetonationManager;
class DtFireManager;
class DtGlobalPlanManager;
class DtJoyDeviceManager;
class DtHostilityManager;
class DtScenarioExtrasMgr;
class DtCustomReportManager;
class DtFactoryManager;
class DtVrfObject;
class DtObjectType;
class DtList;
class DtSimTask;
class DtSetDataRequest;
class DtPlan;
class DtPaperMapDatabase;
class DtMapDatum;
class DtStealthRemoteController;
class DtVrfParameterDb;
class DtSimMessage;
class DtResourceMonitor;
class DtVrfObjectIdGenerator;
class DtVrfPlugin;
class DtVrfPluginManager;
class DtHlaExerciseClock;
class DtExerciseClock;
class DtSimCommand;
class DtImportExportScenarioDescriptionManager;
class DtLuaObjectSerializer;
struct DtOrganizationManagerReadyCallbackInfo;
class DtConsoleCommandOwner;

#include "vrfcgf/vrfcgfDefines.h"
class DT_DLL_vrfcgf DtCgf
{
public:

   DtCgf(const DtSimulationAddress& addr, DtU32 sessionId = 1);

   virtual void init(DtExerciseConn* conn, DtVrfCreator* creator = 0, 
      int entityAdvisory = 100);

   virtual ~DtCgf();

   virtual void tick();

   virtual void sendFinalStatus();

   //-------------------------------------------------------
   //-------------------------------------------------------

   virtual bool importScenarioDescriptionFile(const DtFilename& file, const DtString& format,
      const std::map<std::string, std::string>& importData);

   virtual DtString exportScenarioDescriptionFile(const DtFilename& file, const DtString& format,
      const std::map<std::string, std::string>& exportData);

   virtual bool loadScenario(const DtFilename& name);

   virtual bool loadScenario(const DtScenario& scenario);

   virtual bool newScenario(const DtFilename& dbname = 
      DtFilename::nullFilename(), const DtFilename& simulationModelSet = 
      DtFilename::nullFilename());

   virtual bool saveScenario(const DtFilename& savename);

   virtual void closeScenario(const DtFilename& terrainToOpen = "");

   virtual bool loadAdditionalObjectParameters(const DtFilename& paramsFileName);

   virtual void loadCoreSimulationModelSets();

   virtual void run();

   virtual void pause();

   virtual void rewind();


   virtual void setForceParameterDbReload(bool reload);
   virtual bool forceParameterDbReload() const;


   virtual void setEnableResourceMonitor(bool b);
   virtual bool isResourceMonitorEnabled() const;

#ifdef WIN32
   virtual void setAppInstance(HINSTANCE hInstance);
   virtual void setConsoleWindow(HWND consoleWindow);
#endif


   virtual const DtFilename& defaultTerrainDirectory(); 
   virtual void setDefaultTerrainDirectory(const DtFilename& directory);


   virtual const DtFilename& defaultSimulationModelSetFilename(); 
   virtual void setDefaultSimulationModelSetFilename(const DtFilename& filename);


   virtual void setUseDIGuy(bool diguy);
   virtual bool useDIGuy() const;


   virtual const DtFilename& diGuyCharacterDataFilename(); 
   virtual void setDIGuyCharacterDataFilename(const DtFilename& filename);

   virtual const DtFilename& diGuyAnimationsFilename(); 
   virtual void setDIGuyAnimationsFilename(const DtFilename& filename);


   virtual void setMsdlSIDCMappingFile(const DtFilename&);
   virtual const DtFilename& msdlSIDCMappingFile() const;


   virtual void setCountryCodesMappingFile(const DtFilename&);
   virtual const DtFilename& countryCodesMappingFile() const;

   virtual DtSimulationModelSet* defaultModelSet();

   //-------------------------------------------------------
   //-------------------------------------------------------

   virtual void deleteObject(const DtString& name) const;

   virtual void deleteObject(const DtEntityIdentifier& objectIdentifier) const;

   //-------------------------------------------------------
   //-------------------------------------------------------


   virtual DtVrfObject* createWaypoint(const DtVector& localPosition,
      const DtString& uniqueName = DtString::nullString()) const; 


   virtual DtVrfObject* createRoute(const DtList& vertices,
      const DtString& uniqueName = DtString::nullString()) const; 


   virtual DtVrfObject* createPhaseLine(
      const DtVector& dbPoint1,
      const DtVector& dbPoint2,
      const DtString& uniqueName = DtString::nullString()) const; 
   

   virtual DtVrfObject* createControlArea(
      const DtList& vertices,
      const DtString& uniqueName = DtString::nullString()) const; 


   virtual DtVrfObject* createObstacle(
      const DtList& vertices,
      const DtString& uniqueName = DtString::nullString()) const; 


   virtual DtVrfObject* createDisaggregationArea(
      const DtList& vertices,
      const DtString& uniqueName = DtString::nullString()) const; 

   //-------------------------------------------------------
   //-------------------------------------------------------


   virtual DtVrfObject* createEntity(
      const DtEntityType& entityType,
      DtForceType force,
      const DtVector& dbPosition,
      DtReal heading,
      const DtString& entityName = DtString::nullString(),
      bool allowBlocking = true,
      std::list<DtAdminContent*>* initialAdminContent = 0) const;



   virtual DtVrfObject* createAggregate(
      const DtEntityType& aggregateType, 
      DtForceType force, 
      const DtVector& localPosition,
      DtReal heading,
      DtList* subordinateNames = 0,
      const DtString& aggregateName = DtString::nullString()) const;

   virtual DtVrfObject* createAggregate(
      const DtEntityType& aggregateType, 
      DtForceType force, 
      const DtVector& localPosition,
      DtReal heading,
      bool createSubordinates,
      const DtString& aggregateName = DtString::nullString(),
      bool allowBlocking = true) const;

   virtual bool addSubordinate(DtVrfObject* subordinate,
      DtVrfObject* aggregate);

   virtual bool removeSubordinate(DtVrfObject* subordinate, 
      DtVrfObject* aggregate);

   //-------------------------------------------------------
   //-------------------------------------------------------

   virtual void assignTask(DtVrfObject* entity, const DtSimTask& task);

   virtual void sendSetDataRequest(DtVrfObject* entity, 
      const DtSetDataRequest& request);

   virtual void assignPlanByName(const DtString& name, const DtPlan& plan);

   virtual void abandonPlan(DtVrfObject* entity);

   virtual void restartPlan(DtVrfObject* entity);

   //-------------------------------------------------------
   //-------------------------------------------------------

   virtual void logObjectConsoleToFile(DtVrfObject* object, 
      DtFilename filename = DtFilename::nullFilename());

   virtual void stopLoggingObjectConsoleToFile(DtVrfObject* object);

   virtual void setObjectConsoleNotificationLevel(DtVrfObject* object,
      DtNotifyLevelType level);

   //-------------------------------------------------------
   //-------------------------------------------------------

   virtual DtSimManager* simManager() const;

   virtual DtImportExportScenarioDescriptionManager* importExportScenarioDescriptionManager() const;

   virtual DtResourceMonitor* resourceMonitor() const;

   virtual DtVrfObjectIdGenerator* vrfObjectIdGenerator() const;

   virtual DtFactoryManager* factoryManager() const;

   virtual DtVrfObjectManager* vrfObjectManager() const;

   virtual DtScriptedTaskManager* scriptedTaskManager() const;

   virtual DtScriptedObjectsMovementManager* ScriptedObjectsMovementManager() const;

   virtual DtAggregateSpatialModel* aggregateSpatialModel() const;

   virtual DtDetonationManager* detonationManager() const;

   virtual DtFireManager* fireManager() const;

   virtual DtScenarioExtrasMgr* scenarioExtrasMgr() const;

   virtual DtVrfParameterDb* parameterDatabase() const;

   virtual DtGlobalPlanManager* globalPlanManager();


   virtual DtTerrainInterface* terrainInterface();
   virtual const DtTerrainInterface* terrainInterface() const;

   virtual void setTerrainInterface(DtTerrainInterface* newTerrainDatabase);



   virtual DtPhysicalWorld* physicalWorld();
   virtual const DtPhysicalWorld* physicalWorld() const;

   virtual void setPhysicalWorld(DtPhysicalWorld* newPhysicalWorld);


   virtual DtCommModelManager* commModelManager();
   virtual const DtCommModelManager* commModelManager() const;

   virtual DtScenario* scenario() const;

   virtual const DtSimulationAddress& simulationAddress() const;

   virtual int sessionId() const;   

   virtual DtVrfStatusPublisher* statusPublisher() const;

   virtual DtExerciseConn* exerciseConn() const;

   virtual DtStealthRemoteController* stealthRemoteController() const;
   
   virtual void useMapDatum(const DtMapDatum& mapDatum);
   
   virtual void setParameterDbLoaded(bool flag);

   virtual void setMaxDrainInputTime(DtFloat64 maxTime);
   virtual DtFloat64 maxDrainInputTime() const;

#ifdef DtHLA
   virtual void setMinDrainInputTime(DtFloat64 minTime);
   virtual DtFloat64 minDrainInputTime() const;
#else
   virtual void setMaxDrainInputReads(int maxReads);
   virtual int maxDrainInputReads() const;
#endif

   virtual bool logFrameRateStatistics() const;
   virtual void setLogFrameRateStatistics(bool yesOrNo);
   virtual void setLogFrameRateOutputDirectory(const DtFilename&);
   virtual const DtFilename& logFrameRateOutputDirectory() const;

   virtual void setDefaultParameterDbDirectory(const DtFilename& filename);

#if DtHLA


   virtual void setRunInTimeManagementMode(bool yesOrNo);
   virtual bool runInTimeManagementMode() const;

   static void startTimeManagement(void* usr);
   static void stopTimeManagement(void* usr);

   virtual void processStartTimeManagement();
   virtual void processStopTimeManagement();

#endif

   virtual void setFullyLoadTerrain(bool yesOrNo);
   virtual bool fullyLoadTerrain() const;


   virtual void setAssertOnBlockingTerrainCalls(bool b);
   virtual bool assertOnBlockingTerrainCalls() const;

   //-------------------------------------------------------
   //-------------------------------------------------------

   virtual void addPluginToLoad(const DtString&);

   virtual void setLoadPluginsIfVersionMismatch(bool);
   virtual bool loadPluginsIfVersionMismatch() const;


   DtVrfCreator* vrfCreator();
   const DtVrfCreator* vrfCreator() const;


   virtual void addPreLoadTerrainCallback(
      DtCallbackList<const DtFilename&>::DtCallbackFunctionType fcn, void* usrData);
   virtual void removePreLoadTerrainCallback(
      DtCallbackList<const DtFilename&>::DtCallbackFunctionType fcn, void* usrData);


   virtual void addPostLoadTerrainCallback(
      DtCallbackList<const DtFilename&>::DtCallbackFunctionType fcn, void* usrData);
   virtual void removePostLoadTerrainCallback(
      DtCallbackList<const DtFilename&>::DtCallbackFunctionType fcn, void* usrData);


   virtual void addPreLoadScenarioCallback(
      DtCallbackList<DtScenario&>::DtCallbackFunctionType fcn, void* usrData);
   virtual void removePreLoadScenarioCallback(
      DtCallbackList<DtScenario&>::DtCallbackFunctionType fcn, void* usrData);


   virtual void addPostLoadScenarioCallback(
      DtCallbackList<const DtScenario&>::DtCallbackFunctionType fcn, void* usrData);
   virtual void removePostLoadScenarioCallback(
      DtCallbackList<const DtScenario&>::DtCallbackFunctionType fcn, void* usrData);


   virtual void addPreSaveScenarioCallback(
      DtCallbackList<DtScenario&>::DtCallbackFunctionType fcn, void* usrData);
   virtual void removePreSaveScenarioCallback(
      DtCallbackList<DtScenario&>::DtCallbackFunctionType fcn, void* usrData);


   virtual void addPostSaveScenarioCallback(
      DtCallbackList<const DtScenario&>::DtCallbackFunctionType fcn, void* usrData);
   virtual void removePostSaveScenarioCallback(
      DtCallbackList<const DtScenario&>::DtCallbackFunctionType fcn, void* usrData);


   virtual void addPreCloseScenarioCallback(
      DtNoArgumentCallbackList::DtCallbackFunctionType fcn, void* usrData);
   virtual void removePreCloseScenarioCallback(
      DtNoArgumentCallbackList::DtCallbackFunctionType fcn, void* usrData);   


   virtual void addPostCloseScenarioCallback(
      DtNoArgumentCallbackList::DtCallbackFunctionType fcn, void* usrData);
   virtual void removePostCloseScenarioCallback(
      DtNoArgumentCallbackList::DtCallbackFunctionType fcn, void* usrData);   


   virtual void addScenarioPauseCallback(
      DtNoArgumentCallbackList::DtCallbackFunctionType fcn, void* usrData);
   virtual void removeScenarioPauseCallback(
      DtNoArgumentCallbackList::DtCallbackFunctionType fcn, void* usrData);


   virtual void addScenarioRunCallback(
      DtNoArgumentCallbackList::DtCallbackFunctionType fcn, void* usrData);
   virtual void removeScenarioRunCallback(
      DtNoArgumentCallbackList::DtCallbackFunctionType fcn, void* usrData);


   virtual void addPreScenarioRewindCallback(
      DtNoArgumentCallbackList::DtCallbackFunctionType fcn, void* usrData);
   virtual void removePreScenarioRewindCallback(
      DtNoArgumentCallbackList::DtCallbackFunctionType fcn, void* usrData);


   virtual void addPostScenarioRewindCallback(
      DtNoArgumentCallbackList::DtCallbackFunctionType fcn, void* usrData);
   virtual void removePostScenarioRewindCallback(
      DtNoArgumentCallbackList::DtCallbackFunctionType fcn, void* usrData);


   virtual void addPostTickCallback(
      DtNoArgumentCallbackList::DtCallbackFunctionType fcn, void* usrData);
   virtual void removePostTickCallback(
      DtNoArgumentCallbackList::DtCallbackFunctionType fcn, void* usrData);


   virtual void setTimeToQuit(bool);
   virtual bool timeToQuit() const;

   virtual bool executeSimCommand(const DtSimCommand& simCommand);
   
public:

   static void objectParametersOpCallback(DtSimMessage* msg, void* usr);

protected:
   static void scenarioDescriptionCallback(DtSimMessage*, void* usr);
   virtual void processScenarioDescription(DtSimMessage*);

   static void actionCategoriesRequestCallback(DtSimMessage* msg, void* usr);
   virtual void processActionCategoriesRequest(DtSimMessage* msg);

private:
   DtCgf(const DtCgf& original);
   DtCgf& operator=(const DtCgf& original);

protected:
   virtual void loadAllPlugins();

   virtual bool loadComponentAttachmentTable(const DtFilename& filename);
   virtual bool loadTerrain(const DtFilename& filename);

   virtual DtFilename findTerrainFile(const DtFilename& startFile, const std::vector<DtFilename>& searchPaths,
      const std::string& extension) const;

   virtual void unloadTerrain();

   virtual bool loadOrderOfBattle(const DtFilename& filename);

   virtual bool loadScenarioScripts(const DtFilename& filename);

   virtual bool loadParameterDb(const DtFilename& filename);

   virtual bool loadObjectParametersDBFile(const DtFilename& opdFile);

   virtual bool loadPhysicalWorldFile(const DtFilename& file, bool force = false);

   virtual bool loadPlans(const DtFilename& filename);

   virtual bool loadGlobalPlans(const DtFilename& filename);

   virtual void loadHostilityAndExtras(const DtScenarioExplorer& se);

   virtual void loadModelSetFiles(const DtScenarioExplorer&);

   virtual void loadActionCategories(const DtFilename& f);

   virtual bool loadForceHostility(const DtFilename& filename);

   virtual bool loadScenarioExtras(const DtFilename& filename);

   virtual void processObjectParametersOp(DtSimMessage * msg);


   virtual void emptyParametersDB();

   virtual void setFrameRateMode(const DtString& mode, DtReal deltaTime);

   virtual void setAutoReorganization(bool onOff);

   virtual void drainInput();

   virtual DtVrfPlugin* loadPlugin(const DtString&);

#if DtHLA
   DtHlaExerciseClock* exerciseClock() const;
#else
   DtExerciseClock* exerciseClock() const;
#endif

   virtual bool setupCommModelsForScenario(const DtScenarioExplorer& e);

   virtual void updateReadyStatus();

   virtual void processOrganizationManagerReady(const DtOrganizationManagerReadyCallbackInfo&);
   static void organizationManagerReadyCallback(const DtOrganizationManagerReadyCallbackInfo&, void* usr);


   static void simCommandCallback(DtSimMessage* msg, void* usr);
   virtual void processSimCommand(DtSimMessage* msg);


   static void deferredLoadScenarioCallback(void * data);
   virtual void processDeferredLoadScenario();


   static void deferredRewindCallback(void * data);
   virtual void processDeferredRewind();

   //-------------------------------------------------------
   //-------------------------------------------------------

   static DtOutputLogger& getGlobalFrameRateStatsLogger();
   static std::string createStatsLogFilename(
      const std::string& originalFilename, const DtSimManager& simManager, 
      const DtScenario* scenario, const DtFilename& logFrameRateDir);
   static void logScenarioLoad(const DtSimManager& simManager, 
      const DtScenario* scenario, const DtFilename& logFrameOutDir);
   static void logScenarioRewind();
   static void logScenarioClose();
   static void logFrameRateStatsToFile(DtSimManager* simManager);

protected:

   DtSimulationAddress mySimulationAddress;

   DtU32 mySessionId;

   bool myOK;

   bool myTimeToQuit;

   DtVrfPluginManager* myPluginManager;
   std::vector<DtString>   myPluginsToLoad;
   bool myLoadPluginsIfVersionMismatch;

   DtTerrainInterface* myTerrainInterface;

   DtPhysicalWorld* myPhysicalWorld;

   DtCommModelManager* myCommModelManager;

   DtExerciseConn* myExerciseConn;

   DtSimManager* mySimManager;

   DtScenario* myScenario;

   DtVrfStatusPublisher* myStatusPublisher;

   DtVrfObjectManager* myVrfObjectManager;

   DtAggregateSpatialModel* myAggregateSpatialModel;

   DtDetonationManager* myDetonationManager;
   DtScriptedTaskManager* myScriptedTaskManager;
   DtScriptedObjectsMovementManager* myScriptedObjectsMovementManager;
   DtFireManager* myFireManager;

   DtLuaObjectSerializer* myLuaObjectSerializer;

   DtResourceMonitor* myResourceMonitor;

   DtVrfObjectIdGenerator* myVrfObjectIdGenerator;

   DtVrfParameterDb* myParameterDatabase;

   bool myForceParameterDbReload;
   
   DtGlobalPlanManager* myGlobalPlanManager;

   DtJoyDeviceManager* myJoyDeviceManager;

   DtHostilityManager* myHostilityManager;

   DtScenarioExtrasMgr* myScenarioExtrasManager;
   
   DtStealthRemoteController* myStealthRemoteController;

   DtFactoryManager* myFactoryManager;

   DtFilename myVrfTerrainPathDirectory;

   DtFilename myDefaultTerrainDirectory;

   DtFilename myDefaultSimulationModelSetFilename;

   bool       myUseDIGuy;

   DtFilename myDIGuyCharacterDataFilename;

   DtFilename myDIGuyAnimationsFilename;

   DtFilename myMsdlSIDCMappingFile;

   DtFilename myCountryCodesMappingFile;

   bool myParameterDbLoaded;

   DtFilename myCurrentParameterDatabaseFilename;

   DtFilename myDefaultParameterDbDirectory;

   DtCallbackList<const DtFilename&> myPreLoadTerrainCallbacks;
   DtCallbackList<const DtFilename&> myPostLoadTerrainCallbacks;
   DtCallbackList<DtScenario&> myPreLoadScenarioCallbacks;
   DtCallbackList<const DtScenario&> myPostLoadScenarioCallbacks;
   DtCallbackList<DtScenario&> myPreSaveScenarioCallbacks;
   DtCallbackList<const DtScenario&> myPostSaveScenarioCallbacks;
   DtNoArgumentCallbackList myPreCloseScenarioCallbacks;
   DtNoArgumentCallbackList myPostCloseScenarioCallbacks;
   DtNoArgumentCallbackList myScenarioRunCallbacks;
   DtNoArgumentCallbackList myScenarioPauseCallbacks;
   DtNoArgumentCallbackList myPreScenarioRewindCallbacks;
   DtNoArgumentCallbackList myPostScenarioRewindCallbacks;
   DtNoArgumentCallbackList myPostTickCallbacks;

   DtFloat64 myMaxDrainInputTime;
#if DtHLA
   DtFloat64 myMinDrainInputTime;
#else
   int myMaxDrainInputReads;
#endif
    
   void setVrfCreator(DtVrfCreator* creator);


   bool ownVrfCreator() const;
   void setOwnVrfCreator(bool yesOrNo);

protected:
   bool myLogFrameRateStatistics;

   DtFilename myLogFrameRateOutputDirectory;

   bool myOwnVrfCreatorFlag;
   DtVrfCreator* myVrfCreator;

#if DtHLA
   bool myRunInTimeManagementMode;
#endif

   bool myFullyLoadTerrain;

   bool myAssertOnBlockingTerrainCalls;
   
#if DtHLA
   DtHlaExerciseClock* myExerciseClockPtr;
#else
   DtExerciseClock* myExerciseClockPtr;
#endif

   DtSimulationModelSet*   myDefaultModelSet;

   DtScenario myScenarioToLoad;

   bool myWasPaused;

   DtImportExportScenarioDescriptionManager* myImportScenarioDescriptionManager;

   DtConsoleCommandOwner* myConsoleCommands;

   typedef std::pair<std::string, bool> ActionCategory;
   typedef std::map<std::string, ActionCategory> ActionCategories;
   ActionCategories myActionCategories;
};