Inventor/Gui/viewers/SoGuiViewer.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      : 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

---

Open Inventor Toolkit reference manual, generated on 15 Mar 2023
Copyright © Thermo Fisher Scientific All rights reserved. http://www.openinventor.com/