SoRemoteVizClient.h

/*=======================================================================
*** THE CONTENT OF THIS WORK IS PROPRIETARY TO FEI S.A.S, (FEI S.A.S.),            ***
***              AND IS DISTRIBUTED UNDER A LICENSE AGREEMENT.                     ***
***                                                                                ***
***  REPRODUCTION, DISCLOSURE,  OR USE,  IN WHOLE OR IN PART,  OTHER THAN AS       ***
***  SPECIFIED  IN THE LICENSE ARE  NOT TO BE  UNDERTAKEN  EXCEPT WITH PRIOR       ***
***  WRITTEN AUTHORIZATION OF FEI S.A.S.                                           ***
***                                                                                ***
***                        RESTRICTED RIGHTS LEGEND                                ***
***  USE, DUPLICATION, OR DISCLOSURE BY THE GOVERNMENT OF THE CONTENT OF THIS      ***
***  WORK OR RELATED DOCUMENTATION IS SUBJECT TO RESTRICTIONS AS SET FORTH IN      ***
***  SUBPARAGRAPH (C)(1) OF THE COMMERCIAL COMPUTER SOFTWARE RESTRICTED RIGHT      ***
***  CLAUSE  AT FAR 52.227-19  OR SUBPARAGRAPH  (C)(1)(II)  OF  THE RIGHTS IN      ***
***  TECHNICAL DATA AND COMPUTER SOFTWARE CLAUSE AT DFARS 52.227-7013.             ***
***                                                                                ***
***                   COPYRIGHT (C) 1996-2020 BY FEI S.A.S,                        ***
***                        BORDEAUX, FRANCE                                        ***
***                      ALL RIGHTS RESERVED                                       ***
**=======================================================================*/
 
#ifndef _SO_REMOTEVIZ_CLIENT_
#define _SO_REMOTEVIZ_CLIENT_
 
#include <Inventor/sys/port.h>
#include <RemoteViz/Clients/nodes/LibHelper.h>
 
#include <Inventor/SbPImpl.h>
#include <Inventor/SbString.h>
#include <Inventor/SbVec.h>
#include <Inventor/fields/SoSFString.h>
#include <Inventor/fields/SoSFUShort.h>
#include <Inventor/fields/SoSFBool.h>
#include <Inventor/fields/SoMFVec2String.h>
#include <Inventor/fields/SoSFEnum.h>
#include <Inventor/fields/SoMFEnum.h>
#include <Inventor/nodes/SoNode.h>
#include <Inventor/SbEventHandler.h>
#include <Inventor/SbEventArg.h>
#include <Inventor/devices/SoCpuBufferObject.h>
 
class SoLocation2Event;
class SoMouseButtonEvent;
class SoMouseWheelEvent;
class SoKeyboardEvent;
class SoTouchEvent;
 
SO_PIMPL_BASE_PUBLIC_DECLARATION(SoRemoteVizClient);
 
class RVCLIENT_API SoRemoteVizClient : public SoNode
{
 
  SO_NODE_HEADER(SoRemoteVizClient);
 
  SO_PIMPL_BASE_PUBLIC_HEADER(SoRemoteVizClient);
 
public:
 
  enum DisplayMode {
    STRETCH    ,
    CROP    ,
    FIT
  };
 
  enum VideoDecoder {
    NONE,
    OPENH264,
    INTEL_QUICKSYNC,
    NVDECODE,
    VPX
  };
 
  enum StreamingMode
  {
    /* The streaming mode is not yet known. */
    UNKNOWN,
    /* The client uses image streaming. */
    IMAGE,
    /* The client uses video streaming. */
    VIDEO
  };
 
  SoRemoteVizClient();
 
  virtual ~SoRemoteVizClient();
 
  // Fields:
 
  SoSFBool connect;
 
  SoSFString ipAddress;
 
  SoSFUShort port;
 
  SoSFString renderAreaName;
 
  SoMFEnum videoDecoders;
 
  SoMFVec2String connectionParameters;
 
  SoSFEnum displayMode;
 
  void sendMessage(const SbString& message);
 
  void sendMessage(SoCpuBufferObject* buffer);
 
  void enableSecureConnection(const SbString& publicCertificateFilePath, const SbString& privateKeyFilePath, unsigned int enabledSecurityProtocols = TLSv1_1 | TLSv1_2 | TLSv1_3, const SbString& privateKeyPassphrase = "");
 
