Inventor/actions/SoGLRenderAction.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      : 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-2023 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/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 SoCamera;
class SoSeparator;
class SoGLRenderActionSync;
class SoGLRenderActionImpl;
class SoAccumulatedTextPolygon;
class SoAccumulatedTextTextured;


typedef void    SoGLRenderPassCB(void *userData);

//
//  Class: SoGLRenderAction
//
//  GL rendering action.
//

class  SoGLRenderAction : public SoAction {

  SO_ACTION_HEADER(SoGLRenderAction);

 public:

  enum TransparencyType {
    
    SCREEN_DOOR,

    ADD,

    DELAYED_ADD,

    BLEND,

    DELAYED_BLEND,

    SORTED_OBJECT_ADD,

    SORTED_OBJECT_BLEND,
SoDEPRECATED
    SORTED_LAYERS_BLEND,

    SORTED_PIXELS_BLEND = SORTED_LAYERS_BLEND,
SoDEPRECATED
    DELAYED_SORTED_LAYERS_BLEND,

    DELAYED_SORTED_PIXELS_BLEND = DELAYED_SORTED_LAYERS_BLEND,

    SORTED_TRIANGLES_ADD,

    SORTED_TRIANGLES_BLEND,

    SORTED_OBJECT_TRIANGLES_ADD,

    SORTED_OBJECT_TRIANGLES_BLEND,

    NO_TRANSPARENCY

  };

  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    { return vpLogicalRegion; }

  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 transpType; }

  void setFastEditSavePolicy(FastEditSavePolicy policy, SbBool fastEditDelayedObjects = FALSE);

  FastEditSavePolicy  getFastEditSavePolicy() const { return fastEditPolicy; }


  void                setSmoothing(SbBool smooth);

  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 setSortedTrianglesSortFrequency(int angle);

  int getSortedTrianglesSortFrequency();

  void setSortedTrianglesNumCaches(int numCaches);

  int getSortedTrianglesNumCaches();

  void setInvalidateCacheMode(InvalidateCacheMode icm);

  InvalidateCacheMode getInvalidateCacheMode();

  uint32_t getFrameCounter() const { return m_frameCounter; }

  void resetFrameCounter( uint32_t count = 0 ) { m_frameCounter = count; }

  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;

  SoAccumulatedTextPolygon* getAccumulatedTextPolygon();
  SoAccumulatedTextTextured* getAccumulatedTextTextured();

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

 private:
  static void initClass();
  static void exitClass();

  virtual void apply(SoNode* node);
  virtual void apply(SoPath* path) { SoAction::apply(path); }
  virtual void apply(const SoPathList &pathList, SbBool obeysRules = FALSE) { SoAction::apply(pathList, obeysRules); }

  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; }

  // Used in SoLocateHighlight in order to clear the transparent path cache
  void removeAllDelayedPath();

  bool isTraversalPassTransparent() const;
  bool isTraversalPassTransparentSortedTriangles() const;

  bool handleFastEdit(SoSeparator* sep);

  int getCullTestResults() { return cullBits; }
  void setCullTestResults(int b) { cullBits = b; }

  // Indicates if the action ignores back face culling.
  void setBackFaceCullingIgnored(SbBool flag) { m_isBackFaceCullingIgnored = flag; }
  SbBool isBackFaceCullingIgnored() const { return m_isBackFaceCullingIgnored; }

  SbBool isLogicalRegionSet() const;

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

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

