VolumeViz/nodes/SoVolumeShader.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      : Benjamin GRANGE (Aug 2005)
**=======================================================================*/


#ifndef _SO_VOLUME_SHADER_H_
#define _SO_VOLUME_SHADER_H_


#include <Inventor/nodes/SoShaderProgram.h>
#include <Inventor/nodes/SoShaderObject.h>
#include <Inventor/nodes/SoFragmentShader.h>
#include <Inventor/nodes/SoVertexShader.h>
#include <VolumeViz/nodes/SoVolumeRender.h>

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

/*----------------------------------------------------------------------------*/

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

class SoVolumeData;
class SoGLTexture;
class SoIsosurfaceTexture;
class SoVolumeRenderingQuality;
class SoVolumeDataDrawStyle;
class SoInteractiveComplexity;

class  SoVolumeShader : public SoShaderProgram {

  SO_NODE_HEADER(SoVolumeShader);

public:
  SoVolumeShader();

  enum ShaderPosition {
    GEOMETRY_MAIN =0,

    DATA_COMBINE_FUNCTION,

    GET_DATA_FUNCTION,

    FRAGMENT_COMPUTE_COLOR,

    VERTEX_MAIN,

    FRAGMENT_MAIN,

    VERTEX_POSTPROCESSING,

    CLIPPING_FUNCTION,

    CUSTOM_SHADER = 64
 };

  SoSFBool forVolumeOnly;

#if 1             SoDEPRECATED
  SoSFBool raycasting;
#endif  
  SoSFBool interpolateOnMove;

  static SbBool isSupported(SoState* state=NULL) ;

  virtual SoFragmentShader* setFragmentShader(int pos, const SbString& filenameOrSource,
                                              SoShaderObject::SourceType sourceType = SoShaderObject::FILENAME);

  virtual SoVertexShader* setVertexShader(int pos, const SbString& filenameOrSource,
                                          SoShaderObject::SourceType sourceType = SoShaderObject::FILENAME);

#if 1             SoDEPRECATED
  void setForVolumeOnly(SbBool volOnly) { forVolumeOnly = volOnly; }

#endif 
#ifndef HIDDEN_FROM_DOC
private:

  template<typename T>
  T* getCustomShader(const ShaderPosition pos)
  {
    if (shaderObject.getNum() > pos )
      return static_cast<T*>(shaderObject[pos]);
    return NULL;
  }

  template<typename T>
  void setupPrivateShaderStage(const char* hiddenName, T* defaultShader)
  {
    // check if it is already allocated
    T* fp = (T*)getHiddenShaderObject(hiddenName);
    if ( !fp ||  (fp!=defaultShader) )
      setHiddenShaderObject(hiddenName, defaultShader);
  }

  template<typename T>
  void setupPublicShaderStage(const ShaderPosition stagePos, const char* hiddenName, T* defaultShader)
  {
    T* fp = getCustomShader<T>(stagePos);
    // There is no custom shader for this stage
    if ( !fp )
      setupPrivateShaderStage<T>(hiddenName,defaultShader);
    else
      removeHiddenShaderObject(hiddenName);
  }

  template<typename T>
  void setupPrivateShaderStage(const char* hiddenName, const SbString& shaderSource)
  {
    // check if it is already allocated
    T* fp = (T*)getHiddenShaderObject(hiddenName);
    if ( !fp ||  (fp->sourceProgram.getValue() != shaderSource) )
    {
      fp = new T;
      fp->sourceProgram.setValue(shaderSource);
      setHiddenShaderObject(hiddenName, fp);
    }
  }

  template<typename T>
  void setupPublicShaderStage(const ShaderPosition stagePos, const char* hiddenName, const SbString& shaderSource)
  {
    T* fp = getCustomShader<T>(stagePos);
    // There is no custom shader for this stage
    if ( !fp )
      setupPrivateShaderStage<T>(hiddenName, shaderSource);
    else
      removeHiddenShaderObject(hiddenName);
  }

  bool isInternalFragment(SoFragmentShader* frag) const;

  bool isInternalShaderObject(SoShaderObject* obj) const;

  virtual void doAction(SoAction *action);

  virtual void GLRender(SoGLRenderAction *action);

  virtual void doRendering(SoGLRenderAction *action, SbBool resetShader=TRUE);

  static void initClass() ;

  static void exitClass() ;

  SbBool isForVolumeOnly() { return forVolumeOnly.getValue(); }

