SoShaderProgram.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      : VSG (MMM YYYY)
**=======================================================================*/
 
                                                            /* include files */
#ifndef _SO_SHADER_PROGRAM_H_
#define _SO_SHADER_PROGRAM_H_
 
#include <Inventor/SbBasic.h>
#include <Inventor/nodes/SoNode.h>
#include <Inventor/nodes/SoNode.h>
#include <Inventor/fields/SoMFNode.h>
#include <Inventor/nodes/SoShaderParameter.h>
#include <Inventor/nodes/SoFragmentShader.h>
#include <Inventor/nodes/SoVertexShader.h>
#include <Inventor/nodes/SoTessellationControlShader.h>
#include <Inventor/nodes/SoTessellationEvaluationShader.h>
#include <Inventor/nodes/SoTexture.h>
#include <Inventor/nodes/SoGeometryShader.h>
#include <Inventor/nodes/SoShaderParameterImage.h>
#include <Inventor/STL/vector>
#include <Inventor/STL/cassert>
#include <Inventor/helpers/SbConstCharMap.h>
#include <Inventor/elements/SoEnvironmentElement.h>
#include <memory>
#include <unordered_map>
#include <Inventor/renderer/RendererResourceMacro.h>
#include <Inventor/sensors/SoFileSensor.h>
 
 
#ifdef _WIN32
#pragma warning(push)
#pragma warning(disable:4251)
#endif
 
class SoGLRenderAction;
class SoGLShaderProgram ;
class SoGLShaderObject;
class SoFieldSensor ;
class SoLight;
class SoCache;
class SoShaderParameterBufferObject;
class SoComputeShader;
 
namespace inventor { namespace helper { class ShaderLibrary; } }
namespace inventor { namespace renderer { class ShaderStateUniforms; } }
/*----------------------------------------------------------------------------*/
 
class  SoShaderProgram : public SoNode
{
 
  SO_NODE_HEADER( SoShaderProgram );
  RENDERER_RESOURCE(SoShaderProgram);
 
public:
  enum GeometryInputType
  {
    POINTS_INPUT = GL_POINTS,
 
    LINES_INPUT = GL_LINES,
 
    TRIANGLES_INPUT = GL_TRIANGLES
  };
 
  enum GeometryOutputType
  {
    POINTS_OUTPUT = GL_POINTS,
    LINE_STRIP_OUTPUT = GL_LINE_STRIP,
    TRIANGLE_STRIP_OUTPUT = GL_TRIANGLE_STRIP
  };
 
  SoMFNode shaderObject;
 
  SoSFEnum geometryInputType;
 
  SoSFEnum geometryOutputType;
 
  SoSFBool vertexProgramTwoSide;
 
  SoSFBool shadowShader;
 
  SoSFInt32 maxGeometryOutputVertices;
 
 
  SoSFBool generateTransparency;
 
  SoSFInt32 patchLength;
 
  SoMFNode bufferObjects;
 
  SoMFNode images;
 
  SoShaderProgram();
 
  inline SoFragmentShader* getFragmentShader(int pos) const;
 
  inline SoVertexShader* getVertexShader(int pos) const;
 
  inline SoGeometryShader* getGeometryShader(int pos) const;
 
  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);
 
  virtual SoGeometryShader* setGeometryShader(int pos, const SbString& filenameOrSource,
                                              SoShaderObject::SourceType sourceType = SoShaderObject::FILENAME);
 
  virtual SoComputeShader* setComputeShader(int pos, const SbString& filenameOrSource,
                                            SoShaderObject::SourceType sourceType = SoShaderObject::FILENAME);
 
  static unsigned int getNumReservedTextures();
 
  inline SoTessellationControlShader* getTessellationControlShader(int pos) const;
 
  inline SoTessellationEvaluationShader* getTessellationEvaluationShader(int pos) const;
 
  virtual SoTessellationControlShader* setTessellationControlShader(int pos, const SbString& filenameOrSource,
                                              SoShaderObject::SourceType sourceType = SoShaderObject::FILENAME);
 
  virtual SoTessellationEvaluationShader* setTessellationEvaluationShader(int pos, const SbString& filenameOrSource,
                                              SoShaderObject::SourceType sourceType = SoShaderObject::FILENAME);
 
  /*----------------------------------------------------------------------------*/
 
  SoShaderParameterImage* addShaderParameterImage(const SbString& name, SoTexture* tex);
 
private:
 
  // GLRender
  virtual void doAction(SoAction *action);
  virtual void GLRender( SoGLRenderAction *action );
  virtual void getBoundingBox( SoGetBoundingBoxAction *action );
  virtual void pick( SoPickAction *action );
 
