SoGuiAlgoViewers.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                                       ***
**=======================================================================*/
/*=======================================================================
** Author      : Tristan MEHAMLI (Dec 2008)
**=======================================================================*/
 
 
#ifndef SO_GUI_ALGO_VIEWERS
#define SO_GUI_ALGO_VIEWERS
 
//
//  Class: SoGuiAlgoViewers
//
// Provides common and specific algorithms for viewers.
// 
//
 
#include <Inventor/Gui/viewers/SoGuiConstrainedViewer.h>
#include <Inventor/SbVec.h>
 
class SbProjector;
class SoExtSelection;
class SoFieldSensor;
class SoMPEGRenderer;
class SoNode;
class SoSwitch;
class SoAlarmSensor;
class SbSphereSheetProjector;
 
class  SoGuiAlgoViewers : public SoGuiConstrainedViewer
{
  SO_FIELDCONTAINER_HEADER( SoGuiAlgoViewers );
 
public:
 
  enum ViewerTypes 
  {
    EXAMINER, 
    PLANE, 
    FLY, 
    WALK,
    UNKNOWN
  };
 
  enum DrawStyle
  {
    VIEW_AS_IS,
    VIEW_HIDDEN_LINE,
    VIEW_NO_TEXTURE,
    VIEW_LOW_COMPLEXITY,
    VIEW_LINE,
    VIEW_POINT,
    VIEW_BBOX,
    VIEW_LOW_RES_LINE,
    VIEW_LOW_RES_POINT,
    VIEW_SAME_AS_STILL
  };
 
  enum DrawType
  {
    STILL,
    INTERACTIVE
  };
 
  enum BufferType
  {
    BUFFER_SINGLE,
    BUFFER_DOUBLE,
    BUFFER_INTERACTIVE
  };
 
  enum ProjectorsType
  {
    SPHERICAL, 
    CYLINDRICAL
  };
 
  enum ZoomingType
  {
    AUTOCENTER, 
    GIVENPOSITION
  };
 
  SoGuiAlgoViewers();
 
  void setConstrained( SbBool constrained );
 
  SbBool isConstrained() const;
 
  void setViewerType( ViewerTypes vType );
 
  SoGuiAlgoViewers::ViewerTypes getViewerType() const;
 
  void resetRenderAction();
 
  void setSheetProjectionType( const ProjectorsType &projType );
 
  ProjectorsType getSheetProjectionType() const;
 
  inline void setMouseAngularSpeed( double speedFactor ) { m_mouseAngularSpeed = speedFactor; }
 
  inline double getMouseAngularSpeed( ) { return m_mouseAngularSpeed; }
 
  void setZoomingType( const ZoomingType &zoomType );
 
  ZoomingType getZoomingType() const;
 
  virtual void setRotationTargetPosition( const SbVec3f &targetPos );
 
  virtual void resetRotationTargetPosition( );
 
  virtual bool getRotationTargetPosition( SbVec3f &targetPos );
 
  virtual void getDefaultRotationTargetPosition( SbVec3f &targetPos );
 
  //* Common algorithms *//
 
  virtual void setSceneGraph( SoNode* newScene );
 
  virtual SoNode* getSceneGraph();
 
  void enableShadows( bool onOrOff );
 
  virtual void setCamera( SoCamera* newCamera );
 
  SoCamera* getCamera();
 
  virtual void setCameraType( SoType type );
 
  SoType getCameraType();
 
  virtual void toggleCameraType();
 
  virtual void setPreserveCameraHeightAngle( SbBool flag );
 
  virtual SbBool isCameraHeightAnglePreserved() const;
 
  virtual void viewAll();
 
  virtual void saveHomePosition();
 
  virtual void resetToHomePosition();
 
  virtual void setHeadlight( SbBool insertFlag );
 
  SbBool isHeadlight();
 
  SoDirectionalLight* getHeadlight();
 
  virtual void setDrawStyle( DrawType type, DrawStyle style );
 
  DrawStyle getDrawStyle( DrawType type );
 
  virtual void setBufferingType( BufferType type );
 
