DtCigiNetworkIO.h

Go to the documentation of this file.

/*********************************************************************
** Copyright (c) 2025 MaK Technologies, Inc.
** All rights reserved.
*********************************************************************/


#pragma once

#include <vrvCigi/vrvCigi.h> 
#include <vrvCigi/DtCigiConnectionInitializer.h>
#include <vrvCigi/DtPositionResponder.h>
#include <vrvCigi/DtCollisionResponder.h>
#include <vrvCigi/DtHatHotResponder.h>
#include <vrvCigi/DtSensorResponder.h>

#include <vrvUtil/DtVirtualBaseClass.h>

#include <vlutil/vlInetSocket.h>

#include <CigiTypes.h>
#include <CigiVersionID.h>

class CigiHatHotRespV3_2;
class CigiHatHotRespV4;
class CigiLosRespV3_2;
class CigiLosRespV4;
class CigiLosXRespV3_2;
class CigiLosXRespV4;
class CigiPositionRespV3;
class CigiPositionRespV4;
class CigiCollDetSegRespV3;
class CigiCollDetSegRespV4;
class CigiHatHotRespV3_2;
class CigiHatHotRespV4;
class CigiHatHotXRespV3_2;
class CigiHatHotXRespV4;
class CigiSensorRespV3;
class CigiSensorRespV4;
class CigiSensorXRespV3;
class CigiSensorXRespV4;

class DtInetSocket;
class DtInetSocketMgr;
class DtInetTcpSocket;
class CigiIGSession;
class CigiBasePacket;
class CigiBaseIGCtrl;

namespace makCigiExt
{
   class DtCigiDiGuyCtrl;
   class DtCigiDiGuyCtrlExt;
   class DtCigiDiGuyExecuteGesture;
   class DtCigiDiGuyEndGesture;
   class DtCigiDiGuyCtrlExtV4;
   class DtCigiDiGuyExecuteGestureV4;
   class DtCigiDiGuyEndGestureV4;
}

namespace makVrv
{
   class DtCigiConnectionInitializer;
   class DtCigiSignalProcessor;
   class DtCigiConnection;
   class DtCigiLosBasicResponse;
   class DtCigiLosExtendedResponse;

   class DT_DLL_VRVCIGI DtCigiNetworkIO
   {
   public:
      friend class DtCigiNetworkIOCreator;

      virtual ~DtCigiNetworkIO();

      virtual bool receiveCigiMessages();

      virtual bool sendCigiMessages(unsigned int frameNumber, unsigned int lastHostFrameNumber,
         int igMode, int databaseNumber);

      virtual void setSignalProcessor(DtCigiSignalProcessor& sigProcessor);

      virtual void sendHatHotResponse( const DtHatHotResponder::DtHatHotResponseData* hatHotResponse );

      virtual void sendLosBasicResponse(DtCigiLosBasicResponse* losResponse);

      virtual void sendLosExtendedResponse(DtCigiLosExtendedResponse* losResponse);

      virtual void sendPositionResponse( DtPositionResponder::DtPositionResponseData* posResponse );

      virtual void sendCollisionSegmentResponse( DtCollisionResponder::DtCollisionSegmentResponseData* collReponse );

      virtual void sendSensorResponse( DtSensorResponder::DtSensorResponseData* sensorResponse );

      virtual void sendUserPacket( CigiBasePacket* packet );

      virtual CigiIGSession& session();
      virtual const CigiIGSession& session() const;

      bool cigiSessionExists() const;

      virtual void packLosBasicResponseV3(const DtCigiLosBasicResponse& response, CigiLosRespV3_2& respPacket);
      
      virtual void packLosBasicResponseV4(const DtCigiLosBasicResponse& response, CigiLosRespV4& respPacket);

      virtual void packLosExtendedResponseV3(const DtCigiLosExtendedResponse& response, CigiLosXRespV3_2& respPacket);
      
      virtual void packLosExtendedResponseV4(const DtCigiLosExtendedResponse& response, CigiLosXRespV4& respPacket);

      virtual void packPositionResponseV3(const DtPositionResponder::DtPositionResponseData& response, CigiPositionRespV3& respPacket);
      virtual void packPositionResponseV4(const DtPositionResponder::DtPositionResponseData& response, CigiPositionRespV4& respPacket);

      virtual void packCollisionSegmentResponseV3( const DtCollisionResponder::DtCollisionSegmentResponseData& response, CigiCollDetSegRespV3& respPacket );
      virtual void packCollisionSegmentResponseV4( const DtCollisionResponder::DtCollisionSegmentResponseData& response, CigiCollDetSegRespV4& respPacket );

      virtual void packHatHotResponseV3( const DtHatHotResponder::DtHatHotResponseData& response, CigiHatHotRespV3_2& respPacket );
      virtual void packHatHotResponseV4( const DtHatHotResponder::DtHatHotResponseData& response, CigiHatHotRespV4& respPacket );

