glfShaderProgram.cpp

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

#include "glfShaderProgram.hh"
#include "glfUniformNotFoundException.hh"


using namespace BIAS;
using namespace std;

glfShaderProgram::glfShaderProgram()
{
  id_ = 0;
}

glfShaderProgram::~glfShaderProgram()
{
  if (id_ != 0)
    {

      for (unsigned int i = 0; i < shaders_attached_as_object_.size(); i++)
        {
          glDetachShader(id_, shaders_attached_as_object_[i]);
        }

      // all shaders attached from source are internaly attached as object
      // so glDetachShader was already called
      for (unsigned int i = 0; i < shaders_attached_from_source_.size(); i++)
        {
          delete shaders_attached_from_source_[i];
        }

      shaders_attached_as_object_.clear();
      shaders_attached_from_source_.clear();

      glDeleteProgram(id_);
    }
}


glfShaderProgram& 
glfShaderProgram::operator=(const glfShaderProgram& b)
{ 
  return (*this);
}
    
glfShaderProgram::glfShaderProgram(const glfShaderProgram& b)
{}

void glfShaderProgram::Create()

{
  if (id_ == 0)
    {
      id_ = glCreateProgram();
    }

    GLF_THROW_ON_OPENGL_ERROR;
}

void
glfShaderProgram::AttachShader(const glfShader& shader)
{
  BIASASSERT(id_ != 0);

    GLF_THROW_ON_OPENGL_ERROR;

    if(glIsProgram(id_)==GL_FALSE) {
      GLF_THROW_EXCEPTION("not a valid program id!");
    }

    if(glIsShader(shader.GetShaderID())==GL_FALSE) {
      GLF_THROW_EXCEPTION("not a valid shader id!");
    }
    
    GLsizei count;
    GLuint shaders[50];
    glGetAttachedShaders(id_, 50, &count, shaders);
    bool alreadyAttached=false;
    for (int i=0; i<count; i++) {
      alreadyAttached = alreadyAttached || (shaders[i]==shader.GetShaderID());
    }

    if(!alreadyAttached)
      glAttachShader(id_, shader.GetShaderID());


    GLF_THROW_ON_OPENGL_ERROR;
  shaders_attached_as_object_.push_back(shader.GetShaderID());

    GLF_THROW_ON_OPENGL_ERROR;
}

void
glfShaderProgram::AttachShaderFromSource(GLenum type,
    const std::string& sourceCode)
{
  glfShader* shader = new glfShader();
  shader->Create(type, sourceCode);

  shaders_attached_from_source_.push_back(shader);
  AttachShader(*shader);

}

void
glfShaderProgram::AttachShaderFromFile(GLenum type, const std::string& fileName)
{
  glfShader* shader = new glfShader();
  shader->CreateFromFile(type, fileName);
  shaders_attached_from_source_.push_back(shader);
  AttachShader(*shader);
}

void
glfShaderProgram::Link()
{
  BIASASSERT(id_ != 0);

  glLinkProgram(id_);

  GLint linkSuccess;
  glGetProgramiv(id_, GL_LINK_STATUS, &linkSuccess);
  if (linkSuccess == GL_FALSE)
    {
        GLF_THROW_EXCEPTION("Failed to link shader program: "
            << endl << GetInfoLog());
    }

    GLF_THROW_ON_OPENGL_ERROR;
}

string
glfShaderProgram::GetInfoLog() const
{
  BIASASSERT(id_ != 0);

  GLint logLength = 0;
  glGetProgramiv(id_, GL_INFO_LOG_LENGTH, &logLength);
  char* infoLog = new char[logLength];
  glGetProgramInfoLog(id_, logLength, NULL, infoLog);
  std::string out = infoLog;
  delete[] infoLog;

  GLF_THROW_ON_OPENGL_ERROR;

  return out;
}

void
glfShaderProgram::SetUniform(const std::string& varName, bool value)
{
  Bind();
  GLboolean glValue = (value) ? GL_TRUE : GL_FALSE;
  try{
    GLint loc = GetUniformLocation_(varName);
    glUniform1i(loc, glValue);
  }
  catch(glfException& e) {
    std::cout << "Error: " << e.GetMessageString() << std::endl;      
    return;
  }

  GLF_THROW_ON_OPENGL_ERROR_INFO(varName);
}


void
glfShaderProgram::SetUniform(const std::string& varName, float value)
{
  Bind();
  try{
    GLint loc = GetUniformLocation_(varName);
    glUniform1f(loc, value);
  }
  catch(glfException& e) {
    std::cout << "Error: " << e.GetMessageString() << std::endl;      
    return;
  }

  GLF_THROW_ON_OPENGL_ERROR_INFO(varName);
}

void
glfShaderProgram::SetUniform(const std::string& varName, double value)
{
  SetUniform(varName, (float) value);
}