  BufferType getBufferingType();
 
  virtual void setViewing( SbBool flag );
 
  SbBool isViewing() const;
 
  virtual void recomputeSceneSize();
 
  virtual void setSeekMode( SbBool onOrOff );
 
  SbBool isSeekMode();
 
  virtual void adjustCameraClippingPlanes();
 
  void setBoxSelectionMode( SbBool on );
 
  SbBool isBoxSelection() const;
 
  void setBoxDrawingMode( SbBool on );
 
  SbBool isBoxDrawing() const;
 
  void doBoxZoom( int x1, int y1, int x2, int y2 );
 
  virtual void rollCamera( const SbVec2s& newLocator );
 
  virtual void dollyCamera( const SbVec2s& newLocator );
 
  virtual void dollyCamera( float dist );
 
  virtual void reverseDollyCamera( const SbVec2s& newLocator );
 
  virtual void panCamera( const SbVec2f& newLocator );
 
  void doCameraAnimation();
 
  virtual void rightWheelStart();
 
  virtual void bottomWheelStart();
 
  virtual void leftWheelStart();
 
  virtual void bottomWheelMotion( float newVal );
 
  virtual void leftWheelMotion( float newVal );
 
  virtual void rightWheelMotion( float newVal );
 
  virtual void mouseWheelMotion( float newVal );
 
  void activatePanning();
 
  void setStartMousePositionLocator( const SbVec2s& mousePosition );
 
  SbVec2s getStartMousePositionLocator() const;
 
  void setCurrentMousePositionLocator( const SbVec2s& mousePosition );
 
  SbVec2s getCurrentMousePositionLocator() const;
 
  void setPreviousMousePositionLocator( const SbVec2s& mousePosition );
 
  SbVec2s getPreviousMousePositionLocator() const;
 
  void setCameraPositionLocator( const SbVec3f& camPosition );
 
  SbVec3f getCameraPositionLocator() const;
 
  void setCameraFocalPlane( const SbPlane& focalPlane );
 
   SbPlane getCameraFocalPlane() const;
 
  void interactiveCountInc();
 
  void interactiveCountDec();
 
  void setPrevAnimTime( SbTime previous );
 
  SbTime getPrevAnimTime() const;
 
  virtual void computeSeekFinalOrientation();
 
  virtual void setMPEGRecorder( SoMPEGRenderer* recorder );
 
  virtual SoMPEGRenderer* getMPEGRecorder() const;
 
  void viewX( bool reverse = false );
 
  void viewY( bool reverse = false );
 
  void viewZ( bool reverse = false );
 
  SoNode* getSceneRoot();
 
  //* Examiner algorithms *//
 
  virtual void spinCamera( const SbVec2f& newLocator );
 
  virtual void spinConstrainedCamera( const SbVec2f& newLocator, int axisIndex );
 
  void startSpinAnimation();
 
  void stopSpinAnimation();
 
  virtual void doSpinAnimation();
 
  SbProjector* getSheetProjector() const;
 
  SbSphereSheetProjector* getSphereSheetProjector() const;
 
  void activateSpinning();
 
  void rotateCamera( const SbRotation& rot );
 
  void constrainCameraRotation( bool x = false, bool y = false, bool z = false );
 
  //* Plane algorithms *//
 
  void setPlane( const SbVec3f& newNormal, const SbVec3f& newRight );
 
  //* Fly algorithms *//
 
  void calculateMaxSpeed();
 
  void changeMaxStraightSpeed( SbBool increase );
 
  void setMinSpeed( float speed );
 
  float getMinSpeed() const;
 
  void setMaxSpeed( float speed );
 
  float getMaxSpeed() const;
 
  void setSpeedLimit( float limit );
 
  float getSpeedLimit() const;
 
  void setCurrentSpeed( float speed );
 
  float getCurrentSpeed() const;
 
  void setMaxStraightSpeed( float speed );
 
  float getMaxStraightSpeed() const;
 
  void setMaxSpeedInc( float increment );
 
  float getMaxSpeedInc() const;
 
