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-2025 BY FEI S.A.S,                        ***
 ***                        BORDEAUX, FRANCE                                        ***
 ***                      ALL RIGHTS RESERVED                                       ***
**=======================================================================*/
/*=======================================================================
** Author      : P. ESTRADE (Mar 2000)
**=======================================================================*/
#pragma once
 
#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;

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;

  SoSFVec2i32 stillScreenTileSize;

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