  void useFrontToBack(bool flag, SoGLRenderAction* action);

  static void setTexCoordVolUniform(SoState*state, SoVolumeData* vd);

  static void setDimensionUniforms( SoState* state,
                                    const SbVec3i32 &volumeDim,
                                    const SbVec3i32 &tileDim );

  void setPerTileUniforms(const SbVec3i32 &tileMinIJK, const SbVec3i32 &tileMaxIJK );

  inline bool hasPerTileUniforms() const;

  static int getFirstUsedTextureUnit(SoGLRenderAction* action);

  void setupRectilinearCoordinates(SoState *state);

  void setPerTileRectilinear(const SbVec3f& tileOrigin,
                             const SbVec3f& tileFactor,
                             const SbVec3f&, const SbVec3f&);

  void setDataProjectionMode(SoState* state, bool flag);

  static unsigned int getEarlyzTextureUnit(SoGLRenderAction* action);

  void enableUndefinedValueShader(bool flag);

  void chooseLightConfig(SoState* state, bool forbidVertexTwoSide = false);

  virtual void installTextures(SoGLRenderAction* action);

  void enableColorInterpolation(bool flag);

  virtual SbString getNeededVertexMainFilename(SoState* state);

  virtual SbString getNeededFragmentMainFilename(SoState* state);

  virtual SbString getRenderingModeFragmentName(SoState* state);

  virtual SbBool isRaycastingEnabled(SoState* state) const;

  virtual SbBool isVolumeGroupEnabled(SoState* state) const;

  virtual void allocateTextureUnit(SoGLRenderAction *) const {}

  //Set needed texture samplers
  void setTextureSamplers(SoGLRenderAction* action);
  
  static SbBool isTextureArrayEXTSupported(SoState* state);

  static bool isRaycastingDefault()
  { return s_forceRaycasting; };

private:

#if 1             SoDEPRECATED
  void createRenderModeShaders(){}
#endif  
  virtual bool isInterpolationActive(SoGLRenderAction* action);

  virtual void notify(SoNotList *list);

  enum GradientMethod
  {
    GRADIENT_FORWARD_DIFF = 0,
    GRADIENT_CENTRAL_DIFF,
    GRADIENT_SOBEL,
    GRADIENT_LAST
  };

  enum LightingModel
  {
    OIV6,
    OPENGL,
    LIGHTING_MODEL_LAST
  };

  typedef enum
  {
    ONE_LIGHT_DIR,
    ONE_LIGHT_DIR_2_SIDES,
    N_LIGHTS_DIR,
    N_LIGHTS,
    BASE_COLOR,
    LAST_LIGHTING_CONFIG
  } LightingConfig;

  void setLightingConfig(LightingConfig conf);

  void installIsosurfaceTexture(SoGLRenderAction* action);

  void createGradientShaders();

  void setGradientMethod(GradientMethod method);

  void createLightingModelShaders();

  void setLightingModel(LightingModel model);

  void enableNprShader(bool flag, SoVolumeRenderingQuality* vrq);

  void enableBoundaryOpacityShader(bool flag, float boundaryIntensity,
                                   float boundaryThreshold);

  void enableEdgeColoringShader(bool flag, const SbColor& edgeColor,
                                float threshold);

  void enableJitteringShader(bool flag);

  void enableSegmentedInterpolation(bool flag);

  void enableEdgeImageSpaceShader(bool flag, unsigned int edge2DMethod);

  void enableMrt();

  void enableBumpFunctions(bool flag);

  void enableSliceDefaultMain(bool flag);

  void installJitteringTexture(SoGLRenderAction* action);

  void uninstallJitteringTexture();

  void updateEdgeColoringUniforms(const SbVec3f& color, float threshold);

  void updateBoundaryOpacityUniforms(float intensity, float threshold);

  void updateGradientUniform(float threshold);

  //Set various uniforms for VolumeClippingGroup
  void updateVolumeClippingParameters(SoGLRenderAction* action);

  //Set various uniforms for SoHorizonClippingShader
  void updateGridClippingParameters(SoState *state);

  //Return TRUE if a SoVolumeClippingGroup or SoUniformGridClipping is in the state
  SbBool hasClippingNodesInState(SoState *state);

  ~SoVolumeShader();

  int m_datumSize;

  //Set the VVizUseOrthoCamera to the correct value
  void checkProjectionType(SoGLRenderAction* action);

