/home/master/UCL/VisualizationLibrary/src/vlGraphics/GLSL.hpp

Go to the documentation of this file.

/**************************************************************************************/
/*                                                                                    */
/*  Visualization Library                                                             */
/*  http://visualizationlibrary.org                                                   */
/*                                                                                    */
/*  Copyright (c) 2005-2010, Michele Bosi                                             */
/*  All rights reserved.                                                              */
/*                                                                                    */
/*  Redistribution and use in source and binary forms, with or without modification,  */
/*  are permitted provided that the following conditions are met:                     */
/*                                                                                    */
/*  - Redistributions of source code must retain the above copyright notice, this     */
/*  list of conditions and the following disclaimer.                                  */
/*                                                                                    */
/*  - Redistributions in binary form must reproduce the above copyright notice, this  */
/*  list of conditions and the following disclaimer in the documentation and/or       */
/*  other materials provided with the distribution.                                   */
/*                                                                                    */
/*  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND   */
/*  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED     */
/*  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE            */
/*  DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR  */
/*  ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES    */
/*  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;      */
/*  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON    */
/*  ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT           */
/*  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS     */
/*  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.                      */
/*                                                                                    */
/**************************************************************************************/

#ifndef GLSL_INCLUDE_ONCE
#define GLSL_INCLUDE_ONCE

#include <vlGraphics/UniformSet.hpp>
#include <vlCore/glsl_math.hpp>
#include <vlGraphics/RenderState.hpp>
#include <vlCore/String.hpp>

namespace vl
{
  class Uniform;

  //------------------------------------------------------------------------------
  // UniformInfo
  //------------------------------------------------------------------------------
  struct UniformInfo: public Object
  {
    UniformInfo(const char* name, EUniformType type, int size, int location)
    :Name(name), Type(type), Size(size), Location(location) {}

    std::string Name;  
    EUniformType Type; 
    int Size;          
    int Location;      
  };

  //------------------------------------------------------------------------------
  // AttribInfo
  //------------------------------------------------------------------------------
  struct AttribInfo: public Object
  {
    AttribInfo(const char* name, EAttributeType type, int size, int location)
    :Name(name), Type(type), Size(size), Location(location) {}

    std::string Name;    
    EAttributeType Type; 
    int Size;            
    int Location;        
  };

  //------------------------------------------------------------------------------
  // GLSLShader
  //------------------------------------------------------------------------------
  class VLGRAPHICS_EXPORT GLSLShader: public Object
  {
    VL_INSTRUMENT_CLASS(vl::GLSLShader, Object)

  public:
    GLSLShader();

    GLSLShader(EShaderType type, const String& source_or_path);

    ~GLSLShader();

    void setType(EShaderType type) { mType = type; }

    EShaderType type() const { return mType; }

    void setSource( const String& source_or_path );

    const std::string& source() const { return mSource; }

    void setPath(const char* path) { mPath = path; }

    const std::string& path() const { return mPath; }

    std::string getShaderSource() const;

    bool compile();

    bool compileStatus() const;

    String infoLog() const;

    void createShader();

    void deleteShader();

    unsigned int handle() const { return mHandle; }

  protected:
    EShaderType mType;
    std::string mSource;
    std::string mPath;
    unsigned int mHandle;
    bool mCompiled;
  };
  //------------------------------------------------------------------------------
  class GLSLVertexShader: public GLSLShader
  {
    VL_INSTRUMENT_CLASS(vl::GLSLVertexShader, GLSLShader)

  public:
    GLSLVertexShader(const String& source=String()): GLSLShader(ST_VERTEX_SHADER, source)
    {
      #ifndef NDEBUG
        if (mObjectName.empty())
          mObjectName = className();
      #endif
    }
  };
  //------------------------------------------------------------------------------
  class GLSLFragmentShader: public GLSLShader
  {
    VL_INSTRUMENT_CLASS(vl::GLSLFragmentShader, GLSLShader)

