SoWinViewer.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-2023 BY FEI S.A.S,                        ***
 ***                        BORDEAUX, FRANCE                                        ***
 ***                      ALL RIGHTS RESERVED                                       ***
**=======================================================================*/
/*=======================================================================
** Author      : VSG (MMM YYYY)
**=======================================================================*/
 
 
#ifndef  _SO_WIN_VIEWER_
#define  _SO_WIN_VIEWER_
 
#include <Inventor/Win/SoWinBeginStrict.h>
 
#include <Inventor/SoType.h>
#include <Inventor/Win/SoWinRenderArea.h>
#include <Inventor/misc/SoCallbackList.h>
#include <Inventor/SbElapsedTime.h>
#include <Inventor/events/SoKeyboardEvent.h> 
#include <Inventor/Gui/viewers/SoGuiViewer.h>
 
#include <Inventor/components/stereo/SoStereoViewer.h>
 
// classes
class SoFieldSensor;
class SoNode;
class SoDirectionalLight;
class SoGroup;
class SoRotation;
class SoCamera;
class SoDrawStyle;
class SoLightModel;
class SoTimerSensor;
class SoWinClipboard;
class SoWinViewer;
class SoGetBoundingBoxAction;
class SbPList;
class SoSeparator;
class SoSwitch;
class SoComplexity;
class SoPackedColor;
class SoMaterialBinding;
class SoBaseColor;
class SoSFTime;
class SoAlarmSensor;
class SoNodeSensor;
class SoGetPrimitiveCountAction;
class SoStereoViewer;
class SoBaseStereo;
 
class SoType;  
class SbEventWrapperList;
 
class ScRayPickAction;
 
// callback function prototypes
 
typedef void SoWinViewerCB( void* userData, SoWinViewer* viewer );
 
typedef void SoWinViewerCameraTypeChangeCB( void* userData, SoCamera* camera, SoWinViewer* viewer );
 
typedef void SoWinViewerFPSCB( float fps, void* userData, SoWinViewer* viewer );
 
typedef void SoWinViewerDecimationPercentageCB( float percentage, void* userData, SoWinViewer* viewer );
 
//
//  Class: SoWinViewer
//
//      The Viewer component is the abstract base class for all viewers.
//  It is subclassed from renderArea, adding viewing semantics to Inventor
//  rendering.
//
 
class  SoWinViewer : public SoWinRenderArea, public SoStereoViewer {
  
  public:
  
  enum Type 
  {
      BROWSER,
    EDITOR
    };
  
  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 DecimationStrategy 
  {
      NORMAL,
      FIXED_NUM_TRIANGLES,
      FRAMES_PER_SECOND,
      FIXED_PERCENTAGE
    };
 
  enum CursorStyle 
  {
      CLASSIC,
      XOR,
      SHADOW
    };
 
  virtual void setSceneGraph( SoNode* newScene );
 
  virtual SoNode* getSceneGraph();
 
#ifndef HIDDEN_FROM_DOC
  void saveSceneGraph( const char* fileName ) ;
#endif //HIDDEN_FROM_DOC
 
    virtual void    setCamera(SoCamera *cam);
  
  SoCamera* getCamera() { return m_guiViewer->getCamera(); }
  
    virtual void    setCameraType(SoType type);
  
  SoType getCameraType() { return m_guiViewer->getCameraType(); }
 
    virtual void          setPreserveCameraHeightAngle(SbBool flag)
  { m_guiViewer->setPreserveCameraHeightAngle( flag ); }
 
    virtual SbBool     isCameraHeightAnglePreserved() const
 { return m_guiViewer->isCameraHeightAnglePreserved(); }
 
  virtual void enableSeekWithOrtho( SbBool flag ) { m_guiViewer->enableSeekWithOrtho( flag ); }
 
  virtual SbBool isSeekWithOrthoEnabled() const { return m_guiViewer->isSeekWithOrthoEnabled(); }
 
  virtual void viewAll();
 
  virtual void saveHomePosition();
 
  virtual void resetToHomePosition();
  
  void setCameraTypeChangeCallback( SoWinViewerCameraTypeChangeCB* callback, void* userdata );
  
  void setHeadlight( SbBool onOrOff );
 
