VolumeViz/nodes/SoVolumeRender.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      : P. ESTRADE (Mar 2000)
**=======================================================================*/
#ifndef  _SO_VOLUME_RENDER_
#define  _SO_VOLUME_RENDER_

#include <Inventor/caches/SoCache.h>
#include <Inventor/nodes/SoShape.h>
#include <Inventor/fields/SoSFBool.h>
#include <Inventor/fields/SoSFBitMask.h>
#include <Inventor/fields/SoSFEnum.h>
#include <Inventor/fields/SoSFFloat.h>
#include <Inventor/fields/SoSFVec3f.h>
#include <Inventor/fields/SoSFInt32.h>
#include <Inventor/SbBox.h>

#include <Inventor/STL/vector>
#include <Inventor/STL/map>

#include <VolumeViz/nodes/SoVolumeShape.h>

#include <VolumeViz/LDM/SoLDMTileID.h>

class SbProjection;
class SoFrameBufferObject;
class SoGLProgramGLSL;
class SoGLTexture;
class SoVRImageSpaceEffects;
class SoLDMTileID;
class SoLdmSubDivisionIsosurfacePolicy;
class SoLdmSubDivisionPolicy;
class SoLdmSubDivisionTransferFunctionPolicy;
class SoShaderParameter1f;
class SoShaderParameter1i;
class SoShaderParameter2f;
class SoShaderProgram;
class SoVolumeGroup;
class SoVolumeIsosurface;
class SoVolumeRenderInterface;
class SoVolumeRenderLdm;
class SoVolumeRenderPaging;
class SoVolumeRenderingQuality;
class SoVolumeStateVr;
class SoVolumeRenderDetail;
class SoNodeSensor;
class SoVolumeOffscreenImpl;
class SoProgressIndicator;

#ifdef _WIN32
#pragma warning( push )
#pragma warning(disable:4251)
#endif

class  SoVolumeRender : public SoVolumeShape {
  SO_NODE_HEADER( SoVolumeRender );

 public:

   enum LowResMode
   {
     DECREASE_NONE = 1,
     DECREASE_SLICES = 1 << 1,
     DECREASE_SCREEN_RESOLUTION = 1 << 2
   } ;


    enum NumSlicesControl {
    ALL,
    MANUAL,
    AUTOMATIC,
    MAIN_AXIS
  };

  SoSFEnum  numSlicesControl;

  SoSFInt32 numSlices;

  SoSFBitMask lowResMode;

  SoSFInt32 lowScreenResolutionScale;

#if 1             SoDEPRECATED
  SoSFBool useEarlyZ;
SoDEPRECATED
  SoSFInt32 numEarlyZPasses;
SoDEPRECATED
  SoSFBool gpuVertexGen;
#endif  
  SoSFBool subdivideTile;

  SoSFBool fixedNumSlicesInRoi;

  SoSFInt32 projectedTileSubdivision;

  SoSFBool opacityCorrection;

  enum RenderMode
  {
    VOLUME_RENDERING = 0,

    MIN_INTENSITY_PROJECTION,

    MAX_INTENSITY_PROJECTION,

    SUM_INTENSITY_PROJECTION,

    AVERAGE_INTENSITY_PROJECTION
  };

  SoSFEnum renderMode;

  enum SamplingAlignment
  {
    VIEW_ALIGNED = 0,
    DATA_ALIGNED,
    BOUNDARY_ALIGNED,
    SMOOTH_BOUNDARY_ALIGNED,
  };

  SoSFEnum samplingAlignment;

  SoSFFloat opacityThreshold;

  SoVolumeRender();

  void setRenderProgress(SoProgressIndicator* ps) { m_renderProgress = ps; }

  enum AbortCode {
    CONTINUE,
    ABORT,
    SKIP
  };

  typedef AbortCode SoVolumeRenderAbortCB(int totalElems, int thisElem, void *userData);

  void setAbortCallback( SoVolumeRenderAbortCB *func, void *userData = NULL);


#if 1             SoDEPRECATED
  SoSFBool  lighting;
SoDEPRECATED
  SoSFVec3f lightDirection;
SoDEPRECATED
  SoSFFloat lightIntensity;

#endif 
#if 1             SoDEPRECATED
  SoSFBool viewAlignedSlices;

#endif 
/*****************************************************************************/
private:
  virtual void computeBBox(SoAction *, SbBox3f &box, SbVec3f &center);

  virtual void rayPick(SoRayPickAction *action);

/*****************************************************************************/
private:

  static void initClass();

  static void exitClass();

  SoVolumeRenderingQuality* getVolumeRenderingQuality( SoState* state ) const;

  SoVolumeOffscreenImpl* getVolumeOffscreenImpl() const;

#if 1             SoDEPRECATED
  static int getVolumeRaycastingSlabbingMode();
SoDEPRECATED
   bool isSlabbingEnabled(SoState* state) const;

#endif 
   bool needOivDepth(SoState* state, GLenum& internalDepthFormat);

   bool needRttColor(SoState* state, GLenum& internalColorFormat) const;

