ShaderProgramPool.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
 */

/*
 * ShaderProgramPool.hh
 *
 *  Created on: Mar 6, 2009
 *      Author: africk
 */

#ifndef __SHADER_PROGRAMPOOL_HH__
#define __SHADER_PROGRAMPOOL_HH__

#include <OpenGLFramework/Base/glfShaderProgram.hh>
#include <OpenGLFramework/Base/glfMatrix.hh>
#include <OpenGLFramework/Base/glfException.hh>
#include <bias_config.h>
#include <map>
#include <list>

namespace BIAS
{

  /**
   * this class represents a set of shader programs
   * one can add and remove shader programs to and from the pool
   * all programs have unique names and can be accessed by the name
   * uniform variables of the shader programs can be set by addressing a program by its name
   * by setting a uniform variable it is checked, if a uniform variable of this type and with this name exists, if not an glfException is thrown
   * before using a shader program call : LinkAll();
   *
   * \ingroup g_openglframework 
   * \author frick
   **/
  class BIASOpenGLFramework_EXPORT ShaderProgramPool
  {
  public:

    //key: uniform type - list of uniform names
    typedef std::map<std::string, std::list<std::string> > uniforms_map_t;
    //pair of shader pointer - shader source
    typedef std::pair<glfShader*, std::string> shader_data_t;
    //key: shader_name - value: shader_data
    typedef std::map<std::string, shader_data_t> shader_map_t;
    //pair: program pointer - program uniform data
    typedef std::pair<glfShaderProgram*, uniforms_map_t> program_data_t;
    //key: program name - program_data
    typedef std::map<std::string, program_data_t> program_map_t;

    //###############################################################
    ShaderProgramPool();
    ~ShaderProgramPool();

    //###############################################################
    /**
     * adds a shader program with name shader_program_name to the shader pool
     * throws an glf exception if a program with this name already exists
     * @author frick
     */
    void
    AddShaderProgram(const std::string& shader_program_name);

    /**
     * adds a fragment shader with name shader_name and source code shader_source to the program with the name shader_program_name
     * throws an glf exception if a shader with this name already exists
     * @author frick
     */
    void
    AddFragmentShader(const std::string& shader_source,
        const std::string& shader_name, const std::string& shader_program_name);

    /**
     * adds a vertex shader with name shader_name and source code shader_source to the program with the name shader_program_name
     * throws an glf exception if a shader with this name already exists
     * @author frick
     */
    void
    AddVertexShader(const std::string& shader_source,
        const std::string& shader_name, const std::string& shader_program_name);

    /**
     * adds a fragment shader with name shader_name and source code in a file (path) to the program with the name shader_program_name
     * throws an glf exception if a shader with this name already exists
     * @author frick
     */
    void
    AddFragmentShaderFromFile(const std::string& path_to_shader,
        const std::string& shader_name, const std::string& shader_program_name);

    /**
     * adds a vertex shader with name shader_name and source code in a file (path) to the program with the name shader_program_name
     * throws an glf exception if a shader with this name already exists
     * @author frick
     */
    void
    AddVertexShaderFromFile(const std::string& path_to_shader,
        const std::string& shader_name, const std::string& shader_program_name);

    /**
     * removes a shader program with name shader_program_name to the shader pool
     * @author frick
     */
    void
    RemoveShaderProgram(const std::string& shader_program_name);

    /**
     * returns a vector with pairs (shader program name, shader program pointer) for all shader programs in the shader pool
     * @author frick
     */
    std::vector<std::pair<std::string, glfShaderProgram*> >
    GetShaderPrograms();

    /**
     * returns the pointer to the shader program with the name shader_program_name
     * if a program with this name does not exist NULL is returned
     * @author frick
     */
    glfShaderProgram*
    GetShaderProgram(const std::string& shader_program_name);

    /**
     * Links all shader program
     * after that the programs are ready to be bind and executed and uniform variables may be set
     * @author frick
     */
    void
    LinkAll();

    /**
     * returns true if all programs are linked, false otherwise
     * @author frick
     *
     */
    bool
    IsLinked();

    /**
     * Binds shader program with the given name
     * @author frick
     */
    void
    BindShaderProgram(const std::string& shader_program_name);

    /**
     * fills the vector shader_names with names of all shaders attached to the program with the name shader_program_name
     */
    void
    GetShaderNames(const std::string& shader_program_name, std::vector<
        std::string>& shader_names);

    /**
     * sets uniform variable varName for shader program shader_program_name
     * glfException is thrown if no uniform variables with such type and name exist in the shader program
     */
    template<class StorageType>
      void
      SetUniform(const std::string& shader_program_name,
          const std::string& varName, StorageType value);

    template<class StorageType>
      void
      SetUniformArray(const std::string& shader_program_name,
          const std::string& varName, StorageType values, int arg_number);

    /**
     * returns the type of uniform variable with name varName if such variable exists in the shader_program
     * otherwise an empty string is returned
     */
    std::string
    GetUniformType(const std::string& shader_program_name,
        const std::string& varName);

    /**
     * resets shader pool
     */
    void
    ClearAll();

  private:

    void
    AddShader_(GLenum type, const std::string& shader_source,
        const std::string& shader_name, const std::string& shader_program_name);

    shader_map_t*
    GetShadersMap_(const std::string& shader_program_name);

    shader_data_t*
    GetShaderData_(shader_map_t& shader_map, const std::string& shader_name);

    program_data_t*
    GetShaderProgramData_(const std::string& shader_program_name);

    uniforms_map_t*
    GetUniformMap_(program_data_t& program_data);

    glfShaderProgram*
    GetShaderProgram_(program_data_t& program_data);

    uniforms_map_t*
    GetUniformMap_(const std::string& shader_program_name);

    std::string*
    GetShaderSource_(shader_data_t& shader_data);

    glfShader*
    GetShader_(shader_data_t& shader_data);

    glfShader*
    GetShader_(const std::string& shader_program_name,
        const std::string& shader_name);

    void
    AddUniformDataFromSource_(program_data_t& shader_data,
        std::string shader_source);

    void
    AddUniformVariable_(program_data_t& shader_data, const std::string& type,
        const std::string& name);

    void
    LoadShaderFromFile_(const std::string& shader_path,
        std::string& shader_source);

    std::string RemoveCommentariesFromSource_(const std::string& source);

    //###############################################################


    //key: program name - value: pair program pointer - uniforms_map
    program_map_t program_map_;
    //key: program name - shader_map
    std::map<std::string, shader_map_t> shaders_;

    bool all_program_linked_;
    /* indicates if the programm requires linking.
     * This is required since linking erases all set uniforms.
     * A strategy that relinks everything after a new program has been
     * added would also require the ability to reset all set uniforms to
     * all unchanged but relinked programms. This would cause some overhead.
     * It is better to only relink when realy necessary, this is generally
     * correlated with a new set of uniforms and the user will provide
     * the required interaction.
     */
    std::map<std::string, bool> validitlyLinked_;

  };
}

#endif /* __SHADER_PROGRAMPOOL_HH__ */