#if 1             
  // Adds to the list of paths to render after all other stuff
  // (including delayed/sorted transparent objects) have been
  // rendered. (Used for annotation nodes.)
  // Keep for compatibility. should be removed in OIV 9.2SoDEPRECATED
  void addDelayedPath(SoPath *path);

  // Remove a path containing the node (if exists) from the lists of delayed transparency paths to render
  // after all other stuff.
  // TODO Keep for compatibility. should be removed in OIV 9.2SoDEPRECATED
  void removeDelayedTranspPath(SoNode *node) ;

  // Adds to the list of paths to render before transparent objects
  // but still in a delayed mode
  // TODO Keep for compatibility. should be removed in OIV 9.2SoDEPRECATED
  void addOpaqueDelayedPath(SoPath *path);

  // remove from the list of paths to render before transparent objects
  // but still in a delayed mode
  // TODO Keep for compatibility. should be removed in OIV 9.2SoDEPRECATED
  void removeOpaqueDelayedPath(SoPath *path);

  // remove path from all lists of paths
  // TODO Keep for compatibility. should be removed in OIV 9.2SoDEPRECATED
  void removePathFromAllPass(SoPath *path);

  // Returns TRUE if currently rendering any kind of delayed paths
  // Keep for compatibility. should be removed in OIV 9.2SoDEPRECATED
  bool isRenderingDelayed() const;

  // Returns TRUE if currently rendering delayed paths
  // Keep for compatibility. should be removed in OIV 9.2SoDEPRECATED
  SbBool isRenderingDelayedPaths() const;

  // Returns TRUE if currently rendering opaque delayed paths
  // Keep for compatibility. should be removed in OIV 9.2SoDEPRECATED
  SbBool isRenderingOpaqueDelayedPaths() const;

  // Returns TRUE if currently rendering transparent objects
  // Keep for compatibility. should be removed in OIV 9.2SoDEPRECATED
  SbBool isRenderingTranspObjs() const;

  // Gets the list of paths to render in the front buffer
  // TODO Keep for compatibility. should be removed in OIV 9.2SoDEPRECATED
  const SoPathList &getDelayedPaths() const;

  // Returns TRUE if currently rendering delayed paths
  // TODO Keep for compatibility. should be removed in OIV 9.2SoDEPRECATED
  SbBool isRenderingTranspPaths() const;

  // Updates the list of transparency paths according to the reason which has triggered
  // the sensor. Setting forceRebuilding to TRUE, deletes all the transparency list
  // and the associated caches, forcing them to be rebuilt at the next traversal.
  // If nodeKitToRemove is non null, the path containing it will be removed from the cache
  // list (This is used in PoBase where scenegraph is modified and notifications disabled,
  // causing a corruption of the transparent cache).
  // Keep for compatibility. should be removed in OIV 9.2SoDEPRECATED
  void updateTranspList(SoSensor* sensor, SbBool forceRebuilding=FALSE, SoNode *nodeKitToRemove = NULL);

  // TODO Keep for compatibility. should be removed in OIV 9.2SoDEPRECATED
  SoPathList& getTranspPathsList();

#endif 
private:
  // Initiates action on graph
  virtual void beginTraversal(SoNode *node);
  // End of a traversal
  virtual void endTraversal(SoNode *node);

  SoGLRenderActionSync* m_synchronizer;

SoINTERNAL private:
  FastEditSavePolicy  fastEditPolicy;     // Transparency quality type
  TransparencyType    transpType;     // Transparency quality type

private:
  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
  /* OIV_MULTI_THREADS */
  SbViewportRegion    vpLogicalRegion;// Current logical viewport region
  int                 logicalRegionIsSet;  // for the MP to work properly under windows

  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_ADD or SORTED_OBJECT_BLEND transparency:
  SbBool              delayObjs;           // TRUE if transp objects are to be delayed until after opaque ones
  SbBool              fastEditObjs;        // TRUE if fast edit objects are to be delayed

  SbBool              m_shouldSortOpaquePaths ; // TRUE is opaque paths should be sorted
  SbBool              m_shouldSortTranspPaths ; // TRUE is transparency paths should be sorted
  SbBool              sortObjs;                 // TRUE if objects are to be sorted

  SbBool              remoteRendering;// Remote rendering?

  // BA 2/98 - added decimation variables
  SoDecimationTypeElement::Type decType;    // Decimation type
  float                         decPercent; // Decimation percentage

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

  // Indicates if the action ignores back face culling.
  SbBool m_isBackFaceCullingIgnored;

  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;

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

  static char s_separateSpecularMode;

  bool m_floatingPointFramebuffer;

  //================ FSAA element management ============================
  SbBool m_fsaaEnable;
  int m_fsaaFilterMask;

  bool m_synchronizeStillFrame;

  SoGLRenderActionImpl* m_impl;
};


// INLINE METHODS
inline SoGLRenderActionSync* SoGLRenderAction::getSynchronizer()
{
  return m_synchronizer;
}

inline SoGLRenderActionImpl* SoGLRenderAction::getImpl()
{
  return m_impl;
}

#ifdef _MSC_VER
#pragma warning( pop )
#endif
#endif /* _SO_GL_RENDER_ACTION_ */

---

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