SoShaderObject.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_OBJECT_H_
#define _SO_SHADER_OBJECT_H_
 
#include <Inventor/SbBasic.h>
#include <Inventor/SbString.h>
#include <Inventor/nodes/SoNode.h>
#include <Inventor/fields/SoSFFilePathString.h>
#include <Inventor/fields/SoSFEnum.h>
#include <Inventor/fields/SoSFBool.h>
#include <Inventor/fields/SoMFUniformShaderParameter.h>
#include <Inventor/SbEnums.h>
 
#include <Inventor/STL/cassert>
#include <Inventor/STL/map>
#include <Inventor/helpers/SbConstCharMap.h>
 
class SoGLShaderContainer ;
class SoGLShaderObject ;
class SoFieldSensor ;
class SoNodeSensor ;
class SoFileSensor ;
class SoShaderParser;
 
#ifdef _MSC_VER
#pragma warning( push )
#pragma warning(disable:4251)
#endif

class  SoShaderObject : public SoNode
{
 
  SO_NODE_ABSTRACT_HEADER(SoShaderObject);
 
public:

  enum SourceType
  {SoDEPRECATED
      ARB_PROGRAM,
SoDEPRECATED
      CG_PROGRAM,

      GLSL_PROGRAM,

      FILENAME
  };

  SoSFBool isActive;

  SoSFEnum sourceType;

  SoSFFilePathString sourceProgram;

  SoMFUniformShaderParameter parameter;

  template<typename UniformParamType, typename ParamValueType>
  UniformParamType* addShaderParameter(const SbString& name, ParamValueType val);

  enum ShaderType
  {
    VERTEX_SHADER = SbEnums::SHADER_TYPE_VERTEX,
    GEOMETRY_SHADER = SbEnums::SHADER_TYPE_GEOMETRY,
    FRAGMENT_SHADER = SbEnums::SHADER_TYPE_FRAGMENT,
    TESSELLATION_CONTROL_SHADER = SbEnums::SHADER_TYPE_TESS_CTRL,
    TESSELLATION_EVALUATION_SHADER = SbEnums::SHADER_TYPE_TESS_EVAL,
    COMPUTE_SHADER = SbEnums::SHADER_TYPE_COMPUTE,
  };

  virtual ShaderType getShaderType() const = 0;

