FlowVis/shader.cpp

#include <fstream>

#include "shader.h"

Shader::Shader(const string &path) :
_success(false)
{
        _success = init(path, false, 0, 0, 0);
        if (!_success) return;
        get_errors();
}

Shader::Shader(const string &path, bool geometryShader, GLenum inputType, 
        GLenum outputType, GLint maxOutVertices) : _success(false)
{
        _success = init(path, geometryShader, inputType, outputType, maxOutVertices);
        if (!_success) return;
        get_errors();
}

Shader::~Shader()
{
        glDeleteProgram(_program);
        glDeleteShader(_vertex_shader);
        if (_geometry_shader != 0)
                glDeleteShader(_geometry_shader);
        glDeleteShader(_fragment_shader);
}

bool Shader::init(const string &path, bool geometryShader, GLenum inputType, 
        GLenum outputType, GLint maxOutVertices)
{
        // Load the shader files

        string vertex_shader_source;
        if (file_exists(path+".vert")) {
                vertex_shader_source = read_file(path+".vert");
        } else {
                cerr << "Vertex shader file "
                        << path <<".vert does not exist." << endl;
                return false;
        }

        string geometry_shader_source;
        if (geometryShader)
        {
                if (file_exists(path+".geom")) {
                        geometry_shader_source = read_file(path+".geom");
                } else {
                        cerr << "Geometry shader file "
                                << path <<".geom does not exist." << endl;
                        return false;
                }
        }

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

        // Compile the shaders

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

        get_errors();

        if (geometryShader)
        {
                _geometry_shader = compile(GL_GEOMETRY_SHADER_EXT, geometry_shader_source);
                if (_geometry_shader == 0)
                        return false;

                get_errors();
        }

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

        get_errors();

        // Link the shaders into a program

        link(geometryShader, inputType, outputType, maxOutVertices);
        if (_program == 0)
                return false;

        return true;
}

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, (const GLint*)&len);

        glCompileShader(shader);

        // Check for errors

        int status;

        glGetShaderiv(shader, GL_COMPILE_STATUS, (GLint*)&status);

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

        get_errors();

        return shader;    
}

void Shader::link(bool geometryShader, GLenum inputType, 
        GLenum outputType, GLint maxOutVertices)
{
        // Create program handle
        _program = glCreateProgram();

        if (geometryShader)
        {
                // Set geometry shader params
                glProgramParameteriEXT(_program, GL_GEOMETRY_INPUT_TYPE_EXT, inputType);
                get_errors();
                glProgramParameteriEXT(_program, GL_GEOMETRY_OUTPUT_TYPE_EXT, outputType);
                get_errors();
                if (maxOutVertices == 0)
                        glGetIntegerv(GL_MAX_GEOMETRY_OUTPUT_VERTICES_EXT, &maxOutVertices);
        
                glProgramParameteriEXT(_program, GL_GEOMETRY_VERTICES_OUT_EXT, maxOutVertices);
                get_errors();
        }

        // Attach shaders and link
        glAttachShader(_program, _vertex_shader);
        if (geometryShader)
                glAttachShader(_program, _geometry_shader);
        glAttachShader(_program, _fragment_shader);

        glLinkProgram(_program);

        // Check for problems

        int status;

        glGetProgramiv(_program, GL_LINK_STATUS, (GLint*)&status);

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

                glDeleteProgram(_program);
                _program = 0;
        }

        get_errors();
}

bool Shader::file_exists(const string &filename)
{
        std::ifstream ifile(filename.c_str());
        return ifile;
}

string Shader::read_file(const string &filename)
{
        std::ifstream ifile(filename.c_str());

        return string(std::istreambuf_iterator<char>(ifile),
                std::istreambuf_iterator<char>());
}

void Shader::get_errors(void)
{
        GLenum error = glGetError();

        if (error != GL_NO_ERROR) {
                switch (error) {
                case GL_INVALID_ENUM:
                        cerr << "GL: enum argument out of range." << endl;
                        break;
                case GL_INVALID_VALUE:
                        cerr << "GL: Numeric argument out of range." << endl;
                        break;
                case GL_INVALID_OPERATION:
                        cerr << "GL: Operation illegal in current state." << endl;
                        break;
                //case GL_INVALID_FRAMEBUFFER_OPERATION:
                //      cerr << "GL: Framebuffer object is not complete." << endl;
                //      break;
                case GL_OUT_OF_MEMORY:
                        cerr << "GL: Not enough memory left to execute command." << endl;
                        break;
                default:
                        cerr << "GL: Unknown error." << endl;
                }
        }
}

#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) {
                cout << 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) {
                cout << logBuffer << endl;
        }
};