SoGuiViewer.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      : T.MEHAMLI (Jun 2007)
**=======================================================================*/
 
#ifndef SO_GUI_VIEWER
#define SO_GUI_VIEWER
 
//
//  Class: SoGuiViewer
//
// SoXXViewer implementation class
//
//
 
#include <Inventor/Gui/SoGuiRenderArea.h>
#include <Inventor/SbElapsedTime.h>
#include <Inventor/fields/SoSFEnum.h>
#include <Inventor/fields/SoSFBitMask.h>
#include <Inventor/components/stereo/SoStereoViewer.h>
 
class SoCallbackList;
 
// classes
class SoNode;
class SoDirectionalLight;
class SoGroup;
class SoRotation;
class SoCamera;
class SoDrawStyle;
class SoLightModel;
class SoFieldSensor;
class SoGuiViewer;
class SoGetBoundingBoxAction;
class SoSeparator;
class SoShadowGroup;
class SoSwitch;
class SoComplexity;
class SoColorMask;
class SoMaterialBinding;
class SoSFTime;
class SoNodeSensor;
class SoGetPrimitiveCountAction;
class SoBaseStereo;
class SoDepthBuffer;
class SoPerfCounter;
 
#ifndef HIDDEN_FROM_DOC
// callback function prototypes
typedef void SoGuiViewerCB( void* userData, void* viewer );
typedef void SoGuiViewerCameraTypeChangeCB( void* userData, SoCamera* camera, void* viewer );
 
// Large Model Viewing notification callbacks for
// frames per second and decimation percentage:
typedef void SoGuiViewerFPSCB( float fps, void* userData, void* viewer );
typedef void SoGuiViewerDecimationPercentageCB( float percentage, void* userData, void* viewer );
#endif
 
 
class  SoGuiViewer : public SoGuiRenderArea, virtual public SoStereoViewer
{
#ifndef HIDDEN_FROM_DOC
  SO_FIELDCONTAINER_HEADER( SoGuiViewer );
#endif
 
private:
  SoSFBool stereoActive;
  SoSFEnum stereoType;
  SoSFBitMask stereoColorMask;
  SoSFBool hiddenLine;
 
  enum StereoViewType
  {
    // Monoscopic viewing
    NO_STEREO_VIEW     = 0,
    // Two views interlaced in a single image
    INTERLACED_STEREO  = 1,
    // Each view displayed in a half screen
    HALF_SCREEN_STEREO = 2,
    // Two views superimposed on a single image
    RAW_STEREO         = 3,
    // Ditto
    OPENGL_STEREO      = 3,
    // Each view is displayed through a color filter
    ANAGLYPH_STEREO    = 4,
    // Ditto
    ANAGLYPH           = 4,
#ifndef HIDDEN_FROM_DOC
    // Uses the SSDI library to set the stereo
    SSDI_STEREO        = 5,
#endif
 
    PASSIVE_STEREO     = 6
  };
 
 
  enum Color
  {
    RED = 0x01,
    GREEN = 0x02,
    BLUE = 0x04
  };
 
  // An EDITOR viewer will create a camera under the user supplied scene
  // graph (specified in setSceneGraph()) if it cannot find one in the
  // scene and will leave the camera behind when supplied with a new scene.
  //
  // A BROWSER viewer will also create a camera if it cannot find one in
  // the scene, but will place it above the scene graph node (camera will
  // not appear in the user supplied scene graph), and will automatically
  // remove it when another scene is supplied to the viewer.
  enum Type
  {
    BROWSER,
    EDITOR
  };
 
