include/vrfcore/simMgr.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 1999 MAK Technologies, Inc.
** All rights reserved.
*******************************************************************************/
/*******************************************************************************
** $RCSfile: simMgr.h,v $ $Revision: 1.87 $ $State: Exp $
*******************************************************************************/
#ifndef simMgr_H_
#define simMgr_H_





#include "vrfutil/callbackList.h"
#include <vl/hostStructs.h>
#include <vlutil/vlMachineTypes.h>
#include <vrfmsgs/msgExec.h>

class DtExerciseConn;
class DtPhysicalWorld;
class DtCommModelManager;
class DtReflectedExtEntityList;
class DtThreadSocket;
class DtThreadMessageList;
class DtFrameRateMonitor;
class DtResourceMonitor;

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

class DtScheduler;
class DtExerciseClock;
class DtVrfObjectManager;
class DtAggregateSpatialModel;
class DtDetonationManager;
class DtFireManager;
class DtGlobalPlanManager;
class DtInterfaceMessageExecutive;
class DtJoyDeviceManager;
class DtVrfMessageInterface;
class DtStealthRemoteController;
class DtHostilityManager;
class DtScenarioExtrasMgr;
class DtVrfSimSettingsManager;

typedef void (*DtSimTickFunction)(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 bool createExerciseClock();

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

   
   virtual void setTargetFrameRate(int rate);
   virtual int targetFrameRate() const;

   virtual void sleep() const;

   virtual bool deliverMessage(const DtSimInterfaceMessage& msg);
   virtual bool receiveMessage(const DtSimInterfaceMessage& msg);

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

#if XXX

   virtual bool createAndDeliverMessage(const DtSimulationAddress& sender,
    const DtSimulationAddress& recipient, 
    const DtSimInterfaceContent & content);
#endif


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

   virtual DtExerciseConn* exerciseConn();

   virtual DtExerciseClock* exerciseClock();

   virtual DtFrameRateMonitor* frameRateMonitor();

   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 setVrfObjectManager (DtVrfObjectManager* entityManager);
   virtual DtVrfObjectManager* vrfObjectManager();
   virtual const DtVrfObjectManager* vrfObjectManager() const;

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

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

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


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

   virtual void setJoyDeviceManager(DtJoyDeviceManager* joyDeviceManager);
   virtual const DtJoyDeviceManager* joyDeviceManager() const;
   virtual DtJoyDeviceManager* joyDeviceManager();


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


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

   virtual void setStealthRemoteController(DtStealthRemoteController* controller);
   virtual DtStealthRemoteController* stealthRemoteController();

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

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


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

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

   virtual int vrfSessionId() const;

   virtual int vrfMessageVersionSupported() const;

protected:

   DtScheduler*                 myScheduler;
   DtExerciseClock*             myExerciseClock;
   DtNoArgumentCallbackList     myTickList;
   DtFrameRateMonitor*          myFrameRateMonitor;
   DtVrfSimSettingsManager*     myVrfSimSettingsManager;
   DtVrfMessageInterface*       myMessageInterface;

   DtExerciseConn*              myExerciseConn;
   DtPhysicalWorld*             myPhysicalWorld;
   DtCommModelManager*          myCommModelManager;
   DtVrfObjectManager*          myVrfObjectManager;
   DtAggregateSpatialModel*     myAggregateSpatialModel;
   DtDetonationManager*         myDetonationManager;
   DtFireManager*               myFireManager;
   DtGlobalPlanManager*         myGlobalPlanManager;
   DtJoyDeviceManager*          myJoyDeviceManager;
   DtHostilityManager*          myHostilityManager;
   DtScenarioExtrasMgr*         myScenarioExtrasMgr;
   DtResourceMonitor*           myResourceMonitor;
   DtStealthRemoteController*   myStealthRemoteController;

   int myTargetFrameRate;
};

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

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

#endif