  template<typename UniformParamType, typename ParamValueType>
  void setShaderParameter(const SbString& name, ParamValueType val);
 
#ifndef HIDDEN_FROM_DOC
  //Generate all setFragmentParameter* methods
#define MAKE_HELPHER_FUNC_SET_SHADER_PARAMETER(ParamType)\
 \
  template<typename ParamValueType>\
  void\
  setShaderParameter ## ParamType(const SbString& name, ParamValueType val)\
  {\
  setShaderParameter<SoShaderParameter ## ParamType>(name, val);\
  }
  MAKE_HELPHER_FUNC_SET_SHADER_PARAMETER(1i)
  MAKE_HELPHER_FUNC_SET_SHADER_PARAMETER(2i)
  MAKE_HELPHER_FUNC_SET_SHADER_PARAMETER(3i)
  MAKE_HELPHER_FUNC_SET_SHADER_PARAMETER(4i)
  MAKE_HELPHER_FUNC_SET_SHADER_PARAMETER(1f)
  MAKE_HELPHER_FUNC_SET_SHADER_PARAMETER(2f)
  MAKE_HELPHER_FUNC_SET_SHADER_PARAMETER(3f)
  MAKE_HELPHER_FUNC_SET_SHADER_PARAMETER(4f)
  MAKE_HELPHER_FUNC_SET_SHADER_PARAMETER(Array1f)
  MAKE_HELPHER_FUNC_SET_SHADER_PARAMETER(Array2f)
  MAKE_HELPHER_FUNC_SET_SHADER_PARAMETER(Array3f)
  MAKE_HELPHER_FUNC_SET_SHADER_PARAMETER(Array4f)
  MAKE_HELPHER_FUNC_SET_SHADER_PARAMETER(Array1i)
  MAKE_HELPHER_FUNC_SET_SHADER_PARAMETER(Array2i)
  MAKE_HELPHER_FUNC_SET_SHADER_PARAMETER(Array3i)
  MAKE_HELPHER_FUNC_SET_SHADER_PARAMETER(Array4i)
  MAKE_HELPHER_FUNC_SET_SHADER_PARAMETER(Matrix)
  MAKE_HELPHER_FUNC_SET_SHADER_PARAMETER(Matrix3)
  MAKE_HELPHER_FUNC_SET_SHADER_PARAMETER(MatrixArray)
#undef MAKE_HELPHER_FUNC_SET_SHADER_PARAMETER
 
//Generate all addShaderParameter* methods
#define MAKE_HELPHER_FUNC_ADD_SHADER_PARAMETER(ParamType)\
 \
  template<typename ParamValueType>\
  SoShaderParameter ## ParamType *\
  addShaderParameter ## ParamType(const SbString& name, ParamValueType val)\
  {\
  return addShaderParameter<SoShaderParameter ## ParamType>(name, val);\
  }
  MAKE_HELPHER_FUNC_ADD_SHADER_PARAMETER(1i)
  MAKE_HELPHER_FUNC_ADD_SHADER_PARAMETER(2i)
  MAKE_HELPHER_FUNC_ADD_SHADER_PARAMETER(3i)
  MAKE_HELPHER_FUNC_ADD_SHADER_PARAMETER(4i)
  MAKE_HELPHER_FUNC_ADD_SHADER_PARAMETER(1f)
  MAKE_HELPHER_FUNC_ADD_SHADER_PARAMETER(2f)
  MAKE_HELPHER_FUNC_ADD_SHADER_PARAMETER(3f)
  MAKE_HELPHER_FUNC_ADD_SHADER_PARAMETER(4f)
  MAKE_HELPHER_FUNC_ADD_SHADER_PARAMETER(Array1f)
  MAKE_HELPHER_FUNC_ADD_SHADER_PARAMETER(Array2f)
  MAKE_HELPHER_FUNC_ADD_SHADER_PARAMETER(Array3f)
  MAKE_HELPHER_FUNC_ADD_SHADER_PARAMETER(Array4f)
  MAKE_HELPHER_FUNC_ADD_SHADER_PARAMETER(Array1i)
  MAKE_HELPHER_FUNC_ADD_SHADER_PARAMETER(Array2i)
  MAKE_HELPHER_FUNC_ADD_SHADER_PARAMETER(Array3i)
  MAKE_HELPHER_FUNC_ADD_SHADER_PARAMETER(Array4i)
  MAKE_HELPHER_FUNC_ADD_SHADER_PARAMETER(Matrix)
  MAKE_HELPHER_FUNC_ADD_SHADER_PARAMETER(Matrix3)
  MAKE_HELPHER_FUNC_ADD_SHADER_PARAMETER(MatrixArray)
#undef MAKE_HELPHER_FUNC_ADD_SHADER_PARAMETER
#endif //HIDDEN_FROM_DOC
 
  /*----------------------------------------------------------------------------*/
 
private:

  void setShaderObjectInfos(SoState* state, const SbString& shaderVersion, const SbString& shaderProfile);

  SourceType getSourceType();
 
  static void initClass();
  static void exitClass() ;

  SbBool isInternal() const;
 
  // Returns TRUE if at least one parameter is of SoShaderStateMatrixParameter type
  SbBool containStateMatrixParameters() const
  { return (m_stateMatrixParameters.getLength() != 0) ; }
 
  const SbString& getSourceProgram() const
  { return m_sourceProgram;}

  inline bool isFileFound() const;

  inline bool needUpdate() const { return m_needUpdate; }

  void invalidate();

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

  void removeDefine(const char* name);

  void checkValidity();

  inline void setVersion(const SbString& version) { m_version = version; }

  const SbString& getVersion();

  const SbString& getProfile();

  inline void setProfile(const SbString& profile) { m_profile = profile; }

  static bool isShaderObjectAvailable(SoState* state);

