simManager.h

Go to the documentation of this file.

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


#pragma once

#include <vrfMsgTransport/exerciseClock.h>

#include <vrfmsgs/messageExecutive.h>

#include <vrfutil/vrf4XAPI.h>

#include <matrix/vlVector.h>

#include <vlutil/vlTime.h>

#include <readerWriter/noArgumentCallbackList.h>

#include <tbb/spin_mutex.h>
#include <vrfMsgTransport/vrfDatabaseLoggerInterface.h>
#include <vrfMsgTransport/vrfDatabaseLoggerInterface.h>


class DtPhysicalWorld;
class DtCommModelManager;
class DtThreadSocket;
class DtThreadMessageList;
class DtFrameRateMonitor;
class DtResourceMonitor;
class DtRadarCoverageMonitor;
class DtTerrainProfileRequestManager;
class DtVrfObjectMessage;
class DtCommunicationManager;
class DtSimObjectManager;
class DtSimInternalCommunicationManager;
class DtObjectGeometricModelsManager;
class DtVrfObjectPlanAdministrator;
class DtDiGuyCharacterDataManager;
class DtManagedObjectListManager;

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

class DtScheduler;
class DtDebugDrawManager;
class DtScriptedTaskManager;
class DtScenarioEventManager;
class DtHazardAreaManager;
class DtIntelCollectionAreaManager;
class DtScriptedObjectsMovementManager;
class DtScriptedObjects;
class DtDetonationServiceInterface;
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 DtVrfCallbackQueue;
class DtVrfSimOptionsInterface;
class DtVrfNavAreaManager;
class DtSpawnSinkManager;
class DtSimCommandDistributor;
class DtSimulationServices;
class DtSimImguiThread;
class DtVrfParameterDb;
class DtObjectConsoleManager;
class DtOrbatManager;
class DtEnumDictionary;
class DtSyncMatrixManager;
class DtAisDataServiceInterface;
class DtAdsbDataServiceInterface;
struct DtCommunicationManagerPerformanceTimerInformation;

namespace makVrf
{
   class DtStateDataManager;
}

