simManager.h

Go to the documentation of this file.

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

#pragma once




#include <readerWriter/noArgumentCallbackList.h>
#include <vl/hostStructs.h>
#include <vlutil/vlMachineTypes.h>
#include <vrfmsgs/messageExecutive.h>
#include <matrix/vlVector.h>
#include <tbb/spin_mutex.h>
#include <vrfcore/vrfNetworkEventManager.h>

class DtExerciseConn;
class DtPhysicalWorld;
class DtCommModelManager;
class DtReflectedExtEntityList;
class DtThreadSocket;
class DtThreadMessageList;
class DtEventManager;
class DtFrameRateMonitor;
class DtResourceMonitor;
class DtRadarCoverageMonitor;
class DtTerrainProfileRequestManager;
class DtVrfObjectMessage;

class DtEntityType;
class DtEchelonRoleName;
class DtString;
class DtList;
class DtSimInterfaceMessage;
class DtEntityType;
class DtSimInterfaceContent;

class DtScheduler;
class DtExerciseClock;
class DtDebugDrawManager;
class DtVrfObjectManager;
class DtScriptedTaskManager;
class DtScenarioEventManager;
class DtHazardAreaManager;
class DtIntelCollectionAreaManager;
class DtScriptedObjectsMovementManager;
class DtScriptedObjects;
class DtAggregateSpatialModel;
class DtDetonationManager;
class DtAmmunitionManager;
class DtFireManager;
class DtGlobalPlanManager;
class DtStealthCommandsManager;
class DtInterfaceMessageExecutive;
class DtVrfMessageInterface;
class DtVrfTDLMessageInterface;
class DtHostilityManager;
class DtEngagementZonesManager;
class DtScenarioExtrasMgr;
class DtTimer;
class DtVrfSimSettingsManager;
class DtSimTerrainRequestManager;
class DtEmbeddedEntityInfoManager;
class DtParallelTickManager;
class DtVrfSimOptionsInterface;
class DtVrfNavAreaManager;
class DtSpawnSinkManager;
class DtSimCommandDistributor;
class DtEnumDictionary;

typedef void (*DtSimTickFunction)(void* userData);
typedef void (*DtRunDurationCallbackFcn)(void* userData);

#include "vrfcore/vrfcoreDefines.h"
class DT_DLL_vrfcore DtSimManager
{
public:

   DtSimManager(DtExerciseConn* connection);

   virtual ~DtSimManager();

private:

   DtSimManager(const DtSimManager& orig);

   DtSimManager& operator=(const DtSimManager& orig);

public:

   virtual bool init();

   virtual const DtVrfSimOptionsInterface* simOptions() const;

   virtual void setSimOptions(const DtVrfSimOptionsInterface&);

   virtual bool createExerciseClock();

   virtual bool createScheduler();
   virtual bool createMessageInterface();
   virtual bool createTDLMessageInterface();
   virtual bool createFrameRateMonitor();
   virtual bool createVrfSimSettingsManager();
   virtual bool createParallelTickManager();
   
   virtual void tick();

   virtual bool deliverMessage(const DtSimInterfaceMessage& msg);

   virtual bool receiveMessage(const DtSimInterfaceMessage& msg);

   virtual bool createAndDeliverMessage(
      const DtSimulationAddress& recipient, 
      const DtSimInterfaceContent & content,
      bool overrideTimestampOrder = true) const;


   virtual void addTickEntry(DtSimTickFunction tickFunction, void* userData) const;
   virtual void removeTickEntry(DtSimTickFunction tickFunction, void* userData) const;

   virtual void addPostTickEntry(DtSimTickFunction tickFunction, void* userData) const;
   virtual void removePostTickEntry(DtSimTickFunction tickFunction, void* userData) const;

   DtExerciseConn* exerciseConn();

   const DtExerciseClock* exerciseClock() const;

   virtual DtFrameRateMonitor* frameRateMonitor();

   virtual DtParallelTickManager* parallelTickManager();

   virtual DtScheduler* scheduler();


   virtual void setPhysicalWorld(DtPhysicalWorld* newPhysicalWorld);
   virtual DtPhysicalWorld* physicalWorld();
   virtual const DtPhysicalWorld* physicalWorld() const;


