flowvis_program.cpp

Go to the documentation of this file.

#include "flowvis_program.h"
#include <vector>
#include <fstream>
#include <stdexcept>
#include <string>

namespace
{
    void LoadFile(const char *filename, std::vector<char> &data)
    {
        try
        {
            std::ifstream in((std::string("shader/") + std::string(filename)).c_str(), std::ios::in | std::ios::binary);
            in.exceptions(std::ios::failbit | std::ios::badbit);

            const long size = in.seekg(0, std::ios::end).tellg();
            in.seekg(0, std::ios::beg);

            data.clear();
            data.resize(size + 1, 0);
            in.read(&data[0], size);
        }catch(...)
        {
            throw std::runtime_error((std::string("File loading failed for: ") + std::string(filename)).c_str());
        }
    }
}

FlowVisProgram::FlowVisProgram(const char *name)
    : program_(0)
    , recompile_(true)
    , progname_(name)
    , m_mode(M_BG_INTER)
{
    RecompileWhenRequired();
}

GLuint FlowVisProgram::CompileProgram(const char *name) const
{
    std::vector<char> vs_source;
    LoadFile((std::string(name) + ".v_source").c_str(), vs_source);

    std::vector<char> fs_source;
    LoadFile((std::string(name) + ".f_source").c_str(), fs_source);

    std::string defines = "#define RUNTIME_MODE\n";
    
    switch (m_mode)
    {
    case M_BG_INTER:
        defines += std::string("#define mode M_BG_INTER\n");
        break;
    case M_TEXTURE_ROTATION:
        defines += std::string("#define mode M_TEXROT\n");
        break;
    default:
        defines += std::string("#define mode M_TEXTURE_ROTATION\n");
        break;
    }
    
    
    const char * dsource = defines.c_str();
    const GLchar *vsource[] = { dsource, &vs_source[0] };
    const GLchar *fsource[] = { dsource, &fs_source[0] };

    // classes for exception safety that delete the contained OpenGL Resource

    struct ShaderResource {
        GLuint id;
        ShaderResource() :
            id(0)
        {
        }
        ~ShaderResource()
        {
            glDeleteShader(id);
        }
    };

    struct ProgramResource {
        GLuint id;
        ProgramResource() :
            id(0)
        {
        }
        ~ProgramResource()
        {
            glDeleteProgram(id);
        }
    };

    ShaderResource vs;
    vs.id = glCreateShader(GL_VERTEX_SHADER);
    if (!vs.id) throw std::runtime_error("Shader creation failed for vertex shader!");
    glShaderSource(vs.id, 2, vsource, 0);
    glCompileShader(vs.id);
    GLint vcompile_status;
    glGetShaderiv(vs.id, GL_COMPILE_STATUS, &vcompile_status);

    if (vcompile_status != GL_TRUE) throw std::runtime_error("Vertex shader compilation failed!");

    ShaderResource fs;
    fs.id = glCreateShader(GL_FRAGMENT_SHADER);
    if (!fs.id) throw std::runtime_error("Shader creation failed for fragment shader!");
    glShaderSource(fs.id, 2, fsource, 0);
    glCompileShader(fs.id);
    GLint fcompile_status;
    glGetShaderiv(fs.id, GL_COMPILE_STATUS, &fcompile_status);

    if (fcompile_status != GL_TRUE) throw std::runtime_error("Fragment shader compilation failed!");

    ProgramResource prog;
    prog.id = glCreateProgram();
    if (!prog.id) throw std::runtime_error("Shader program creation failed!");
    glAttachShader(prog.id, vs.id);
    glAttachShader(prog.id, fs.id);
    glLinkProgram(prog.id);
    GLint link_status;
    glGetProgramiv(prog.id, GL_LINK_STATUS, &link_status);

    if (link_status != GL_TRUE) throw std::runtime_error("Shader program linking failed!");

    GLuint result = prog.id;

    // make sure the new program is not automatically deleted by a destructor
    prog.id = 0;

    return result;
}

FlowVisProgram::~FlowVisProgram()
{
    glDeleteProgram(program_);
}

void FlowVisProgram::RecompileWhenRequired()
{
    if (recompile_) {
        recompile_ = false;
        
        if(program_) glDeleteProgram(program_);
        program_ = CompileProgram(progname_.c_str());
    }
}

void FlowVisProgram::Use()
{
    Prepare();
    Start();
}

void FlowVisProgram::Prepare()
{
    try {
        RecompileWhenRequired();
    } catch (...) {
        glUseProgram(0);
        return;
    }

    glActiveTexture(GL_TEXTURE2);
    glBindTexture(GL_TEXTURE_2D, m_glyph_texture_);
    glActiveTexture(GL_TEXTURE1);
    glBindTexture(GL_TEXTURE_1D, m_transfer_texture_);
    glActiveTexture(GL_TEXTURE0);
    glBindTexture(GL_TEXTURE_2D, m_bgdata_texture_);
}

void FlowVisProgram::Start()
{
    glUseProgram(program_);

    glUniform1i(glGetUniformLocation(program_, "bgdata_texture"), 0);
    glUniform1i(glGetUniformLocation(program_, "transfer_texture"), 1);
    glUniform1i(glGetUniformLocation(program_, "glyph_texture"), 2);
}

void FlowVisProgram::Stop()
{
    glUseProgram(0);
}

void FlowVisProgram::SetBGDataTexture(GLuint tex)
{
    m_bgdata_texture_ = tex;
}

void FlowVisProgram::SetVelocityTexture(GLuint tex)
{
    m_velocity_texture_ = tex;
}

void FlowVisProgram::SetTransferFunctionTexture(GLuint tex)
{
    m_transfer_texture_ = tex;
}

void FlowVisProgram::SetMode(Mode new_mode)
{
    recompile_ = m_mode != new_mode;
    m_mode = new_mode;
}

void FlowVisProgram::SetArrowTexture(GLuint tex)
{
    m_arrow_texture_ = tex;
}

void FlowVisProgram::SetGlyphTexture(GLuint tex)
{
    m_glyph_texture_ = tex;
}

---