namespace makVrfEvents
{
   class DtEventManager;
   class DtEvent;
   class DtDetonationInteraction;
   class DtFireInteraction;
   class DtDataInteraction;
   class DtCommentInteraction;
}

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

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

   DtSimManager(DtCommunicationManager*);

   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 createScheduler();
   virtual bool createMessageInterface();
   virtual bool createTDLMessageInterface();
   virtual bool createFrameRateMonitor();
   virtual bool createVrfSimSettingsManager();
   virtual bool createParallelQueue();
   virtual bool createDatabaseLogger();

   virtual bool beginFrame(DtCommunicationManagerPerformanceTimerInformation* info = nullptr);

   virtual void tick();

   virtual bool advanceFrame(DtCommunicationManagerPerformanceTimerInformation* timerInformation = nullptr);

   virtual bool deliverMessage(const DtSimInterfaceMessage& msg);

   virtual bool receiveMessage(const DtSimInterfaceMessage& msg);

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

   virtual bool allowInfiniteObjects() 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;

   virtual DtFrameRateMonitor* frameRateMonitor();

   virtual DtVrfCallbackQueue* parallelQueue();

   virtual DtScheduler* scheduler();

   virtual bool canTransferObjects() const;

   virtual double simTime() const;
   virtual double dT() const;
   virtual double elapsedRealTime() const;
   virtual double absRealTime() const;
   virtual double approximateElapsedRealTime() const;
   virtual bool isPaused() const;
   virtual double timeMultiplier() const;
   double simTimeScale() const { return timeMultiplier(); };

   virtual void setObjectNavDataPaths(const DtReaderWriter::SearchPaths&);
   virtual const DtReaderWriter::SearchPaths& objectNavDataPaths() const;

   virtual void setSimTime(double d);
   virtual void setTimeMultiplier(double d);

   virtual void setExerciseStartTime(double);
   virtual double exerciseTime() const;
   virtual double exerciseStartTime() const;


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

   virtual void pause();
   virtual void run();

   virtual DtSimulationServices* simulationServices();
   virtual const DtSimulationServices* simulationServices() const;

   virtual DtSimImguiThread* simImguiManager();
   virtual const DtSimImguiThread* simImguiManager() 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 setSimObjectManager (DtSimObjectManager* entityManager);
   virtual const DtSimObjectManager* simObjectManager() const;
   virtual DtSimObjectManager* simObjectManager();

   void setPlanAdministrator (DtVrfObjectPlanAdministrator* entityManager);
   DtVrfObjectPlanAdministrator* planAdministrator() const;

   void setDiGuyCharacterManager (DtDiGuyCharacterDataManager* entityManager);
   DtDiGuyCharacterDataManager* diGuyCharacterManager() 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 setOrbatManager (DtOrbatManager*);
   virtual DtOrbatManager* orbatManager();
   virtual const DtOrbatManager* orbatManager() const;

   virtual void sendServerMessage(const DtString&, int severity = DtNlWarn, const DtSimulationAddress& addr = DtSimSendToAll);

   virtual void setSimInternalCommunicationManager(DtSimInternalCommunicationManager*);
   virtual DtSimInternalCommunicationManager* simInternalCommunicationManager() const;

   virtual void setObjectListManager(DtManagedObjectListManager*);
   virtual DtManagedObjectListManager* objectListManager() const;

   virtual void setObjectModelsManager (DtObjectGeometricModelsManager*);
   virtual DtObjectGeometricModelsManager* objectModelsManager();
   virtual const DtObjectGeometricModelsManager* objectModelsManager() 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 void setDetonationManager(DtDetonationServiceInterface* detonationManager);
   virtual DtDetonationServiceInterface* detonationManager();
   virtual const DtDetonationServiceInterface* 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 setCommunicationManager(DtCommunicationManager*);
   DtCommunicationManager* communicationManager() const;
   makVrfEvents::DtEventManager* eventManager() const;

   makVrf::DtStateDataManager* stateDataManager() const;

   virtual bool runFullyThreaded() const;

   virtual void addEvent(const makVrfEvents::DtEvent&);


   virtual DtString nextEventId(const DtString& entityId);


   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();


   virtual void setObjectParametersDB(const DtVrfParameterDb*);
   virtual const DtVrfParameterDb* objectParametersDB() const;


   virtual void setObjectConsoleManager(DtObjectConsoleManager*);
   virtual const DtObjectConsoleManager* objectConsoleManager() const;
   virtual DtObjectConsoleManager* objectConsoleManager();


   virtual void setAisDataManager(DtAisDataServiceInterface*);
   virtual const DtAisDataServiceInterface* aisDataManager() const;
   virtual DtAisDataServiceInterface* aisDataManager();


   virtual void setAdsbDataManager(DtAdsbDataServiceInterface*);
   virtual const DtAdsbDataServiceInterface* adsbDataManager() const;
   virtual DtAdsbDataServiceInterface* adsbDataManager();

   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 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 setMaxTasks(int);

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

   const DtEnumDictionary* enumerationDictionary() const;

   virtual void clearEnumerations();
   
   virtual bool initializeEnumerations();

   virtual bool loadEnumerations(const DtFilename&);

   virtual DtFilename enumerationsFileDirectory() const;
   virtual void setEnumerationsFileDirectory(const DtFilename& directory);


   virtual void setSyncMatrixManager(DtSyncMatrixManager* SyncMatrixManager);
   virtual const DtSyncMatrixManager* syncMatrixManager() const;
   virtual DtSyncMatrixManager* syncMatrixManager();

   virtual DtVrfDatabaseLoggerInterface* databaseLogger();
   virtual void setDatabaseLogger(DtVrfDatabaseLoggerInterface*);

   static void setBlockOnAsynchronousOperations(bool shouldBlock);
   static bool blockOnAsynchronousOperations();
protected:
   virtual void setupMessagesToNotSelfReflect();

