SoGLRenderAction.h

/*=======================================================================
 * 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      : Paul S. Strauss (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-2024 BY FEI S.A.S,                        ***
 ***                        BORDEAUX, FRANCE                                        ***
 ***                      ALL RIGHTS RESERVED                                       ***
**=======================================================================*/
/*=======================================================================
** Modified by : VSG (MMM YYYY)
**=======================================================================*/
 
#ifndef  _SO_GL_RENDER_ACTION_
#define  _SO_GL_RENDER_ACTION_
 
#include <Inventor/SbViewportRegion.h>
#include <Inventor/nodes/SoViewport.h>
#include <Inventor/actions/SoSubAction.h>
#include <Inventor/elements/SoShapeStyleElement.h>
#include <Inventor/elements/SoDecimationTypeElement.h>
#include <Inventor/lists/SoPathList.h>
#include <Inventor/lists/SoSensorList.h>
 
#ifdef _MSC_VER
#pragma warning( push )
#pragma warning(disable:4251)
#endif
 
class SbBox3f;
class SoGetBoundingBoxAction;
class SoGLDepthPeeling;
class SoCache;
class SoCamera;
class SoSeparator;
class SoGLRenderActionSync;
class SoGLRenderActionImpl;
 
 
typedef void    SoGLRenderPassCB(void *userData);
 
//
//  Class: SoGLRenderAction
//
//  GL rendering action.
//
 
class  SoGLRenderAction : public SoAction {
 
  SO_ACTION_HEADER(SoGLRenderAction);
 
 public:
 
  enum TransparencyType
  {
SoDEPRECATED
    NO_TRANSPARENCY,
 
    NO_SORT,
 
    OPAQUE_FIRST,
 
    SORTED_OBJECT,
 
    SORTED_PIXEL,
 
  };
 
  enum FastEditSavePolicy {
    DISABLE,
 
    EACH_FRAME,
 
    WHEN_NEEDED
  };
 
  enum AbortCode {
    CONTINUE,
 
    ABORT,
 
    PRUNE,
 
    DELAY
  };
 
  typedef AbortCode SoGLRenderAbortCB(void *userData);
 
    enum InvalidateCacheMode {
    OFF,
 
    ONCE,
 
    ALWAYS
  };
 
  SoGLRenderAction(const SbViewportRegion &viewportRegion);
 
#ifndef HIDDEN_FROM_DOC
  // Destructor
  virtual ~SoGLRenderAction();
#endif // HIDDEN_FROM_DOC
 
  void setViewportRegion(const SbViewportRegion &newRegion);
 
  const SbViewportRegion &getViewportRegion() const   { return vpRegion; }
 
  void setLogicalViewportRegion(const SbViewportRegion &newLogicalRegion);
 
  const SbViewportRegion& getLogicalViewportRegion() const;
 
  void setUpdateArea(const SbVec2f &origin, const SbVec2f &size);
 
  void                getUpdateArea(SbVec2f &origin, SbVec2f &size) const;
 
  void setAbortCallback(SoGLRenderAbortCB *func, void *userData)
    { abortCB = func; abortData = userData; }
 
  void                setTransparencyType(TransparencyType type);
 
  TransparencyType    getTransparencyType() const
  { return m_transpType; }
 
  void setFastEditSavePolicy(FastEditSavePolicy policy, SbBool fastEditDelayedObjects = FALSE);
 
  FastEditSavePolicy  getFastEditSavePolicy() const
  { return m_fastEditPolicy; }
SoDEPRECATED
  void                setSmoothing(SbBool smooth);
SoDEPRECATED
  SbBool              isSmoothing() const             { return doSmooth; }
 
  void setNumPasses(int num);
 
  int getNumPasses() const  { return numPasses; }
 
  void                setPassUpdate(SbBool flag)      { passUpdate = flag; }
 
  SbBool              isPassUpdate() const            { return passUpdate; }
 
  void                setPassCallback(SoGLRenderPassCB *func, void *userData)
    { passCB = func; passData = userData; }
 
  void setCacheContext(uint32_t context);
 
  uint32_t getCacheContext() const;
 