  enum SecurityProtocols
  {
    SSLv2 = 0x1, // 2^0, bit 0
    SSLv3 = 0x2, // 2^1, bit 1
    TLSv1 = 0x4, // 2^2, bit 2
    TLSv1_1 = 0x8, // 2^3, bit 3
    TLSv1_2 = 0x10, // 2^4, bit 4
    TLSv1_3 = 0x20 // 2^5, bit 5
  };
 
  unsigned int getEnabledSecurityProtocols() const;
 
  bool isSecureConnection() const;
 
  void requestRenderAreaSize(const SbVec2s& size);
 
  SbVec2s getRenderAreaSize() const;
 
  SbVec2s getContainerSize() const;
 
  bool isImageStreamingSupported() const;
 
  bool isVideoStreamingSupported() const;
 
  VideoDecoder getVideoDecoder() const;
 
  StreamingMode getStreamingMode() const;
 
  struct RVCLIENT_API ServiceMessageEventArg : public SbEventArg
  {
    enum State
    {
      CONNECTED,
      DISCONNECTED,
      START_NETWORK_CALIBRATION,
      FINISH_NETWORK_CALIBRATION,
      START_BANDWIDTH_CALIBRATION,
      FINISH_BANDWIDTH_CALIBRATION,
      START_LATENCY_CALIBRATION,
      FINISH_LATENCY_CALIBRATION,
      PENDING_NETWORK_CALIBRATION
    };
 
    ServiceMessageEventArg(SoRemoteVizClient* source, State state, SbVec2s renderAreaSize, const SbString& details)
      : m_source( source ), m_state( state ), m_renderAreaSize( renderAreaSize ), m_details( &details ) {}
 
    SoRemoteVizClient* getSource() const { return m_source; }
 
    State getState() const { return m_state; }
 
    const SbVec2s& getRenderAreaSize() const { return m_renderAreaSize; }
 
    const SbString& getDetails() const { return *m_details; }
 
  private:
    SoRemoteVizClient* m_source;
    State m_state;
    SbVec2s m_renderAreaSize;
    const SbString* m_details;
  };
 
  struct RVCLIENT_API MessageEventArg : public SbEventArg
  {
    MessageEventArg(SoRemoteVizClient* source, const SbString& message)
      : m_source(source), m_message(&message) {}
 
    SoRemoteVizClient* getSource() const { return m_source; }
 
    const SbString& getMessage() const { return *m_message; }
 
  private:
    SoRemoteVizClient* m_source;
    const SbString* m_message;
  };
 
  struct RVCLIENT_API BinaryMessageEventArg : public SbEventArg
  {
    BinaryMessageEventArg(SoRemoteVizClient* source, SoCpuBufferObject* buffer)
      : m_source(source), m_buffer(buffer) {}
 
    SoRemoteVizClient* getSource() const {return m_source;}
 
    SoCpuBufferObject* getBuffer() const {return m_buffer;}
 
  private:
    SoRemoteVizClient* m_source;
    SoCpuBufferObject* m_buffer;
  };
 
  struct RVCLIENT_API RenderAreaSizeEventArg : public SbEventArg
  {
    RenderAreaSizeEventArg(SoRemoteVizClient* source, SbVec2s size)
      : m_source(source), m_size(size) {}
 
    SoRemoteVizClient* getSource() const { return m_source; }
 
    const SbVec2s& getSize() const { return m_size; }
 
    private:
      SoRemoteVizClient* m_source;
      SbVec2s m_size;
  };
  
  struct RVCLIENT_API FrameEventArg : public SbEventArg
  {
    FrameEventArg(SoRemoteVizClient* source, uint64_t id, uint64_t dataLength, bool isLossless, const SbString& message)
      : m_source(source), m_id(id), m_dataLength(dataLength), m_isLossless(isLossless), m_message(&message) {}
 
    SoRemoteVizClient* getSource() const { return m_source; }
 
    uint64_t getId() const { return m_id; }
 
    uint64_t getDataLength() const { return m_dataLength; }
 
    bool isLossless() const { return m_isLossless; }
 
    const SbString& getMessage() const { return *m_message; }
 