   virtual void setCommModelManager(DtCommModelManager* newCommModelManager);
   virtual DtCommModelManager* commModelManager();
   virtual const DtCommModelManager* commModelManager() const;


   virtual void setSimTerrainRequestManager(DtSimTerrainRequestManager* newSimTerrainRequestManager);
   virtual DtSimTerrainRequestManager* simTerrainRequestManager();
   virtual const DtSimTerrainRequestManager* simTerrainRequestManager() const;

   virtual void setVrfObjectManager (DtVrfObjectManager* entityManager);
   virtual DtVrfObjectManager* vrfObjectManager();
   virtual const DtVrfObjectManager* vrfObjectManager() const;

   virtual void setVrfNavAreaManager(DtVrfNavAreaManager* navAreaManager);
   virtual DtVrfNavAreaManager* vrfNavAreaManager();
   virtual const DtVrfNavAreaManager* vrfNavAreaManager() const;

   virtual void setSpawnSinkManager(DtSpawnSinkManager* spawnSinkManager);
   virtual DtSpawnSinkManager* spawnSinkManager();
   virtual const DtSpawnSinkManager* spawnSinkManager() const;

   virtual void setEmbeddedEntityInfoManager(DtEmbeddedEntityInfoManager* eeInfManager);
   virtual DtEmbeddedEntityInfoManager* embeddedEntityInfoManager();
   virtual const DtEmbeddedEntityInfoManager* embeddedEntityInfoManager() const;

   virtual void setScriptedTaskManager (DtScriptedTaskManager*);
   virtual DtScriptedTaskManager* scriptedTaskManager();
   virtual const DtScriptedTaskManager* scriptedTaskManager() const;

   virtual void setScenarioEventManager (DtScenarioEventManager*);
   virtual DtScenarioEventManager* scenarioEventManager();
   virtual const DtScenarioEventManager* scenarioEventManager() const;

   virtual void setHazardAreaManager (DtHazardAreaManager*);
   virtual DtHazardAreaManager* hazardAreaManager();
   virtual const DtHazardAreaManager* hazardAreaManager() const;

   virtual void setIntelCollectionAreaManager (DtIntelCollectionAreaManager*);
   virtual DtIntelCollectionAreaManager* intelCollectionAreaManager();
   virtual const DtIntelCollectionAreaManager* intelCollectionAreaManager() const;

   virtual void setScriptedObjectsMovementManager (DtScriptedObjectsMovementManager*);
   virtual DtScriptedObjectsMovementManager* scriptedObjectsMovementManager();
   virtual const DtScriptedObjectsMovementManager* scriptedObjectsMovementManager() const;

   virtual DtEventId nextEventId(const DtGlobalObjectDesignator& entId);

   virtual void setAggregateSpatialModel (DtAggregateSpatialModel* aggregateSpatialModel);
   virtual DtAggregateSpatialModel* aggregateSpatialModel();
   virtual const DtAggregateSpatialModel* aggregateSpatialModel() const;

   virtual void setDetonationManager(DtDetonationManager* detonationManager);
   virtual DtDetonationManager* detonationManager();
   virtual const DtDetonationManager* detonationManager() const;

   virtual void setAmmunitionManager(DtAmmunitionManager* ammunitionManager);
   virtual DtAmmunitionManager* ammunitionManager();

   virtual void setFireManager(DtFireManager* fireManager);
   virtual DtFireManager* fireManager();
   virtual const DtFireManager* fireManager() const;


   virtual void setGlobalPlanManager(DtGlobalPlanManager* planManager);
   virtual const DtGlobalPlanManager* globalPlanManager() const;
   virtual DtGlobalPlanManager* globalPlanManager();


   virtual void setStealthCommandsManager(DtStealthCommandsManager* planManager);
   virtual const DtStealthCommandsManager* stealthCommandsManager() const;
   virtual DtStealthCommandsManager* stealthCommandsManager();


   virtual void setHostilityManager(DtHostilityManager* hostilityManager);
   virtual const DtHostilityManager* hostilityManager() const;
   virtual DtHostilityManager* hostilityManager();