  void startFlyAnimation();
 
  void stopFlyAnimation();
 
  void activateFlying();
 
  //* Walk algorithms *//
 
  enum WalkViewerMode
  {
    WALK_MODE, 
    PAN_MODE
  };
 
  void updateCameraFocalPoint();
 
  void setWalkViewerAnimMode( WalkViewerMode mode );
 
  SoGuiAlgoViewers::WalkViewerMode getWalkViewerAnimMode() const;
 
  void startWalkAnimation();
 
  void stopWalkAnimation();
 
  void rotateCamera();
 
private:
 
  void setMMode( int mode );
  int getMMode() const;
 
  // Utility method to project and get rotation on SheetProjector at once
  int sheetProjProjectAndGetRotation( const SbVec2f& newLocator, SbRotation& rot );
 
private:
  // Destructor.
  virtual ~SoGuiAlgoViewers();
 
  SbProjector* makeSheetProjector( const ProjectorsType &mode );
  
private:
  static void spinAnimationSensorCB( void* v, SoSensor* sensor ); // Examiner
  static void constrainedAnimationSensorCB( void* v, SoSensor* sensor ); // Fly and walk
  static void setFocalPointFinishCallback( void* data, void* v ); // Walk viewer only
  static void mouseWheelMotionAlarmSensorCB(void *data, SoSensor *sensor); // mouse wheel motion
 
  void rotateCameraAboutVwCenter( const SbRotation& rot );
  void rotateCameraWithRotTarget( const SbRotation& rot );
  void rotateCameraWithRotTargetCore( const SbRotation& rot );
  void rotateCameraWithRotTargetDec( const SbRotation& rot );
  void mouseWheelMotion_( float newVal, float &scaleFactor );
  void screenToFocalPlanePoint( const SbVec2s &pxPoint, SbVec3f &worldPoint, SbPlane *focPlane = NULL );
  void screenNormToFocalPlanePoint( const SbVec2f &normPoint, SbVec3f &worldPoint, SbPlane *fplane = NULL );
  void sheetProjProjectAndGetRotationCore( const SbVec2f& newLocator, SbRotation& rot );
 
 
  int m_mode;
  SbBool m_constrained; // Used to determine whether the algorithm to use is for constrained viewers.
  ViewerTypes m_vType; // Current viewer type.
  SbBool m_boxDrawing, m_boxSelection, m_firstActivation;
  SoExtSelection* m_selection;
  SoSwitch* m_selectionSwitch;
 
  SbVec2s m_locator, m_prevPos, m_startPos; // mouse position
 
  // Sensors for animations
  SoFieldSensor* m_seekAnimationSensor;
  SoFieldSensor* m_spinAnimationSensor;
  SoFieldSensor* m_walkAnimationSensor;
  SoFieldSensor* m_flyAnimationSensor;
 
  SoAlarmSensor* m_mouseWheelMotionAlarmSensor;
 
  // variables used for spinning animation
  SbProjector* m_sheetProjector;
  ProjectorsType m_projectorType;
 
  SbBool m_computeAverage;
  SbRotation m_averageRotation;
  SbRotation* m_rotBuffer;
  int m_firstIndex, m_lastIndex;
  SbVec3s m_constrainedAxis;
 
  // Camera translation vars.
  SbVec3f m_locator3D;
  SbPlane m_focalplane;
 
  // Plane viewer.
  void computeTranslateValues();
  float m_transXspeed, m_transYspeed;
 
  // Fly viewer.
  float m_minSpeed, m_maxInc, m_speedLimit;
  float m_speed, m_maxSpeed, m_maxStraightSpeed;
  SbTime m_prevAnimTime;
 
  // Walk viewer.
  WalkViewerMode m_wvMode;
  SbBool m_walkAnimation;
 
  // Rotation temp data
  SbVec2f* m_lastRotStepLocator; // during the projection and get rotation
  double m_mouseAngularSpeed;
  ZoomingType m_zoomingType;
  SbVec3f *m_rotationTargetPosition;
};
 
#endif // SO_GUI_ALGO_VIEWERS