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_*/