  static uint32_t generateCacheContext();
 
  static bool isUsedCacheContext( uint32_t context );
 
  void setSortedLayersNumPasses(int num)
    { m_sortedLayersNumPasses = num; }
 
 
  int getSortedLayersNumPasses() const
    { return m_sortedLayersNumPasses ; }
 
  static SbBool isSortedLayersSupported(SoState* state=NULL) ;
 
  void setAlphaTest( SbBool flag );
 
  SbBool isAlphaTest() const
    { return m_alphaTest; }
 
 
  void                  setRenderingIsRemote(SbBool flag);
  SbBool              getRenderingIsRemote() const;
 
  virtual void        invalidateState();
 
  void setDecimationValue(SoDecimationTypeElement::Type type,
                          float percentage = 1.0);
 
  SoDecimationTypeElement::Type getDecimationType() { return decType; };
 
  float               getDecimationPercentage() { return decPercent; };
 
  void setInvalidateCacheMode(InvalidateCacheMode icm);
 
  InvalidateCacheMode getInvalidateCacheMode();
 
  uint32_t getFrameCounter() const { return m_frameCounter; }
 
  void resetFrameCounter( uint32_t count = 0 ) { m_frameCounter = count; }
 
  virtual void apply(SoNode* node);
 
  virtual void apply(SoPath* path);
 
  virtual void apply(const SoPathList& pathList, SbBool obeysRules = FALSE);
 
  enum AutoCacheMode
  {
    DO_AUTO_CACHE = 1,
    DONT_AUTO_CACHE = 2
  };
 
  void shouldAutoCache( AutoCacheMode mode );
 
private:
  inline bool isDoingDepthPeeling() const { return m_isDoingDepthPeeling; }
 
  int getDepthPeelingPass();
 
  void enableDepthPeeling3D(bool flag) const;
 
  SoGLDepthPeeling* getDepthPeelingInterface() const;
 
  // Returns current rendering pass number
  int getCurPass() const              { return curPass; }
 
  // Returns TRUE if render action should abort - checks user callback
  SbBool abortNow()
    { return (hasTerminated() || (abortCB != NULL && checkAbort())); }
 
  // Returns TRUE if render action handles processing of a
  // transparent object (if it is to be sorted and rendered later).
  // If this returns FALSE, the object should just go ahead and
  // render itself.
  // The optional argument isTransparent ensures that the object being
  // rendered will be taken as transparent, regardless of transparency
  // in the state.  If it is false, the state is checked for transparency.
  virtual SbBool handleTransparency(SbBool isTransparent = FALSE, SbBool isLinesOrPoints = FALSE);
 
  virtual void setUpState();
 
  void setDelayedObjDepthWrite( SbBool flag ) { m_delayedObjDepthWrite = flag; }
 
  SbBool getDelayedObjDepthWrite() const { return m_delayedObjDepthWrite; }
 
  virtual bool preDelayedTraversal();
 
  virtual void postDelayedTraversal();
 
  void setCache( SoCache* cache );
 
  SoCache* getCache() const;
 
 private:
  static void initClass();
  static void exitClass();
 
  inline bool isFloatingPointFramebuffer() const { return m_floatingPointFramebuffer; }
  inline void setFloatingPointFramebuffer(bool flag) { m_floatingPointFramebuffer = flag; }
 
  // Returns TRUE if rendering is being delayed because of transparency sorting or delaying
  SbBool isDelaying() const { return delayObjs; }
 
  // Returns true if the current state contains any transparency
  bool stateContainsTransparency() const;
 
  // Used in SoLocateHighlight in order to clear the transparent path cache
  void removeAllDelayedPath();
 
  bool isTraversalPassTransparent() const;
 
  bool handleFastEdit(SoSeparator* sep);
 
  int getCullTestResults() { return cullBits; }
  void setCullTestResults(int b) { cullBits = b; }
 
  SbBool isLogicalRegionSet() const;
 
  void setTiledViewportRegion(const SbVec4f& region, int info = 0);
 
