volprogram.cpp

Go to the documentation of this file.

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

namespace
{
    void LoadFile(const char *filename, std::vector<char> &data)
    {
        std::ifstream in(filename, 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);
    }
}

VolProgram::VolProgram(const char *name) :
    program_(0), mode_(M_SLICE), recompile_(true), progname_(name)
{
    RecompileWhenRequired();
}

GLuint VolProgram::CompileProgram(const char *name, const CompileSettings& settings) 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";
    defines += std::string("#define mode ") + settings.mode + "\n";

    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("glCreateShader failed");
    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("glCreateShader failed");
    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("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("program linking failed");

    GLuint result = prog.id;

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

    return result;
}

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

void VolProgram::SetVolumeTexture(GLuint texture)
{
    volume_texture_ = texture;
}

void VolProgram::SetBackAndFrontTextures(GLuint back, GLuint front)
{
    back_texture_ = back;
    front_texture_ = front;
}

void VolProgram::SetTransferFunctionTexture(GLuint tex)
{
    transfer_texture_ = tex;
}

void VolProgram::SetMode(Mode mode)
{
    recompile_ = mode_ != mode;
    mode_ = mode;
}

void VolProgram::RecompileWhenRequired()
{
    if (recompile_) {
        recompile_ = false;
        CompileSettings settings;

        switch (mode_) {
        case M_SLICE:
            settings.mode = "SLICE_MODE";
            break;
        case M_3D_COLOR_CUBE:
            settings.mode = "COLOR_CUBE_MODE";
            break;
        case M_3D_RAYCAST:
            settings.mode = "RAYCAST_MODE";
            break;
        }

        glDeleteProgram(program_);
        program_ = CompileProgram(progname_.c_str(), settings);
    }
}

void VolProgram::Use()
{
    try {
        RecompileWhenRequired();
    } catch (...) {
        glUseProgram(0);
        return;
    }

    glActiveTexture(GL_TEXTURE3);
    glBindTexture(GL_TEXTURE_1D, transfer_texture_);
    glActiveTexture(GL_TEXTURE2);
    glBindTexture(GL_TEXTURE_2D, back_texture_);
    glActiveTexture(GL_TEXTURE1);
    glBindTexture(GL_TEXTURE_2D, front_texture_);
    glActiveTexture(GL_TEXTURE0);
    glBindTexture(GL_TEXTURE_3D, volume_texture_);

    glUseProgram(program_);

    glUniform1i(glGetUniformLocation(program_, "volume_texture"), 0);
    glUniform1i(glGetUniformLocation(program_, "front_texture"), 1);
    glUniform1i(glGetUniformLocation(program_, "back_texture"), 2);
    glUniform1i(glGetUniformLocation(program_, "transfer_texture"), 3);
}

---