D:/VL/BuildSystem/VL_DISTRO/Visualization_Library_SDK/src/vlGraphics/GLSL.hpp

Go to the documentation of this file.

/**************************************************************************************/
/*                                                                                    */
/*  Visualization Library                                                             */
/*  http://www.visualizationlibrary.com                                               */
/*                                                                                    */
/*  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/GLSLmath.hpp>
#include <vlGraphics/RenderState.hpp>
#include <vlCore/String.hpp>

namespace vl
{
  class Uniform;

  //------------------------------------------------------------------------------
  // GLSLShader
  //------------------------------------------------------------------------------
  class VLGRAPHICS_EXPORT GLSLShader: public Object
  {
  public:
    GLSLShader(EShaderType type, const String& source=String());

    ~GLSLShader();

    virtual const char* className() { return "vl::Unnamed GLSLShader"; }

    EShaderType type() const { return mType; }

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

    bool compile();

    bool compileStatus() const;

    String infoLog() const;

    void createShader();

    void deleteShader();

    unsigned int handle() const { return mHandle; }

  protected:
    EShaderType mType;
    std::string mSource;
    unsigned int mHandle;
    bool mCompiled;
  };
  //------------------------------------------------------------------------------
  class GLSLVertexShader: public GLSLShader
  {
  public:
    GLSLVertexShader(const String& source=String()): GLSLShader(ST_VERTEX_SHADER, source)
    {
      #ifndef NDEBUG
        if (mObjectName.empty())
          mObjectName = className();
      #endif
    }
    virtual const char* className() { return "vl::GLSLVertexShader"; }
  };
  //------------------------------------------------------------------------------
  class GLSLFragmentShader: public GLSLShader
  {
  public:
    GLSLFragmentShader(const String& source=String()): GLSLShader(ST_FRAGMENT_SHADER, source)
    {
      #ifndef NDEBUG
        if (mObjectName.empty())
          mObjectName = className();
      #endif
    }
    virtual const char* className() { return "vl::GLSLFragmentShader"; }
  };
  //------------------------------------------------------------------------------
  class GLSLGeometryShader: public GLSLShader
  {
  public:
    GLSLGeometryShader(const String& source=String()): GLSLShader(ST_GEOMETRY_SHADER, source)
    {
      #ifndef NDEBUG
        if (mObjectName.empty())
          mObjectName = className();
      #endif
    }
    virtual const char* className() { return "vl::GLSLGeometryShader"; }
  };
  //------------------------------------------------------------------------------
  class GLSLTessControlShader: public GLSLShader
  {
  public:
    GLSLTessControlShader(const String& source=String()): GLSLShader(ST_TESS_CONTROL_SHADER, source)
    {
      #ifndef NDEBUG
        if (mObjectName.empty())
          mObjectName = className();
      #endif
    }
    virtual const char* className() { return "vl::GLSLTessControlShader"; }
  };
  //------------------------------------------------------------------------------
  class GLSLTessEvaluationShader: public GLSLShader
  {
  public:
    GLSLTessEvaluationShader(const String& source=String()): GLSLShader(ST_TESS_EVALUATION_SHADER, source)
    {
      #ifndef NDEBUG
        if (mObjectName.empty())
          mObjectName = className();
      #endif
    }
    virtual const char* className() { return "vl::GLSLTessEvaluationShader"; }
  };
  //------------------------------------------------------------------------------
  // GLSLProgram
  //------------------------------------------------------------------------------
  class VLGRAPHICS_EXPORT GLSLProgram: public RenderState
  {
    // applyUniform
    friend class Renderer;
  public:
    GLSLProgram();

    ~GLSLProgram();

    virtual const char* className() { return "vl::GLSLProgram"; }

    virtual ERenderState type() const { return RS_GLSLProgram; }

    void createProgram();

    void deleteProgram();

    unsigned int handle() const { return mHandle; }

    bool useProgram() const;

    void apply(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 std::string& name);

    void addAutoAttribLocation(const char* attr_name, int attr_index) { 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( GLEW_Has_Shading_Language_20 )
      if( !GLEW_Has_Shading_Language_20 )
        return -1;
      VL_CHECK(handle())
      VL_CHECK(linked())
      int location = glGetAttribLocation(handle(), name);
      return location;
    }

    static int maxVertexAttribs();

    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 std::string& name);
    void unbindFragDataLocation(const std::string& name);
    int fragDataLocationBinding(const std::string& name) const;

    // --------------- 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 std::string& name) const
    {
      VL_CHECK( GLEW_Has_Shading_Language_20 )
      if( !GLEW_Has_Shading_Language_20 )
        return -1;
      VL_CHECK(linked())

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

    int getUniformLocation(const char* name) const
    {
      VL_CHECK( GLEW_Has_Shading_Language_20 )
      if( !GLEW_Has_Shading_Language_20 )
        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( GLEW_Has_Shading_Language_20 )
      if( !GLEW_Has_Shading_Language_20 )
        return;
      VL_CHECK(linked())
      VL_CHECK(handle())
      glGetUniformfv(handle(), location, params); VL_CHECK_OGL()
    }
    void getUniformfv(const std::string& name, float* params) const { getUniformfv(getUniformLocation(name), params); }
    void getUniformiv(int location, int* params) const
    {
      VL_CHECK( GLEW_Has_Shading_Language_20 )
      if( !GLEW_Has_Shading_Language_20 )
        return;
      VL_CHECK(linked())
      VL_CHECK(handle())
      glGetUniformiv(handle(), location, params); VL_CHECK_OGL()
    }
    void getUniformiv(const std::string& 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 std::string& name, fvec2& vec) const { getUniform(getUniformLocation(name), vec); }
    void getUniform(const std::string& name, fvec3& vec) const { getUniform(getUniformLocation(name), vec); }
    void getUniform(const std::string& name, fvec4& vec) const { getUniform(getUniformLocation(name), vec); }
    void getUniform(const std::string& name, fmat2& mat) const { getUniform(getUniformLocation(name), mat); }
    void getUniform(const std::string& name, fmat3& mat) const { getUniform(getUniformLocation(name), mat); }
    void getUniform(const std::string& name, fmat4& mat) const { getUniform(getUniformLocation(name), mat); }
    void getUniform(const std::string& name, ivec2& vec) const { getUniform(getUniformLocation(name), vec); }
    void getUniform(const std::string& name, ivec3& vec) const { getUniform(getUniformLocation(name), vec); }
    void getUniform(const std::string& name, ivec4& vec) const { getUniform(getUniformLocation(name), vec); }

    // mic fixme: documenta la differenza tra vari tipi di Uniforms, "see also" tutte le funzioni sotto, documenta il fatto che non devono esserci collisioni.

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

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

    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, int> mActiveUniformLocation;
    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