vrfDriver.h

Go to the documentation of this file.

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



#pragma once

#include <vrfVrlSharedSource/vrfProtocol.h>
#include <vrfGuiCore/guiThreadVrfRemoteController.h>
#include <vrfGuiCore/sharedNetworkSignaler.h>
#include <vrvVrl/DtVrlinkBaseConnection.h>
#include <vrvUtil/DtSignalConnectionManager.h>
#include <vrvCore/DtSharedModelSetSettings.h>
#include <vlutil/vlPerformanceStats.h>
#include <vrfStateData/dataGate.h>

#include <vrvVrl/DtVrlinkConnection.h>

#include <vlpi/entityType.h>
#include <matrix/vlVector.h>

#include <vrfutil/scenario.h>

#if DtHLA
#include <vrfExtObjects/influenceInteractionHLA.h>
#else
#include <vrfmsgs/ifSaveComplete.h>
#include <vlutil/vlPerformanceStats.h>
#endif
#include "vrfutil/rwColor.h"


#if DtHLA
namespace makVrfVrlinkExtToolkit
{
   class DtReflectedExtendedAttributesObjectList;
}
#endif

namespace makVrv
{
   class DtElement;
   class DtEntityElement;
   class DtTacticalGraphicElement;

   namespace DT_PROTOCOL_NAMESPACE
   {
      class DtVrlinkEntityStateListener;
      class DtVrlinkAggregateElement;
      class DtSensorFieldOfViewSimDataProcessor;
      class DtVrlinkLaserDesignatorStateListener;
   }
}

class DtVrfRemoteController;
class DtCommunicationManager;
class DtTimeAndDateStateRepository;

namespace makVrf 
{
   class DtVrlinkVrfRemoteController;
   class DtRemoteLoggerController;
   class DtVrlinkNetworkInterface;
   class DtRadioProcessor;
   class DtVrfConnectionHelper;
   class DtNetworkMessageInterface;
   class DtStateDataManager;

   namespace VRF_PROTOCOL_NAMESPACE
   {
      class DtVrlinkVantageToLegionIdMapper;
      class DtVrfCloudLayerStateProcessor;
      class DtVrfAggregateObjectDataStateProcessor;
      class DtOrbatSimDataProcessor;
      class DtVrfFogOfWarHandler;
      class DtVrfEmbarkationProcessor;
      class DtVrfWeatherProcessor;
      class DtVrfCloudLayerProcessor;
      class DtVrfVrlinkGuiOrbatManager;
      class DtVrlinkVantageLegionToIdMapper;

      class VRF_PROTOCOL_EXPORT DtVrfDriver : public VRF_DRIVER_BASE_CLASS
      {
      public:
         DtVrfDriver(makVrv::DtAgentManager& agentManager, const std::string& uniqueName);

         virtual ~DtVrfDriver() override;

      public:
         virtual bool onStart() override;

      public:
         virtual void setConditionLockTimeout(double d);
         double conditionLockTimeout() const
         {
            return myConditionLockTimeout;
         }

         virtual DtVrlinkVrfRemoteController* vrfRemoteController() const;
         virtual DtVrfRemoteController* remoteController() const;
         virtual DtCommunicationManager* communicationManager() const;
         virtual DtVrlinkVantageToLegionIdMapper* vrfVantageToLegionIdMapper() const;

         virtual void realizeConfiguration(const makVrv::DtConfiguration& config) override;

         virtual void sendLoggerSetFilename(std::string filename);

         virtual void sendLoggerRecordMessage();

         virtual void sendLoggerStopMessage();

         virtual void requestOrbatList();

         virtual void clearOrbatList();

         virtual void receivedNetworkMessage(DtNetworkMessageInterface* iface);

         virtual void executeGesture(std::string gesture, std::vector<makVrv::DtUniqueID>);

         virtual void executeAnimation(std::string gesture, std::vector<makVrv::DtUniqueID>);
         virtual void executeAnimations(std::map<makVrv::DtUniqueID, std::string>);

         virtual void setIconColor(DtRwColor iconColor, std::vector<makVrv::DtUniqueID>);

         virtual void blockNetworkAnimationChange(std::vector<makVrv::DtUniqueID>, bool, double);
         virtual void blockNetworkGestureChange(std::vector<makVrv::DtUniqueID>, bool);

         virtual void startFreezeScenario(DtSimulationAddress, bool sendStart);

         virtual void sendSensorFieldOfViewControl(const DtSensorFieldOfViewControlInteractionData* d);

         virtual void sendDetonation(const DtDetonationInteractionData* d);

         virtual void queueConnectionFunction(const boost::function<void ()>& function);

         virtual void queuePostAdvanceFrameConnectionFunction(const boost::function<void ()>& function);

         DtStateDataManager* stateDataManager() const;

         DtVrfConnectionHelper* connectionHelper() const
         {
            return myConnectionHelper;
         }

         DtVrfCloudLayerStateProcessor* cloudLayerDataProcessor()
         {
            return myCloudLayerDataProcessor;
         }

         DtOrbatSimDataProcessor*  orbatDataProcessor()
         {
            return myOrbatDataProcessor;
         }

         DtVrlinkNetworkInterface* vrlinkNetworkInterface()
         {
            return myVrlinkNetworkInterface;
         }

         DtVrfVrlinkGuiOrbatManager*  orbatManager()
         {
            return myOrbatManager;
         }

         void setUseThreadFlag(bool b)
         {
            myUseThreadFlag = b;
         }

         bool connected() const
         {
            return myConnected;
         }