void
glfShaderProgram::SetUniform(const std::string& varName, int value)
{
  Bind();
  try{
    GLint loc = GetUniformLocation_(varName);
    glUniform1i(loc, value);
  }
  catch(glfException& e) {
    std::cout << "Error: " << e.GetMessageString() << std::endl;      
    return;
  }

  GLF_THROW_ON_OPENGL_ERROR_INFO(varName);
}

void
glfShaderProgram::SetUniform(const std::string& varName, int count, int *value)
{
  Bind();
  try{
    GLint loc = GetUniformLocation_(varName);
    glUniform1iv(loc, count, value);
  }
  catch(glfException& e) {
    std::cout << "Error: " << e.GetMessageString() << std::endl;      
    return;
  }
  
  GLF_THROW_ON_OPENGL_ERROR_INFO(varName);
}

void glfShaderProgram::SetUniform(const std::string& varName, int count, float *value) {
  Bind();
  try {
    GLint loc = GetUniformLocation_(varName);
    glUniform1fv(loc, count, value);
  }
  catch (glfException& e) {
    std::cout << "Error: " << e.GetMessageString() << std::endl;
    return;
  }

  GLF_THROW_ON_OPENGL_ERROR_INFO(varName);
}

void
glfShaderProgram::SetUniform(const std::string& varName, 
                             const BIAS::Vector<float>& v)
{
  Bind();

    GLint loc = GetUniformLocation_(varName);
    switch (v.GetNumElements())
      {
      case 1:
        glUniform1fv(loc, 1, v.GetData());
        break;
      case 2:
        glUniform2fv(loc, 1, v.GetData());
        break;
      case 3:
        glUniform3fv(loc, 1, v.GetData());
        break;
      case 4:
        glUniform4fv(loc, 1, v.GetData());
        break;
      default:
        GLF_THROW_EXCEPTION("Invalid vector size "<<v.GetNumElements()<< " for uniform "<<varName)
          ;
        break;
      }
  
  GLF_THROW_ON_OPENGL_ERROR;
}

void
glfShaderProgram::SetUniform(const std::string& varName, const BIAS::Vector<
    double>& v)
{
  Vector<float> vf(v.GetNumElements());
  for (int i = 0; i < v.GetNumElements(); i++)
    {
      vf[i] = (float) v[i];
    }
  SetUniform(varName, vf);
}

void
glfShaderProgram::SetUniform(const std::string& varName,
                             const BIAS::Vector<int>& v)
{
  Bind();
  try{
    GLint loc = GetUniformLocation_(varName);

    switch (v.GetNumElements())
      {
      case 1:
        glUniform1iv(loc, 1, v.GetData());
        break;
      case 2:
        glUniform2iv(loc, 1, v.GetData());
        break;
      case 3:
        glUniform3iv(loc, 1, v.GetData());
        break;
      case 4:
        glUniform4iv(loc, 1, v.GetData());
        break;
      default:
        GLF_THROW_EXCEPTION("Invalid vector size for uniform")
          ;
        break;
      }
  }
  catch(glfException& e) {
    std::cout << "Error: " << e.GetMessageString() << std::endl;      
    return;
  }
  GLF_THROW_ON_OPENGL_ERROR;
}

void
glfShaderProgram::SetUniform(const std::string& varName, 
                             const BIAS::Matrix<float>& md)
{
  BIAS::Matrix<float> m = md.Transpose();
  Bind();
  try{
    GLint loc = GetUniformLocation_(varName);
    switch (m.GetRows())
      {
      case 2:
        switch (m.GetCols())
          {
          case 2:
            glUniformMatrix2fv(loc, 1, GL_FALSE, m.GetData());
            break;
            //case 3: glUniformMatrix2x3fv(loc, 1, GL_FALSE, m.GetData());  break;
            //case 4: glUniformMatrix2x4fv(loc, 1, GL_FALSE, m.GetData());  break;
          default:
            GLF_THROW_EXCEPTION("Invalid number of columns for uniform matrix")
              ;
            break;
          }
        break;
      case 3:
        switch (m.GetCols())
          {
            //case 2: glUniformMatrix3x2fv(loc, 1, GL_FALSE, m.GetData());  break;
          case 3:
            glUniformMatrix3fv(loc, 1, GL_FALSE, m.GetData());
            break;
            //case 4: glUniformMatrix3x4fv(loc, 1, GL_FALSE, m.GetData());  break;
          default:
            GLF_THROW_EXCEPTION("Invalid number of columns for uniform matrix")
              ;
            break;
          }
        break;
      case 4:
        switch (m.GetCols())
          {
            //case 2: glUniformMatrix4x2fv(loc, 1, GL_FALSE, m.GetData()); break;
            //case 3: glUniformMatrix4x3fv(loc, 1, GL_FALSE, m.GetData()); break;
          case 4:
            glUniformMatrix4fv(loc, 1, GL_FALSE, m.GetData());
            break;
          default:
            GLF_THROW_EXCEPTION("Invalid number of columns for uniform matrix")
              ;
            break;
          }
        break;
      default:
        GLF_THROW_EXCEPTION("Invalid number of rows for uniform matrix")
          ;
        break;
      }
  }
  catch(glfException& e) {
    std::cout << "Error: " << e.GetMessageString() << std::endl;      
    return;
  }
  GLF_THROW_ON_OPENGL_ERROR;
}

