GLSLShader.cc

/*===========================================================================*\
 *                                                                           *
 *                              OpenFlipper                                  *
 *           Copyright (c) 2001-2015, RWTH-Aachen University                 *
 *           Department of Computer Graphics and Multimedia                  *
 *                          All rights reserved.                             *
 *                            www.openflipper.org                            *
 *                                                                           *
 *---------------------------------------------------------------------------*
 * This file is part of OpenFlipper.                                         *
 *---------------------------------------------------------------------------*
 *                                                                           *
 * Redistribution and use in source and binary forms, with or without        *
 * modification, are permitted provided that the following conditions        *
 * are met:                                                                  *
 *                                                                           *
 * 1. Redistributions of source code must retain the above copyright notice, *
 *    this list of conditions and the following disclaimer.                  *
 *                                                                           *
 * 2. 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.   *
 *                                                                           *
 * 3. Neither the name of the copyright holder nor the names of its          *
 *    contributors may be used to endorse or promote products derived from   *
 *    this software without specific prior written permission.               *
 *                                                                           *
 * 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.              *
 *                                                                           *
\*===========================================================================*/
 
 
 
#include <ACG/GL/acg_glew.hh>
 
#include <QApplication>
#include <QDir>
 
#include <iostream>
#include <fstream>
 
#include <ACG/GL/gl.hh>
#include <ACG/GL/GLState.hh>
#include <ACG/GL/GLError.hh>
 
#include "GLSLShader.hh"
#include <ACG/GL/ShaderGenerator.hh>
 
#ifdef WIN32
  #ifndef __MINGW32__
    #define snprintf sprintf_s
  #endif 
#endif
 
//==============================================================================
 
namespace GLSL {
 
  //--------------------------------------------------------------------------
  // Generic shader
  //--------------------------------------------------------------------------
 
  Shader::Shader(GLenum shaderType)
  : m_shaderId(0)
  {
 
    if ( !ACG::openGLVersion(2,0) ) {
      std::cerr << "Shaders not supported with OpenGL Version less than 2.0" << std::endl;
      return;
    }
 
    this->m_shaderId = glCreateShader(shaderType);
    if ( this->m_shaderId == 0 ) {
      std::cerr << "could not create shader" << std::endl;
    }
 
  }
 
  Shader::~Shader() {
    if (this->m_shaderId) {
      glDeleteShader(m_shaderId);
    }
  }
 
  void Shader::setSource(const StringList& source)  {
 
    if ( this->m_shaderId == 0 ) {
      std::cerr << "shader not initialized" << std::endl;
      return;
    }
 
    const char **stringArray = new const char*[source.size()];
 
    int index = 0;
    for (StringList::const_iterator it = source.begin();it != source.end();++it) {
      stringArray[index] = (*it).c_str();
      ++index;
    }
 
    glShaderSource(this->m_shaderId, int(source.size()), stringArray, 0);
 
    delete[] stringArray;
  }
 
 
  void Shader::setSource(const QStringList& source)  {
 
    if ( this->m_shaderId == 0 ) {
      std::cerr << "shader not initialized" << std::endl;
      return;
    }
 
    StringList strlist;
 
    for (QStringList::const_iterator it = source.begin();it != source.end();++it)
      strlist.push_back(std::string((const char*)it->toLatin1()) + '\n');
 
    setSource(strlist);
  }
 
  bool Shader::compile(bool verbose) {
    if ( this->m_shaderId == 0 ) {
      std::cerr << "shader not initialized" << std::endl;
      return false;
    }
 
    glCompileShader(m_shaderId);
 
    GLint compileStatus;
    glGetShaderiv(m_shaderId, GL_COMPILE_STATUS, &compileStatus);
    if (compileStatus == GL_FALSE) {
 
      if (verbose) {
        GLchar *errorLog = new GLchar[GLSL_MAX_LOGSIZE];
        GLsizei errorLength, srcLength;
        glGetShaderiv(m_shaderId, GL_SHADER_SOURCE_LENGTH, &srcLength);
        GLchar* shaderSource = new GLchar[srcLength];
        glGetShaderSource(m_shaderId, srcLength, &errorLength, shaderSource);
        std::cout << "shader source: " << std::endl << shaderSource << std::endl;
        glGetShaderInfoLog(m_shaderId, GLSL_MAX_LOGSIZE, &errorLength, errorLog);
        std::cout << "GLSL compile error:" << std::endl << errorLog << std::endl;
 
        delete[] shaderSource;
        delete[] errorLog;
      }
 
      return false;
    }
    return true;
  }
 