protected:
   DtVrfSimOptionsInterface*    mySimOptions;
   double myDT;

   DtScheduler*                 myScheduler;
   mutable DtNoArgumentCallbackList     myTickList;
   mutable DtNoArgumentCallbackList     myPostTickList;
   DtFrameRateMonitor*          myFrameRateMonitor;
   DtVrfSimSettingsManager*     myVrfSimSettingsManager;
   DtSimObjectManager*           mySimObjectManager;
   DtVrfMessageInterface*       myMessageInterface;
   DtVrfTDLMessageInterface*    myTDLMessageInterface;
   DtVrfObjectPlanAdministrator* myPlanAdministrator;
   DtDiGuyCharacterDataManager* myDiGuyCharacterManager;

   DtPhysicalWorld*             myPhysicalWorld;
   DtCommModelManager*          myCommModelManager;
   DtSimTerrainRequestManager*  mySimTerrainRequestManager;
   DtEmbeddedEntityInfoManager* myEmbeddedEntityInfoManager;
   DtDetonationServiceInterface*         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;
   DtOrbatManager*               myOrbatManager;
   DtManagedObjectListManager* myObjectListManager;
   DtObjectGeometricModelsManager* myObjectModelsManager;
   DtVrfCallbackQueue*       myParallelQueue;
   DtVrfNavAreaManager*            myVrfNavAreaManager;
   DtSpawnSinkManager*          mySpawnSinkManager;
   DtSimCommandDistributor*     mySimCommandDistributor;
   DtCommunicationManager*      myCommunicationManager;
   DtDebugDrawManager*          myDebugDrawManager;
   const DtVrfParameterDb*     myObjectParametersDB;
   DtObjectConsoleManager*     myObjectConsoleManager;
   DtSimInternalCommunicationManager* mySimInternalCommunicationManager;
   DtSyncMatrixManager* mySyncMatrixManager;
   DtAisDataServiceInterface* myAisDataManager;
   DtAdsbDataServiceInterface* myAdsbDataManager;
   DtVrfDatabaseLoggerInterface* myDatabaseLogger;

   DtSimulationServices* mySimulationServices;

   DtSimImguiThread* mySimImguiManager;

   DtTimer* mySimulationDurationTimer;
   DtNoArgumentCallbackList     mySimulationDurationCallbackList;
   double myRunDurationTime;
   DtReaderWriter::SearchPaths myObjectNavDataPaths;

   int myScenarioRunId;
   bool myRejectMismatchedScenarioMessages;
   DtU32 myScenarioCapabilities;

   DtEnumDictionary* myEnumDictionary;
   DtFilename myEnumsFileDirectory;

   tbb::spin_mutex myMutex;
   double mySimTime;
   std::atomic<int> myNextEventNumber;

   static bool theBlockOnAsynchronousOperations;

public:
   VRF4API_METHOD const DtSimulationServices* exerciseClock() const;
};

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 void DtSimManager::setPlanAdministrator(DtVrfObjectPlanAdministrator* m)
{
   myPlanAdministrator = m;
}

inline DtVrfObjectPlanAdministrator* DtSimManager::planAdministrator() const
{
   return myPlanAdministrator;
}

inline void DtSimManager::setDiGuyCharacterManager(DtDiGuyCharacterDataManager* m)
{
   myDiGuyCharacterManager = m;
}

inline DtDiGuyCharacterDataManager* DtSimManager::diGuyCharacterManager() const
{
   return myDiGuyCharacterManager;
}

inline DtCommunicationManager* DtSimManager::communicationManager() const
{
   return myCommunicationManager;
}

inline void DtSimManager::setObjectParametersDB(const DtVrfParameterDb* db)
{
   myObjectParametersDB = db;
}

inline const DtVrfParameterDb* DtSimManager::objectParametersDB() const
{
   return myObjectParametersDB;
}

inline void DtSimManager::setObjectConsoleManager(DtObjectConsoleManager* db)
{
   myObjectConsoleManager = db;
}

inline const DtObjectConsoleManager* DtSimManager::objectConsoleManager() const
{
   return myObjectConsoleManager;
}

inline DtObjectConsoleManager* DtSimManager::objectConsoleManager()
{
   return myObjectConsoleManager;
}

inline void DtSimManager::setOrbatManager (DtOrbatManager* entityManager)
{
   myOrbatManager = entityManager;
}

inline DtOrbatManager* DtSimManager::orbatManager()
{
   return myOrbatManager;
}

inline void DtSimManager::setObjectListManager(DtManagedObjectListManager* m)
{
   myObjectListManager = m;
}

inline DtManagedObjectListManager* DtSimManager::objectListManager() const
{
   return myObjectListManager;
}

inline const DtOrbatManager* DtSimManager::orbatManager() const
{
   return myOrbatManager;
}

inline void DtSimManager::setObjectModelsManager (DtObjectGeometricModelsManager* entityManager)
{
   myObjectModelsManager = entityManager;
}

inline DtObjectGeometricModelsManager* DtSimManager::objectModelsManager()
{
   return myObjectModelsManager;
}

inline const DtObjectGeometricModelsManager* DtSimManager::objectModelsManager() const
{
   return myObjectModelsManager;
}

inline void DtSimManager::setSimInternalCommunicationManager(DtSimInternalCommunicationManager* m)
{
   mySimInternalCommunicationManager = m;
}

inline  DtSimInternalCommunicationManager* DtSimManager::simInternalCommunicationManager() const
{
   return mySimInternalCommunicationManager;
}

inline DtVrfDatabaseLoggerInterface* DtSimManager::databaseLogger()
{
   return myDatabaseLogger;
}

inline const DtReaderWriter::SearchPaths& DtSimManager::objectNavDataPaths() const
{
   return myObjectNavDataPaths;
}

inline void DtSimManager::setObjectNavDataPaths(const DtReaderWriter::SearchPaths& s)
{
   myObjectNavDataPaths = s;
}