Inventor/nodes/SoShaderProgram.h

Go to the documentation of this file.

/*=======================================================================
 *** 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-2020 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/STL/vector>
#include <Inventor/STL/cassert>
#include <Inventor/helpers/SbConstCharMap.h>
#include <Inventor/elements/SoEnvironmentElement.h>

#ifdef _WIN32
#pragma warning(push)
#pragma warning(disable:4251)
#endif

class SoGLRenderAction;
class SoGLShaderProgram ;
class SoGLShaderObject;
class SoFieldSensor ;
class SoLight;
class SoCache;

/*----------------------------------------------------------------------------*/

class  SoShaderProgram : public SoNode
{

  SO_NODE_HEADER( 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;

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

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

  /*----------------------------------------------------------------------------*/

private:

  // GLRender
  virtual void doAction(SoAction *action);
  virtual void GLRender( SoGLRenderAction *action );
  virtual void getBoundingBox( SoGetBoundingBoxAction *action );
  virtual void pick( SoPickAction *action );

private:
  enum LightType
  {
    LIGHT_TYPE_NONE,
    LIGHT_TYPE_POINT,
    LIGHT_TYPE_SPOT,
    LIGHT_TYPE_DIRECTIONAL
  };

  enum EnvMode
  {
    ENV_MODE_MODULATE,
    ENV_MODE_REPLACE,
    ENV_MODE_DECAL,
    ENV_MODE_BLEND,
    ENV_MODE_ADD,
    ENV_MODE_NONE
  };

  enum TexGenMode
  {
    TEXGEN_TYPE_NONE,
    TEXGEN_TYPE_OBJECT_PLANE,
    TEXGEN_TYPE_REFLECTION_MAP,
    TEXGEN_TYPE_SPHERE_MAP,
    TEXGEN_TYPE_NORMAL_MAP,
    TEXGEN_TYPE_EYE_PLANE
  };

  enum GPUVendorType
  {
    GPU_TYPE_NOT_INITIALIZED = -1,
    GPU_NVIDIA = 0,
    GPU_ATI = 1,
    GPU_INTEL = 2,
    GPU_FIREPRO_MAC = 3
  };

  //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();

  // Update state matrix parameters of each shader object
  void updateStateMatrixParameters( SoState *state );

  // Returns TRUE if at least one parameter among all shader objects
  // is of SoShaderStateMatrixParameter type
  SbBool containStateMatrixParameters() const;

  void getAttribLocation(SoGLRenderAction* action, const char* paramName, int32_t identifier, int& firstInd);
  void getAttribSize(SoGLRenderAction* action, SoVertexShaderParameter * param, int& size);

  SoGLShaderProgram* getGLShaderProgram() const;

  void invalidate();

  void setModelMatrix(SoGLRenderAction* actio, const SbMatrix& modelMatrix);

  void setTwoSidedLighting(SoGLRenderAction* action);

  void setCounterClockWise(SoGLRenderAction* action);

  void setTexturing(SoGLRenderAction* action);

  void setViewMatrix(SoGLRenderAction* action, const SbMatrix& viewMatrix);

  void setProjectionMatrix(SoGLRenderAction* action, const SbMatrix& projectionMatrix);

  void setModelViewProjectionMatrix(SoGLRenderAction* action, const SbMatrix& mvpMatrix);

  void setNormalMatrix(SoGLRenderAction* action, const SbMatrix& normalMatrix);

  void setInstanceModelMatrix(SoGLRenderAction* action, const SbMatrix& instanceModelMatrix);

  void setInstanceUseMaterialColor(SoGLRenderAction* action, bool instanceUseMaterialColor);

  void setViewportSize(SoGLRenderAction* action, const SbVec2f& viewportSize);

  void setLight(SoGLRenderAction* action, int num, LightType type);

  void setClipPlaneParameters(SoGLRenderAction* action);

  void setShadowParameters(SoGLRenderAction* action);

  void setLights(SoGLRenderAction* action);

  void setFog(SoState* state);

  void sendLazyElementUniforms(SoState* state);

  void setBuiltInUniforms( SoGLRenderAction* action );

  SoGLShaderObject* getFirstGLShaderObject(SoState* state) const;

  void setShaderParameter1i(SoGLRenderAction* action, const char* paramName,
                            int value);
  void setShaderParameter2i(SoGLRenderAction* action, const char* paramName,
                            const SbVec2i32& value);
  void setShaderParameter3i(SoGLRenderAction* action, const char* paramName,
                            const SbVec3i32& value);
  void setShaderParameter4i(SoGLRenderAction* action, const char* paramName,
                            const SbVec4i32& value);
  void setShaderParameterArray1i(SoGLRenderAction* action, const char* paramName,
                                 size_t numElem, const int* values);
  void setShaderParameterArray2i(SoGLRenderAction* action, const char* paramName,
                                 size_t numElem, const SbVec2i32* values);
  void setShaderParameterArray3i(SoGLRenderAction* action, const char* paramName,
                                 size_t numElem, const SbVec3i32* values);
  void setShaderParameterArray4i(SoGLRenderAction* action, const char* paramName,
                                 size_t numElem, const SbVec4i32* values);
  void setShaderParameterArray1f(SoGLRenderAction* action, const char* paramName,
                                 size_t numElem, const float* values);
  void setShaderParameterArray2f(SoGLRenderAction* action, const char* paramName,
                                 size_t numElem, const SbVec2f* values);
  void setShaderParameterArray3f(SoGLRenderAction* action, const char* paramName,
                                 size_t numElem, const SbVec3f* values);
  void setShaderParameterArray4f(SoGLRenderAction* action, const char* paramName,
                                 size_t numElem, const SbVec4f* values);
  void setShaderParameter1f(SoGLRenderAction* action, const char* paramName,
                            float value);
  void setShaderParameter2f(SoGLRenderAction* action, const char* paramName,
                            const SbVec2f& value);
  void setShaderParameter3f(SoGLRenderAction* action, const char* paramName,
                            const SbVec3f& value);
  void setShaderParameter4f(SoGLRenderAction* action, const char* paramName,
                            const SbVec4f& value);
  void setShaderParameterMatrix(SoGLRenderAction* action, const char* paramName,
                                 const SbMatrix& matrix);

  void setShaderParameterMatrix4(SoGLRenderAction* action, const char* paramName,
                                 const SbMatrix& matrix);

  void disableLight(SoGLRenderAction* action, int num);

  void setLight(SoState* state, SoLight* light);

  void enableLighting(SoState* state, bool flag);

  void enableColorMaterial(SoState* state, bool flag);

  void enableTexturing(SoState* state, const std::vector<bool>& flag);

  void enableTexturing(SoState* state);

  void enableTexGen(SoState* state, TexGenMode mode);

  void setTexEnv(SoState* state, SoTexture::Model model);

  bool isGlslProgram() 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 SbConstCharMap<SoShaderObject*>& getHiddenShaderObjects() const;

  static GPUVendorType getGPUVendorType();

private:
  typedef std::vector<SoShaderObject*> ShaderObjectVector;
  typedef SbConstCharMap<SoShaderObject*> ShaderObjectMap;
  typedef SoShaderObject::DefineMap DefineMap;
  typedef SoShaderObject::HeaderSet HeaderSet;

  struct Members
  {
    Members();
    ~Members();
    void unref();

    ShaderObjectVector& getShadowShaderLib();

    SoGLShaderProgram *m_glShaderProgram;
    bool m_isShadowShader;
    std::vector<LightType> m_lights;

    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;

    // Checks dynamically the modifications geometry shader parameters
    bool m_geomParametersChanged;

    SoShaderProgram* m_shadowPassShader;

    SoCache* m_cache;

    DefineMap m_defineMap;

    HeaderSet m_headerMap;

    bool m_isValid;

    ShaderObjectVector m_shadowShaderLib;

    private:
      void createShadowShaderLib();

  };
  SbThreadStorage<Members*> m_members;

  void shadowMapGLRender(SoGLRenderAction* action);

  void shadowMapDoAction(SoAction* action);

  void initShadowMapShader(SoAction* action);

  virtual SoShaderProgram* generateShadowShader() const;

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

  enum
  {
    SHADOW_LIBRARY_FRAG,
    GENERATE_SHADOWMAP_FRAG,
    SHADOW_LIBRARY_VERT,
    SHADER_LAST
  };

  void addDefines(SoShaderObject* obj);

  void addHeaders(SoShaderObject* obj);

  void setShadowLibraryDefines(const ShaderObjectVector& shaderObjectsList);

  void updateCache(SoState *state);

  void addShadowLibrary(SoState* state, ShaderObjectVector& shaderObjectsList);

  void enableShadowLibrary(bool flag);

  void addHiddenShaderObjects(ShaderObjectVector& shaderObjectsList);

  static LightType lightToLightType(SoLight* light);

  static EnvMode modelToEnvMode(SoTexture::Model model);

  void updateLightState(SoLight* light);

  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 isUsingUniform(SoGLRenderAction* action, const char* uniformName);

  bool needOivViewMatrixUniforms(SoGLRenderAction* action);

  bool needOivProjectionMatrixUniforms(SoGLRenderAction* action);

  bool needOivModelMatrixUniforms(SoGLRenderAction* action);

  bool needOivModelViewProjMatrixUniforms(SoGLRenderAction* action);

  bool needOivNormalMatrixUniforms(SoGLRenderAction* action);

  bool needOivInstanceModelMatrixUniforms(SoGLRenderAction* action);

  bool needOivInstanceUseMaterialColor(SoGLRenderAction* action);

  bool needOivViewportSizeUniforms(SoGLRenderAction* action);

  bool hasShaderObjectsChanged() const;

  void updatePrevShaderObject();

  // Checks dynamically the modifications of shaders objects
  void shaderObjectSensorCB( void *data, SoSensor *sensor);

  static void invalidate(ShaderObjectMap::value_type& p);

  void addGPUVendorDefine();

  bool hasFragmentShader();

  void setShaderBufferObject(SoGLRenderAction* action);

private:
  SoCache* m_cache;

  int m_previousTransparencyType;

  static GPUVendorType s_gpuVendorType;

  static int s_firstUsedTextureUnit;

  static bool s_debugCache;
};
/*----------------------------------------------------------------------------*/

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

---

Open Inventor Toolkit reference manual, generated on 12 Feb 2024
Copyright © Thermo Fisher Scientific All rights reserved. http://www.openinventor.com/