  public:
    GLSLFragmentShader(const String& source=String()): GLSLShader(ST_FRAGMENT_SHADER, source)
    {
      #ifndef NDEBUG
        if (mObjectName.empty())
          mObjectName = className();
      #endif
    }
  };
  //------------------------------------------------------------------------------
  class GLSLGeometryShader: public GLSLShader
  {
    VL_INSTRUMENT_CLASS(vl::GLSLGeometryShader, GLSLShader)

  public:
    GLSLGeometryShader(const String& source=String()): GLSLShader(ST_GEOMETRY_SHADER, source)
    {
      #ifndef NDEBUG
        if (mObjectName.empty())
          mObjectName = className();
      #endif
    }
  };
  //------------------------------------------------------------------------------
  class GLSLTessControlShader: public GLSLShader
  {
    VL_INSTRUMENT_CLASS(vl::GLSLTessControlShader, GLSLShader)

  public:
    GLSLTessControlShader(const String& source=String()): GLSLShader(ST_TESS_CONTROL_SHADER, source)
    {
      #ifndef NDEBUG
        if (mObjectName.empty())
          mObjectName = className();
      #endif
    }
  };
  //------------------------------------------------------------------------------
  class GLSLTessEvaluationShader: public GLSLShader
  {
    VL_INSTRUMENT_CLASS(vl::GLSLTessEvaluationShader, GLSLShader)

  public:
    GLSLTessEvaluationShader(const String& source=String()): GLSLShader(ST_TESS_EVALUATION_SHADER, source)
    {
      #ifndef NDEBUG
        if (mObjectName.empty())
          mObjectName = className();
      #endif
    }
  };
  //------------------------------------------------------------------------------
  // GLSLProgram
  //------------------------------------------------------------------------------
  class VLGRAPHICS_EXPORT GLSLProgram: public RenderStateNonIndexed
  {
    VL_INSTRUMENT_CLASS(vl::GLSLProgram, RenderStateNonIndexed)

    // applyUniform
    friend class Renderer;
  public:
    GLSLProgram();

    ~GLSLProgram();

    virtual ERenderState type() const { return RS_GLSLProgram; }

    virtual ref<RenderState> clone() const
    {
      ref<GLSLProgram> rs = new GLSLProgram;
      *rs = *this;
      return rs;
    }

    GLSLProgram& operator=(const GLSLProgram& other);

    void createProgram();

    void deleteProgram();

    unsigned int handle() const { return mHandle; }

    bool useProgram() const;

    void apply(int index, const Camera*, OpenGLContext* ctx) const;

    bool linkProgram(bool force_relink = false);

    bool linkStatus() const;

    bool linked() const { return mHandle && !mScheduleLink; }

    void scheduleRelinking() { mScheduleLink = true; }

    bool attachShader(GLSLShader* shader);

    bool detachShader(GLSLShader* shader);

    void discardAllShaders();

    String infoLog() const;

    bool validateProgram() const;

    void bindAttribLocation(unsigned int index, const char* name);

    void addAutoAttribLocation(int attr_index, const char* attr_name) { mAutoAttribLocation[attr_name] = attr_index; mScheduleLink = true; }

    void removeAutoAttribLocation(const char* attr_name) { mAutoAttribLocation.erase(attr_name); mScheduleLink = true; }

    void setAutoAttribLocations(const std::map<std::string, int>& attrib_bindings) { mAutoAttribLocation = attrib_bindings; mScheduleLink = true; }

    const std::map<std::string, int>& autoAttribLocations() const { return  mAutoAttribLocation; }

    void clearAutoAttribLocations() { mAutoAttribLocation.clear(); }

    int getAttribLocation(const char* name) const
    {
      VL_CHECK( Has_GLSL )
      if( !Has_GLSL )
        return -1;
      VL_CHECK(handle())
      VL_CHECK(linked())
      int location = glGetAttribLocation(handle(), name);
      return location;
    }

    int shaderCount() const { return (int)mShaders.size(); }

    const GLSLShader* shader(int i) const { return mShaders[i].get(); }

    GLSLShader* shader(int i) { return mShaders[i].get(); }

    void detachAllShaders();

    // --------------- bind frag data location ---------------

    void bindFragDataLocation(int color_number, const char* name);

    void unbindFragDataLocation(const char* name);

    int fragDataLocation(const char* name) const;