   virtual void setEngagementZonesManager(DtEngagementZonesManager* manager);
   virtual const DtEngagementZonesManager* engagementZonesManager() const;
   virtual DtEngagementZonesManager* engagementZonesManager();


   virtual void setScenarioExtrasMgr(DtScenarioExtrasMgr* scenarioExtrasMgr);
   virtual const DtScenarioExtrasMgr* scenarioExtrasMgr() const;
   virtual DtScenarioExtrasMgr* scenarioExtrasMgr();

   void setEventManager(DtEventManager*);
   DtEventManager* eventManager() const;

   virtual void addEvent(const DtEvent&);

   virtual void addEvent(const DtDetonationInteraction&);
   virtual void addEvent(const DtFireInteraction&);
   virtual void addEvent(const DtAcknowledgeInteraction&);
   virtual void addEvent(const DtStopFreezeInteraction&);
   virtual void addEvent(const DtStartResumeInteraction&);
   virtual void addEvent(const DtDataInteraction&);
   virtual void addEvent(const DtSignalInteraction&);
   virtual void addEvent(const DtCommentInteraction&);
   virtual void addEvent(const DtSensorFieldOfViewControlInter&);
   virtual void addevent(const DtSimInterfaceContent&);

#if DtHLA
   virtual void addEvent(const DtDataInteractionWithTransportType&);
   virtual void addEvent(const DtInfluenceInteraction&);
   virtual void addEvent(const DtInfluenceInteractionExtension&);
   virtual void addEvent(const DtEndGestureInter&);
   virtual void addEvent(const DtExecuteGestureInter&);
#else
   virtual void addEvent(const DtDIGuyCustomPdu&);
#endif



   virtual void setSimCommandDistributor(DtSimCommandDistributor* distributor);
   virtual const DtSimCommandDistributor* simCommandDistributor() const;
   virtual DtSimCommandDistributor* simCommandDistributor();


   virtual void setDebugDrawManager(DtDebugDrawManager* debugDrawManager);
   virtual const DtDebugDrawManager* debugDrawManager() const;
   virtual DtDebugDrawManager* debugDrawManager();


   void setClockMode(int clockMode);

   virtual void setScenarioRunId(int);
   virtual int scenarioRunId() const;

   virtual void setRejectMismatchedScenarioMessages(bool);
   virtual bool rejectMismatchedScenarioMessages() const;

   virtual bool rejectMessage(const DtVrfObjectMessage*) const;

   virtual DtVrfSimSettingsManager* vrfSimSettingsManager();
   
   virtual void addMessageCallback(int type, DtMessageCallbackFcn fcn, 
      void* usrData);

   virtual void removeMessageCallback(int type, DtMessageCallbackFcn fcn, 
      void* usrData);


   virtual DtU32 scenarioCapabilities() const;
   virtual void setScenarioCapabilities(DtU32 v);


   virtual DtVrfMessageInterface* messageInterface() const;
   virtual DtInterfaceMessageExecutive* messageExecutive();

   virtual DtVrfTDLMessageInterface* tdlMessageInterface() const;

   static void TickFunction(void* userData);

   virtual void registerInterfaceCallbacks();

   virtual bool registerExtendedProperties();

   virtual const DtSimulationAddress& messageAddress() const;

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

   virtual unsigned long sequenceNumber();

   virtual void setSequenceNumber(unsigned long sequenceNumber);

   DtResourceMonitor* resourceMonitor();
   void setResourceMonitor(DtResourceMonitor*);

   DtRadarCoverageMonitor* radarCoverageMonitor();
   void setRadarCoverageMonitor(DtRadarCoverageMonitor*);

   DtTerrainProfileRequestManager* terrainProfileRequestManager();
   void setTerrainProfileRequestManager(DtTerrainProfileRequestManager*);

   virtual int vrfSessionId() const;

   virtual int vrfMessageVersionSupported() const;

   virtual void runForDuration(double);
   virtual double runDurationTime() const;

   virtual void stopSimulationDurationTimer();

   static void runDurationCompleteCallback(DtTimer*);
   virtual void processRunDurationComplete();

