Shader.cpp

Go to the documentation of this file.

#include "Shader.h"
#include <iostream>
#include <fstream>

using namespace vis2;

Shader::Shader(const std::string& _vertexShader,
               const std::string& _fragmentShader)
            : program_handle(0), vertex_shader_handle(0), fragment_shader_handle(0), shader_in_use(false)
{
    // initialize a program handle
    this->program_handle = glCreateProgram();
    if (this->program_handle == 0)
    {
        std::cout << "Could not create shader program!" << std::endl;
        system("PAUSE");
        exit(-1);
    }

    // load vertex and fragment shader
    loadShader(_vertexShader,GL_VERTEX_SHADER,this->vertex_shader_handle);
    loadShader(_fragmentShader,GL_FRAGMENT_SHADER,this->fragment_shader_handle);

    // link the shaders to a complete program
    link();
    
}

Shader::~Shader()
{
    glDeleteProgram(this->program_handle);
    glDeleteShader(this->vertex_shader_handle);
    glDeleteShader(this->fragment_shader_handle);
}

void Shader::useShader()
{
    glUseProgram(this->program_handle);
    shader_in_use = true;
}

void Shader::releaseShader()
{
    glUseProgram(0);
    shader_in_use = false;
}

void Shader::loadShader(const std::string&  _path_to_shader,
                        GLenum              _shaderType,
                        GLuint&             _shaderHandle)
{
    std::ifstream shader_file(_path_to_shader);
    if (shader_file.good())
    {
        // read the entire file content (shortes version of this preocedure)
        std::string str_code = std::string( std::istreambuf_iterator<char>(shader_file),
                                            std::istreambuf_iterator<char>());
        shader_file.close();

        // initialize the shader handle
        _shaderHandle = glCreateShader(_shaderType);
        if (_shaderHandle == 0)
        {
            std::cout << "Failed to create shader handle!" << std::endl;
            system("PAUSE");
            exit(-1);
        }

        // transfer shader code to the GK
        const char* code_Ptr = str_code.c_str();
        glShaderSource(_shaderHandle,1,&code_Ptr,NULL);
        glCompileShader(_shaderHandle);

        // check for compile errors
        GLint success;
        glGetShaderiv(_shaderHandle,GL_COMPILE_STATUS,&success);
        if (success == GL_FALSE || !glIsShader(_shaderHandle))
        {
            // read the compiler log and print on stdout
            GLint log_size;
            glGetShaderiv(_shaderHandle,GL_INFO_LOG_LENGTH,&log_size);
            GLchar* log_content_Ptr = new char[log_size];

            glGetShaderInfoLog(_shaderHandle,log_size,NULL,log_content_Ptr);
            std::cout << "Failed to compile shader:\n" << log_content_Ptr << std::endl;
            system("PAUSE");
            delete [] log_content_Ptr;
            exit(-1);

        }

    }
    else
    {
        std::cout << "Failed to open shader source code file \"" << _path_to_shader << "\" !" << std::endl;
        system("PAUSE");
        exit(-1);
    }

}


void Shader::link()
{
    // attach the shader to the program
    glAttachShader(this->program_handle,this->vertex_shader_handle);
    glAttachShader(this->program_handle,this->fragment_shader_handle);

    // bind output (frag data location)
    glBindFragDataLocation(this->program_handle,0,"fragColor");

    // link
    glLinkProgram(this->program_handle);

    // check for errors
    GLint success;
    glGetProgramiv(this->program_handle,GL_LINK_STATUS,&success);

    if (!success) // anything other than ZERO
    {
        // read the compiler log and print on stdout
        GLint log_size;
        glGetProgramiv(this->program_handle,GL_INFO_LOG_LENGTH,&log_size);

        GLchar* log_content_Ptr = new char[log_size];
        glGetProgramInfoLog(this->program_handle,log_size,NULL,log_content_Ptr);

        std::cout << "Failed to link shader program:\n" << log_content_Ptr << std::endl;
        system("PAUSE");
        delete [] log_content_Ptr;
        exit(-1);
    }

}