    const std::map<std::string, int>& fragDataLocations() const { return mFragDataLocation; }

    // --------------- geometry shader ---------------

    void setGeometryVerticesOut(int vertex_count) 
    { 
      if (mGeometryVerticesOut != vertex_count)
      {
        scheduleRelinking(); 
        mGeometryVerticesOut = vertex_count; 
      }
    }

    int geometryVerticesOut() const { return mGeometryVerticesOut; }

    void setGeometryInputType(EGeometryInputType type) 
    { 
      if (mGeometryInputType != type)
      {
        scheduleRelinking(); 
        mGeometryInputType = type; 
      }
    }
    EGeometryInputType geometryInputType() const { return mGeometryInputType; }

    void setGeometryOutputType(EGeometryOutputType type) 
    { 
      if (mGeometryOutputType != type)
      {
        scheduleRelinking(); 
        mGeometryOutputType = type; 
      }
    }
    
    EGeometryOutputType geometryOutputType() const { return mGeometryOutputType; }

    // --------------- GLSL 4.x ---------------

    void setProgramBinaryRetrievableHint(bool hint) { mProgramBinaryRetrievableHint = hint; }
    
    bool programBinaryRetrievableHint() const { return mProgramBinaryRetrievableHint; }

    void setProgramSeparable(bool separable) 
    { 
      if (mProgramSeparable != separable)
      {
        scheduleRelinking();
        mProgramSeparable = separable; 
      }
    }

    bool programSeparable() const { return mProgramSeparable; }

    bool getProgramBinary(GLenum& binary_format, std::vector<unsigned char>& binary) const;

    bool programBinary(GLenum binary_format, const std::vector<unsigned char>& binary) { return programBinary(binary_format, &binary[0], (int)binary.size()); }

    bool programBinary(GLenum binary_format, const void* binary, int length);

    // --------------- uniform variables ---------------

    bool applyUniformSet(const UniformSet* uniforms) const;

    int getUniformLocation(const char* name) const
    {
      VL_CHECK( Has_GLSL )
      if( !Has_GLSL )
        return -1;
      VL_CHECK(linked())

      int location = glGetUniformLocation(handle(), name);
      return location;
    }

    // --------------- uniform variables: getters ---------------

    // general uniform getters: use these to access to all the types supported by your GLSL implementation,
    // and not only the ordinary fvec2, fvec3, fvec4, ivec2, ivec3, ivec4, fmat2, fmat3, fmat4

    void getUniformfv(int location, float* params) const
    {
      VL_CHECK( Has_GLSL )
      if( !Has_GLSL )
        return;
      VL_CHECK(linked())
      VL_CHECK(handle())
      glGetUniformfv(handle(), location, params); VL_CHECK_OGL()
    }
    void getUniformfv(const char* name, float* params) const { getUniformfv(getUniformLocation(name), params); }
    void getUniformiv(int location, int* params) const
    {
      VL_CHECK( Has_GLSL )
      if( !Has_GLSL )
        return;
      VL_CHECK(linked())
      VL_CHECK(handle())
      glGetUniformiv(handle(), location, params); VL_CHECK_OGL()
    }
    void getUniformiv(const char* name, int* params) const { getUniformiv(getUniformLocation(name), params); }

    // utility functions for fvec2, fvec3, fvec4, ivec2, ivec3, ivec4, fmat2, fmat3, fmat4