  SbBool isHeadlight() { return m_guiViewer->isHeadlight(); }
 
  SoDirectionalLight* getHeadlight() { return m_guiViewer->getHeadlight(); }
  
  void setDrawStyle( SoWinViewer::DrawType type, SoWinViewer::DrawStyle style );
 
  SoWinViewer::DrawStyle getDrawStyle( SoWinViewer::DrawType type );
  
  void setBufferingType( SoWinViewer::BufferType type );
 
  SoWinViewer::BufferType getBufferingType() 
  { return (SoWinViewer::BufferType)m_guiViewer->getBufferingType(); }
    
  virtual void setViewing( SbBool onOrOff );
 
  SbBool isViewing() const { return m_guiViewer->isViewing(); }
 
  virtual void    setSeekMode(SbBool onOrOff);
 
  SbBool isSeekMode() { return m_guiViewer->isSeekMode(); }
 
  virtual void  setCursorEnabled( SbBool onOrOff );
 
  SbBool isCursorEnabled() const { return m_guiViewer->isCursorEnabled(); }
  
  void setAutoClipping( SbBool onOrOff );
 
  SbBool isAutoClipping() const { return m_guiViewer->isAutoClipping(); }
  
  virtual void setStereoViewing( SbBool onOrOff );
 
  virtual SbBool isStereoViewing();
 
  void setStereoOffset( float dist );
 
  float getStereoOffset();
  
  void setDetailSeek( SbBool onOrOff ) { m_guiViewer->setDetailSeek( onOrOff ); }
 
  SbBool isDetailSeek() { return m_guiViewer->isDetailSeek(); }
  
  void setSeekTime( float seconds ) { m_guiViewer->setSeekTime( seconds ); }
 
  float getSeekTime() { return m_guiViewer->getSeekTime(); }
  
  void addStartCallback( SoWinViewerCB* f, void* userData = NULL )
  { m_guiViewer->addStartCallback( (SoGuiViewerCB*)f, userData ); }
 
  void addFinishCallback( SoWinViewerCB* f, void* userData = NULL )
  { m_guiViewer->addFinishCallback( (SoGuiViewerCB*)f, userData ); }
 
  void removeStartCallback( SoWinViewerCB* f, void* userData = NULL )
  { m_guiViewer->removeStartCallback( (SoGuiViewerCB*)f, userData ); }
 
  void removeFinishCallback( SoWinViewerCB *f, void* userData = NULL )
  { m_guiViewer->removeFinishCallback( (SoGuiViewerCB*)f, userData ); }
 
  void copyView( Time eventTime );
 
  void pasteView( Time eventTime );
  
    // redefine this routine to also correctly set the buffering type
    // on the viewer.
  virtual void setNormalVisual( XVisualInfo* i );
  
    virtual void  recomputeSceneSize();
  
    // --- Large Model Viewing additions:
  
  void setDecimationStrategy( SoWinViewer::DecimationStrategy strategy );
 
  SoWinViewer::DecimationStrategy getDecimationStrategy() 
  { return (SoWinViewer::DecimationStrategy)m_guiViewer->getDecimationStrategy(); }
  
    void    setGoalNumberOfTriangles(int32_t goal);
 
  int32_t getGoalNumberOfTriangles() { return m_guiViewer->getGoalNumberOfTriangles(); }
  
  void setGoalFramesPerSecond( float goal );
 
  float getGoalFramesPerSecond()  { return m_guiViewer->getGoalFramesPerSecond(); }
  
  void setFixedPercentage( float percent );
 
  float getFixedPercentage() { return m_guiViewer->getFixedPercentage(); }
  
  void enableFullRenderingWhenStill( SbBool onOff );
 
  SbBool isFullRenderingWhenStill() { return m_guiViewer->isFullRenderingWhenStill(); }
  
  SbBool isStillNow() { return m_guiViewer->isStillNow(); }
  
  void setFramesPerSecondCallback( SoWinViewerFPSCB* callback, void* userData = NULL );
  
  void setNumSamples( int numFrames );
 
  int getNumSamples() { return m_guiViewer->getNumSamples(); }
  
  void setDecimationPercentageCallback( SoWinViewerDecimationPercentageCB *callback, 
                                        void* userData = NULL );
  