  static bool isGLSLLanguageAvailable(SoState* state);

  void invalidateSource();

  void buildSourceToLoad(SbString &builtSource);

  SbString getFileAbsolutePath(const SbString& filename);

  virtual void notify(SoNotList *list);

  void getHeaderFilenames( std::vector<SbString>& filenames );

  void setIsFixedPipeline(bool isFixedPipelineShader)
  {
    m_isFixedPipelineShader = isFixedPipelineShader;
  }

  bool isFixedPipeline() const
  {
    return m_isFixedPipelineShader;
  }
 
private:
 
  friend class SoShaderProgram;
  typedef SbConstCharMap<SbString> DefineMap;
  typedef DefineMap::iterator DefineMapIt;

  typedef std::vector<SbString> SbStringVector;

  void setGlobalDefine(const DefineMap& map);

  void setDefine(DefineMap::value_type& p);

  bool hasDefine(const char* name) const;

  typedef std::set<SbString> HeaderSet;
  typedef HeaderSet::iterator HeaderSetIt;

  void setGlobalHeader(const HeaderSet& map);
 
  // Extract the source from a given file if sourceType equals FILENAME.
  void readSource();

  SoShaderObject();
 
  // Destructor
  virtual ~SoShaderObject();
 
private:
  SoShaderParser* m_parser;
  SbString          m_sourceProgram;

  SbString m_version;
  SbString m_profile;
  typedef std::map<std::string, std::string> ExtensionMap;
  ExtensionMap m_extensionList;
 
  typedef std::map<SbString, SbString> StrStrMap;

  void extractInfosFromSource(SbString& version, SbString& source,SbString& profile, ExtensionMap& extensionList);

  bool isEmptyLine(const std::string& line) const;

  static SbString definesExtension(const SbString& source, const ExtensionMap::value_type& p);

  static SbString definesAcc(const SbString& source, const DefineMap::value_type& p);

  void getSourceFilename(std::vector<SbString>& filenames) const;

  DefineMap m_defineMap;

  DefineMap m_defineGlobalMap;

  HeaderSet m_headerGlobalSet;

  SbStringVector m_includeSourceVector;

  SbStringVector m_includeFilenameVector;

  SbString m_directoryFound;
 
  // Update the list of state matrix parameters
  void updateStateMatrixList() ;
 
  // Store the list of state matrix parameters
  SoNodeList    m_stateMatrixParameters ;
 
  // True if the shader can't be read
  bool m_fileFound;

  bool m_needUpdate;

  bool m_needRead;
 
  bool m_isFixedPipelineShader;

  static StrStrMap s_shadersPaths;
  static SbThreadRWMutex s_shadersPathsMutex;
  static bool s_debugCache;
};
/*----------------------------------------------------------------------------*/
 
/*******************************************************************************/
template<typename UniformParamType, typename ParamValueType>
UniformParamType*
SoShaderObject::addShaderParameter(const SbString& name, ParamValueType val)
{
  UniformParamType *param = dynamic_cast<UniformParamType *>(parameter.findUniformParameterByName(name));
  if (param)
  {
    // This parameter already exist => prefer to replace it
    param->value.setValue(val);
  }
  else
  {
    param = new UniformParamType;
    param->name = name;
    param->value.setValue(val);
    parameter.addShaderParameter(param);
  }
 
  return param;
}
 
/*****************************************************************************/
template<typename UniformParamType, typename ParamValueType>
void
SoShaderObject::setShaderParameter(const SbString& name, ParamValueType val)
{
  SoUniformShaderParameter* param = parameter.findUniformParameterByName(name);
  assert(param);
  assert(param->isOfType(UniformParamType::getClassTypeId()) == TRUE);
  UniformParamType* i = static_cast<UniformParamType*>(param);
  i->value = val;
}
 
/*****************************************************************************/
bool
SoShaderObject::isFileFound() const
{
  return m_fileFound;
}
 
#ifdef _MSC_VER
#pragma warning( pop )
#endif
 
#endif /*_SO_SHADER_OBJECT_H_*/