void
glfShaderProgram::SetUniform(const std::string& varName, const BIAS::Matrix<
    double>& m)
{
  Matrix<float> mf(m.GetRows(), m.GetCols());
  for (unsigned int i = 1; i <= m.GetRows(); i++)
    {
      for (unsigned int j = 1; j <= m.GetCols(); j++)
        {
          mf(i, j) = (float) m(i, j);
        }
    }
  SetUniform(varName, mf);
}

void
glfShaderProgram::SetUniform(const std::string& varName, const glfMatrix& m)
{
  Bind();
  try{
    GLint loc = GetUniformLocation_(varName);
    glUniformMatrix4fv(loc, 1, GL_FALSE, m.GetArray());
  }
  catch(glfException& e) {
    std::cout << "Error: " << e.GetMessageString() << std::endl;      
    return;
  }

}

void
glfShaderProgram::Bind() const
{
  BIASASSERT(id_ != 0);
  glUseProgram(id_);
}

bool 
glfShaderProgram::IsSamplerType_(GLenum type) {
  bool isSampler = false;
  switch(type) {
    case GL_SAMPLER_1D :
    case GL_SAMPLER_2D :
    case GL_SAMPLER_3D :
    case GL_SAMPLER_CUBE :
    case GL_SAMPLER_1D_SHADOW :
    case GL_SAMPLER_2D_SHADOW :
      isSampler = true;
      break;
    default :
      BIASWARN("Sampler Type List is incomplete!");
        isSampler = false;
        break;
  }
  return isSampler;
}

void 
glfShaderProgram::AutoSetSamplerUniforms() 
{
  BIASASSERT(id_ != 0);
  GLint numActiveUniforms;
  glGetProgramiv(id_, GL_ACTIVE_UNIFORMS, &numActiveUniforms);
  GLF_THROW_ON_OPENGL_ERROR_DEBUG;
  //cout<<"num active uniforms = "<<numActiveUniforms<<endl;
  GLint assignTU = 0;
  GLenum uniformType;
  const int bufSize = 50;
  char name[bufSize];
  GLsizei length;
  GLint uniformSize;
  for(int i=0; i<numActiveUniforms; i++) {
    glGetActiveUniform(id_, i, bufSize, &length, &uniformSize, &uniformType, name);
    if(IsSamplerType_(uniformType)) {
   //   cout<<"assigning TU "<<assignTU<<" to "<<name<<endl;
      SetUniform(name, assignTU++);
    }
  } 
  GLF_THROW_ON_OPENGL_ERROR;
}

GLint
glfShaderProgram::GetUniformLocation_(const std::string& varName)
{
  BIASASSERT(id_ != 0);
  GLint loc = glGetUniformLocation(id_, varName.c_str());
  if(loc == -1) {
    std::stringstream msg;                                              
    msg << "no active uniform named "
        <<varName
        <<"! Check: 1. Is Program Linked?, 2. Typo?, 3. Correct shader?";    
   // throw glfUniformNotFoundException(__FILE__, __LINE__, msg.str(), varName);
//    BIASWARN(msg.str()<<endl);
  }
  return loc;
}

GLint
glfShaderProgram::GetUniformLocation(const std::string& varName)
{
  BIASASSERT(id_ != 0);  
  GLint loc = glGetUniformLocation(id_, varName.c_str());
  if(loc == -1) {
    std::stringstream msg;                                              
    msg << "no active uniform named "
        <<varName
        <<"! Check: 1. Is Program Linked?, 2. Typo?, 3. Correct shader?";    
    throw glfUniformNotFoundException(__FILE__, __LINE__, msg.str(), varName); 
  }
  return loc;
}


int
glfShaderProgram::GetMaxCombinedTextureUnits()
{
  GLint TUs = 0;

  glGetIntegerv(GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS, &TUs);

  return static_cast<GLint> (TUs);
}

#ifdef GL_VERSION_3_0
void 
glfShaderProgram::BindAttribLocation(GLuint indexSlot, const std::string& VertexAttributeName)
{
  BIASASSERT(id_ != 0);
  glBindAttribLocation(id_, indexSlot, VertexAttributeName.c_str());
}
#endif