    float getCurrentDecimationPercentage();
 
  void enableMouseWheelDolly( SbBool onOff ) { m_guiViewer->enableMouseWheelDolly( onOff );  }
 
 
  void  setPickRadius( float radius );
 
  float getPickRadius() const;
 
public:
    
  virtual SoCamera* getViewerCamera();
 
  virtual SbBool isViewerDoubleBuffer();
 
  virtual void actualRendering();
 
  virtual const SbVec2s& getSize();
 
  virtual const SbVec2s& getTopLeft() ;
 
  virtual const SbVec2s& getBottomRight() ;
 
  void setStereoViewType( SoBaseStereo* stereo );
 
  SoBaseStereo* getStereoViewType();
 
  void reverseStereoView( SbBool reverse );
 
  SbBool isStereoViewReversed();
 
  virtual void setStereoAbsoluteAdjustments( SbBool absolute );
 
  virtual SbBool isStereoAbsoluteAdjustments() const { return m_guiViewer->isStereoAbsoluteAdjustments(); }
 
  virtual void setStereoBalance( float balance, SbBool nearFrac = false );
 
  virtual float getStereoBalance();
 
  virtual SbBool isStereoBalanceNearFrac();
 
  virtual void setStereoActive( SbBool activate ) ;
 
  virtual SbBool isStereoActive() ;
 
  void setViewport( short left, short bottom, short width, short height ) ;
 
  void getViewport( short& left, short& bottom, short& width, short& height ) ;
 
  virtual void setCursorStyle( SoWinViewer::CursorStyle style );
 
  SoWinViewer::CursorStyle getCursorStyle() 
  { return (SoWinViewer::CursorStyle)m_guiViewer->getCursorStyle(); }
 
  void setAutoClipTolerance ( float tolerance ) { m_guiViewer->setAutoClipTolerance( tolerance ); }
 
  float getAutoClipTolerance () const { return m_guiViewer->getAutoClipTolerance(); }
  
  virtual void setCameraSceneGraph( SoNode* cameraSceneGraph );
 
    SoNode* getCameraSceneGraph();
 
  virtual void toggleCameraType();
 
#if 1             SoDEPRECATED
  virtual void adjustClippingPlanes();
 
#endif 
  SbBool getDepthValue(int x, int y, float &depth)
  {
    return m_guiViewer->getDepthValue(x, y, depth);
  }
  
 private:
 
    virtual ~SoWinViewer();
    
  float getAntoClipTolerance() const { return m_guiViewer->getAutoClipTolerance(); }
 
  SoSeparator* getSceneRoot() { return m_guiViewer->getSceneRoot(); }
  
    virtual SbBool isInteractive() const;
  
  SoGuiViewer* getGuiViewer() const;
 
  // These members are public only for retro compatibility purposes.
  // They should not be called directly. Use their accessors instead.
  SoCamera* camera;
  SbBool createdCursors, viewingFlag;
  CursorStyle cursorStyle;
  SoSeparator* sceneRoot;
  float sceneSize;
  SoBaseStereo* stereoViewType;
  SbBool m_seekWithOrtho, m_preserveHeightAngle, cursorEnabledFlag, seekDistAsPercentage, computeSeekVariables;
  float m_previousHeightAngle, viewerSpeed, seekDistance;
  SoWinViewer::Type type;
  SoNode* sceneGraph;
  SbVec3f seekPoint, seekNormal, oldCamPosition, newCamPosition;
  SbRotation oldCamOrientation, newCamOrientation;
 
  virtual SoGLContext* getViewerContext() { return getNormalSoContext(); }
  virtual SoSceneManager* getViewerSceneManager() { return getSceneManager(); }
 
  private:
 
  virtual void  adjustCameraClippingPlanes();
 
    // list of new Binding
  SbEventWrapperList* m_eventWrapperList;
 
    void windowsKeyArrayConvert();
  SoKeyboardEvent::Key* m_windowsKeyArray;
 
  SoKeyboardEvent::Key keyCodeToEnum(WPARAM param);
 
  // Constructor/Destructor
  SoWinViewer( SoWidget parent,
               const char* name, 
               SbBool buildInsideParent, 
               SoWinViewer::Type type,   // Removed class qualifier from enum --mmh 1/12/95
               SbBool buildNow,
               SbBool sync );
 
