DtLegionConnection.h

Go to the documentation of this file.

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


#pragma once

#include <vrvLegion/vrvLegion.h>

#include <vrvCore/DtDriver.h>
#include <vrvCore/DtBaseConnection.h>
#include <vrvUtil/DtRandomNumberGenerator.h>
#include <vrvCore/DtSelectionManager.h>
#include <vrvCore/DtViewStateProcessor.h>
#include "legionNet/boundarySpatialSpherical.h"
#include "legionDataStore/configuration.h"

#include <vrvVrl/DtConnection.h>

#include <legionDataStore/dataTypes.h>
#include <legionDataStore/vector.h>

#include <matrix/vlVector.h>

#include <vlutil/vlTimeStampType.h>
#include <map>
#include <string>

#include <boost/signals2.hpp>

class DtEntityType;

namespace Legion
{
   class Connection;
   class ViewManager;
   class WriteEntityRepository;
   class BoundarySpatialSpherical;
   class SimulationDatabase;
   class Configuration;
}

namespace STE
{
   class EntityView;
}

namespace MAK
{
   class ServerStatResult;
   class ClientStatResult;
}

namespace makVrv
{
   class DtLegionDriver;
   class DtEntityProcessor;
   class DtFireEventProcessor;
   class DtDetonationEventProcessor;

   class VRV_LEGION_DLL DtLegionConnection : public DtConnection
   {
   public:

      DtLegionConnection(DtAgentManagerInterface& aSceneInterface,
         const DtCoordinateSystem& coordSystem,
         const DtEntityAppearanceMapperFactoryCreator& appFactoryCreator,
         DtSharedSettingsManager& settingsManager, DtLegionDriver& driver);

      virtual ~DtLegionConnection();


      virtual void setConnectionConfiguration(const Legion::Configuration& config);


      virtual bool connect();

      virtual bool connected() const;

      virtual bool disconnect();

      virtual void tick(double dt);

      virtual double simTime() const;

      virtual void setSimTime( double simTime);

      virtual double clockTime() const;

      virtual DtTimeStampType timeStampType() const;


      virtual void setViewControlChanged( bool enabled );

      virtual void setConnectionFrameTime( double frameTime );

      virtual double connectionFrameTime() const;

      virtual void setUseTopoForFlatEarthVectorConversion( bool enabled );

      virtual void observerUpdated(const std::string& observerName,
         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);


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

      boost::signals2::signal <void()> signal_exerciseConnectionCreated;

      boost::signals2::signal <void()> signal_preTick;

      boost::signals2::signal <void()> signal_postTick;

      boost::signals2::signal <void()> signal_postBeginFrame;

      boost::signals2::signal <void()> signal_preEndFrame;

      boost::signals2::signal <void()> signal_databaseCreated;

      virtual void queueDriverFunction(boost::function<void()> func);

      virtual void queueConnectionFunction(boost::function<void()> func);

      Legion::SimulationDatabase* database();
      Legion::Connection* connection();
      Legion::ViewManager* viewManager();

      virtual DtLegionDriver& driver();
      virtual const DtLegionDriver& driver() const;


      virtual void setInterestSize(int size);
      virtual int interestSize();

      virtual void setObserverForward(DtVector& localPos, DtVector& localFwd);
      virtual Legion::Vector3d observerForward();
      virtual Legion::Vector3d observerLocation();

      virtual void resetConnection();

      virtual void setExternalCommunicationControl(bool);

   protected:
      void addObserverPublisher(const std::string& observerName);
      void updateInterest();
#if 0
      void handleStats(const MAK::ServerStatResult& servers, const std::vector<MAK::ClientStatResult>& clients);
#endif
   protected:

      
      //Publishers for observers
      bool myViewControlsEnabled;
      bool myUseTopoForFlatEarthVectorConversion;
      DtSignalConnectionManager myConnections;
      double myConnectionFrameTime;

      bool mySupportsDelayedVisualizerCreation;
      DtLegionDriver& myDriver;

      DtEntityProcessor* myEntityProcessor;
      DtFireEventProcessor* myFireProcessor;
      DtDetonationEventProcessor* myDetonationProcessor;

      Legion::Configuration* myConnectionConfiguration;
      Legion::SimulationDatabase* myDatabase;
      Legion::Connection* myConnection;
      Legion::ViewManager* myViewManager;

      double mySimTime;
      float myInterestSize;

      Legion::Vector3f myObserverForward;
      Legion::Vector3d myObserverLocation;
      Legion::Vector3d myLastObserverLocation;
      Legion::BoundarySpatialSpherical* myBoundary;

      bool myExternalCommunicationControl;
   };
}