  //
  // list of possible drawing styles
  //
  // Note: Refer to the SoXxViewer man pages for a complete
  // description of those draw styles.
  //
  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
  };
 
  //
  // list of different buffering types
  //
  enum BufferType
  {
    BUFFER_SINGLE,
    BUFFER_DOUBLE,
    BUFFER_INTERACTIVE
  };
 
  //
  // list of decimation strategies
  //
  enum DecimationStrategy
  {
    NORMAL,
    FIXED_NUM_TRIANGLES,
    FRAMES_PER_SECOND,
    FIXED_PERCENTAGE
  };
 
  // Classic cursors are all white and tend to disappear over white
  // geometry or white background.  New styles avoid that problem
  enum CursorStyle
  {
    CLASSIC,
    XOR,
    SHADOW
  };
 
  // Arrow key direction enum
  enum Direction
  {
    AKP_UP,
    AKP_DOWN,
    AKP_RIGHT,
    AKP_LEFT
  };
 
  SoGuiViewer();
 
  virtual void setSceneGraph( SoNode* newScene );
 
  virtual SoNode* getSceneGraph();
 
  virtual void setCamera( SoCamera* newCamera );
 
  SoCamera* getCamera();
 
  SoNONUNICODE SbBool saveSceneGraph( const char* fileName );
 
 
  SbBool saveSceneGraph( const SbString& fileName );
 
  virtual void setCameraType( SoType type );
 
  SoType getCameraType();
 
  virtual void setPreserveCameraHeightAngle( SbBool flag );
 
  virtual SbBool isCameraHeightAnglePreserved() const;
 
  virtual void enableSeekWithOrtho( SbBool flag );
 
  virtual SbBool isSeekWithOrthoEnabled() 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 );
 
  SoGuiViewer::DrawStyle getDrawStyle( SoGuiViewer::DrawType type );
 
  virtual void setBufferingType( BufferType type );
 
  SoGuiViewer::BufferType getBufferingType();
 
  virtual void setViewing( SbBool flag );
 
  SbBool isViewing() const;
 
  virtual void setCursorEnabled( SbBool flag );
 
  SbBool isCursorEnabled() const;
 
  void setAutoClipping( SbBool flag );
 
  virtual SbBool isStereoViewing();
 
  SbBool isAutoClipping() const;
 
  void setStereoOffset( float dist );
 
  float getStereoOffset();
 
  void setDetailSeek( SbBool onOrOff );
 
  SbBool isDetailSeek();
 
  void setSeekTime( float seconds );
 
  float getSeekTime();
 
  virtual void recomputeSceneSize();
 
  // --- Large Model Viewing additions:
 
  void setDecimationStrategy( DecimationStrategy strategy );
  DecimationStrategy getDecimationStrategy() const;
 
  void setGoalNumberOfTriangles( int32_t goal );
 
  int32_t getGoalNumberOfTriangles();
 
  void setGoalFramesPerSecond( float goal );
 
  float getGoalFramesPerSecond();
 
  void setFixedPercentage( float percent );
 
  float getFixedPercentage();
 
  void enableFullRenderingWhenStill( SbBool onOff );
 
  SbBool isFullRenderingWhenStill();
 
  void setStill( SbBool isStill );
  SbBool isStillNow();
 
  void setNumSamples( int numFrames );
 
  int getNumSamples();
 
  float getCurrentDecimationPercentage();
 
  // Implementing methods from the pure virtual class from SoStereoViewer
  virtual void setStereoActive(SbBool activate);
  virtual SbBool isStereoActive();
  virtual void actualRendering();
  virtual SoCamera* getViewerCamera();
  virtual const SbVec2s& getSize();
  virtual const SbVec2s& getTopLeft();
  virtual const SbVec2s& getBottomRight();
  virtual SbBool isViewerDoubleBuffer();
  virtual void setStereoViewType( SoBaseStereo* stereo );
  virtual SoBaseStereo* getStereoViewType();
  virtual void reverseStereoView( SbBool reverse );
  virtual SbBool isStereoViewReversed();
  virtual void setStereoAbsoluteAdjustments( SbBool absolute );
  virtual SbBool isStereoAbsoluteAdjustments() const;
  virtual void setStereoBalance( float balance, SbBool nearFrac = false );
  virtual float getStereoBalance();
  virtual SbBool isStereoBalanceNearFrac();
  virtual void setViewport( short left, short bottom, short width, short height );
  virtual void getViewport(short& left, short& bottom, short& width, short& height);
  virtual SoGLContext* getViewerContext() { return NULL;  }
  virtual SoSceneManager* getViewerSceneManager() { return this->getSceneManager(); }
 
  SoSeparator* getSceneRoot();
  bool getFirstRedrawFlag() const
  { return m_isFirstRedraw; }
  void setFirstRedrawFlag(bool value)
  { m_isFirstRedraw = value; }
 
 
  virtual void setCursorStyle( CursorStyle style );
 
  CursorStyle getCursorStyle() const;
 
  void setAutoClipTolerance ( float tolerance );
 
  float getAutoClipTolerance () const;
 
  virtual void setCameraSceneGraph( SoNode* cameraSceneGraph );
 
  SoNode* getCameraSceneGraph();
 
  void enableShadows( bool onOrOff );
 
  SbBool isEnableShadows();
 
  SoShadowGroup* getShadowGroup();
 
  void enableMouseWheelDolly( SbBool onOff );
  SbBool isMouseWheelEnabled() const;
 
  SbBool isInteractive() const;
 
  // This routine will toggle the current camera from perspective to
  // orthographic, and from orthographic back to perspective.
  virtual void toggleCameraType();
 
  virtual void setSeekMode( SbBool flag );
  SbBool isSeekMode() const;
 
  // Accessor and mutator for the member m_interactiveFlag
  void setInteractiveFlag( SbBool flag );
  SbBool getInteractiveFlag() const;
 
  // Accessor and mutator for the member m_stillDrawStyle
  void setStillDrawStyle( DrawStyle style );
  DrawStyle getStillDrawStyle() const;
 
  // Accessor and mutator for the member m_interactiveDrawStyle
  void setInteractiveDrawStyle( DrawStyle style );
  DrawStyle getInteractiveDrawStyle() const;
 
  // Accessor and mutator for the member m_seekStartTime
  void setSeekStartTime( SbTime seekTime );
  SbTime getSeekStartTime() const;
 
  // Accessor and mutator for the member m_newCamOrientation
  void setNewCamOrientation( SbRotation newOrientation );
  SbRotation getNewCamOrientation() const;
 
  // Accessor and mutator for the member m_newCamOrientation
  void setSeekPoint( SbVec3f newOrientation );
  SbVec3f getSeekPoint() const;
 
  // Accessor and mutator for the member m_viewerSpeed
  void setViewerSpeed( float speed );
  float getViewerSpeed() const;
 
  // Mutator for the member m_headlightFlag
  void setHeadLightFlag( SbBool flag );
 
  // Accessor and Mutator for the member m_createdCursors
  void setCreatedCursors( SbBool flag );
  SbBool getCreatedCursors() const;
 
  // Mutator for the member m_interactiveCount
  void setInteractiveCount( int count );
 
  // Accessor for the member m_finishCBList
  SoCallbackList* getFinishCBList();
 
  // Accessor and mutator for the member m_checkForDrawStyle
  void setCheckForDrawStyle( SbBool flag );
  SbBool getCheckForDrawStyle() const;
 
  // Accessor and mutator for the member m_type
  void setType( Type type );
  Type getType() const;
 
  // Accessor and mutator for the member m_viewerRealTime
  void setRealTime( SoSFTime* type );
  SoSFTime* getRealTime() const;
 
  // Accessor and mutator for the member m_seekDistance
  void setSeekDistance( float seekDistance );
  float getSeekDistance();
 
  // Accessor and mutator for the member m_sceneSize
  void setSceneSize( float size );
  float getSceneSize();
 
  // Retro compatibility accessors
  SbBool getComputeSeekVariables() const { return m_computeSeekVariables; }
  float getPreviousHeightAngle() { return m_previousHeightAngle; }
  SbVec3f getSeekNormal() { return m_seekNormal; }
  SbVec3f getNewCamPosition() { return m_newCamPosition; }
 
  // Seek sensor accessors
  void setSeekSensor( SoFieldSensor* s );
  SoFieldSensor* getSeekSensor() const;
 
  // Accessor for the member m_createdCamera
  SbBool getCreatedCamera() const;
 
  void setViewer( void* viewer );
 
  // redefine this to call the viewer setBufferingType() method instead.
  virtual SbBool setDoubleBuffer( SbBool flag );
 
  // Writes to file the scene graph
  //
  // @UNICODE_WARNING
  SoNONUNICODE static void writeScene( SoNode* node, const char* filename );
 
  // Writes to file the scene graph
  static void writeScene( SoNode* node, const SbString& filename );
 
  // Callbacks
  void setCameraTypeChangeCallback( SoGuiViewerCameraTypeChangeCB* callback, void* userdata );
  void addStartCallback( SoGuiViewerCB* f, void* userData = NULL );
  void addFinishCallback( SoGuiViewerCB* f, void* userData = NULL );
  void removeStartCallback( SoGuiViewerCB* f, void* userData = NULL );
  void removeFinishCallback( SoGuiViewerCB* f, void* userData = NULL );
 
  void setFramesPerSecondCallback( SoGuiViewerFPSCB* callback, void* userData = NULL );
 
  void setDecimationPercentageCallback( SoGuiViewerDecimationPercentageCB* callback, void* userData = NULL );
 
  SbBool isZBufferOff();
 
  void arrowKeyPressed( Direction direction );
 
  SbBool getDepthValue(int x, int y, float &depth);
  //Inner public class
  class CameraFields {
  public:
    CameraFields();
    SbBool isModified( SoCamera* cam );
    void setCameraFields( SoCamera* cam );
    static bool stereoDataMatchViewerState( SoCamera* cam, SoGuiViewer* viewer );
    static void setViewerStereoData( SoCamera* cam, SoGuiViewer* viewer );
    static void setCameraStereoData( SoCamera* cam, SoGuiViewer* viewer );
 
  private:
    int m_viewportMapping;
    SbVec3f m_position;
    SbRotation m_orientation;
    float m_aspectRatio;
    float m_nearDistance;
    float m_farDistance;
    float m_focalDistance;
    float m_height;
    //stereo data
    bool  m_stereoAbsoluteAdjustments;
    float m_stereoAdjustment;
    float m_balanceAdjustment;
    int m_stereoMode;
    bool m_balanceNearFrac;
  };
 
  // ----------------------- Extension usage -----------------------------------
 
  virtual void afterRealizeHook();
 
  virtual void  adjustCameraClippingPlanes();
 
  // Invokes the start and finish viewing callbacks. Subclasses NEED to call
  // those routines when they start and finish doing interactive viewing
  // operations so that correct interactive drawing style and buffering
  // types, as well as application callbacks, gets set and called properly.
  //
  // Those routines simply increment and decrement a counter. When the counter
  // changes from 0->1 the start viewing callbacks are called. When the counter
  // changes back from 1->0 the finish viewing callbacks are called.
  // The counter approach enables different parts of a viewer to call those
  // routines withough having to know about each others (which is not
  void interactiveCountInc();
  void interactiveCountDec();
  int getInteractiveCount();
 
  //
  // This routine is used by subclasses to initiate the seek animation. Given a
  // screen mouse location, this routine will return the picked point
  // and the normal at that point. It will also schedule the sensor to animate
  // if necessary. The routine returns TRUE if something got picked...
  //
  // Note: if detailSeek is on, the point and normal correspond to the exact
  // 3D location under the cursor.
  // if detailSeek if off, the object bbox center and the camera
  // orientation are instead returned.
  //
  // @param mouseLocation screen mouse location.
  // @param allowChangeOrientation if true, allows change of camera orientation.
  // @param allowChangeDistance if true, allows change of camera distance or height.
  SbBool seekToPoint( const SbVec2s& mouseLocation, SbBool allowChangeOrientation=TRUE, SbBool allowChangeDistance=TRUE );
 
  // This routine is used by subclasses to initiate the seek animation.
  // Given a target world point location and a world normal (at that point). 
  // It will also schedule the sensor to animate if necessary.
  // The routine returns TRUE unless there a camera is defined
  //
  // @param worldPoint world point location.
  // @param worldNormal world normal.
  // @param allowChangeOrientation if true, allows change of camera orientation.
  // @param allowChangeDistance if true, allows change of camera distance or height.
  SbBool seekToPoint( const SbVec3f& worldPoint, const SbVec3f& worldNormal, SbBool allowChangeOrientation=TRUE, SbBool allowChangeDistance=TRUE );
 
  // Subclasses CAN redefine this to interpolate camera position/orientation
  // while the seek animation is going on (called by animation sensor).
  // The parameter t is a [0,1] value corresponding to the animation percentage
  // completion. (i.e. a value of 0.25 means that animation is only 1/4 of the way
  // through).
  virtual void interpolateSeekAnimation( float t );
  virtual void computeSeekFinalOrientation();
 
  // redefine this routine to adjust the camera clipping planes just
  // before doing a redraw. The sensor will be unschedule after the camera
  // is changed in the base class to prevent a second redraw from occurring.
  virtual void actualRedraw();
 
  // This is called during a paste.
  // Subclasses may wish to redefine this in a way that
  // keeps their viewing paradigm intact.
  virtual void changeCameraValues( SoCamera* newCamera );
 
  // Override redraw() in order to calculate render time including
  // frame buffer switch
  virtual void preViewerRedraw();
  virtual void postViewerRedraw();
 
  // Subclasses may override this function to change way that
  // viewer tries to calculate decimation percentage for
  // DecimationStrategy FRAMES_PER_SECOND.
  // Given goal frames per second, timeTaken in last render,
  // and last decimation value used, this function should return
  // decimation percentage value to use in next render.
  virtual float decimationForFramesPerSecond( float fps,
                                              double lasttime,
                                              float lastDec );
  // Subclasses may override this function to change way that
  // viewer tries to calculate decimation percentage for
  // DecimationStrategy FIXED_NUM_TRIANGLES.
  // Given goal number of triangles to reach, this function
  // should return decimation percentage value to use.
  virtual float decimationForNumTriangles( uint32_t numTris );
 
  // Convenience routines which subclasses can use when drawing viewer
  // feedback which may be common across multiple viewers. There is for
  // example a convenience routine which sets an orthographics projection
  // and a method to draw common feedback like the roll anchor (used by
  // a couple of viewers).
  //
  // All drawing routines assume that the window and projection is
  // already set by the caller.
  //
  // set an ortho projection of the glx window size - this also turns
  // zbuffering off and lighting off (if necessary).
  static void setFeedbackOrthoProjection( const SbVec2s& size );
  // restores the zbuffer and lighting state that was changed when
  // setFeedbackOrthoProjection() was last called.
  static void restoreGLStateAfterFeedback();
  // draws a simple 2 colored cross at given position
  static void drawViewerCrossFeedback( SbVec2s loc );
  // draws the anchor feedback given center of rotation and mouse location
  static void drawViewerRollFeedback( SbVec2s center, SbVec2s loc );
 
  void setCurrentDrawStyle( SoGuiViewer::DrawStyle style );
 
  void doBoxZoom( int x1, int y1, int x2, int y2 );
  void setZoomMode( SbBool zoomMode );
  SbBool isZoomModeEnabled() const;
  void setSeekDistAsPercentage( SbBool seekDist );
 
