SoVolumeRender.h

/*=======================================================================
 *** 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                                       ***
**=======================================================================*/
/*=======================================================================
** 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/nodes/SoShaderParameter.h>
#include <Inventor/nodes/SoGroup.h>
#include <Inventor/nodes/SoTextureUnit.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 SoShaderProgram;
class SoVolumeGroup;
class SoVolumeIsosurface;
class SoVolumeRenderInterface;
class SoVolumeRenderRaycast;
class SoVolumeRenderLdm;
class SoVolumeRenderLdm;
class SoVolumeRenderPaging;
class SoVolumeRenderingQuality;
class SoVolumeStateVr;
class SoVolumeRenderDetail;
class SoNodeSensor;
class SoVolumeOffscreenImpl;
 
#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
  };
 
  SoMFInt32 dataSetIds;
 
  SoSFEnum  numSlicesControl;
 
  SoSFInt32 numSlices;
 
  SoSFBitMask lowResMode;
 
  SoSFInt32 lowScreenResolutionScale;
 
 
  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,
 
    MAX_INTENSITY_DIFFERENCE_ACCUMULATION,
 
    INTENSITY_DIFFERENCE_ACCUMULATION,
 
    MAX_GRADIENT_DIFFERENCE_ACCUMULATION,
 
    GRADIENT_DIFFERENCE_ACCUMULATION
  };
 
  SoSFEnum renderMode;
 
  enum SamplingAlignment
  {
    VIEW_ALIGNED = 0,
    DATA_ALIGNED,
    BOUNDARY_ALIGNED,
    SMOOTH_BOUNDARY_ALIGNED,
  };
 
  SoSFEnum samplingAlignment;
 
  SoSFFloat opacityThreshold;
 
  SoVolumeRender();
 
  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
 
#endif 
   bool needOivDepth(SoState* state);
 
   bool needRttColor(SoState* state) const;
 
   bool needRttEdgeDetect(SoState* state) const;
 
   bool needRttBoundaryDepth(SoState* state) const;
 
   bool needRttBoundaryColor(SoState* state) const;
 
   SamplingAlignment getSamplingAlignment(SoState* state) const;
 
   void removeDsFromRegList(SoDataSet* pDs);
   
   virtual void notify(SoNotList *list);
 
   void onUserInteractionChange(SoState*state, bool stopMoving);
   
/*****************************************************************************/
 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( SoGLRenderAction* action );
 
   void setupFrontToBackGlState(SoState* state);
 
  SbBool shouldGLRender(SoGLRenderAction *renderAction, SbBool isPointsOrLines);
 
/*****************************************************************************/
SoINTERNAL private:
 
  virtual void ldmAction(SoLdmValuationAction* action);
 
/*****************************************************************************/
private:
 
#if 1             SoDEPRECATED
  SoSFBool useEarlyZ;SoDEPRECATED
  SoSFInt32 numEarlyZPasses;SoDEPRECATED
  SoSFBool gpuVertexGen;
#endif  
   void fillDetail(SoRayPickAction* rpa, SoVolumeRenderDetail* detail, const SoLDM::DataSetIdPair& idPair);
 
   void genPrimDataSet(SoAction* action, const SoLDM::DataSetIdPair& idPair);
 
   bool canSubdivideTiles(SoState* state);
 
   bool isRaycastingEnabled(SoState* state) const;
 
  SoVolumeRenderAbortCB *m_abortCBfunc;
  void  *m_abortCBuserData;
  void   GLRenderTex2D3D(SoGLRenderAction* action);
 
   void useOffscreenRendering(SoGLRenderAction* action);
 
   void initInternalShaders();
 
  void setupDepthPeelingTextures(SoGLRenderAction *action);
 
  void rayPickDataSet(SoRayPickAction* action, const SoLDM::DataSetIdPair& idPair);
 
  SoVRImageSpaceEffects* m_imageSpaceEffects;
 
  int m_vpScale;
 
  int m_lowScreenResScale;
 
  SoShaderParameter1i *m_opacityTex;
  SoGLProgramGLSL* m_binaryOpacityComposeShader;
 
  SoShaderProgram* m_writeFragShader;
 
  SoVolumeIsosurface* m_volumeIsosurface;
 
  void deleteShadersFboTextures();
 
  void updateLowResScale( SoState* state );
 
  void registerCtxId(const SoLDM::DsVector &dsVector, int ctxId); 
 
  void unregisterCtxId(const SoLDM::DsVector &dsVector, int ctxId);
 
  bool m_useLowResMove;
 
  bool m_useLowNumSliceMove;
 
  SoVolumeRenderLdm* m_vriLdm;
  SoVolumeRenderRaycast* m_vriRaycast;
  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;
 
  SoVolumeOffscreenImpl* m_volumeOffscreenImpl;
 
  // Associate a Node sensor to each DataSet managed
  std::map<SoDataSet*, SoNodeSensor*> m_mapDsSensor;
 
  friend class SoVolumeRenderLdm;
  friend class SoVolumeRenderRaycast;
 
  SoRef<SoGroup> m_depthPeelingSG;
  SoRef<SoGroup> m_depthPeelingColorTexGroup;
  SoRef<SoTextureUnit> m_depthPeelingColorTexUnit;
  SoRef<SoGroup> m_depthPeelingDepthTexGroup;
  SoRef<SoTextureUnit> m_depthPeelingDepthTexUnit;
};
 
#if defined(_WIN32)
#pragma warning( pop )
#endif
 
#endif // _SO_VOLUME_RENDER_