glfShaderProgram.hh

/*
 This file is part of the BIAS library (Basic ImageAlgorithmS).

 Copyright (C)  2008, 2009    (see file CONTACT for details)
 Multimediale Systeme der Informationsverarbeitung
 Institut fuer Informatik
 Christian-Albrechts-Universitaet Kiel


 BIAS is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
 the Free Software Foundation; either version 2.1 of the License, or
 (at your option) any later version.

 BIAS is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU Lesser General Public License for more details.

 You should have received a copy of the GNU Lesser General Public License
 along with BIAS; if not, write to the Free Software
 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

#ifndef __glfShaderProgram_hh__
#define __glfShaderProgram_hh__

#include <Base/Math/Vector.hh>
#include <Base/Math/Matrix.hh>
#include "glfShader.hh"
#include "glfMatrix.hh"

namespace BIAS {

  /**
   * \brief A shader program composed of several shaders.
   * \ingroup g_openglframework
   * \author jkollmann
   */
  class BIASOpenGLFramework_EXPORT glfShaderProgram {
  public:
    glfShaderProgram();
    ~glfShaderProgram();

    /**
     * Creates the shader program. After this, you can attach shaders.
     */
    void Create();

    /**
     * Attaches a shader to the program. Must be called after glfShaderProgram::Create
     * and before glfShaderProgram::Link.
     */
    void AttachShader(const glfShader& shader);

    /**
     * Attaches a shader to the program, without the need to create an
     * instance of the <code>glfShader</code> class.
     * \param type Either GL_VERTEX_SHADER or GL_FRAGMENT_SHADER.
     * \param sourceCode The GLSL source code.
     */
    void AttachShaderFromSource(GLenum type, const std::string& sourceCode);

    /**
     * Attaches a shader to the program, without the need to create an
     * instance of the <code>glfShader</code> class. The source code of the
     * shader is loaded from a file.
     * \param type Either GL_VERTEX_SHADER or GL_FRAGMENT_SHADER.
     * \param fileName Name of file to load the GLSL source from.
     */
    void AttachShaderFromFile(GLenum type, const std::string& fileName);

    /**
     * Links the attached shaders. After this, the shader program can be used
     * for rendering.
     * \attention clears all set uniforms!
     */
    void Link();

    /**
     * Returns the info log containing information about the linking
     * of the shader program.
     * \note If linking the shader programs fails, the info log is also
     * contained in the message of the thrown exception.
     */
    std::string GetInfoLog() const;

    /** \name Methods to set uniform parameters.
        \note All double parameters are converted to floats, because OpenGL
        supports only float uniforms. 
        \attention Program has to be linked successfully.
        */
    /** @{ */
    void SetUniform(const std::string& varName, float value);
    void SetUniform(const std::string& varName, double value);
    void SetUniform(const std::string& varName, int value);
    void SetUniform(const std::string& varName, bool value);
    void SetUniform(const std::string& varName, int count, int *value);
    void SetUniform(const std::string& varName, int count, float *value);
    void SetUniform(const std::string& varName, const BIAS::Vector<float>& v);
    void SetUniform(const std::string& varName, const BIAS::Vector<double>& v);
    void SetUniform(const std::string& varName, const BIAS::Vector<int>& v);
    void SetUniform(const std::string& varName, const BIAS::Matrix<float>& m);
    void SetUniform(const std::string& varName, const BIAS::Matrix<double>& m);
    void SetUniform(const std::string& varName, const glfMatrix& m);

    /** Finds all sampler uniforms and automatically assigns them texture unit indices. 
    **/
    void AutoSetSamplerUniforms();
    /** @} */

//#ifdef BIAS_HAVE_OPENGL3
#ifdef GL_VERSION_3_0
    /** Binds vertex shader variable to vertex attrib slot. 
        \attention The settings will only be used when programm is (re)linked afterwards!
        \param indexSlot id for the vertex attribute slot
        \param VertexAttributeName name of varying variable in vertex shader source
     **/
    void BindAttribLocation(GLuint indexSlot, const std::string& VertexAttributeName);
#endif

    /**
     * Binds the shader program.
     */
    void Bind() const;

    static int GetMaxCombinedTextureUnits();
    
    GLuint GetProgramId() {return id_;}
    GLint GetUniformLocation(const std::string& varName);

  private:
    bool IsSamplerType_(GLenum type);
    GLint GetUniformLocation_(const std::string& varName);

    GLuint id_;

    /** An intuitive assignment operator should generate a copy, as long as nobody is willing to implement
     * the generation of a copy in gl controlled memory this operator cannot be used.
     */
    glfShaderProgram& operator=(const glfShaderProgram& b);
    
    /** An intuitive copy constructor should generate a copy, as long as nobody is willing to implement
     * the generation of a copy in gl controlled memory this constructor cannot be used.
     */
    glfShaderProgram(const glfShaderProgram& b);    


    std::vector<glfShader*> shaders_attached_from_source_;
    std::vector<GLuint> shaders_attached_as_object_;

  };

} // namespace BIAS

#endif // __glfShaderProgram_hh__