#if 1             SoDEPRECATED
    virtual void adjustClippingPlanes();SoDEPRECATED
    virtual HDC getCurrentDC();
#endif 
private:
 
  virtual ~SoGuiViewer();
 
  SoShadowGroup* getShadowGroup() const { return m_shadowGroup; };
 
  SoGetBoundingBoxAction* m_sceneSizeBBoxAction;
  static void seekAnimationSensorCB( void* p, SoSensor* sensor );
 
  void* getViewer() { return (void*)this; }
 
  // ----------------------- Private usage -------------------------------------
 
private:
 
  void doRendering();
  static void drawStyleStartCallback( void* userData, void* v );
  static void drawStyleFinishCallback( void* userData, void* v );
  static void changeCB( void* thisp, SoSensor* sensor );
  void changeSensorCalled();
 
  void setStereoOffsetP( float dist );
  void setStereoBalanceP( float balance, SbBool nearFrac );
  void setStereoAbsoluteAdjustmentsP( SbBool absolute );
 
  // local tree variables
  SoSeparator* m_sceneRoot; // root node given to the RA
  SoNode* m_sceneGraph; // user supplied scene graph
  void* m_viewerPtr;
 
  // global vars
  SoNode* m_cameraSceneGraph;
  SoType m_cameraType;
  SoCamera* m_camera; // camera being edited
  SoGuiViewer::Type m_type;
  SbBool m_viewingFlag; // FALSE when the viewer is off
  SbBool m_interactiveFlag; // TRUE while doing interactive work
  BufferType m_bufferType;
  SbBool m_cursorEnabledFlag;
  float m_sceneSize; // the larger of the X,Y,Z scene BBox
  static SoSFTime* m_viewerRealTime; // pointer to "realTime" global field
  SbBool m_firstLeftRender;
  float m_viewerSpeed;
 
  // camera original values, used to restore the camera
  SbBool m_createdCamera;
  SbVec3f m_origPosition;
  SbRotation m_origOrientation;
  float m_origNearDistance;
  float m_origFarDistance;
  float m_origFocalDistance;
  float m_origHeight;
 
  // headlight variables
  SbBool m_headlightFlag; // true when headlight in turned on
  SoGroup* m_headlightGroup;
  SoDirectionalLight* m_headlightNode;
  SoRotation* m_headlightRot;
 
  // current state vars
  SbBool m_preserveHeightAngle;
  SbBool m_seekWithOrtho;
  SbBool m_mouseWheelEnable;
  float  m_previousHeightAngle;
  CameraFields* m_prevCam;
  SoBaseStereo* m_stereoViewType;
  double m_farDistS;
  double m_nearDistS;
 
  // draw style vars
  SbBool m_checkForDrawStyle;
  DrawStyle m_stillDrawStyle, m_interactiveDrawStyle;
  SoSwitch* m_drawStyleSwitch; // on/off draw styles
  SoDrawStyle* m_drawStyleNode; // LINE vs POINT
  SoLightModel* m_lightModelNode; // BASE_COLOR vs PHONG
  SoComplexity* m_complexityNode; // low complexity & texture off
  SoColorMask* m_colorMaskNode; // hidden line first pass
  SoMaterialBinding *m_matBindingNode; // hidden line first pass
  SoDepthBuffer *m_depthBuffer ; // depth buffer parameters
 
  // shadows
  SoShadowGroup* m_shadowGroup;
  bool m_shadowGroupCurrState;
 
  // auto clipping vars and routines
  SbBool m_autoClipFlag;
  float m_minimumNearPlane; // minimum near plane as percentage of far
  SoGetBoundingBoxAction* m_autoClipBboxAction;
  bool m_autoClipPlaneViewVolumeCulling; // true to clip scene bbox with viewVolume when adjusting auto clipplane.
 
  // seek animation vars
  SbBool m_detailSeekFlag;
  float m_seekAnimTime;
  SbBool m_seekModeFlag; // TRUE when seek turned on externally
  SbBool m_seekAllowChangeOrientation; // if true allow change of camera orientation
  SbBool m_seekAllowChangeDistance; // if true allow change of camera distance or height
  SoFieldSensor* m_seekAnimationSensor;
 
  // Decimation strategy additions
  DecimationStrategy m_decStrategy;
  SbBool m_isStill, m_doFullRendering, m_wasStill;
  int32_t m_goalTris; // Goal Number of Triangles
  float m_goalFps; // Goal Frames Per Second
  float m_decPercentage; // Fixed percentage
  float m_lastDecimationValue; // Last decimation value and render time
  double m_lastRenderTime; // used when (strategy==FRAMES_PER_SECOND)
 
  SoPerfCounter* m_fpsCounter;
 
  int m_lastDirection;
  SoGetPrimitiveCountAction* m_primCountAction;
  SoNodeSensor* m_motionSensor;
 
  // Frames per second calculating:
  int m_numSamples;
  SoGuiViewerFPSCB* m_fpsUserCallback;
  void* m_fpsUserData;
 
  // For release 2.6 we added the concept of cursor "style", at least
  // on Windows, and moved the definition variables and methods up to
  // this class (protected not private!) so subclasses can override
  // the cursor definitions if they need/want to.
  //
  // We now have "classic", XOR and "shadow" style cursors (new in v2.6)
  SoGuiViewer::CursorStyle m_cursorStyle;
  // Previously declared in subclasses (before v2.6)
  // Note that each subclass viewer uses a subset of these standard
  // cursor names.  Note that the Fly and Walk viewers used slightly
  // different names (that were too generic) for their specific cursors
  // (the last two in the list) prior to v2.6.
  SbBool m_createdCursors;
 
  // interactive viewing callbacks
  SoCallbackList* m_startCBList;
  SoCallbackList* m_finishCBList;
 
  // variables used for interpolating seek animations
  SbVec3f m_seekPoint, m_seekNormal;
  SbBool m_computeSeekVariables;
  SbTime m_seekStartTime;
  SbRotation m_oldCamOrientation, m_newCamOrientation;
  SbVec3f m_oldCamPosition, m_newCamPosition;
  float m_seekDistance;
  SbBool m_seekDistAsPercentage; // percentage/absolute flag
 
  // flag indicating whether a render traversal is in
  // progress.
  SbBool m_isWinRedrawing;
 
  // Camera type change callback
  SoGuiViewerCameraTypeChangeCB* m_viewerCameraTypeChangeCallback;
  void* m_viewerCameraTypeChangeCallbackUserData;
 
  // Decimation Percentage callback
  SoGuiViewerDecimationPercentageCB* m_decimationUserCallback;
  void* m_decimationUserData;
 
  SbBool m_zoomMode;
  static bool s_enableIgnoreScreenSpaceBBox;
 
  bool m_isFirstRedraw;
};
 
#endif // SO_GUI_VIEWER