Inventor/Xt/viewers/SoXtViewer.h

Go to the documentation of this file.

/*=======================================================================
 * Copyright 1991-1996, Silicon Graphics, Inc.
 * ALL RIGHTS RESERVED
 *
 * UNPUBLISHED -- Rights reserved under the copyright laws of the United
 * States.   Use of a copyright notice is precautionary only and does not
 * imply publication or disclosure.
 *
 * U.S. GOVERNMENT RESTRICTED RIGHTS LEGEND:
 * Use, duplication or disclosure by the Government is subject to restrictions
 * as set forth in FAR 52.227.19(c)(2) or subparagraph (c)(1)(ii) of the Rights
 * in Technical Data and Computer Software clause at DFARS 252.227-7013 and/or
 * in similar or successor clauses in the FAR, or the DOD or NASA FAR
 * Supplement.  Contractor/manufacturer is Silicon Graphics, Inc.,
 * 2011 N. Shoreline Blvd. Mountain View, CA 94039-7311.
 *
 * THE CONTENT OF THIS WORK CONTAINS CONFIDENTIAL AND PROPRIETARY
 * INFORMATION OF SILICON GRAPHICS, INC. ANY DUPLICATION, MODIFICATION,
 * DISTRIBUTION, OR DISCLOSURE IN ANY FORM, IN WHOLE, OR IN PART, IS STRICTLY
 * PROHIBITED WITHOUT THE PRIOR EXPRESS WRITTEN PERMISSION OF SILICON
 * GRAPHICS, INC.
**=======================================================================*/
/*=======================================================================
** Author      : Alain Dumesny (MMM yyyy)
**=======================================================================*/
/*=======================================================================
 *** 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                                       ***
**=======================================================================*/
/*=======================================================================
** Modified by : VSG (MMM YYYY)
**=======================================================================*/



#ifdef SOQT
#  include <Inventor/Qt/viewers/SoQtViewer.h>
#elif defined _WIN32
#  include <Inventor/Win/viewers/SoWinViewer.h>
#else

#ifndef  _SO_XT_VIEWER_
#define  _SO_XT_VIEWER_

#include <Inventor/SoType.h>
#include <Inventor/Xt/SoXtRenderArea.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 SoNode;
class SoDirectionalLight;
class SoGroup;
class SoRotation;
class SoCamera;
class SoDrawStyle;
class SoLightModel;
class SoFieldSensor;
class SoXtClipboard;
class SoXtViewer;
class SoGetBoundingBoxAction;
class SbPList;
class SoSeparator;
class SoSwitch;
class SoComplexity;
class SoPackedColor;
class SoMaterialBinding;
class SoSFTime;
class SoXtInputFocus;
class SoAlarmSensor;
class SoNodeSensor;
class SoGetPrimitiveCountAction;
class SoStereoViewer;
class SoBaseStereo;
class ScRayPickAction;

// callback function prototypes
typedef void SoXtViewerCB( void* userData, SoXtViewer* viewer );
typedef void SoXtViewerCameraTypeChangeCB( void* userData, SoCamera* camera, SoXtViewer* viewer );

// Large Model Viewing notification callbacks for
// frames per second and decimation percentage:
typedef void SoXtViewerFPSCB( float fps, void* userData, SoXtViewer* viewer );
typedef void SoXtViewerDecimationPercentageCB( float percentage, void* userData, SoXtViewer* viewer );

//
//  Class: SoXtViewer
//
//      The Viewer component is the abstract base class for all viewers.
//  It is subclassed from renderArea, adding viewing semantics to Inventor
//  rendering.
//