    void getUniform(int location, fvec2& vec) const { getUniformfv(location, vec.ptr()); }
    void getUniform(int location, fvec3& vec) const { getUniformfv(location, vec.ptr()); }
    void getUniform(int location, fvec4& vec) const { getUniformfv(location, vec.ptr()); }
    void getUniform(int location, fmat2& mat) const { getUniformfv(location, mat.ptr()); }
    void getUniform(int location, fmat3& mat) const { getUniformfv(location, mat.ptr()); }
    void getUniform(int location, fmat4& mat) const { getUniformfv(location, mat.ptr()); }
    void getUniform(int location, ivec2& vec) const { getUniformiv(location, vec.ptr()); }
    void getUniform(int location, ivec3& vec) const { getUniformiv(location, vec.ptr()); }
    void getUniform(int location, ivec4& vec) const { getUniformiv(location, vec.ptr()); }
    void getUniform(const char* name, fvec2& vec) const { getUniform(getUniformLocation(name), vec); }
    void getUniform(const char* name, fvec3& vec) const { getUniform(getUniformLocation(name), vec); }
    void getUniform(const char* name, fvec4& vec) const { getUniform(getUniformLocation(name), vec); }
    void getUniform(const char* name, fmat2& mat) const { getUniform(getUniformLocation(name), mat); }
    void getUniform(const char* name, fmat3& mat) const { getUniform(getUniformLocation(name), mat); }
    void getUniform(const char* name, fmat4& mat) const { getUniform(getUniformLocation(name), mat); }
    void getUniform(const char* name, ivec2& vec) const { getUniform(getUniformLocation(name), vec); }
    void getUniform(const char* name, ivec3& vec) const { getUniform(getUniformLocation(name), vec); }
    void getUniform(const char* name, ivec4& vec) const { getUniform(getUniformLocation(name), vec); }

    UniformSet* getUniformSet() { return mUniformSet.get(); }
    const UniformSet* getUniformSet() const { return mUniformSet.get(); }
    void setUniformSet(UniformSet* uniforms) { mUniformSet = uniforms; }
    void setUniform(Uniform* uniform) { if (!getUniformSet()) setUniformSet(new UniformSet); getUniformSet()->setUniform(uniform); }
    Uniform* getUniform(const char* name) { if (!getUniformSet()) return NULL; return getUniformSet()->getUniform(name); }
    Uniform* gocUniform(const char* name) { if (!getUniformSet()) setUniformSet(new UniformSet); return getUniformSet()->gocUniform(name); }
    void eraseUniform(const char* name) { if(getUniformSet()) getUniformSet()->eraseUniform(name); }
    void eraseUniform(const Uniform* uniform) { if(getUniformSet()) getUniformSet()->eraseUniform(uniform); }
    void eraseAllUniforms() { if(getUniformSet()) getUniformSet()->eraseAllUniforms(); }

    const std::map<std::string, ref<UniformInfo> >& activeUniforms() const { return mActiveUniforms; }

    const UniformInfo* activeUniformInfo(const char* name) const 
    { 
      std::map<std::string, ref<UniformInfo> >::const_iterator it = mActiveUniforms.find(name);
      if (it == mActiveUniforms.end())
        return NULL;
      else
        return it->second.get();
    }

    const std::map<std::string, ref<AttribInfo> >& activeAttribs() const { return mActiveAttribs; }

    const AttribInfo* activeAttribInfo(const char* name) const 
    { 
      std::map<std::string, ref<AttribInfo> >::const_iterator it = mActiveAttribs.find(name);
      if (it == mActiveAttribs.end())
        return NULL;
      else
        return it->second.get();
    }

    int vl_ModelViewMatrix() const { return m_vl_ModelViewMatrix; }

    int vl_ProjectionMatrix() const  { return m_vl_ProjectionMatrix; }

    int vl_ModelViewProjectionMatrix() const  { return m_vl_ModelViewProjectionMatrix; }

    int vl_NormalMatrix() const { return m_vl_NormalMatrix; }

  private:
    void preLink();
    void postLink();

  protected:
    std::vector< ref<GLSLShader> > mShaders;
    std::map<std::string, int> mFragDataLocation;
    std::map<std::string, ref<UniformInfo> > mActiveUniforms;
    std::map<std::string, ref<AttribInfo> > mActiveAttribs;
    std::map<std::string, int> mAutoAttribLocation;
    ref<UniformSet> mUniformSet;
    unsigned int mHandle;
    bool mScheduleLink;

    // glProgramParameter
    int mGeometryVerticesOut;
    EGeometryInputType mGeometryInputType;
    EGeometryOutputType mGeometryOutputType;
    bool mProgramBinaryRetrievableHint;
    bool mProgramSeparable;

    int m_vl_ModelViewMatrix;
    int m_vl_ProjectionMatrix;
    int m_vl_ModelViewProjectionMatrix;
    int m_vl_NormalMatrix;
  };
}

#endif