DtCigiDriver.h

Go to the documentation of this file.

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

 
#pragma once

#include <vrvCigi/DtCigiViewController.h>

#include <vrvCore/DtDriver.h>
#include <vrvCore/DtSharedSettingsManager.h>
#include <vrvCore/DtViewStateProcessor.h>

#include <vrvUtil/DtLockedBufferedQueue.h>
#include <vrvUtil/DtSignalConnectionManager.h>

#include <matrix/vlVector.h>
#include <vlutil/vlRunnable.h>

class DtThread;

namespace makVrv 
{
   class DtAsynchronousAgentManager;
   class DtAsynchronousEventQueue;
   class DtCigiConnection;
   class DtCigiConnectionInitializer;
   class DtCigiIntersectionHandler;
   class DtIgSettingsController;
   class DtLosResponder;
   class DtPositionResponder;
   class DtCigiPositionHandler;
   class DtCollisionResponder;
   class DtSensorResponder;
   class DtCigiSensorController;
   class DtCigiViewManager;
   class DtCigiSymbolHandler;
   class DT_DLL_VRVCIGI DtCigiDriver : public DtDriver, 
      protected DtRunnable
   {
   public:

      DtCigiDriver(DtAgentManager& agentManager, 
         const std::string& uniqueName);

      virtual ~DtCigiDriver();

      virtual const std::string& className() const;
      
      const DtCigiConnectionInitializer& connectionSettings() const;

      virtual void setConnectionSettings(const DtCigiConnectionInitializer& settings);

      virtual DtConfiguration createConfiguration() const;

      virtual void realizeConfiguration(const DtConfiguration& config);

      virtual void run();

      virtual DtAgentManagerInterface& sceneInterface();

      virtual bool useThreadFlag() const;

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

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

      void reportSmoothingEnabledChanged( bool enabled );

      boost::signalslib::signal<void (DtCigiConnection*)> signal_sessionCreated;

      boost::signalslib::signal<void (DtCigiConnection*)> signal_sessionAboutToBeDestroyed;

      virtual DtIgSettingsController& igSettingsController();
      virtual const DtIgSettingsController& isSettingsController() const;

      virtual DtCigiViewController& viewController();
      virtual const DtCigiViewController& viewController() const;

      virtual DtCigiIntersectionHandler& intersectionHandler();
      virtual const DtCigiIntersectionHandler& intersectionHandler() const;

      virtual const DtCigiPositionHandler& positionHandler() const;
      virtual DtCigiPositionHandler& positionHandler();
      
      virtual const DtCigiSensorController& sensorController() const;
      virtual DtCigiSensorController& sensorController();
      virtual const DtCigiSymbolHandler& symbolHandler() const;
      virtual DtCigiSymbolHandler& symbolHandler();



   protected:
      static std::string theCigiDriverClassName;

   protected:
      virtual bool onStart();

      virtual bool onStop();

      virtual bool onTick();

      virtual void startThread();

      virtual void stopThread();

      virtual void setConnectionState(bool connected);

      virtual void slot_onLoadDatabase(const std::string& filename);

      virtual void performLoadDatabase(const std::string& filename);

      virtual void slot_terrainPatchCreated();

      // \brief Calls setDatabaseLoaded on the DtCigiConnection.
      virtual void slot_firstTickAfterTerrainPatchCreated();

      virtual void slot_onCoordinateSystemChanged(
         const std::string& name, 
         const std::string& params);

      typedef DtLockedBufferedQueue<boost::function<void ()> > FunctionCallQueue;
      typedef std::vector<boost::function<void ()> > FunctionCallList;

      virtual void runFunctionQueue(FunctionCallQueue& queue);

      virtual void slot_displayEngineAdded( const DtDeRecord& igRecord );

   protected:
      bool      myUseThreadFlag;

      DtThread* myThread;

      DtCigiConnection* myConnection;

      DtLosResponder* myLosResponder;

      DtPositionResponder* myPositionResponder;

      DtCollisionResponder* myCollisionResponder;

      DtSensorResponder* mySensorResponder;

      DtCigiViewManager* myViewManager;


      bool myConnectedFlag;

      DtCigiConnectionInitializer *myInitializer;

      DtAsynchronousEventQueue* myAsynchronousEventQueue;
      DtAsynchronousAgentManager* myAsynchronousInterface;
      DtDe&                       myDe;

      FunctionCallQueue myDriverThreadFunctions;
      FunctionCallQueue myConnectionThreadFunctions;

      DtSignalConnectionManager  myDynamicSignals;

      DtCigiViewController*      myViewController;

      DtCigiSensorController* mySensorController;

      DtIgSettingsController*    myComponentController;

      DtCigiIntersectionHandler* myIntersectionHandler;

      DtCigiPositionHandler* myPositionHandler;

      DtCigiSymbolHandler* mySymbolHandler;

      double                     myNextFrameTime;
   };

   inline const DtCigiConnectionInitializer& DtCigiDriver::connectionSettings() const
   {
      return (*myInitializer);
   }

   class DT_DLL_VRVCIGI DtCigiDriverCreator : public DtDriverCreator
   {
   public:     

      DtCigiDriverCreator();

      virtual ~DtCigiDriverCreator();

      virtual const std::string& extension() const;

      virtual DtDriver* create(DtAgentManager& agentManager,
         const std::string& instanceName) const;

   protected:
      std::string myFileExtension;

   };
}