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-2025 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);

  enum NotificationsPolicy
  {
    DISABLE_NOTIFICATIONS,
    ENABLE_NOTIFICATIONS,
  };

  void setDefine(const char* name, const char* value, NotificationsPolicy notifPolicy = DISABLE_NOTIFICATIONS);
 
  void setDefine(const char* name, const SbString& value, NotificationsPolicy notifPolicy = DISABLE_NOTIFICATIONS)
  {
    setDefine(name, value.toLatin1(), notifPolicy);
  }

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

  void setVertexProgramTwoSide(SoState* state, bool allowVertexTwoSideLighting = true);

  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;

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