         int sessionId() const
         {
            return mySessionId;
         }

         virtual bool onStop() override;

         virtual bool onTick() override;

         virtual bool updateVisibility(makVrv::DtEntityElement*, bool b, makVrv::DtVisualizerShowHideContext::VisualizerShowHideContext,
            makVrv::DtModelSetId id = makVrv::DtModelSetId::Unspecified) const;
         virtual bool updateVisibility(makVrv::DtTacticalGraphicElement*, bool b, makVrv::DtVisualizerShowHideContext::VisualizerShowHideContext,
            makVrv::DtModelSetId id = makVrv::DtModelSetId::Unspecified) const;

         boost::signals2::signal<void ()> signal_connectionSetUp;
         boost::signals2::signal<void ()> signal_connectionCleanedUp;
         boost::signals2::signal<void ()> signal_connectionAboutToBeCleanedUp;
         boost::signals2::signal<void ()> signal_onFirstTickDriverInitialization;
         boost::signals2::signal<void ()> signal_driverStarted;
         boost::signals2::signal<void ()> signal_driverAboutToBeSetUp;
         boost::signals2::signal<void ()> signal_postConnectionTick;

      public:
         const std::string& nonVrfObjectsUseUUIDScheme() const;

      protected:
#if DtDIS
         virtual void slot_scenarioAboutToBeSaved(DtScenario& s) const;
         virtual void slot_scenarioSaved(DtSaveResult result, const DtString& sError);
         virtual void enterTimeoutProcessingMode();
         virtual void leaveTimeoutProcessingMode();
#endif

         virtual void slot_timeAndDateDiscovered(DtTimeAndDateStateRepository*);

         virtual void remoteControllerInit();
         virtual void slot_scenarioLoaded();

         virtual bool createExerciseConnection();
         virtual void onSetupExerciseConnection();
         virtual void onCleanupExerciseConnection();

         virtual void connectionConnected();

         virtual void elementAttributeChangeRequested( 
            makVrv::DtUniqueID id, makVrv::DtUniqueID parentId, std::shared_ptr<const makVrv::DtElementAttribute> atr );

         makVrv::DtElement* findElementWithId(makVrv::DtUniqueID id) const;

         virtual makVrv::DtVrlinkBaseConnection* createConnection() override;

         virtual void slot_entityElementCreated(makVrv::DtEntityElement* e);

         virtual void slot_postConnectionTick();
         virtual void slot_preConnectionTick();
         virtual void slot_coordinateSystemChanged();

         virtual void visualsLoaded();

         virtual void slot_parameterDatabaseInitialized(bool);

         virtual void setVisibleForElement(makVrv::DtElement*, bool flag, int context) const;

         virtual void rediscoverListeners();

         virtual void resetVisualFlags(makVrv::DtEntityElement*);
         virtual void resetVisualFlags(makVrv::DtTacticalGraphicElement*);
         virtual void resetVisuals(makVrv::DtEntityElement*, const makVrv::DtSharedModelSetSettings::ModelSetVisualizedMap&);
         virtual void slot_advanceFrame(bool& continueAdvance);

      protected:
         DtVrfConnectionHelper*     myConnectionHelper;
         DtRemoteLoggerController*  myLoggerControl;

         DtVrfCloudLayerStateProcessor* myCloudLayerDataProcessor = nullptr;

         makVrv::DtAgentManager& myAgentManager;

         DtVrlinkNetworkInterface* myVrlinkNetworkInterface;

         DtVrfVrlinkGuiOrbatManager* myOrbatManager;

         DtOrbatSimDataProcessor*  myOrbatDataProcessor;

         bool myRtiError;
         std::string                   myHostAddressString;
         std::string                   myReportedHostAddressString;
         int                           mySessionId;
         DtVrfFogOfWarHandler*         myFogOfWarHandler;

         DtVrfEmbarkationProcessor*    myVrfEmbarkationProcessor;
         makVrv::DtSignalConnectionManager     myConnectionManager;

         DtVrfWeatherProcessor*        myVrfWeatherProcessor = nullptr;
         DtVrfCloudLayerProcessor*     myVrfCloudLayerProcessor = nullptr;

         typedef std::map<unsigned int, bool> ContextMap;
         typedef std::map<makVrv::DtUniqueID, ContextMap> ShowHideContextMap;

         bool myConnected;
         std::string myLocalSettingsDesignator;

         int myFileTransporterReceivePort;
         std::string myNonVrfObjectsUseUUIDScheme;
         unsigned myNumberOfRemoteNetworkThreads;

         DtExerciseConn* myExerciseConnection;

#if DtHLA
         bool myDisableRequestUpdatesFlag;
         bool myRequestWhenInitializedFlag;
#endif


         bool myNeedsFirstTickInitialization;

#ifdef DtDIS
         mutable double myTimeSaveStarted = 0.;
         double myEnteredTimeoutProcessingModeAt = 0.;
#endif

         bool myRemoteDiscoveryDisabled;
         bool myProcessStateDataUponDiscovery;
         bool myAdvancedFrame = true;
         DtGateLock myGateLock;

         double myConditionLockTimeout = 1.0 / 20.0;
         double myAdvanceFramePeriod = 0.2;
         std::chrono::milliseconds myWaitForMainThreadTimout = std::chrono::milliseconds(10);
         tbb::tick_count myLastFrameAdvanceTime = tbb::tick_count::now();
      };

      inline const std::string& DtVrfDriver::nonVrfObjectsUseUUIDScheme() const
      {
         return myNonVrfObjectsUseUUIDScheme;
      }
   }
}