   virtual void addSimulationRunDurationCallback(DtRunDurationCallbackFcn tickFunction, void* userData);
   virtual void removeSimulationRunDurationCallback(DtRunDurationCallbackFcn tickFunction, void* userData);

   virtual void doNotSelfReflect(unsigned int);
   virtual void selfReflect(unsigned int);

   virtual bool selfReflecting() const;

   const DtEnumDictionary* enumerationDictionary() const;

   virtual std::vector<DtFilename> enumerationsFiles() const;

protected:
   DtVrfSimOptionsInterface*    mySimOptions;

   DtScheduler*                 myScheduler;
   DtExerciseClock*             myExerciseClock;
   mutable DtNoArgumentCallbackList     myTickList;
   mutable DtNoArgumentCallbackList     myPostTickList;
   DtFrameRateMonitor*          myFrameRateMonitor;
   DtVrfSimSettingsManager*     myVrfSimSettingsManager;
   DtVrfMessageInterface*       myMessageInterface;
   DtVrfTDLMessageInterface*    myTDLMessageInterface;

   DtExerciseConn*              myExerciseConn;
   DtPhysicalWorld*             myPhysicalWorld;
   DtCommModelManager*          myCommModelManager;
   DtSimTerrainRequestManager*  mySimTerrainRequestManager;
   DtVrfObjectManager*          myVrfObjectManager;
   DtEmbeddedEntityInfoManager* myEmbeddedEntityInfoManager;
   DtAggregateSpatialModel*     myAggregateSpatialModel;
   DtDetonationManager*         myDetonationManager;
   DtAmmunitionManager*        myAmmunitionManager;
   DtFireManager*               myFireManager;
   DtGlobalPlanManager*         myGlobalPlanManager;
   DtStealthCommandsManager*    myStealthCommandsManager;
   DtHostilityManager*          myHostilityManager;
   DtEngagementZonesManager*    myEngagementZonesManager;
   DtScenarioExtrasMgr*         myScenarioExtrasMgr;
   DtResourceMonitor*           myResourceMonitor;
   DtRadarCoverageMonitor*      myRadarCoverageMonitor;
   DtTerrainProfileRequestManager*      myTerrainProfileRequestManager;
   DtScriptedTaskManager*       myScriptedTaskManager;
   DtScenarioEventManager*      myScenarioEventManager;
   DtHazardAreaManager*         myHazardAreaManager;
   DtIntelCollectionAreaManager*         myIntelCollectionAreaManager;
   DtScriptedObjectsMovementManager*   myScriptedObjectsMovementManager;
   DtParallelTickManager*       myParallelTickManager;
   DtVrfNavAreaManager*            myVrfNavAreaManager;
   DtSpawnSinkManager*          mySpawnSinkManager; 
   DtSimCommandDistributor*     mySimCommandDistributor;
   DtEventManager*              myEventManager;
   DtDebugDrawManager*          myDebugDrawManager;

   int                          myClockMode;

   DtTimer* mySimulationDurationTimer;
   DtNoArgumentCallbackList     mySimulationDurationCallbackList;
   double myRunDurationTime;

   int myScenarioRunId;
   bool myRejectMismatchedScenarioMessages;
   DtU32 myScenarioCapabilities;

   DtEnumDictionary* myEnumDictionary;

   tbb::spin_mutex myMutex;
};

inline DtResourceMonitor* DtSimManager::resourceMonitor()
{
   return myResourceMonitor;
}

inline DtRadarCoverageMonitor* DtSimManager::radarCoverageMonitor()
{
   return myRadarCoverageMonitor;
}

inline DtTerrainProfileRequestManager* DtSimManager::terrainProfileRequestManager()
{
   return myTerrainProfileRequestManager;
}

inline void DtSimManager::setResourceMonitor(DtResourceMonitor* m)
{
   myResourceMonitor = m;
}

inline void DtSimManager::setRadarCoverageMonitor(DtRadarCoverageMonitor* m)
{
   myRadarCoverageMonitor = m;
}

inline void DtSimManager::setTerrainProfileRequestManager(DtTerrainProfileRequestManager* m)
{
   myTerrainProfileRequestManager = m;
}

inline DtEventManager* DtSimManager::eventManager() const
{
   return myEventManager;
}