Inventor/Gui/viewers/SoGuiAlgoViewers.h

Go to the documentation of this file.

/*=======================================================================
 *** 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();

#if 1             SoDEPRECATED
  SbBool setFullSceneAntialiasing( SbBool enable,
                                   float quality = -1.f,
                                   int filterMask = SoFullSceneAntialiasing::ALL );
SoDEPRECATED
  SbBool isFullSceneAntialiasingEnabled() const;
SoDEPRECATED
  SbBool getFullSceneAntialiasing( float& quality, int& filterMask ) const;
SoDEPRECATED
  SbBool isFullSceneAntialiasingAvailable();
SoDEPRECATED
  SbBool isFullSceneAntialiasingHQAvailable();
SoDEPRECATED
  SbBool setFullSceneAntialiasingHQ( SbBool enable );
SoDEPRECATED
  SbBool isFullSceneAntialiasingHQEnabled() const;
SoDEPRECATED
  int getFullSceneAntialiasingMaxSamples() const;

#endif 
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

---

Open Inventor Toolkit reference manual, generated on 12 Feb 2024
Copyright © Thermo Fisher Scientific All rights reserved. http://www.openinventor.com/