  //--------------------------------------------------------------------------
  // Vertex shader
  //--------------------------------------------------------------------------
 
  VertexShader::VertexShader() : Shader(GL_VERTEX_SHADER) {}
  VertexShader::~VertexShader() {}
 
  //--------------------------------------------------------------------------
  // Fragment shader
  //--------------------------------------------------------------------------
 
  FragmentShader::FragmentShader() : Shader(GL_FRAGMENT_SHADER) {}
  FragmentShader::~FragmentShader() {}
 
  //--------------------------------------------------------------------------
  // Geometry shader
  //--------------------------------------------------------------------------
 
  GeometryShader::GeometryShader() : Shader(GL_GEOMETRY_SHADER_EXT) {}
  GeometryShader::~GeometryShader() {}
 
  //--------------------------------------------------------------------------
  // Tessellation-Control shader
  //--------------------------------------------------------------------------
 
#ifdef GL_ARB_tessellation_shader
 
  TessControlShader::TessControlShader() : Shader(GL_TESS_CONTROL_SHADER) {}
  TessControlShader::~TessControlShader() {}
 
  //--------------------------------------------------------------------------
  // Tessellation-Evaluation shader
  //--------------------------------------------------------------------------
 
  TessEvaluationShader::TessEvaluationShader() : Shader(GL_TESS_EVALUATION_SHADER) {}
  TessEvaluationShader::~TessEvaluationShader() {}
 
#endif // GL_ARB_tessellation_shader
 
  //--------------------------------------------------------------------------
  // Compute shader
  //--------------------------------------------------------------------------
 
 
  ComputeShader::Caps ComputeShader::caps_;
  bool ComputeShader::capsInitialized_ = false;
 
  ComputeShader::ComputeShader() : Shader(
#ifdef GL_ARB_compute_shader
    GL_COMPUTE_SHADER
#else
    0
#endif
    ) {}
  ComputeShader::~ComputeShader() {}
 
  const ComputeShader::Caps& ComputeShader::caps() {
    if (!capsInitialized_) {
      capsInitialized_ = true;
 
#ifdef GL_ARB_compute_shader
      glGetIntegerv(GL_MAX_COMPUTE_UNIFORM_BLOCKS, &caps_.maxUniformBlocks_);
      glGetIntegerv(GL_MAX_COMPUTE_TEXTURE_IMAGE_UNITS, &caps_.maxTextureImageUnits_);
      glGetIntegerv(GL_MAX_COMPUTE_IMAGE_UNIFORMS, &caps_.maxImageUniforms_);
      glGetIntegerv(GL_MAX_COMPUTE_SHARED_MEMORY_SIZE, &caps_.maxSharedMemorySize_);
      glGetIntegerv(GL_MAX_COMPUTE_UNIFORM_COMPONENTS, &caps_.maxUniformComponents_);
      glGetIntegerv(GL_MAX_COMPUTE_ATOMIC_COUNTER_BUFFERS, &caps_.maxAtomicCounterBufs_);
      glGetIntegerv(GL_MAX_COMPUTE_ATOMIC_COUNTERS, &caps_.maxAtomicCounters_);
      glGetIntegerv(GL_MAX_COMBINED_COMPUTE_UNIFORM_COMPONENTS, &caps_.maxCombinedUniformComponents_);
      glGetIntegerv(GL_MAX_COMPUTE_WORK_GROUP_INVOCATIONS, &caps_.maxWorkGroupInvocations_);
 
      for (int i = 0; i < 3; ++i) {
        glGetIntegeri_v(GL_MAX_COMPUTE_WORK_GROUP_COUNT, 0, caps_.maxWorkGroupCount_ + i);
        glGetIntegeri_v(GL_MAX_COMPUTE_WORK_GROUP_SIZE, 0, caps_.maxWorkGroupSize_ + i);
      }
#else
      memset(&caps_, 0, sizeof(caps_));
#endif
    }
    return caps_;
  }
 
