DtVrlinkConnection.h

Go to the documentation of this file.

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


#pragma once

#include <vrvCore/DtDriver.h>
#include <vrvVrl/DtConnection.h>

#include <vl/entityPub.h>
#include <vrvUtil/DtSignalConnectionManager.h>

#include <boost/unordered_map.hpp>

class DtExerciseConnInitializer;
class DtExerciseConn;
class DtStealthControlPdu;

#ifndef DT_PROTOCOL_NAMESPACE
#error Namespace Protocol Macro DT_PROTOCOL_NAMESPACE not defined.
#endif

#if DtHLA
#include <vl/geodeticRegion.h>
#endif

namespace makVrv
{   
   namespace DT_PROTOCOL_NAMESPACE
   {
      class DtEntityStateInterceptorCreator;      

      class DL_DLL_IGCONVRLINK DtVrlinkConnection : public DtConnection
      {
      public:

         DtVrlinkConnection(DtAgentManagerInterface& aSceneInterface,
            const DtCoordinateSystem& coordSystem,
            const DtEntityAppearanceMapperFactoryCreator& appFactoryCreator,
            DtSharedSettingsManager& settingsManager);

         virtual ~DtVrlinkConnection();

         virtual void setExerciseConnInit(const DtExerciseConnInitializer& exConnInitializer);

         virtual bool connect();

         virtual bool connected() const;

         virtual bool disconnect();

         virtual void tick();

         virtual void setViewControlChanged( bool enabled );

         virtual void observerUpdated(const std::string& name,
            double x, double y, double z,
            double psi, double theta, double phi);

         virtual void observerUpdated(const std::string& observerName,
            double x, double y, double z,
            double psi, double theta, double phi,
            double dx, double dy, double dz,
            double dpsi, double dtheta, double dphi);

         virtual void stopPublishingObserver(const std::string& observerName);

         virtual void startPublishingObserver(const std::string& observerName);

         virtual void attachObserverObject(const std::string& observerName, DtUniqueID id);

         virtual void detachObjects(const std::string& observerName);

         inline DtExerciseConn* exerciseConn()
         {
            return myExerciseConnection;
         }

         virtual const std::string& tag()
         {
#ifdef DtDIS
            const static std::string str("DIS");
#elif DtHLA_1516_EVOLVED
            const static std::string str("HLA1516e");
#elif DtHLA_1516
            const static std::string str("HLA1516");
#elif DtHLA
            const static std::string str("HLA13");
#else
            const static std::string str("");
#endif
            return str;
         }


#if DtHLA
         inline const DtDDMRegionSet& regions() const
         {
            return myRegions;
         }

         virtual void addDdmRegionForObserver(const std::string& observerName);

         virtual void removeDdmRegionForObserver(const std::string& observerName);

         virtual void setDdmRegionSize(int sizeInMeters);

         virtual void setRegionUpdateThreshold(int percentage);

         virtual void setUseAltitudeThreshold(bool yesNo);

         virtual void setAltitudeThreshold(int meters);

         virtual void updateDdmRegion(const std::string& observerName,
            const DtVector& observerLocation);

         virtual void setRegionOutOfBounds(DtDDMRegionSP region);

         boost::signal<void (DtDDMRegionSP)> signal_regionAdded;
         boost::signal<void (DtDDMRegionSP)> signal_regionToBeRemoved;

#endif

#if DtDIS
         //Check to see if entity is published by this simulation.
         bool entityIsPublished(const DtEntityIdentifier& id) const;

         virtual bool timeoutProcessing() const;

         virtual void setTimeoutProcessing(bool enabled);

         virtual double timeoutInterval() const;

         virtual void setTimeoutInterval(double interval);
#endif      

         void setSupportsDelayedVisualizerCreation(bool);
         bool supportsDelayedVisualizerCreation() const;

         // Signal sent before the tick starts
         boost::signal<void ()> signal_preTick;

         // Signal sent after the tick has been completed
         boost::signal<void ()> signal_postTick;

      protected:

         void addObserverPublisher(const std::string& observerName);

   protected:

         typedef boost::unordered_map<std::string, DtEntityPublisher*> 
            ObserverPublisherMap;

         //Exercise Connection settings.
         DtExerciseConnInitializer* myExConnInitializer;     


         //Active connection
         DtExerciseConn* myExerciseConnection;

#if DtHLA
         bool initializeDdm();

         DtDDMRegionSet myRegions;

         struct RegionInfo
         {
            DtGeodeticRegionSP region;
            DtVector           geocentricLocation;
            bool               outOfBounds;
         };

         typedef boost::unordered_map<std::string, RegionInfo> ObserverRegions;
         ObserverRegions myObserverRegions;
         int myRegionUpdateThreshold;
         int myDdmRegionSize;
         bool myUseAltitudeThreshold;
         double myAltitudeThreshold;
#endif

#if DtDIS
         bool myTimeoutProcessing;
         double myTimeoutInterval;
#endif


         //Publishers for observers
         ObserverPublisherMap myObserverPublishers;
         bool myViewControlsEnabled;
         DtSignalConnectionManager myConnections;

         bool mySupportsDelayedVisualizerCreation;
      };
   }
}