DtCigiDriver.h

Go to the documentation of this file.

/****************************************************************************** 
** Copyright (c) 2007 MAK Technologies, Inc. 
** All rights reserved. 
******************************************************************************/ 
/****************************************************************************** 
** $RCSfile: DtCigiDriver.h,v $ $Revision: 1.18 $ $State: Exp $ 
******************************************************************************/ 
 
 
#ifndef DtCigiDriver_H_ 
#define DtCigiDriver_H_ 
 
#include <vrvCigi/vrvCigi.h> 

#include <vrvCigi/DtCigiViewController.h>

#include <vrvCore/DtDriver.h>
#include <vrvCore/DtSharedSettingsManager.h>
#include <vrvCore/DtUniqueID.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 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 addDriverFunction(boost::function<void ()> func);

      virtual void generateLosResponse(int losId, DtUniqueID entityId,
         bool visible, double range, int responseCount, int hostFrame);

      virtual void generateHatHotResponse(double height, unsigned int hotId, bool hat,
         unsigned int lastFrame, bool valid);

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

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


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

   protected:
      bool      myUseThreadFlag;

      DtThread* myThread;

      DtCigiConnection* myConnection;

      DtLosResponder* myLosResponder;

      bool myConnectedFlag;

      DtCigiConnectionInitializer *myInitializer;

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

      FunctionCallQueue myDriverThreadFunctions;
      FunctionCallQueue mySimulationThreadFunctions;

      DtSignalConnectionManager  myDynamicSignals;

      DtCigiViewController*      myViewController;

      DtIgSettingsController*    myComponentController;

      DtCigiIntersectionHandler* myIntersectionHandler;

      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;

   };
} 
 
#endif