MeVisLab/Standard/Sources/Inventor/SoShader/Inventor/misc/SoGLShaderProgram.h

Go to the documentation of this file.

// **InsertLicense** code



#ifndef  _SO_GL_SHADER_PROGRAM_
#define  _SO_GL_SHADER_PROGRAM_

#include "SoShaderSystem.h"
#include "Inventor/misc/SoGLShader.h"
#include "Inventor/misc/SoUniformParameterBase.h"
#include <Inventor/SbString.h>
#ifdef MEVISLAB
#include <mlGLResources.h>
#else
#include <Inventor/system/SbOpenGL.h>
#endif
#include <list>
#include <map>
#include <string>

class SoGLShaderObject;

class INVENTOR_SHADER_API SoGLShaderProgram : public SoGLShader, public SoUniformParameterBase
{
   typedef SoGLShader inherited;

   protected:
  
#ifdef MEVISLAB
      ml::GLSLProgram  _programRes;
#define PROGRAMHANDLE (_programRes.getHandle())
#endif
  
      GLint _geometryInputType;
      GLint _geometryOutputType;
      GLint _geometryVerticesOut;

   public:

      SoGLShaderProgram();
      
      virtual ~SoGLShaderProgram();
      
      virtual void  reset();

      void          addShaderObject(SoGLShaderObject *shaderObject);
      void          removeShaderObject(SoGLShaderObject *shaderObject);
      void          removeAllShaderObjects();

      void          enable(int context);
      void          disable();

      void          scheduleLinking();
  
      void          setGeometryInputType(GLint type) {
         if (_geometryInputType != type) { _geometryInputType = type; scheduleLinking(); }
      }
      void          setGeometryOutputType(GLint type) {
         if (_geometryOutputType != type) { _geometryOutputType = type; scheduleLinking(); }
      }
      void          setGeometryVerticesOut(GLint number) {
         if (_geometryVerticesOut != number) { _geometryVerticesOut = number; scheduleLinking(); }
      }
  
      virtual SbBool        isActiveUniform(const SbString &name);

      virtual void          clearAssignedTextureUnits() { _assignedTextureUnits = 0; }

      virtual int           addTextureSampler(const SbString &name);

      virtual void          set1f(const SbString &name, const float  value);
      virtual void          set2f(const SbString &name, const float *value);
      virtual void          set3f(const SbString &name, const float *value);
      virtual void          set4f(const SbString &name, const float *value);
      virtual void          set2f(const SbString &name, const float value0, const float value1);
      virtual void          set3f(const SbString &name, const float value0, const float value1, const float value2);
      virtual void          set4f(const SbString &name, const float value0, const float value1, const float value2, const float value3);

      virtual void          set1fv(const SbString &name, const int num, const float *value);
      virtual void          set2fv(const SbString &name, const int num, const float *value);
      virtual void          set3fv(const SbString &name, const int num, const float *value);
      virtual void          set4fv(const SbString &name, const int num, const float *value);

      virtual void          set1i(const SbString &name, const int32_t  value);
      virtual void          set2i(const SbString &name, const int32_t *value);
      virtual void          set2i(const SbString &name, const SbVec2s &value);
      virtual void          set3i(const SbString &name, const int32_t *value);
      virtual void          set3i(const SbString &name, const SbVec3s &value);
      virtual void          set4i(const SbString &name, const int32_t *value);
      
      virtual void          setMatrix3f(const SbString &name, const float *value, SbBool transpose = FALSE);
      virtual void          setMatrix4f(const SbString &name, const float *value, SbBool transpose = FALSE);

      SbBool        areAllContextsStillValid(int context);

      void setName(const SbString& name) { _name = name; }

      const SbString& getName() const { return _name; }

   SoINTERNAL public:

      enum LinkageResult {
         LR_FAILURE = 0,
         LR_SUCCESS = 1,
         LR_SKIPPED = 2
      };

#ifdef MEVISLAB
      ml::GLSLProgram &getProgramResource() {
         return _programRes;
      }
#endif
   
      GLuint        getProgramHandle() const {
         return PROGRAMHANDLE;
      }

      SbBool        isExecutable() const {
         return _isExecutable;
      }

      SbBool        shouldLink() const {
         return _shouldLink;
      }
   
      LinkageResult link(int context);

   protected:
  
      std::list<SoGLShaderObject *> _shaderObjects;
      SbBool                        _shouldLink;
      SbBool                        _isExecutable;

      SbString                      _name;

      int                           _assignedTextureUnits;

      struct UniformInfo {
         GLint  location;
         GLenum type;
         GLint  size;
         UniformInfo() : location(-1), type(GL_INT), size(0) {}
         UniformInfo(GLint _location, GLenum _type, GLint _size) : location(_location), type(_type), size(_size) {}
      };
      std::map<std::string, UniformInfo> _uniformInfo;

      GLint getUniform(const SbString &name, GLenum type, int *num = NULL);
};

#endif  // _SO_GL_SHADER_PROGRAM_