SoVolumeShader.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      : 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 <Inventor/nodes/SoTextureUnit.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 SoIsosurfaceTexture;
class SoVolumeRenderingQuality;
class SoVolumeDataDrawStyle;
class SoInteractiveComplexity;
class SoNodeDependencies;
class SoGroup;
class SoTexture;
 
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,
 
    TESS_VERTEX_SHIFT,
 
    CUSTOM_SHADER = 64
 };
 
  SoSFBool forVolumeOnly;
 
 
  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);
 
#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>
  T* setupPublicShaderStage(const ShaderPosition stagePos, const char* hiddenName, T* defaultShader)
  {
    T* fp = getCustomShader<T>(stagePos);
    // There is no custom shader for this stage
    if ( !fp )
      return setupPrivateShaderStage<T>(hiddenName,defaultShader);
    else
      removeHiddenShaderObject(hiddenName);
    return fp;
  }
 
 
  template<typename T>
  T* 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 )
      return setupPrivateShaderStage<T>(hiddenName, shaderSource);
    else
      removeHiddenShaderObject(hiddenName);
    return fp;
  }
 
  template<typename T>
  T* setupPrivateShaderStageNoOverride(const char* hiddenName, const SbString& shaderSource)
  {
    T* fp = (T*) getHiddenShaderObject(hiddenName);
    if (fp == nullptr)
    {
      fp = new T;
      fp->sourceProgram.setValue(shaderSource);
      setHiddenShaderObject(hiddenName, fp);
    }
    return fp;
  }
 
  template<typename T>
  T* setupPublicShaderStageNoOverride(const ShaderPosition stagePos, const char* hiddenName, const SbString& shaderSource)
  {
    T* fp = getCustomShader<T>(stagePos);
    if (fp == nullptr)
      return setupPrivateShaderStageNoOverride<T>(hiddenName, shaderSource);
    else
      removeHiddenShaderObject(hiddenName);
    return fp;
  }
 
  bool isInternalFragment(SoFragmentShader* frag) const;
 
  bool isInternalShaderObject(SoShaderObject* obj) const;
 
  virtual void doAction(SoAction *action);
 
  virtual void GLRender( SoGLRenderAction *action );
 
  void installShaderProgram( SoGLRenderAction *action );
 
  virtual void doRendering(SoGLRenderAction *action);
 
  static void initClass() ;
 
  static void exitClass() ;
 
  SbBool isForVolumeOnly() { return forVolumeOnly.getValue(); }
 
  static void setTexCoordVolUniform(SoState*state, SoVolumeData* vd, SoNode* node);
 
  static int getFirstUsedTextureUnit(SoGLRenderAction* action);
 
  virtual void installTextures(SoGLRenderAction* ) {}
 
  virtual SbBool isRaycastingEnabled(SoState* state) const;
 
  virtual SbBool isVolumeGroupEnabled(SoState* state) const;
 
  virtual void allocateTextureUnit(SoGLRenderAction *) const {}
  
  static SbBool isTextureArrayEXTSupported(SoState* state);
 
  static bool isRaycastingDefault()
  { return s_forceRaycasting; };
 
 
#if 1             SoDEPRECATED
  void createRenderModeShaders(){}
#endif  
  virtual bool isInterpolationActive(SoGLRenderAction* action);
 
  bool mustUseOrthoCamera( SoState* state );
 
private:
 
  virtual void notify(SoNotList *list);
 
  void installJitteringTexture(SoGLRenderAction* action);
 
  void uninstallJitteringTexture();
 
  ~SoVolumeShader();
 
  // 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;
 
#endif //HIDEN_FROM_DOC
 
#if 1             
SoINTERNAL private:SoDEPRECATED
  SoSFBool raycasting;
#endif  
private:
 
  static const size_t JITTER_TEX_SIZE;
 
  void createJitterTex();
 
  bool hasToHandleFakeSoVolumeIsosurfaceStyle(SoState* state);
  void handleFakeSoVolumeIsosurfaceStyle(SoGLRenderAction* action);
 
  SoRef<SoGroup> m_jitterTextureGroup;
  SoRef<SoTextureUnit> m_jitterTextureUnit;
  SoRef<SoTexture2> m_jitterTexture;
 
  SoVolumeDataDrawStyle* m_volumeDataDrawStyle;
 
  static int s_texture_array_EXT_extensionID;
  static bool s_forceRaycasting;
};
 
#ifdef _WIN32
#pragma warning(pop)
#endif
 
#endif /*_SO_VOLUME_SHADER_H_*/