  //--------------------------------------------------------------------------
  // Shader program object
  //--------------------------------------------------------------------------
 
  Program::Program() : m_programId(0), m_linkStatus(GL_FALSE) {
    if ( !ACG::openGLVersion(2,0) ) {
      std::cerr << "Shaders not supported with OpenGL Version less than 2.0" << std::endl;
      return;
    }
 
    this->m_programId = glCreateProgram();
 
    if ( this->m_programId == 0 ) {
      std::cerr << "could not create GLSL program" << std::endl;
      return;
    }
 
  }
 
  Program::~Program() {
    if (this->m_programId) {
      glDeleteProgram(this->m_programId);
    }
    // free linked shaders
    this->m_linkedShaders.clear();
  }
 
  void Program::attach(PtrConstShader _shader) {
    if ( this->m_programId == 0 ) {
      std::cerr << "attach invalid program" << std::endl;
      return;
    }
 
    if ( _shader->m_shaderId == 0 ) {
      std::cerr << "attach invalid shader" << std::endl;
      return;
    }
 
    glAttachShader(this->m_programId, _shader->m_shaderId);
    m_linkedShaders.push_back(_shader);
  }
 
  void Program::detach(PtrConstShader _shader) {
    if ( this->m_programId == 0 ) {
      std::cerr << "detach invalid program" << std::endl;
      return;
    }
 
    if ( _shader->m_shaderId == 0 ) {
      std::cerr << "detach invalid shader" << std::endl;
      return;
    }
 
    glDetachShader(this->m_programId, _shader->m_shaderId);
    m_linkedShaders.remove(_shader);
  }
 
  void Program::link() {
    glLinkProgram(this->m_programId);
    checkGLError2("link program failed");
    
    GLint status = GL_FALSE;
    glGetProgramiv(this->m_programId, GL_LINK_STATUS, &status);
    if ( !status ){
      GLint InfoLogLength = 0;
      glGetProgramiv(this->m_programId, GL_INFO_LOG_LENGTH, &InfoLogLength);
      std::string errorlog(InfoLogLength,'\0');
      glGetProgramInfoLog(this->m_programId, InfoLogLength, NULL, &errorlog[0]);
      std::cerr << "program link error: " << errorlog << std::endl;
    }
 
    m_linkStatus = status;
  }
 
  void Program::use() {
    if (m_linkStatus)
    {
      ACG::GLState::useProgram(this->m_programId);
      checkGLError2("use program failed");
    }
  }
 
  void Program::disable() {
    ACG::GLState::useProgram(0);
    checkGLError2("shader disable failed");
  }
 
  bool Program::isActive() {
    GLint programId;
    glGetIntegerv(GL_CURRENT_PROGRAM, &programId);
    return programId == this->m_programId;
  }
 
  bool Program::isLinked() {
    return m_linkStatus != GL_FALSE;
  }
 
  GLuint Program::getProgramId() {
    return (GLuint)m_programId;
  }
 
  void Program::setUniform(const char *_name, GLint _value) {
    checkGLError();
    GLint location = glGetUniformLocation(this->m_programId, _name);
    checkGLError2(_name);
    glUniform1i(location, _value);
    checkGLError2(_name);
  }
 
  void Program::setUniform(const char *_name, const ACG::Vec2i &_value) {
    checkGLError();
    GLint location = glGetUniformLocation(this->m_programId, _name);
    checkGLError2(_name);
    glUniform2iv(location, 1, _value.data());
    checkGLError();
  }
 