   bool needRttEdgeDetect(SoState* state, GLenum& internalFormat) const;

   bool needRttBoundaryDepth(SoState* state, GLenum& internalFormat) const;

   bool needRttBoundaryColor(SoState* state, GLenum& internalFormat) const;

   SamplingAlignment getSamplingAlignment(SoState* state) const;

   void removeDsFromRegList(SoDataSet* pDs);

/*****************************************************************************/
 private:
   // Destructor
   virtual ~SoVolumeRender();

   void createVolumeRender( SoState* state );

   void generatePrimitives(SoAction *action);

   void doRendering(SoGLRenderAction *action);

   void setupVolumeRenderInterface(SoState* state);

   SoDetail *createTriangleDetail(SoRayPickAction *,
                                  const SoPrimitiveVertex *v1,
                                  const SoPrimitiveVertex *,
                                  const SoPrimitiveVertex *,
                                  SoPickedPoint *);

   void beginOffscreenRendering(SoGLRenderAction *action);

   void endOffscreenRendering( SoState* state );

   void setupFrontToBackGlState();

  SbBool shouldGLRender(SoGLRenderAction *renderAction, SbBool isPointsOrLines);

  virtual void notify(SoNotList *list);

SoINTERNAL private:
  virtual void ldmAction(SoLdmValuationAction* action);

/*****************************************************************************/
private:
   static SoVolumeData* getVolumeData(SoState* state);

   void fillDetail(SoRayPickAction* rpa, SoVolumeRenderDetail* detail, SoVolumeData* vd);


   static bool canSubdivideTiles(SoState* state);

   bool isRaycastingEnabled(SoState* state) const;

  bool m_useEarlyZ;
  
  SoVolumeRenderAbortCB *m_abortCBfunc;
  void  *m_abortCBuserData;
  void   GLRenderTex2D3D(SoGLRenderAction* action);

  void onViewportChange(SoState* state);

   void onUserInteractionChange(SoState*state, bool stopMoving);

   void useOffscreenRendering(SoGLRenderAction* action);

   void initInternalShaders();

  void GLRenderTex2D3DLDMSortedTiles(SoState* state, const SbMatrix& mpvmx,
                                     int Zaxis, float sliceSpacing, float sliceOffset,
                                     const SoLDM::TileIdVector& tiles,
                                     const std::vector<SbBox3i32>& boxes,
                                     const SbVec3f& eyeAxis, int textype,
                                     const SbVec3f& scale);
  void GLRenderTex2D3DLDMUnsortedTiles(SoState* state, const SbMatrix& mpvmx,
                                       int Zaxis, float sliceSpacing, float sliceOffset,
                                       const SoLDM::TileIdVector& tiles,
                                       const SbBox3i32 * const boxes, int numBoxes,
                                       const SbVec3f& eyeAxis, int textype, int numSliceToDraw,
                                       float min, float max,
                                       const SbVec3f& scale);

  void checkEarlyZ( SoState* state );

  void setupDepthPeelingTextures(SoGLRenderAction *action);

  SoVRImageSpaceEffects* m_imageSpaceEffects;

  int m_vpScale;

  int m_lowScreenResScale;

  SoShaderProgram* m_earlyZShader;
  SoShaderParameter1i *m_opacityTex;
  SoGLProgramGLSL* m_binaryOpacityComposeShader;

  SoShaderProgram* m_earlyZInBBoxShader;
  SoShaderProgram* m_writeFragShader;

  SoShaderParameter2f* m_vpSizeParameter;
  SoShaderParameter1f* m_vvizZNear;

  size_t m_numEarlyPasses;

  SoVolumeIsosurface* m_volumeIsosurface;

  void deleteShadersFboTextures();

  void updateLowResScale( SoState* state );

  void initTextureUnits(SoGLRenderAction *action);

  void registerCtxId(const SoLDM::DsVector &dsVector, int ctxId); 

  void unregisterCtxId(const SoLDM::DsVector &dsVector, int ctxId);

  bool m_useLowResMove;

  bool m_useLowNumSliceMove;

  bool m_showEarlyZ;

  SoVolumeRenderInterface* m_vri;

  bool m_frontToBackComposition;

  // List of dataset gathered in previous valuation action
  SoLDM::DsVector m_prevDsList;

  // Callback to manage deletion of dataset
  static void volDataDeleteCB(void* data, SoSensor *sensor);

  // ctxId attached to this volumeRender. Set by ValuationAction.
  int m_prevRegisteredCtxId;

  SoVolumeStateVr* m_vs;

  SoProgressIndicator* m_renderProgress;
  SoVolumeOffscreenImpl* m_volumeOffscreenImpl;

  // Associate a Node sensor to each DataSet managed
  std::map<SoDataSet*, SoNodeSensor*> m_mapDsSensor;

  static int s_volumeRaycastSlabbingMode;

  friend class SoVolumeRenderInterface;
  friend class SoVolumeRenderLdm;
  friend class SoVolumeRenderRaycast;

};

#if defined(_WIN32)
#pragma warning( pop )
#endif

#endif // _SO_VOLUME_RENDER_

---

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