Inventor/MP/Win/viewers/SoWinMPViewer.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      : VSG (MMM YYYY)
**=======================================================================*/



#ifndef  _SO_WIN_MP_VIEWER_
#define  _SO_WIN_MP_VIEWER_

#if defined(_WIN32)
#  include <Inventor/Win/SoWinBeginStrict.h>
#endif
#include <Inventor/SoType.h>
#include <Inventor/MP/Win/SoWinMPRenderArea.h>
#include <Inventor/misc/SoCallbackList.h>
#include <Inventor/SbTime.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 SoWinMPViewer;
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 SoTransform;


// callback function prototypes
typedef void SoWinMPViewerCB(void *userData, SoWinMPViewer *viewer);
typedef void SoWinMPViewerCameraTypeChangeCB(void *userData, SoCamera *camera, SoWinMPViewer *viewer);

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

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

//class SoWinMPViewer : public SoWinMPRenderArea, public SoStereoViewer {
class  SoWinMPViewer : public SoWinMPRenderArea {

 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
  };
  
  
  //
  // Sets/gets the scene graph to render. Whenever a new scene is supplied
  // the first camera encountered will be by default used as the edited
  // camera, else a new camera will be created.
  //
  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 camera; }
  
  virtual void    setCameraType(SoType type);
  SoType          getCameraType()         { return cameraType; }
     
  virtual void          setPreserveCameraHeightAngle(SbBool flag)
    {m_preserveHeightAngle = flag; }

  virtual SbBool     isCameraHeightAnglePreserved() const
    {return m_preserveHeightAngle; }

  virtual void          enableSeekWithOrtho(SbBool flag)
    {m_seekWithOrtho = flag; }
    
  virtual SbBool     isSeekWithOrthoEnabled() const
    {return m_seekWithOrtho; }

  
  virtual void    viewAll();
  virtual void    saveHomePosition();
  virtual void    resetToHomePosition();
  
  void setCameraTypeChangeCallback(SoWinMPViewerCameraTypeChangeCB *callback,
                                   void *userdata);
  
  void            setHeadlight(SbBool onOrOff);
  SbBool          isHeadlight()           { return headlightFlag; }
  SoDirectionalLight *getHeadlight()      { return headlightNode; }
  
  void setDrawStyle(SoWinMPViewer::DrawType type, 
                    SoWinMPViewer::DrawStyle style);
  SoWinMPViewer::DrawStyle getDrawStyle(SoWinMPViewer::DrawType type);
  
  void setBufferingType(SoWinMPViewer::BufferType type);
  SoWinMPViewer::BufferType getBufferingType()       { return bufferType; }
  
  // redefine this to call the viewer setBufferingType() method instead.
  virtual void    setDoubleBuffer(SbBool onOrOff);
  virtual void    setViewing(SbBool onOrOff);
  SbBool          isViewing() const       { return viewingFlag; };
  
  virtual void  setCursorEnabled(SbBool onOrOff);
  SbBool            isCursorEnabled() const   { return cursorEnabledFlag; }
  
  void            setAutoClipping(SbBool onOrOff);
  SbBool          isAutoClipping() const          { return autoClipFlag; }
  
  //  virtual void    setStereoViewing(SbBool onOrOff);
  //  virtual SbBool  isStereoViewing();
  //  void            setStereoOffset(float dist) { stereoOffset = dist; scheduleRedraw() ;}
  //  float           getStereoOffset()   { return stereoOffset; }
  
  void            setDetailSeek(SbBool onOrOff)   { detailSeekFlag = onOrOff; };
  SbBool          isDetailSeek()                  { return detailSeekFlag; }
  
  void            setSeekTime(float seconds)      { seekAnimTime = seconds; }
  float           getSeekTime()                   { return seekAnimTime; }

  void    addStartCallback(SoWinMPViewerCB *f, void *userData = NULL)
    { startCBList->addCallback((SoCallbackListCB *)f, userData); }

  void    addFinishCallback(SoWinMPViewerCB *f, void *userData = NULL)
    { finishCBList->addCallback((SoCallbackListCB *)f, userData); }

  void    removeStartCallback(SoWinMPViewerCB *f, void *userData = NULL)
    { startCBList->removeCallback((SoCallbackListCB *)f, userData); }

  void    removeFinishCallback(SoWinMPViewerCB *f, void *userData = NULL)
    { finishCBList->removeCallback((SoCallbackListCB *)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 *);
  
  virtual void  recomputeSceneSize();
  
  
  // --- Large Model Viewing additions:
  
  void setDecimationStrategy(DecimationStrategy strategy);
  DecimationStrategy getDecimationStrategy() { return decStrategy; };
  
  void    setGoalNumberOfTriangles(int32_t goal);
  int32_t getGoalNumberOfTriangles()  { return goalTris; };
  
  void    setGoalFramesPerSecond(float goal);
  float getGoalFramesPerSecond()  { return goalFps; };
  
  void  setFixedPercentage(float percent);
  float getFixedPercentage()  { return decPercentage; };
  
  void   enableFullRenderingWhenStill(SbBool onOff);
  SbBool isFullRenderingWhenStill() { return doFullRendering; };
  
  SbBool isStillNow() { return isStill; };
  
  void setFramesPerSecondCallback(SoWinMPViewerFPSCB *callback,
                                  void *userData = NULL);
  
  void setNumSamples(int numFrames);
  int  getNumSamples() { return numSamples; };
  
  void setDecimationPercentageCallback(SoWinMPViewerDecimationPercentageCB *callback,
                                       void *userData = NULL);
  
  float getCurrentDecimationPercentage();
  
  void insertSceneTransform(void);
  
  SoTransform * getSceneTransform(void);
  
  SoTransform * getWandTransform(void);

  void setWandGeometryFile(SbString wandFile);

  void setHeadTracking(int value);
  
  virtual void navigate(void);



 public:
  HDC getCurrentDC( int id );
  
  virtual void setCursorStyle( SoWinMPViewer::CursorStyle style );
  SoWinMPViewer::CursorStyle getCursorStyle() { return cursorStyle; };
  
  virtual void toggleCameraType();

#if 1             SoDEPRECATED
  HDC getCurrentDC();

#endif 
 private:
  virtual ~SoWinMPViewer();
    
  // tell whether create the wand or not. Default is TRUE 
  void useWand(SbBool flag)
    { addWandGroup = flag;};
  
 private:
  // Constructor/Destructor
  SoWinMPViewer(SoWidget parent,
                const char *name, 
                SbBool buildInsideParent, 
                Type type,   // Removed class qualifier from enum --mmh 1/12/95
                SbBool buildNow);
  
  // global vars
  SoWinMPViewer::Type   type;
  SoCamera            *camera;        // camera being edited
  SbBool              viewingFlag;    // FALSE when the viewer is off
  SbBool              m_preserveHeightAngle;
  float               m_previousHeightAngle; 
 
  // global vars new in v2.1
  SbBool                altSwitchBack;  // flag to return to PICK after an Alt release
  SbBool                cursorEnabledFlag;
  static SoSFTime       *viewerRealTime;  // pointer to "realTime" global field
  float         sceneSize;   // the larger of the X,Y,Z scene BBox
  float         viewerSpeed; // default to 1.0 - SoXtFullViewer add UI to inc/dec
  
  // 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)
  SoWinMPViewer::CursorStyle 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 createdCursors;
  HCURSOR normalCursor,   // std arrow
    dollyCursor, panCursor, rollCursor, seekCursor,
    spinCursor, upCursor, flyCursor, walkCursor;
  
  // 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() {};
  
#ifdef __sgi
  // set to TRUE when we are using the SGI specific stereo extensions
  // which enables us to emulate OpenGL stereo on most machines.
  SbBool              useSGIStereoExt;
#endif
  
  // local tree variables
  SoSeparator         *sceneRoot;     // root node given to the RA
  SoNode              *sceneGraph;    // user supplied scene graph
  
  // 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 interactiveCount; }
  
  //
  // 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();
  
  // variables used for interpolating seek animations
  float           seekDistance;
  SbBool          seekDistAsPercentage; // percentage/absolute flag
  SbBool          computeSeekVariables;
  SbVec3f         seekPoint, seekNormal;
  SbRotation      oldCamOrientation, newCamOrientation;
  SbVec3f         oldCamPosition, newCamPosition;
  
  // Externally set the viewer into/out off seek mode (default OFF). Actual
  // seeking will not happen until the viewer decides to (ex: mouse click).
  //
  // Note: setting the viewer out of seek mode while the camera is being
  // animated will stop the animation to the current location.
  virtual void    setSeekMode(SbBool onOrOff);
  SbBool          isSeekMode()                    { return seekModeFlag; }
  
  // 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    prepareRedraw();
  virtual void    actualRedraw();
  virtual void    endRedraw();
  
  // 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 SoWinMPRenderArea to also check to make
  // sure that SoWinMPViewer::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();
  
  // 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);

  SbBool              m_seekWithOrtho;

  //  SoBaseStereo * stereoViewType ;

 private:
  // current state vars
  SoType              cameraType;
  BufferType          bufferType;
  SbBool              interactiveFlag; // TRUE while doing interactive work
   
  // draw style vars
  DrawStyle           stillDrawStyle, interactiveDrawStyle;
  SbBool              checkForDrawStyle;
  SoSwitch            *drawStyleSwitch;   // on/off draw styles
  SoDrawStyle         *drawStyleNode;     // LINE vs POINT
  SoLightModel        *lightModelNode;    // BASE_COLOR vs PHONG
  SoPackedColor       *colorNode;
  // hidden line first pass
  SoMaterialBinding    *matBindingNode;
  // hidden line first pass
  SoComplexity        *complexityNode;    // low complexity & texture off
  void                setCurrentDrawStyle(SoWinMPViewer::DrawStyle style);
  void                doRendering();
   
  // copy and paste support
  SoWinClipboard       *clipboard;
  static void         pasteDoneCB(void *userData, SoPathList *pathList);
   
  // camera original values, used to restore the camera
  SbBool              createdCamera;
  SbVec3f             origPosition;
  SbRotation          origOrientation;
  float               origNearDistance;
  float               origFarDistance;
  float               origFocalDistance;
  float               origHeight;
   
  // seek animation vars
  SbBool              seekModeFlag; // TRUE when seek turned on externally
  SoFieldSensor      *seekAnimationSensor;
  SbBool              detailSeekFlag;
  float               seekAnimTime;
  SbTime              seekStartTime;
  static void         seekAnimationSensorCB(void *p, SoSensor *);
   
  // headlight variables
  SoFieldSensor       *headlightSensor;   // attached to camera
  SoDirectionalLight  *headlightNode;
  SoGroup             *headlightGroup;
  SoRotation          *headlightRot;
  SbBool              headlightFlag;  // true when headlight in turned on
  static void         headlightSensorCB(void *, SoSensor *);
   
  // interactive viewing callbacks
  int                 interactiveCount;
  SoCallbackList      *startCBList;
  SoCallbackList      *finishCBList;
  static void         drawStyleStartCallback(void *, SoWinMPViewer *v);
  static void         drawStyleFinishCallback(void *, SoWinMPViewer *v);
  static void         bufferStartCallback(void *, SoWinMPViewer *v);
  static void         bufferFinishCallback(void *, SoWinMPViewer *v);
   
  // 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:
  DecimationStrategy decStrategy;
  int32_t goalTris;       // Goal Number of Triangles
  float   goalFps;        // Goal Frames Per Second
  float   decPercentage;  // Fixed percentage
  float   lastDecimationValue;  // Last decimation value and render time
  double   lastRenderTime;      // used when (strategy==FRAMES_PER_SECOND)
  int lastDirection; // changed decimation up or down last time?
  SoGetPrimitiveCountAction *primCountAction, *userCountAction;
  SbBool isStill, doFullRendering;
  SoAlarmSensor *stillSensor;
  static void alarmCB(void* thisp, SoSensor*)
    { ((SoWinMPViewer*)thisp)->stillSensorCalled(); };
  void stillSensorCalled();
  SoNodeSensor *motionSensor;
  static void changeCB(void* thisp, SoSensor*)
    { ((SoWinMPViewer*)thisp)->changeSensorCalled(); };
  void changeSensorCalled();
   
  // Camera type change callback
  SoWinMPViewerCameraTypeChangeCB *viewerCameraTypeChangeCallback;
  void *viewerCameraTypeChangeCallbackUserData;
   
  // Frames per second calculating:
  int numSamples, curNumSamples;
  double curTotalTime;
  SoWinMPViewerFPSCB  *fpsUserCallback;
  void             *fpsUserData;
   
  // Decimation Percentage callback
  SoWinMPViewerDecimationPercentageCB  *decimationUserCallback;
  void         *decimationUserData;
   
  // flag indicating whether a render traversal is in
  // progress.
  SbBool          isWinRedrawing;

  // SoTransform Node that will modify the scene
  // this node is inserted just after the camera 
  // that the viewer is using.
  SoTransform * sceneTransform;
  // TRUE if we are in MP immersive mode
  SbBool addSceneTransform;

  // Wand 
  SoSeparator * wandGroup;
  SoTransform * wandTransform;
  SoSeparator * wandGeometry;
  static const char * defaultWandGeometry;
  SbString wandFileStr;
  SbBool addWandGroup;
  void createWandGroup(void);
  void insertWandGroup(void);
  
  void scaleScene(SoNode * scene);
};

#if defined(_WIN32)
#  include <Inventor/Win/SoWinEndStrict.h>
#endif

#endif  /* _SO_WIN_VIEWER_ */

---

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