  void Program::setUniform(const char *_name, const ACG::Vec3i &_value) {
    checkGLError();
    GLint location = glGetUniformLocation(this->m_programId, _name);
    checkGLError2(_name);
    glUniform3iv(location, 1, _value.data());
    checkGLError();
  }
 
  void Program::setUniform(const char *_name, const ACG::Vec4i &_value) {
    checkGLError();
    GLint location = glGetUniformLocation(this->m_programId, _name);
    checkGLError2(_name);
    glUniform4iv(location, 1, _value.data());
    checkGLError();
  }
 
  void Program::setUniform(const char *_name, GLuint _value) {
    checkGLError();
    GLint location = glGetUniformLocation(this->m_programId, _name);
    checkGLError2(_name);
    glUniform1ui(location, _value);
    checkGLError2(_name);
  }
 
  void Program::setUniform(const char *_name, const ACG::Vec2ui &_value) {
    checkGLError();
    GLint location = glGetUniformLocation(this->m_programId, _name);
    checkGLError2(_name);
    glUniform2uiv(location, 1, _value.data());
    checkGLError();
  }
 
  void Program::setUniform(const char *_name, const ACG::Vec3ui &_value) {
    checkGLError();
    GLint location = glGetUniformLocation(this->m_programId, _name);
    checkGLError2(_name);
    glUniform3uiv(location, 1, _value.data());
    checkGLError();
  }
 
  void Program::setUniform(const char *_name, const ACG::Vec4ui &_value) {
    checkGLError();
    GLint location = glGetUniformLocation(this->m_programId, _name);
    checkGLError2(_name);
    glUniform4uiv(location, 1, _value.data());
    checkGLError();
  }
 
  void Program::setUniform(const char *_name, GLfloat _value) {
    checkGLError2("prev opengl error");
    GLint location = glGetUniformLocation(this->m_programId, _name);
    checkGLError2(_name);
    glUniform1f(location, _value);
    checkGLError2(_name);
  }
 
  void Program::setUniform(const char *_name, const ACG::Vec2f &_value) {
    checkGLError();
    GLint location = glGetUniformLocation(this->m_programId, _name);
    checkGLError2(_name);
    glUniform2fv(location, 1, _value.data());
    checkGLError();
  }
 
  void Program::setUniform(const char *_name, const ACG::Vec3f &_value) {
    checkGLError();
    GLint location = glGetUniformLocation(this->m_programId, _name);
    checkGLError2(_name);
    glUniform3fv(location, 1, _value.data());
    checkGLError();
  }
 
  void Program::setUniform(const char *_name, const ACG::Vec4f &_value) {
    checkGLError();
    GLint location = glGetUniformLocation(this->m_programId, _name);
    checkGLError2(_name);
    glUniform4fv(location, 1, _value.data());
    checkGLError();
  }
 
  void Program::setUniform(const char *_name, const GLint *_values, int _count) {
    checkGLError();
    GLint location = glGetUniformLocation(this->m_programId, _name);
    checkGLError2(_name);
    glUniform1iv(location, _count, _values);
    checkGLError();
  }
 
  void Program::setUniform(const char *_name, const GLfloat *_values, int _count) {
    checkGLError();
    GLint location = glGetUniformLocation(this->m_programId, _name);
    checkGLError2(_name);
    glUniform1fv(location, _count, _values);
    checkGLError();
  }
 
  void Program::setUniform(const char *_name, const ACG::Vec2f* _values, int _count) {
    checkGLError();
    GLint location = glGetUniformLocation(this->m_programId, _name);
    checkGLError2(_name);
    glUniform2fv(location, _count, (GLfloat*)_values);
    checkGLError();
  }
 
  void Program::setUniform(const char *_name, const ACG::Vec3f* _values, int _count) {
    checkGLError();
    GLint location = glGetUniformLocation(this->m_programId, _name);
    checkGLError2(_name);
    glUniform3fv(location, _count, (GLfloat*)_values);
    checkGLError();
  }
  