  void setMaxDepthOffset(float maxDepthOffset);
 
/* FAST EDIT METHODS*/
  // set the buffer type.
  void setDoubleBuffer(SbBool db);
  // The main scene must be redrawn.
  void setForceRender();
  // Set viewing mode (from viewer).
  void setViewing(SbBool viewing);
  // Is there any delayed object to render ?
  SbBool hasDelayedNodesToRender() const;
  // initialize the start of a stereo pass.
  void setFirstStereoPass(SbBool first);
 
  SoPathList transpPaths; // Keep for compatibility. should be removed in OIV 9.2
 
  void setRenderingFromOffscreen(SbBool renderFromOffscreen)
  { m_renderingFromOffscreen = renderFromOffscreen; }
 
  SbBool getRenderingFromOffscreen() const
  { return m_renderingFromOffscreen; }
 
  //Return true after an apply if there were transparent objects
  //(used in SoLocateHighlight in order to redraw the whole scene only in this case)
  SbBool hasDrawnTransparentObjs() const
  { return m_hasDrawnTransparentObjs; }
 
  // Set the fullscene antialiasing element
  void setFullSceneAntialiasingElement( SbBool enable, int filterMask );
 
  // Set the number of samples for MSAA
  void setMSNumSamples(int numSamples);
 
  enum RenderMode {
    ALL_OBJECTS,
    OPAQUE_OBJECTS,
    DELAYED_OBJECTS
  };
 
  //
  // Allow to restrict which object will be render during the next ::render call.
  // After the ::render call, this mode is reset to its default value.
  // Note :  this is used by ScaleViz Depth compositing to manage delayed object.
  void setRestrictObjectRenderingMode( const RenderMode mode = ALL_OBJECTS )
  { m_restrictObjectRendering = mode; };
 
  int getRestrictObjectRenderingMode() const
  { return m_restrictObjectRendering; };
 
  SoGLRenderActionSync* getSynchronizer() const;
  void setSynchronizer( SoGLRenderActionSync* );
 
  virtual void updateParametersFrom( SoGLRenderAction* );
  SoGLRenderPassCB* getPassCallback( void*& data )
  {
    data = passData;
    return passCB;
  }
 
  SoGLRenderActionImpl* getImpl();
 
  // Used to temporary change the depth peeling interface, used
  // for depth only. Returns the value in use before the call.
  SoGLDepthPeeling* setDepthPeelingInterface(SoGLDepthPeeling*);
 
  bool isFastEditManipulating();
 
  SoPathList delayedPaths; // Keep for compatibility. should be removed in OIV 9.2
 
  bool isLazyEvaluating() const { return m_lazyEvaluating; }
  void setLazyEvaluating(bool value) { m_lazyEvaluating = value; }
 
  void copyParametersFrom( SoGLRenderAction* action );
 
  SoViewport* getViewportNode() const
  {
    return m_viewport.ptr();
  }
 
  // These flags determine which things have to be sent to GL when
  // the action is applied. They indicate what's changed since the
  // last time the action was applied.
  enum flags {
    TRANSPARENCY_TYPE = 0x01,
    SMOOTHING         = 0x02,
    ALPHA_TEST        = 0x04,
    FASTEDIT_SAVE_POLICY = 0x08,
    SCENE_GRAPH       = 0x10,
    ANTIALIASING      = 0x20,
    ALL               = 0x3F  // Initial value
  };
 
private:
  // Initiates action on graph
  virtual void beginTraversal(SoNode *node);
 
SoINTERNAL private:
  // used internally to temporary change the fastEditPolicy without reseting any caches
  void setFastEditSavePolicyInternal(FastEditSavePolicy policy)
  { m_fastEditPolicy = policy; }
 
  // used internally to temporary change the transparencyType without reseting any caches
  void setTransparencyTypeInternal(TransparencyType type)
  { m_transpType = type; }
 
  uint32_t getWhatChanged() const
  {
    return whatChanged;
  }
 
private:
 
  template<typename ApplyType> void commonApply(ApplyType applyObject, SbBool obeysRules);
 
  template<typename ApplyType> void applyTo(ApplyType applyObject, SbBool obeysRules);
 
  SoGLRenderActionSync* m_synchronizer;
 