class  SoXtViewer : public SoXtRenderArea, 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();

  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( SoXtViewerCameraTypeChangeCB* callback, void* userdata );

  virtual void setHeadlight( SbBool onOrOff );

  SbBool isHeadlight() { return m_guiViewer->isHeadlight(); }

  SoDirectionalLight* getHeadlight() { return m_guiViewer->getHeadlight(); }

  virtual void setDrawStyle( SoXtViewer::DrawType type, SoXtViewer::DrawStyle style );

  SoXtViewer::DrawStyle getDrawStyle( SoXtViewer::DrawType type );

  virtual void setBufferingType( SoXtViewer::BufferType type) ;

  SoXtViewer::BufferType getBufferingType()
  { return (SoXtViewer::BufferType)m_guiViewer->getBufferingType(); }

  virtual void setViewing( SbBool onOrOff );

  SbBool isViewing() const { return m_guiViewer->isViewing(); };

  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( SoXtViewerCB* f, void* userData = NULL )
    {  m_guiViewer->addStartCallback( (SoGuiViewerCB*)f, userData ); }

  void addFinishCallback( SoXtViewerCB* f, void* userData = NULL )
    { m_guiViewer->addFinishCallback( (SoGuiViewerCB*)f, userData ); }

  void removeStartCallback( SoXtViewerCB* f, void* userData = NULL )
    { m_guiViewer->removeStartCallback( (SoGuiViewerCB*)f, userData ); }

  void removeFinishCallback( SoXtViewerCB* f, void* userData = NULL )
    { m_guiViewer->removeFinishCallback( (SoGuiViewerCB*)f, userData ); }

  void copyView( Time eventTime );

  void pasteView( Time eventTime );

  virtual void recomputeSceneSize();

  // --- Large Model Viewing additions:

  void setDecimationStrategy( SoXtViewer::DecimationStrategy strategy );

  SoXtViewer::DecimationStrategy getDecimationStrategy()
  { return (SoXtViewer::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( SoXtViewerFPSCB* callback, void* userData = NULL );

  void setNumSamples( int numFrames );
  int getNumSamples() { return m_guiViewer->getNumSamples(); }

  void setDecimationPercentageCallback( SoXtViewerDecimationPercentageCB* callback, void* userData = NULL );

  float getCurrentDecimationPercentage();

  // Implementing methods from the pure virtual class from SoStereoViewer

  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 );
  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( SoXtViewer::CursorStyle style );

  SoXtViewer::CursorStyle getCursorStyle() 
  { return (SoXtViewer::CursorStyle)m_guiViewer->getCursorStyle(); }


  SoSeparator* getSceneRoot() { return m_guiViewer->getSceneRoot(); }

  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();

  virtual void setSeekMode( SbBool onOrOff );

  void  setPickRadius( float radius );

  float getPickRadius() const;

#if 1             SoDEPRECATED
  virtual void adjustClippingPlanes();

#endif 
  SbBool getDepthValue(int x, int y, float &depth)
  {
    return m_guiViewer->getDepthValue(x, y, depth);
  }

 private:
  virtual ~SoXtViewer();

  // redefine this routine to also correctly set the buffering type
  // on the viewer.
  virtual void setNormalVisual( XVisualInfo* v );

#ifndef HIDDEN_FROM_DOC
  void saveSceneGraph( const char* fileName ) ;
#endif //HIDDEN_FROM_DOC

  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;
  SoXtViewer::Type type;
  SoNode* sceneGraph;
  SbVec3f seekPoint, seekNormal, oldCamPosition, newCamPosition;
  SbRotation oldCamOrientation, newCamOrientation;

  virtual SoGLContext* getViewerContext() { return getNormalSoContext(); }
  virtual SoSceneManager* getViewerSceneManager() { return getSceneManager(); }

 private:

  // Constructor/Destructor
  SoXtViewer( SoWidget parent,
              const char* name,
              SbBool buildInsideParent,
              SoXtViewer::Type type,
              SbBool buildNow,
              SbBool sync = TRUE );

  SoXtViewer( SoWidget parent,
              const char* name,
              SbBool buildInsideParent,
              SoXtViewer::Type type,
              SbBool buildNow,
              SbBool sync,
              SoGuiViewer* guiViewer );


  // Subclasses should (and do) override this method! (new in v2.6)
  // (The setCursorStyle method calls this to force a dynamic change)
  virtual void updateCursor() {};

  // global vars
  SbBool altSwitchBack; // flag to return to PICK after an Alt release

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

  SbBool isSeekMode() { return m_guiViewer->isSeekMode(); }

  // 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 );

  // redefine this for a better default draw style (need to wait for context)
  virtual void afterRealizeHook();

  virtual void widgetChanged( SoWidget );

  // auto clipping vars and routines
  SbBool autoClipFlag;
  float minimumNearPlane; // minimum near plane as percentage of far
  SoGetBoundingBoxAction* autoClipBboxAction;
  virtual void adjustCameraClippingPlanes();

  // 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 );

  // Return a pointer to the XtWidget for stereo
  void* getViewer() { return (void*)this; }

private:
  void constructorCommon( SoXtViewer::Type t, SbBool buildNow );

  void constructorCommon2( SoXtViewer::Type t, SbBool buildNow );

  SoGuiViewer* m_guiViewer; // Implementation class for SoXxViewer

  SbBool m_firstRealize;

  // current state vars
  SoXtInputFocus* inputFocus;

  // draw style vars
  void setCurrentDrawStyle( SoXtViewer::DrawStyle style );

  // copy and paste support
  SoXtClipboard* clipboard;
  static void pasteDoneCB( void* userData, SoPathList* pathList );

  // set the zbuffer on current window to correct state
  void setZbufferState();
  SbBool isZbufferOff();
  void arrowKeyPressed( KeySym key );

  // Decimation strategy additions:
  static SoGLRenderAction::AbortCode renderAbortCB( void* data );
  SoAlarmSensor* stillSensor;
  static void alarmCB( void* thisp, SoSensor* )
  { ((SoXtViewer*)thisp)->stillSensorCalled(); }

  // PoViews
  static SbBool viewingEventCB( SoXtViewer* viewer, XAnyEvent* anyEvent );

  void stillSensorCalled();

  // Seek animation
  static void seekAnimationSensorCB( void* p, SoSensor* sensor );
};

#endif /* _SO_XT_VIEWER_ */

#endif

---

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