  void Program::setUniform(const char *_name, const ACG::Vec4f* _values, int _count) {
    checkGLError();
    GLint location = glGetUniformLocation(this->m_programId, _name);
    checkGLError2(_name);
    glUniform4fv(location, _count, (GLfloat*)_values);
    checkGLError();
  }
 
  void Program::setUniform(const char *_name, int _index, bool _value) {
    char varName[1024];
    snprintf(varName, 1024, "%s[%d]", _name, _index);
    setUniform(varName, (GLint) _value);
  }
 
  void Program::setUniform(const char *_name, int _index, int _value) {
    char varName[1024];
    snprintf(varName, 1024, "%s[%d]", _name, _index);
    setUniform(varName, (GLint) _value);
  }
 
  void Program::setUniform(const char *_name, int _index, float _value) {
    char varName[1024];
    snprintf(varName, 1024, "%s[%d]", _name, _index);
    setUniform(varName, _value);
  }
 
 
  void Program::setUniform( const char *_name, const ACG::GLMatrixf &_value, bool _transposed){
    checkGLError();
    GLint location = glGetUniformLocation(this->m_programId, _name);
    checkGLError2(_name);
    glUniformMatrix4fv(location, 1, _transposed, _value.data());
    checkGLError();
  }
 
  void Program::setUniformMat3( const char *_name, const ACG::GLMatrixf &_value, bool _transposed){
    checkGLError();
    GLint location = glGetUniformLocation(this->m_programId, _name);
    checkGLError2(_name);
 
    float tmp[9];
    for (int i = 0; i < 3; ++i)
      for (int k = 0; k < 3; ++k)
        tmp[i*3+k] = _value.data()[i*4+k];
 
    glUniformMatrix3fv(location, 1, _transposed, tmp);
    checkGLError();
  }
 
  void Program::bindAttributeLocation(unsigned int _index, const char *_name) {
    glBindAttribLocation(this->m_programId, _index, _name);
    checkGLError2(_name);
  }
 
  void Program::bindFragDataLocation(unsigned int _index, const char *_name) {
    glBindFragDataLocation(this->m_programId, _index, _name);
    checkGLError2(_name);
  }
 
  int Program::getAttributeLocation(const char *_name) {
    int attributeLocation = glGetAttribLocation(this->m_programId, _name);
    checkGLError2(_name);
    return attributeLocation;
  }
 
  int Program::getUniformLocation(const char *_name) {
    int attributeLocation = glGetUniformLocation(this->m_programId, _name);
    checkGLError2(_name);
    return attributeLocation;
  }
 
  int Program::getFragDataLocation(const char *_name) {
    int attributeLocation = glGetFragDataLocation(this->m_programId, _name);
    checkGLError2(_name);
    return attributeLocation;
  }
 
  void Program::setGeometryInputType(GLint _type) {
    glProgramParameteri(this->m_programId, GL_GEOMETRY_INPUT_TYPE_EXT, _type);
  }
 
  void Program::setGeometryOutputType(GLint _type) {
    glProgramParameteri(this->m_programId, GL_GEOMETRY_OUTPUT_TYPE_EXT, _type);
  }
 
  void Program::setGeometryVertexCount(GLint _numVerticesOut){
    glProgramParameteri(this->m_programId, GL_GEOMETRY_VERTICES_OUT_EXT, _numVerticesOut);
  }
 
  
  GLuint Program::getUniformBlockIndex( const char *_name ) {
#ifdef GL_ARB_uniform_buffer_object
    GLuint idx = glGetUniformBlockIndex(m_programId, _name);
    checkGLError2(_name);
    return idx;
#else
    return 0xFFFFFFFF;
#endif
  }
 
  void Program::setUniformBlockBinding( GLuint _index, int _binding ) {
#ifdef GL_ARB_uniform_buffer_object
    glUniformBlockBinding(m_programId, _index, GLuint(_binding));
    checkGLError();
#endif
  }
 
  void Program::setUniformBlockBinding( const char* _name, int _binding ) {
    GLuint idx = getUniformBlockIndex(_name);
    setUniformBlockBinding(idx, _binding);
  }
 