private:
  enum GPUVendorType
  {
    GPU_TYPE_NOT_INITIALIZED = -1,
    GPU_NVIDIA = 0,
    GPU_ATI = 1,
    GPU_INTEL = 2,
    GPU_FIREPRO_MAC = 3,
    GPU_MESA = 4
  };
 
  // Constant, max number of texture image properties that can be set
  enum { MAX_IMG_UNITS = 8 };
 
  static const char* getMainSlotName(SbEnums::ShaderType shaderType);
 
  bool hasPrivateMainShaderType(SbEnums::ShaderType shaderType) const;
 
  bool hasPublicMainShaderType(SbEnums::ShaderType shaderType) const;
 
  bool hasMainShaderType(SbEnums::ShaderType shaderType) const;
 
  bool hasFixedPipelineMainShaderType(SbEnums::ShaderType shaderType) const;
 
  bool hasFixedPipelineMain() const;
 
  void getAllParameters(SoState* state, std::vector<SoUniformShaderParameter*>& shaderParameters);
 
  void getShaderObjects(std::vector<SoShaderObject*>& shaderObjectsList) const;
 
  SbString getLinkedShaderFileNames(SbEnums::ShaderType shaderType) const;
 
  void displayLinkedFileNames() const;
 
  //Return true if its an internal Oiv/Vviz name
  static bool isOivReservedName(const std::string &paramName);
 
  virtual void notify(SoNotList *list);
 
  void setDefine(const char* name, const char* value);
  void setDefine(const char* name, const SbString& value)
  { setDefine(name,value.toLatin1()); }
 
  bool getDefine(const char* name, SbString& value) const;
 
  void removeDefine(const char* name);
 
  void setHeader(const SbString& filename);
 
  void removeHeader(const SbString& name);
 
  static GLint offsetToGLTextureUnit(SoGLRenderAction* action, const char* offset);
 
  static int offsetToTextureUnit(SoGLRenderAction* action, const char* offset);
 
  // Initializes the classes.
  static void initClass();
  static void exitClass();
 
  void invalidate();
 
  bool isGlslProgram() const;
 
  bool isComputeShader() const;
 
  bool isShadowShader() const;
 
  SoShaderProgram* getShadowPassShader() const;
 
  void setShadowShader(bool flag);
 
  void setHiddenShaderObject(const char* objName, SoShaderObject* obj);
 
  void removeHiddenShaderObject(const char* objName);
 
  SoShaderObject* getHiddenShaderObject(const char* objName) const;
 
  const SbConstCharMap<SoShaderObject*>& getHiddenShaderObjects() const;
 
  static GPUVendorType getGPUVendorType();
 
 
  template<typename T>
  T* setupPrivateShaderStage(const char* hiddenName, const SbString& shaderSource, SoShaderObject::SourceType sourceType = SoShaderObject::FILENAME)
  {
    // check if it is already allocated
    T* fp = (T*)getHiddenShaderObject(hiddenName);
    if (!fp || (fp->sourceProgram.getValue() != shaderSource))
    {
      fp = new T;
      fp->sourceProgram.setValue(shaderSource);
      fp->sourceType = sourceType;
      setHiddenShaderObject(hiddenName, fp);
    }
    return fp;
  }
 
  void removeAllPrivateShaderType(SbEnums::ShaderType shaderType);
 
  enum ShaderLibraryState
  {
    LIBRARY_NOT_INSTALLED,
    LIBRARY_INSTALLED_EMPTY,
    LIBRARY_INSTALLED,
  };
 
  ShaderLibraryState getLibraryState( inventor::helper::ShaderLibrary* library ) const;
 
  void setLibraryState( inventor::helper::ShaderLibrary* library, ShaderLibraryState libraryState );
 
  bool getPreviousNeedDepthPeelingLibrary() const
  {
    return m_previousNeedDepthPeelingLibrary;
  }
 
  void setIsFixedPipeline(bool isFixedPipelineShader)
  {
    m_isFixedPipelineShader = isFixedPipelineShader;
  }
 
  bool isFixedPipeline() const
  {
    return m_isFixedPipelineShader;
  }
 
  SoSFBool multiSampling;
 
private:
  typedef std::vector<SoShaderObject*> ShaderObjectVector;
  typedef SbConstCharMap<SoShaderObject*> ShaderObjectMap;
  typedef SoShaderObject::DefineMap DefineMap;
  typedef SoShaderObject::HeaderSet HeaderSet;
 
  struct Members
  {
    Members();
    ~Members();
    void unref();
 
    bool m_isShadowShader;
 
    ShaderObjectMap m_hiddenShaderObjects;
 
    // Contains the list of vertex and fragment shaders,
    // before modification.
    // Enable to track add/remove/change or shader objects.
    std::vector<SoShaderObject*> m_prevShaderObject;
    std::vector< SoNode * > m_toUnrefShaderObjects;
 
    SoShaderProgram* m_shadowPassShader;
 
    DefineMap m_defineMap;
 
    HeaderSet m_headerMap;
 
    bool m_isValid;
  };
  Members m_members;
 
  // Destructor
  virtual ~SoShaderProgram();
 
  // Check if all shader objects are valid
  SbBool isValidShaderObjects() const;
 
  // Check if at least one of the shader objects has
  // its "isActive" field set to true
  SbBool isOneShaderObjectActive();
 
  static SoShaderProgram::Members* getMembers(const SoShaderProgram* prog);
 
