GLSL.hpp

Go to the documentation of this file.

/**************************************************************************************/
/*                                                                                    */
/*  Visualization Library                                                             */
/*  http://visualizationlibrary.org                                                   */
/*                                                                                    */
/*  Copyright (c) 2005-2020, 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;

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

    
    static String processSource( const String& source );

  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 String& path) { mPath = path; }

    const String& path() const { return mPath; }

    bool reload();

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

    bool reload();

    void createProgram();

    void deleteProgram();

    unsigned int handle() const { return mHandle; }

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

    int getAttribLocation(const char* name) const
    {
      VL_CHECK_OGL();
      VL_CHECK( Has_GLSL )
      VL_CHECK( handle() )
      if( ! Has_GLSL || ! linked() ) {
        return -1;
      }
      int location = glGetAttribLocation( handle(), name );
      VL_CHECK_OGL();
      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 ---------------

    // --------------- 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 = NULL) const;

    int getUniformLocation(const char* name) const
    {
      VL_CHECK_OGL();
      VL_CHECK( Has_GLSL )
      VL_CHECK( handle() )
      if( ! Has_GLSL || ! linked() ) {
        return -1;
      }
      int location = glGetUniformLocation( handle(), name );
      VL_CHECK_OGL();
      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(); }

    int vl_WorldMatrix() const { return m_vl_WorldMatrix; }

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

    // --- vertex attribute binding ---

    int vl_VertexPosition() const { return m_vl_VertexPosition; }
    int vl_VertexNormal() const { return m_vl_VertexNormal; }
    int vl_VertexColor() const { return m_vl_VertexColor; }
    int vl_VertexSecondaryColor() const { return m_vl_VertexSecondaryColor; }
    int vl_VertexFogCoord() const { return m_vl_VertexFogCoord; }
    int vl_VertexTexCoord0() const { return m_vl_VertexTexCoord0; }
    int vl_VertexTexCoord1() const { return m_vl_VertexTexCoord1; }
    int vl_VertexTexCoord2() const { return m_vl_VertexTexCoord2; }
    int vl_VertexTexCoord3() const { return m_vl_VertexTexCoord3; }
    int vl_VertexTexCoord4() const { return m_vl_VertexTexCoord4; }
    int vl_VertexTexCoord5() const { return m_vl_VertexTexCoord5; }
    int vl_VertexTexCoord6() const { return m_vl_VertexTexCoord6; }
    int vl_VertexTexCoord7() const { return m_vl_VertexTexCoord7; }
    int vl_VertexTexCoord8() const { return m_vl_VertexTexCoord8; }
    int vl_VertexTexCoord9() const { return m_vl_VertexTexCoord9; }
    int vl_VertexTexCoord10() const { return m_vl_VertexTexCoord10; }

  private:
    void preLink();
    void postLink();
    void operator=(const GLSLProgram&) { }
    void resetBindingLocations();

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

    // glProgramParameter
    bool mProgramBinaryRetrievableHint;
    bool mProgramSeparable;

    // VL standard uniforms

    int m_vl_WorldMatrix;
    int m_vl_ModelViewMatrix;
    int m_vl_ProjectionMatrix;
    int m_vl_ModelViewProjectionMatrix;
    int m_vl_NormalMatrix;

    // VL standard vertex attributes

    int m_vl_VertexPosition;
    int m_vl_VertexNormal;
    int m_vl_VertexColor;
    int m_vl_VertexSecondaryColor;
    int m_vl_VertexFogCoord;
    int m_vl_VertexTexCoord0;
    int m_vl_VertexTexCoord1;
    int m_vl_VertexTexCoord2;
    int m_vl_VertexTexCoord3;
    int m_vl_VertexTexCoord4;
    int m_vl_VertexTexCoord5;
    int m_vl_VertexTexCoord6;
    int m_vl_VertexTexCoord7;
    int m_vl_VertexTexCoord8;
    int m_vl_VertexTexCoord9;
    int m_vl_VertexTexCoord10;
  };
}

#endif