  FastEditSavePolicy  m_fastEditPolicy;     // Transparency quality type
  TransparencyType    m_transpType;     // Transparency quality type
 
  void removeInvalidPaths();
 
  bool m_isDoingDepthPeeling;
 
  SbBool m_hasDrawnTransparentObjs;
  SbBool m_isViewing;
  SoNode* m_appliedNode;
  SbBool m_isFirstApply;
  SbBool m_firstStereoPass;
  int m_lastStereoMode;
 
  int    m_useCacheOpt;
  int    m_useCompactPaths;
 
  SbViewportRegion    vpRegion;       // Current viewport region
 
  // super viewport node that manage viewport, modify viewport and logical viewport
  SoRef<SoViewport> m_viewport;
 
  SoRef<SoNode> m_maxDepthOffset;
 
  SbVec2f             updateOrigin;   // Origin of update area
  SbVec2f             updateSize;     // Size of update area
 
 
  // Variables for render abort:
  SoGLRenderAbortCB   *abortCB;       // Callback to test abort
  void                *abortData;     // User data for abort callback
 
  // Variables for transparency, smoothing, and multi-pass rendering:
  SbBool              doSmooth;       // Doing smoothing ?
  int                 numPasses;      // Number of rendering passes
  int                 curPass;        // Current pass
  SbBool              passUpdate;     // Whether to update after each pass
  SoGLRenderPassCB    *passCB;        // Callback between passes
  void                *passData;      // User data for pass callback
 
  // For SORTED_OBJECT transparency:
  SbBool              delayObjs;           // TRUE if transp objects are to be delayed until after opaque ones
 
  SbBool              remoteRendering;// Remote rendering?
 
  // BA 2/98 - added decimation variables
  SoDecimationTypeElement::Type decType;    // Decimation type
  float                         decPercent; // Decimation percentage
 
  uint32_t whatChanged;
 
  // Enables or disables GL blending
  void enableBlending(SbBool enable);
 
  // Enables or disables GL smoothing
  void enableSmoothing(SbBool enable);
 
  // Returns TRUE if render action should abort based on callback
  SbBool checkAbort();
 
  // Keep track of which planes we need to view-volume cull test
  // against:
  int cullBits;
 
  SbBool m_delayedObjDepthWrite;
 
  // Indicates if the next render is asked for Offscreen
  SbBool m_renderingFromOffscreen;
 
  SbBool m_alphaTest;
 
  // Count frames rendered with this action (for debugging)
  uint32_t  m_frameCounter;
 
  // indicate if action is currently called to evaluate lazy eval or for classical traversal.
  // See isLazyEvaluating() doc for details.
  bool m_lazyEvaluating;
 
  //================== Begin sorted layers rendering ========================
 
  int m_sortedLayersNumPasses ;
 
  // Realizes a sorted layers rendering using depth peeling technics.
  void renderSortedLayers(SoNode *node) ;
  void initDepthPeeling(SoNode *node);
 
  // Rendering callback for sorted layers rendering.
  static void renderSortedLayersCB(void *userData, SoGLDepthPeeling *mgr) ;
 
  SoGLDepthPeeling *m_glDepthPeeling ;
 
  static void cameraPostCB( SoCamera *camera, SoGLRenderAction* renderAction );
  bool m_ignoreCameraPostCB;
  //================== End Sorted layers rendering ========================
 
 
  InvalidateCacheMode m_invalidateAllCaches;
  RenderMode m_restrictObjectRendering;
 
  bool m_floatingPointFramebuffer;
 
  //================ FSAA element management ============================
  SbBool m_fsaaEnable;
  int m_fsaaFilterMask;
  int m_fsaaNumSamples;
 
  SoGLRenderActionImpl* m_impl;
};
 
 
// INLINE METHODS
inline SoGLRenderActionSync* SoGLRenderAction::getSynchronizer() const
{
  return m_synchronizer;
}
 
inline SoGLRenderActionImpl* SoGLRenderAction::getImpl()
{
  return m_impl;
}
 
#ifdef _MSC_VER
#pragma warning( pop )
#endif
#endif /* _SO_GL_RENDER_ACTION_ */