  int Program::getUniformBlockSize( GLuint _index ) {
    GLint bufsize = 0;
#ifdef GL_ARB_uniform_buffer_object
    glGetActiveUniformBlockiv(m_programId, _index, GL_UNIFORM_BLOCK_DATA_SIZE, &bufsize);
    checkGLError();
#endif
    return bufsize;
  }
 
  int Program::getUniformBlockSize( const char* _name ) {
    GLuint idx = getUniformBlockIndex(_name);
    return getUniformBlockSize(idx);
  }
 
  void Program::getUniformBlockOffsets( int _numUniforms, const char **_names, int *_outOffsets ) {
#ifdef GL_ARB_uniform_buffer_object
    GLuint* idx = new GLuint[_numUniforms];
    glGetUniformIndices(m_programId, _numUniforms, _names, idx);
    checkGLError();
    glGetActiveUniformsiv(m_programId, _numUniforms, idx, GL_UNIFORM_OFFSET, _outOffsets);
    checkGLError();
    delete [] idx;
#endif
  }
 
 
  void loadShaderRec(const char *filename, bool appendNewLineChar, std::map<QString, int>& includeMap, GLSL::StringList& shaderSource){
    QString path_file;
    if (QDir(filename).isRelative()) {
      path_file = qApp->applicationDirPath() + QString("/../shader/")
        + QString(filename);
    } else {
      path_file = QString::fromLatin1(filename);
    }
 
    // avoid include loop
    std::map<QString, int>::iterator includeIter = includeMap.find(path_file);
 
    if (includeIter == includeMap.end()){
      includeMap[path_file] = 1;
 
      std::ifstream iShader(path_file.toLatin1());
      if (!iShader) {
        std::cout << "ERROR: Could not open file " << path_file.toStdString() << std::endl;
        return;
      }
 
      while (!iShader.eof()) {
        std::string strLine;
        std::getline(iShader, strLine);
 
        // check for includes
        QString qstrLine = strLine.c_str();
        if (qstrLine.trimmed().startsWith("#include")) {
 
          // try to load included file
          QString strIncludeFile = qstrLine.remove("#include ").remove('\"').remove('<').remove('>').trimmed();
          QFileInfo loadedShaderFile(path_file);
          QString includePath = loadedShaderFile.absolutePath();
 
          if (strIncludeFile.isEmpty())
            std::cout << "wrong include syntax: " << strLine.c_str() << std::endl;
          else {
            QString fullPathToIncludeFile = includePath + QDir::separator() + strIncludeFile;
 
            loadShaderRec(fullPathToIncludeFile.toLatin1(), appendNewLineChar, includeMap, shaderSource);
          }
        }
        else {
          if (appendNewLineChar)
            strLine += "\n";
          shaderSource.push_back(strLine);
        }
      }
      iShader.close();
    }
  }
 
  GLSL::StringList loadShader(const char *filename, const GLSL::StringList *macros, bool appendNewLineChar, GLSL::StringList* outIncludes) {
 
    GLSL::StringList src;
 
    std::map<QString, int> includeMap;
    loadShaderRec(filename, appendNewLineChar, includeMap, src);
 
 
    // add preprocesor macros
    if (macros && !macros->empty() && !macros->front().empty())
    {
      bool foundVersionDirective = false;
 
      for (GLSL::StringList::iterator it = src.begin(); it != src.end(); ++it)
      {
        QString qstr = it->c_str();
        if (qstr.trimmed().startsWith("#version "))
        {
          foundVersionDirective = true;
 
          // insert preprocessor macros in the next line
          ++it;
          for (GLSL::StringList::const_iterator itMacro = macros->begin(); itMacro != macros->end(); ++itMacro)
            src.insert(it, *itMacro + "\n");
 
          break;
        }
      }
 
      if (!foundVersionDirective)
      {
        // shader did not contain a #version directive
        // add preprocessor macros to beginning of shader
        for (GLSL::StringList::const_reverse_iterator it = macros->rbegin(); it != macros->rend(); ++it)
          src.push_front(*it + "\n");
      }
    }
 
    if (outIncludes)
    {
      for (std::map<QString, int>::iterator it = includeMap.begin(); it != includeMap.end(); ++it)
        outIncludes->push_back(it->first.toStdString());
    }
    return src;
  }
 
