Shader.cpp

Go to the documentation of this file.

#include "Shader.hpp"


Shader::Shader(string const & name)
    : m_name(name)
    , m_id(0)
{
    m_id = glCreateProgram();

    if (m_id == 0)
    {
        cerr << "ERROR: Failed to create shader program" << endl;
        exit(EXIT_FAILURE);
    }

    auto vs = loadShader("content\\shaders\\" + name + ".vert", GL_VERTEX_SHADER);
    auto fs = loadShader("content\\shaders\\" + name + ".frag", GL_FRAGMENT_SHADER);
    
    glAttachShader(m_id, vs);
    glAttachShader(m_id, fs);

    link();

    glDeleteShader(vs);
    glDeleteShader(fs);
}

Shader::~Shader()
{
    glDeleteProgram(m_id);
    m_id = 0;
}

int Shader::loadShader(string const & file, GLenum shaderType)
{
    string code = Util::read_file_to_string(file);

    GLuint id = glCreateShader(shaderType);

    if ( id == 0 )
    {
        stringstream temp;

        temp << shaderType;
        string type = temp.str();

        switch( shaderType )
        {
            case GL_FRAGMENT_SHADER:        type = string("GL_FRAGMENT_SHADER"); break;
            case GL_TESS_EVALUATION_SHADER: type = string("GL_TESS_EVALUATION_SHADER"); break;
            case GL_TESS_CONTROL_SHADER:    type = string("GL_TESS_CONTROL_SHADER"); break;
            case GL_GEOMETRY_SHADER:        type = string("GL_GEOMETRY_SHADER"); break;
            case GL_VERTEX_SHADER:          type = string("GL_VERTEX_SHADER"); break;
            default: break;
        }

        temp.str(string());

        cerr << "ERROR: Loading shader '" << file << "' failed (Shader-type '" << type << "' not supported)" << endl;       
        
        exit(EXIT_FAILURE);
    }

    
    GLint result = GL_FALSE;
    int infoLogLength;
    char const * shaderCodePtr = code.c_str();
    glShaderSource(id, 1, &shaderCodePtr , nullptr);
    glCompileShader(id);
     
    glGetShaderiv(id, GL_COMPILE_STATUS, &result);
    if (result != GL_TRUE)
    {       
        glGetShaderiv(id, GL_INFO_LOG_LENGTH, &infoLogLength);

        vector<char> errorMessage(infoLogLength);
        glGetShaderInfoLog(id, infoLogLength, nullptr, &errorMessage[0]);
    
        cerr << "ERROR: Loading shader '" << file << "' failed (Compile-error: '" << string(&errorMessage[0]) << "')" << endl;  

        glDeleteShader(id);

        exit(EXIT_FAILURE);
    }

    return id;
}
void Shader::link()
{
    glLinkProgram(m_id);
       
    GLint succeded;
    glGetProgramiv(m_id, GL_LINK_STATUS, &succeded);

    if (!succeded)
    {
        GLint infoLogLength;
        glGetProgramiv(m_id, GL_INFO_LOG_LENGTH, &infoLogLength);
               
        vector<char> errorMessage(infoLogLength);
        glGetProgramInfoLog(m_id, infoLogLength, nullptr, &errorMessage[0]);
            
        cerr << "ERROR: Loading shader '" << m_name << "' failed (Link-error: '" << string(&errorMessage[0]) << "')" << endl;   
            
        exit(EXIT_FAILURE);
    }
}



void Shader::use()
{
    glUseProgram(m_id);
}
GLint Shader::uniform(string const & name)
{
    auto found = m_uniforms.find(name);
    if (found != m_uniforms.end())
        return found->second;

    auto& entry = m_uniforms[name];
    entry = glGetUniformLocation(m_id, name.c_str());
    return entry;
}
GLint Shader::uniformBlock(string const & name)
{
    auto found = m_uniforms.find(name);
    if (found != m_uniforms.end())
        return found->second;

    auto& entry = m_uniforms[name];
    entry = glGetUniformBlockIndex(m_id, name.c_str());
    return entry;
}




Shader* Shaders::get(string const & name)
{
    auto found = m_shaders.find(name);

    if (found != m_shaders.end())
        return found->second.get();

    auto& entry = m_shaders[name];
    entry.reset(new Shader(name));
    return entry.get();
}