Shader.cpp

#include <fstream>

#include "Shader.hpp"
 
//**************************************************//
// Initialize the shader
//**************************************************//
Shader::Shader(const string &path) : _success(false) {

    // Load the shader files
    string vertex_shader_source;
    if (FileExists(path+".vert")) {
        vertex_shader_source = ReadFile(path+".vert");
    } else {
        cerr << "Vertex shader file "
            << path <<".vert does not exist." << endl;
        return;
    }

    string fragment_shader_source;
    if (FileExists(path+".frag")) {
        fragment_shader_source = ReadFile(path+".frag");
    } else {
        cerr << "Fragment shader file " << path <<".frag does not exist." << endl;
        return;
    }

    string geometry_shader_source;
    if (FileExists(path+".geom")) {
        geometry_shader_source = ReadFile(path+".geom");
    } else {
        cerr << "Geometry shader file " << path <<".geom does not exist." << endl;
    }


    // Compile the shaders

    _vertex_shader = compile(GL_VERTEX_SHADER, vertex_shader_source);
    if (_vertex_shader == 0)
        return;
    GetErrors();

    _fragment_shader = compile(GL_FRAGMENT_SHADER, fragment_shader_source);
    if (_fragment_shader == 0)
        return;
    GetErrors();

    _geometry_shader = compile(GL_GEOMETRY_SHADER, geometry_shader_source);
    if (_geometry_shader == 0)
        return;
    GetErrors();

    // Link the shaders into a program

    link();
    if (_program == 0)
        return;
    GenerateAddresses();
    _success = true;
    GetErrors();
}

//**************************************************//
// Free resources
//**************************************************//
Shader::~Shader() {
    glDeleteProgram(_program);
    glDeleteShader(_vertex_shader);
    glDeleteShader(_fragment_shader);
    glDeleteShader(_geometry_shader);
}

//**************************************************//
// Generate shader addresses
//**************************************************//
void Shader::GenerateAddresses(void) {

    _shaderAddresses[Shader::Position] = 0;
    _shaderAddresses[Shader::Radius] = 1;
    _shaderAddresses[Shader::Color] = 2;
    _shaderAddresses[Shader::UVQuad] = 3;

    _shaderAddresses[Shader::ProjectionMatrix] = get_uniform_location("projectionMatrix");
    _shaderAddresses[Shader::LightPosition] = get_uniform_location("lightPosition");
    _shaderAddresses[Shader::OcclusionDirections] = get_uniform_location("numberOfDirections");
    _shaderAddresses[Shader::OcclusionTexture] = get_uniform_location("textureMap");
    _shaderAddresses[Shader::ModelViewMatrix] = get_uniform_location("modelViewMatrix");
    _shaderAddresses[Shader::ShadowMVMatrix] = get_uniform_location("shadowMVMatrix");
    _shaderAddresses[Shader::ShadowPMatrix] = get_uniform_location("shadowPMatrix");
    _shaderAddresses[Shader::ContourData] = get_uniform_location("contourData");
    _shaderAddresses[Shader::ShadowActive] = get_uniform_location("shadowActive");
    _shaderAddresses[Shader::OcclusionActive] = get_uniform_location("occlusionActive");
    _shaderAddresses[Shader::AmbientIntensity] = get_uniform_location("ambientIntensity");
    _shaderAddresses[Shader::DirectIntensity] = get_uniform_location("directIntensity");
    _shaderAddresses[Shader::Glossiness] = get_uniform_location("glossiness");
    _shaderAddresses[Shader::ShadowTex] = get_uniform_location("shadowMap");
    _shaderAddresses[Shader::FarPlane] = get_uniform_location("farPlane");
    

}

//**************************************************//
// Returns the shader address
//**************************************************//
GLuint Shader::GetAddress(int address) {
    return _shaderAddresses[address];
}

GLuint Shader::compile (GLenum type, const string &source)
{
    // Create shader object

    GLuint shader = glCreateShader(type);

    if (shader == 0) {
        cerr << "Could not create shader object." << endl;
        return 0;
    }

    // Define shader source and compile

    const char* src = source.data();
    int len = source.size();

    glShaderSource(shader, 1, &src, &len);

    glCompileShader(shader);

    // Check for errors

    int status;

    glGetShaderiv(shader, GL_COMPILE_STATUS, &status);

    if (status != GL_TRUE) {
        qDebug() << "Shader compilation failed." << endl;
        shader_log(shader);
    }


    GetErrors();

    return shader;    
}

void Shader::link(void)
{
    // Create program handle
    _program = glCreateProgram();

    // Attach shaders and link

    glAttachShader(_program, _vertex_shader);
    glAttachShader(_program, _fragment_shader);

    glAttachShader(_program, _geometry_shader);

    glLinkProgram(_program);

    // Check for problems

    int status;

    glGetProgramiv(_program, GL_LINK_STATUS, &status);

    if (status != GL_TRUE) {
        qDebug() << "Shader linking failed." << endl;
        program_log(_program);

        glDeleteProgram(_program);
        _program = 0;
    }

    GetErrors();
}

#define LOG_BUFFER_SIZE 8096

void Shader::program_log(GLuint program)
{
    char logBuffer[LOG_BUFFER_SIZE];
    GLsizei length;

    logBuffer[0] = '\0';
    glGetProgramInfoLog(program, LOG_BUFFER_SIZE, &length,logBuffer);

    if (length > 0) {
        qDebug()  << logBuffer << endl;
    }
};

void Shader::shader_log(GLuint shader)
{
    char logBuffer[LOG_BUFFER_SIZE];
    GLsizei length;

    logBuffer[0] = '\0';
    glGetShaderInfoLog(shader, LOG_BUFFER_SIZE, &length,logBuffer);

    if (length > 0) {
        qDebug() << logBuffer << endl;
    }
};