  GLSL::PtrVertexShader loadVertexShader(const char *name, const GLSL::StringList *macros, bool verbose) {
    PtrVertexShader vertexShader = 0;
    StringList sourceVertex = loadShader(name, macros);
 
    if (!sourceVertex.empty() ) {
      vertexShader = new GLSL::VertexShader();
      vertexShader->setSource(sourceVertex);
      vertexShader->compile(verbose);
    }
    return vertexShader;
  }
 
  GLSL::PtrFragmentShader loadFragmentShader(const char *name, const GLSL::StringList *macros, bool verbose) {
    PtrFragmentShader fragmentShader = 0;
    StringList sourceVertex = loadShader(name, macros);
 
    if ( !sourceVertex.empty() ) {
      fragmentShader = new GLSL::FragmentShader();
      fragmentShader->setSource(sourceVertex);
      if (!fragmentShader->compile(verbose)) {
        delete fragmentShader;
        fragmentShader = 0;
      }
    }
    return fragmentShader;
  }
 
  GLSL::PtrGeometryShader loadGeometryShader(const char *name, const GLSL::StringList *macros, bool verbose) {
    PtrGeometryShader geometryShader = 0;
    StringList sourceVertex = loadShader(name, macros);
 
    if (!sourceVertex.empty()) {
      geometryShader = new GLSL::GeometryShader();
      geometryShader->setSource(sourceVertex);
      if (!geometryShader->compile(verbose)) {
        delete geometryShader;
        geometryShader = 0;
      }
    }
    return geometryShader;
  }
 
 
  GLSL::PtrShader loadTessControlShader(const char *name, const GLSL::StringList *macros, bool verbose) {
    GLSL::PtrShader shader = 0;
#ifdef GL_ARB_tessellation_shader
    StringList src = loadShader(name, macros);
 
    if (!src.empty()) {
      shader = new GLSL::TessControlShader();
      shader->setSource(src);
      if (!shader->compile(verbose)) {
        delete shader;
        shader = 0;
      }
    }
#endif // GL_ARB_tessellation_shader
    return shader;
  }
 
  GLSL::PtrShader loadTessEvaluationShader(const char *name, const GLSL::StringList *macros, bool verbose) {
    GLSL::PtrShader shader = 0;
#ifdef GL_ARB_tessellation_shader
    StringList src = loadShader(name, macros);
 
    if (!src.empty()) {
      shader = new GLSL::TessEvaluationShader();
      shader->setSource(src);
      if (!shader->compile(verbose)) {
        delete shader;
        shader = 0;
      }
    }
#endif // GL_ARB_tessellation_shader
    return shader;
  }
 
 
  GLSL::PtrComputeShader loadComputeShader(const char *name, const GLSL::StringList *macros, bool verbose) {
    GLSL::PtrComputeShader shader = 0;
#ifdef GL_ARB_compute_shader
    StringList src = loadShader(name, macros);
 
    if (!src.empty()) {
      shader = new GLSL::ComputeShader();
      shader->setSource(src);
      if (!shader->compile(verbose)) {
        delete shader;
        shader = 0;
      }
    }
#endif // GL_ARB_compute_shader
    return shader;
  }
 
 
 