      virtual void packHatHotExtendedResponseV3( const DtHatHotResponder::DtHatHotResponseData& response, CigiHatHotXRespV3_2& respPacket );
      virtual void packHatHotExtendedResponseV4( const DtHatHotResponder::DtHatHotResponseData& response, CigiHatHotXRespV4& respPacket );

      virtual void packSensorResponseV3( const DtSensorResponder::DtSensorResponseData& response, CigiSensorRespV3& respPacket );
      virtual void packSensorResponseV4( const DtSensorResponder::DtSensorResponseData& response, CigiSensorRespV4& respPacket );

      virtual void packSensorExtendedResponseV3( const DtSensorResponder::DtSensorResponseData& response, CigiSensorXRespV3& respPacket );
      virtual void packSensorExtendedResponseV4( const DtSensorResponder::DtSensorResponseData& response, CigiSensorXRespV4& respPacket );

      virtual bool registerUserPacket(CigiBasePacket* packet, 
         unsigned int packetId, bool hostSend, bool igSend);
 
      static bool addSocketCb(DtInetSocket* sock, void* usr);

      static bool removeSocketCb(DtInetSocket* sock, void* usr);

      virtual void reset();

      DtCigiNetworkIO() = delete;
      DtCigiNetworkIO( DtCigiNetworkIO& ) = delete;
      DtCigiNetworkIO( DtCigiNetworkIO&& ) = delete;
      DtCigiNetworkIO& operator=( DtCigiNetworkIO& ) = delete;
      DtCigiNetworkIO& operator=( DtCigiNetworkIO&& ) = delete;

   protected:
      DtCigiNetworkIO(const DtCigiConnectionInitializer& initializer, 
         DtCigiConnection& connection );

      virtual void initializeUdpSocket(const DtInetEndpoint& endpoint, 
         unsigned int listenPort, DtInetDevice* device);

      virtual void initializeTcpSocket(const DtInetEndpoint& endpoint, 
         DtInetDevice* device, int localPort);

      virtual void addSocket(DtInetTcpSocket* sock);
      
      virtual void removeSocket(DtInetTcpSocket* sock);

      virtual DtInetAddr findFirstNetworkDeviceAddress(bool& found) const;

      CigiBaseIGCtrl* igControlPacket( Cigi_uint8* Dta );

      virtual bool packAndSendCigiMessage();

   protected:
      DtCigiConnection& myConnection;

      DtInetSocket*     mySocket;

      CigiIGSession*    myCigiIgSession;

      DtInetBufferChain myReceiveBufferChain;

      DtInetBuffer      myReceiveBuffer;

      unsigned int      myReceiveBufferSize;

      DtInetEndpoint    myDestinationAddress;

      DtCigiSignalProcessor* mySignalProcessor;

      DtInetSocketMgr*  mySocketMgr;

      bool              myUseTcpClient;

      bool               myUseTcpServer;

      bool               myUseSynchronousMode;

      std::vector<const DtHatHotResponder::DtHatHotResponseData*> myHatHotBasicResponses;
      std::vector<const DtHatHotResponder::DtHatHotResponseData*> myHatHotExtendedResponses;

      std::vector<DtCigiLosBasicResponse*> myLosBasicResponses;
      std::vector<DtCigiLosExtendedResponse*> myLosExtendedResponses;

      std::vector<DtPositionResponder::DtPositionResponseData*> myPositionResponses;

      std::vector<DtCollisionResponder::DtCollisionSegmentResponseData*> myCollisionSegmentResponses;

      std::vector<DtSensorResponder::DtSensorResponseData*> mySensorResponses;
      std::vector<DtSensorResponder::DtSensorResponseData*> mySensorExtendedResponses;

      std::vector<CigiBasePacket*> myUserPacketsToSend;

      double myTimeSlice;

      makCigiExt::DtCigiDiGuyCtrl* myDiGuyCtrlPacket;


      makCigiExt::DtCigiDiGuyCtrlExt* myDiGuyCtrlExtPacket;

      makCigiExt::DtCigiDiGuyExecuteGesture* myDiGuyExecuteGesturePacket;

      makCigiExt::DtCigiDiGuyEndGesture* myDiGuyEndGesturePacket;


      makCigiExt::DtCigiDiGuyCtrlExtV4* myDiGuyCtrlExtPacketV4;

      makCigiExt::DtCigiDiGuyExecuteGestureV4* myDiGuyExecuteGesturePacketV4;

      makCigiExt::DtCigiDiGuyEndGestureV4* myDiGuyEndGesturePacketV4;

   };

   class DT_DLL_VRVCIGI DtCigiNetworkIOCreator : public DtVirtualBaseClass
   {
   public:     
      DtCigiNetworkIOCreator();

      virtual ~DtCigiNetworkIOCreator();

      static DtCigiNetworkIOCreator& instance( DtDe& de );

      static DtCigiNetworkIOCreator& instance( DtCigiConnection& con );
      
      virtual DtCigiNetworkIOCreator* clone();

      static void copyInstance(DtCigiConnection& con, DtDe& de);

      virtual DtCigiNetworkIO* create( const DtCigiConnectionInitializer& initializer, 
         DtCigiConnection& connection ) const;
   };
}