    private:
      SoRemoteVizClient* m_source;
      uint64_t m_id;
      uint64_t m_dataLength;
      bool m_isLossless;
      const SbString* m_message;
  };
 
  struct RVCLIENT_API MouseLocationEventArg : public SbEventArg
  {
    MouseLocationEventArg(SoRemoteVizClient* source, SoLocation2Event* mouseLocationEvent)
      : m_source(source), m_mouseLocationEvent(mouseLocationEvent) {}
 
    SoRemoteVizClient* getSource() const { return m_source; }
 
    SoLocation2Event* getMouseLocationEvent() const { return m_mouseLocationEvent; }
 
    private:
      SoRemoteVizClient* m_source;
      SoLocation2Event* m_mouseLocationEvent;
  };
 
  struct RVCLIENT_API MouseButtonEventArg : public SbEventArg
  {
    MouseButtonEventArg(SoRemoteVizClient* source, SoMouseButtonEvent* mouseButtonEvent)
      : m_source(source), m_mouseButtonEvent(mouseButtonEvent) {}
 
    SoRemoteVizClient* getSource() const { return m_source; }
 
    SoMouseButtonEvent* getMouseButtonEvent() const { return m_mouseButtonEvent; }
 
    private:
      SoRemoteVizClient* m_source;
      SoMouseButtonEvent* m_mouseButtonEvent;
  };
 
  struct RVCLIENT_API MouseWheelEventArg : public SbEventArg
  {
    MouseWheelEventArg(SoRemoteVizClient* source, SoMouseWheelEvent* mouseWheelEvent)
      : m_source(source), m_mouseWheelEvent(mouseWheelEvent) {}
 
    SoRemoteVizClient* getSource() const { return m_source; }
 
    SoMouseWheelEvent* getMouseWheelEvent() const { return m_mouseWheelEvent; }
 
    private:
      SoRemoteVizClient* m_source;
      SoMouseWheelEvent* m_mouseWheelEvent;
  };
 
  struct RVCLIENT_API KeyboardEventArg : public SbEventArg
  {
    KeyboardEventArg(SoRemoteVizClient* source, SoKeyboardEvent* keyboardEvent)
      : m_source(source), m_keyboardEvent(keyboardEvent) {}
 
    SoRemoteVizClient* getSource() const { return m_source; }
 
    SoKeyboardEvent* getKeyboardEvent() const { return m_keyboardEvent; }
 
    private:
      SoRemoteVizClient* m_source;
      SoKeyboardEvent* m_keyboardEvent;
  };
 
  struct RVCLIENT_API TouchEventArg : public SbEventArg
  {
    TouchEventArg(SoRemoteVizClient* source, SoTouchEvent* touchEvent)
      : m_source(source), m_touchEvent(touchEvent) {}
 
    SoRemoteVizClient* getSource() const { return m_source; }
 
    SoTouchEvent* getTouchEvent() const { return m_touchEvent; }
 
    private:
      SoRemoteVizClient* m_source;
      SoTouchEvent* m_touchEvent;
  };
 
  SbEventHandler<ServiceMessageEventArg&> onServiceMessage;
 
  SbEventHandler<MessageEventArg&> onReceivedMessage;
 
  SbEventHandler<BinaryMessageEventArg&> onReceivedBinaryMessage;
 
  SbEventHandler<RenderAreaSizeEventArg&> onRenderAreaResize;
 
  SbEventHandler<FrameEventArg&> onReceivedFrame;
 
  SbEventHandler<FrameEventArg&> onDecodedFrame;
 
  SbEventHandler<MouseLocationEventArg&> onMouseLocationEvent;
 
  SbEventHandler<MouseButtonEventArg&> onMouseButtonEvent;
 
  SbEventHandler<MouseWheelEventArg&> onMouseWheelEvent;
 
  SbEventHandler<KeyboardEventArg&> onKeyboardEvent;
 
  SbEventHandler<TouchEventArg&> onTouchEvent;
 
  private:
  // Initializes this class
  static void       initClass();
  static void       exitClass();
 
private:
  virtual void notify(SoNotList *list);
 
  virtual void doAction(SoAction *action);
 
  virtual void GLRender(SoGLRenderAction *action);
 
  virtual void handleEvent(SoHandleEventAction *action);
 
 
private:
 
  void construct();
};
 
#endif // _SO_REMOTEVIZ_CLIENT_