  GLSL::PtrProgram loadProgram(const char *vertexShaderFile,
    const char *tessControlShaderFile,
    const char *tessEvaluationShaderFile,
    const char *geometryShaderFile,
    const char *fragmentShaderFile, 
    const GLSL::StringList *macros,
    bool verbose){
 
      GLSL::Program* result = 0;
 
      const int numShaders = 5;
      const char* ShaderFiles[numShaders] = {vertexShaderFile, tessControlShaderFile, tessEvaluationShaderFile, geometryShaderFile, fragmentShaderFile};
      GLSL::Shader* tempShaders[numShaders] = {0};
 
      for (int i = 0; i < numShaders; ++i) {
 
        QString inputFile = ShaderFiles[i];
        if (ShaderFiles[i] && !inputFile.isEmpty()) {
          QDir inputFileDir = inputFile;
 
          // eventually add shader dir to relative filepath
          QString shaderFile = inputFile;
          if (inputFileDir.isRelative())
            shaderFile = ACG::ShaderProgGenerator::getShaderDir() + QDir::separator() + inputFile;
 
          if (i == 0) // vertex shader
            tempShaders[i] = GLSL::loadVertexShader(shaderFile.toUtf8(), macros, verbose);
          else if (i == 1 && tessControlShaderFile) // tesscontrol shader
            tempShaders[i] = GLSL::loadTessControlShader(shaderFile.toUtf8(), macros, verbose);
          else if (i == 2 && tessEvaluationShaderFile) // tesseval shader
            tempShaders[i] = GLSL::loadTessEvaluationShader(shaderFile.toUtf8(), macros, verbose);
          else if (i == 3 && geometryShaderFile) // geometry shader
            tempShaders[i] = GLSL::loadGeometryShader(shaderFile.toUtf8(), macros, verbose);
          else if (i == 4) // fragment shader
            tempShaders[i] = GLSL::loadFragmentShader(shaderFile.toUtf8(), macros, verbose);
 
          if (!tempShaders[i] && ShaderFiles[i]) {
            if (verbose)
              std::cerr << ShaderFiles[i] << " could not be loaded and compiled" << std::endl;
 
            // avoid memleak
            for (int k = 0; k < numShaders; ++k)
              delete tempShaders[k];
 
            return 0;
          }
        }
      }
 
      // create program
 
      result = new GLSL::Program();
      for (int i = 0; i < numShaders; ++i)
        if (tempShaders[i])
          result->attach(tempShaders[i]);
      result->link();
 
      for (int i = 0; i < numShaders; ++i)
        delete tempShaders[i];
 
      if (verbose)
        ACG::glCheckErrors();
 
 
      return result;
  }
 
  GLSL::PtrProgram loadProgram(const char *vertexShaderFile, const char *geometryShaderFile, const char *fragmentShaderFile, const GLSL::StringList *macros, bool verbose){
 
    return loadProgram(vertexShaderFile, 0, 0, geometryShaderFile, fragmentShaderFile, macros, verbose);
  }
 
 
  GLSL::PtrProgram loadProgram(const char *vertexShaderFile, const char *fragmentShaderFile, const GLSL::StringList *macros, bool verbose){
    return loadProgram(vertexShaderFile, 0, fragmentShaderFile, macros, verbose);
  }
 
 
  GLSL::PtrProgram loadComputeProgram(const char *computeShaderFile, const GLSL::StringList *macros /* = 0 */, bool verbose /* = true */) {
    GLSL::PtrProgram result = 0;
 
    QString inputFile = computeShaderFile;
    if (computeShaderFile && !inputFile.isEmpty()) {
      QDir inputFileDir = inputFile;
 
      // eventually add shader dir to relative filepath
      QString shaderFile = inputFile;
      if (inputFileDir.isRelative())
        shaderFile = ACG::ShaderProgGenerator::getShaderDir() + QDir::separator() + inputFile;
 
      GLSL::PtrShader sh = GLSL::loadComputeShader(computeShaderFile, macros, verbose);
 
      if (!sh) {
        if (verbose)
          std::cerr << computeShaderFile << " could not be loaded and compiled" << std::endl;
 
        // avoid memleak
        delete sh;
 
        return 0;
      }
      
 
      // create program
      result = new GLSL::Program();
      result->attach(sh);
      result->link();
 
      delete sh;
 
      if (verbose)
        ACG::glCheckErrors();
    }
 
    return result;
  }
 
 
}
 
 
//==============================================================================