  SoWinViewer( SoWidget parent,
               const char* name, 
               SbBool buildInsideParent, 
               SoWinViewer::Type type, 
               SbBool buildNow,
               SbBool sync,
               SoGuiViewer* guiViewer );
  
    // global vars new in v2.1
  SbBool altSwitchBack;  // flag to return to PICK after an Alt release
 
    // 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.
    HCURSOR normalCursor,   // std arrow
      dollyCursor, panCursor, rollCursor, seekCursor,
      spinCursor, upCursor, flyCursor, walkCursor,
      pickCursor, manipCursor; // => For constrained viewer.
 
    // Load cursor definitions from resource file.
    // previously declared in subclasses (before v2.6).
    // Subclasses may override, but are not required to do so
    // unless they need more or different cursor definitions.
    virtual void defineCursors();
  
    // Subclasses should (and do) override this method! (new in v2.6)
    // (The setCursorStyle method calls this to force a dynamic change)
    virtual void updateCursor() {};
  
    // Subclasses can call this routine to handle a common set of events. A Boolean
    // is returned to specify whether the event was handled by the base class.
    // Currently handled events and functions are :
    //      'Esc' key - toggles viewing on/off
    //      When viewing OFF - send all events down the scene graph
    //      When camera == NULL - Discard all viewing events
    //      'home' Key - calls resetToHomePosition()
    //      's' Key - toggles seek on/off
    //      Arrow Keys - moves the camera up/down/right/left in the viewing plane
    SbBool          processCommonEvents(XAnyEvent *xe);
  
    // 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() { return m_guiViewer->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 retuns 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.
    SbBool          seekToPoint(const SbVec2s &mouseLocation);
  
    //
    // 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 occuring.
    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 );
  
    //
    // 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& glxSize );
    // 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 );
  
    //
    // set the right zbuffer state (based on the current draw style) whenever
    // the window changes.
    //
    // HACK: redefines this routine from SoWinRenderArea to also check to make
    // sure that SoWinViewer::setBufferingType() is updated if users call 
    // SoWinGLWidget::setDoubleBuffer() instead.
    //
  virtual void widgetChanged( SoWidget );
  
    // redefine this for a better default draw style (need to wait for context)
    virtual void  afterRealizeHook();
  
    // Override redraw() in order to calculate render time including
    // frame buffer switch
    virtual void redraw();
  
    // 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 timeTaken, float decimation );
 
    // 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);
 
  void setCurrentDrawStyle(SoWinViewer::DrawStyle style);
  
  private:
 
  void constructorCommon( SoWinViewer::Type t, SbBool buildNow );
  void constructorCommon2( SoWinViewer::Type t, SbBool buildNow );
 
  SoGuiViewer* m_guiViewer; // Implementation class for SoXxViewer
 
   SbBool m_firstRealize;
   
    // copy and paste support
  SoWinClipboard* clipboard;
  static void pasteDoneCB( void* userData, SoPathList* pathList );
   
  // headlight variables
  SoFieldSensor* headlightSensor;   // attached to camera
  static void headlightSensorCB( void* v, SoSensor* s );
 
  // Attach/detach headlightSensor.
  static void visibilityChangeCB( void* pt, SbBool visible );
 
  // set the zbuffer on current window to correct state
  void                setZbufferState();
  SbBool              isZbufferOff();
  void arrowKeyPressed( KeySym key );
 
  // Decimation strategy additions:
  SoAlarmSensor* stillSensor;
  static void alarmCB( void* thisp, SoSensor* s );
  void stillSensorCalled();
 
  // Seek animation
  static void seekAnimationSensorCB( void* p, SoSensor* sensor );
 
  // PoViews
  static SbBool viewingEventCB( SoWinViewer* viewer, XAnyEvent* anyEvent );
 
private:
  void* getViewer() { return (void*)this; }
  };
 
inline void 
SoWinViewer::alarmCB( void* thisp, SoSensor* )
{ 
  ((SoWinViewer*)thisp)->stillSensorCalled();
}
 
#include <Inventor/Win/SoWinEndStrict.h>
 
#endif  /* _SO_WIN_VIEWER_ */