private:
  // Required for compat with some old IV files. (cf ebug#3765)
  SoMFNode prevShaderObject;
 
  void addDefines(SoShaderObject* obj);
 
  void addHeaders(SoShaderObject* obj);
 
  void addHiddenShaderObjects(ShaderObjectVector& shaderObjectsList);
 
  static bool lessVersion(SoShaderObject* obj1, SoShaderObject* obj2);
 
  static SbString getMaxVersion(const ShaderObjectVector& objList);
 
  static bool lessProfile(SoShaderObject* obj1, SoShaderObject* obj2);
 
  static SbString getLoosestProfile(const ShaderObjectVector& objList);
 
  bool hasShaderObjectsChanged() const;
 
  void updatePrevShaderObject();
 
  static void invalidate(ShaderObjectMap::value_type& p);
 
  void addGPUVendorDefine();
 
  void setShaderBufferObject(SoGLRenderAction* action);
 
  void setShaderTextureImages(SoGLRenderAction* action) const;
 
private:  
  void notifyAddedShaderObject(const char* hiddenShaderObjectName);
  
  static void fileSensorCB(void *data, SoSensor *) ;
 
  void updateFileSensor();
 
  std::unique_ptr<SoFileSensor> m_fileSensor;
 
  bool m_previousNeedDepthPeelingLibrary;
 
  typedef std::unordered_map<inventor::helper::ShaderLibrary*, ShaderLibraryState> ShaderLibraryStateMap;
  ShaderLibraryStateMap m_shaderLibrariesStates;
 
  static GPUVendorType s_gpuVendorType;
 
  static int s_firstUsedTextureUnit;
 
  static bool s_debugCache;
 
 
  bool m_isFixedPipelineShader;
 
  friend class SoUniformShaderParameter;
};
/*----------------------------------------------------------------------------*/
 
/*******************************************************************************/
SoFragmentShader*
SoShaderProgram::getFragmentShader(int pos) const
{
  assert(pos >= 0 && pos < shaderObject.getNum());
  SoShaderObject* obj = static_cast<SoShaderObject*>(shaderObject[pos]);
 
  if ( !obj )
    return NULL;
 
  assert(obj->getTypeId() == SoFragmentShader::getClassTypeId());
 
  return static_cast<SoFragmentShader*>(obj);
}
 
/*******************************************************************************/
SoVertexShader*
SoShaderProgram::getVertexShader(int pos) const
{
  assert(pos >= 0 && pos < shaderObject.getNum());
  SoShaderObject* obj = static_cast<SoShaderObject*>(shaderObject[pos]);
 
  if ( !obj )
    return NULL;
 
  assert(obj->getTypeId() == SoVertexShader::getClassTypeId());
 
  return static_cast<SoVertexShader*>(obj);
}
 
/*******************************************************************************/
SoGeometryShader*
SoShaderProgram::getGeometryShader(int pos) const
{
  assert(pos >= 0 && pos < shaderObject.getNum());
  SoShaderObject* obj = static_cast<SoShaderObject*>(shaderObject[pos]);
 
  if ( !obj )
    return NULL;
 
  assert(obj->getTypeId() == SoGeometryShader::getClassTypeId());
 
  return static_cast<SoGeometryShader*>(obj);
}
 
/*******************************************************************************/
SoTessellationControlShader*
SoShaderProgram::getTessellationControlShader(int pos) const
{
  assert(pos >= 0 && pos < shaderObject.getNum());
  SoShaderObject* obj = static_cast<SoShaderObject*>(shaderObject[pos]);
 
  if ( !obj )
    return NULL;
 
  assert(obj->getTypeId() == SoTessellationControlShader::getClassTypeId());
 
  return static_cast<SoTessellationControlShader*>(obj);
}
 
/*******************************************************************************/
SoTessellationEvaluationShader*
SoShaderProgram::getTessellationEvaluationShader(int pos) const
{
  assert(pos >= 0 && pos < shaderObject.getNum());
  SoShaderObject* obj = static_cast<SoShaderObject*>(shaderObject[pos]);
 
  if ( !obj )
    return NULL;
 
  assert(obj->getTypeId() == SoTessellationEvaluationShader::getClassTypeId());
 
  return static_cast<SoTessellationEvaluationShader*>(obj);
}
 
#ifdef _WIN32
#pragma warning(pop)
#endif
 
#endif /*_SO_SHADER_PROGRAM_H_*/