  //Create a vertex shader and search it in the path of the findShaders method
  SoVertexShader *createVertexProgram(const SbString &shader);
  SoFragmentShader *createFragmentProgram(const SbString &shader);

  // Clean a specified path:
  // - converts the path to unix path.
  // - removes the drive is the path is a windows path.
  static SbString cleanUpFilePath( const SbString& string );

  virtual SoShaderProgram* generateShadowShader() const;

  void updateShaderSlots( SoState* state );

  static const float DEFAULT_GRADIENT_THRESHOLD;

  static const float DEFAULT_EDGE_THRESHOLD;

  static const float DEFAULT_BOUNDARY_THRESHOLD;
  static const float DEFAULT_BOUNDARY_INTENSITY;

  SoIsosurfaceTexture* m_isosurfaceTexture;

#endif //HIDEN_FROM_DOC

private:

  void updateDataDrawStyleCache(SoState* state);

  static const size_t JITTER_TEX_SIZE;

  void createLightingFragmentShader();

  void createJitterTex(SoState* state, size_t size);

  void getUniformsLocation();

  bool hasToHandleFakeSoVolumeIsosurfaceStyle(SoState* state);
  void handleFakeSoVolumeIsosurfaceStyle(SoGLRenderAction* action);

  SoGLTexture* m_jitterTex;

  int m_previousProjectionType;
  bool m_useFrontToBack;

  enum ClippingMode {
    CLIP_MODE_VOLUME = (1 << 1),
    CLIP_MODE_UNIFORM_GRID = (1 << 2),
    CLIP_MODE_NONE = 0
  };

   enum DefaultMainPos {
     DEFAULT_FRAG_VOLUME = 0,
     DEFAULT_FRAG_SLICE,
     DEFAULT_FRAG_LAST
   };

  int m_currentClippingModeMask;

  SoGLTexture *m_rectilinearMappingTex;

  SoFragmentShader* m_computeRectilinearCoordinates;
  SoFragmentShader* m_computeUniformCoordinates;

  SoShaderParameter3f* m_VVizRootTileDimensions;
  SoShaderParameter3f* m_VVizTileFactor;
  SoShaderParameter3f* m_VVizTileOrigin;
  SoShaderParameter1i* m_VVizRectilinearMappingSize;

  SoFragmentShader* m_defaultMainFragment[DEFAULT_FRAG_LAST];

  GLint m_vvizTileMaxIJK;
  GLint m_vvizTileMinIJK;

  size_t m_numUniformGridClipping;

  std::vector<SoFragmentShader*> m_gradientShaders;
  GradientMethod m_currentGradientMethod;

  std::vector<SoFragmentShader*> m_lightingModelShaders;
  LightingModel m_currentLightingModel;

  bool m_heightFieldLightingEnaled;

  unsigned int m_edge2dMethod;
  bool m_edgeImageSpaceEnabled;
  bool m_mrtEnabled;
  bool m_boundaryOpacityEnabled;
  bool m_jitterEnabled;
  bool m_edjeColoringEnabled;
  bool m_nprEnabled;
  bool m_nprNeedGradient;
  bool m_undefinedValueEnabled;

  SbVec3f m_edgeColor;
  float m_edgeThreshold;

  float m_gradientThreshold;

  float m_boundaryOpacityThreshold;
  float m_boundaryOpacityIntensity;

  bool m_colorInterpolation;

  SoShaderParameter3f* m_vvizDepthTexSize;
  SoShaderParameter3f* m_vvizOneOverDepthTexSize;
  SoShaderParameter1f* m_vvizExclusive;
  SoShaderParameter1f* m_vvizNumLayers;
  SoShaderParameter1f* m_vvizNumPassUsed;

  std::vector<SoFragmentShader*> m_lightingFragmentShader;
  LightingConfig m_curLight;

  SoVolumeDataDrawStyle* m_volumeDataDrawStyle;

  SoCache* m_dataDrawStyleCache;

  static int s_texture_array_EXT_extensionID;
  static bool s_forceRaycasting;
};

#ifndef HIDDEN_FROM_DOC
/*******************************************************************************/
bool
SoVolumeShader::hasPerTileUniforms() const
{
  return m_vvizTileMinIJK != -1 || m_vvizTileMaxIJK != -1;
}

#endif // HIDDEN_FROM_DOC
#ifdef _WIN32
#pragma warning(pop)
#endif

#endif /*_SO_VOLUME_SHADER_H_*/

---

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