GLRenderWidget.cpp

Go to the documentation of this file.

#include "GLRenderWidget.h"
#include "FileReader.h"
#include <iostream>

#ifdef _DEBUG
#define ENABLE_GL_DBG_OUTPUT
#endif

GLRenderWidget::GLRenderWidget(QWidget *parent) : QOpenGLWidget(parent), vbo(QOpenGLBuffer::VertexBuffer), indices(QOpenGLBuffer::IndexBuffer), dirty(false), hasData(false), hasShader(false) {
    QSurfaceFormat fmt;
    fmt.setRenderableType(QSurfaceFormat::OpenGL);
    fmt.setDepthBufferSize(24);
    fmt.setVersion(4, 3);
    fmt.setProfile(QSurfaceFormat::CoreProfile);
#ifdef ENABLE_GL_DBG_OUTPUT
    fmt.setOption(QSurfaceFormat::DebugContext);
#endif
    setFormat(fmt);
    QSurfaceFormat::setDefaultFormat(fmt);
}

GLRenderWidget::~GLRenderWidget()
{
}

void GLRenderWidget::initializeGL() {
    auto ctxfmt = context()->format();
    auto prof = ctxfmt.profile();
    auto ctxprofile = prof == QSurfaceFormat::CompatibilityProfile ? "Comp" : prof == QSurfaceFormat::CoreProfile ? "Core" : "No Profile";
    auto ctxvers = ctxfmt.version();
    std::cout << " Version: " << ctxvers.first << "." << ctxvers.second << " | Profile " << ctxprofile << std::endl;

    initializeOpenGLFunctions();
#ifdef ENABLE_GL_DBG_OUTPUT
    logger = new QOpenGLDebugLogger(this);
    logger->initialize();
#endif

    glEnable(GL_BLEND);
    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
    glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
    glViewport(0, 0, (GLint)this->width(), (GLint)this->height());
}


void GLRenderWidget::resizeGL(int width, int height) {
    glViewport(0, 0, (GLint)width, (GLint)height);
}

void GLRenderWidget::paintGL() {

    if (dirty && hasShader) {
        updateVBOs();
    }
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

    if (hasShader && hasData && hasRegionSeperatorValueAndColors && volume != nullptr && volume->isCreated()) {
        vao.bind();
        shader->bind();
        volume->bind();
        shader->setUniformValue("regionSeperator",regionSeperator);
        shader->setUniformValue("regionColor1",regionColor1);
        shader->setUniformValue("regionColor2",regionColor2);
        shader->setUniformValue("depth",volume->depth());
        shader->setUniformValue("height", volume->height());
        shader->setUniformValue("width", volume->width());
        shader->setUniformValue("orientation", orientation);
        glDrawElements(GL_TRIANGLES, (GLuint)numVerts, GL_UNSIGNED_INT, 0);
        shader->release();
        vao.release();
#ifdef ENABLE_GL_DBG_OUTPUT
        auto msgs = logger->loggedMessages();
        for (const auto& msg : msgs) {
            std::cout << "Rendering: " << msg.message().toStdString();
        }
#endif
    }
}

void GLRenderWidget::setRenderObject(RenderData &data) {
    objectData = data;
    dirty = true;
}

void GLRenderWidget::setOrientation(int ori) {
    orientation = ori;
}

void GLRenderWidget::setShader(const std::string &vert, const std::string &frag) {
    makeCurrent();
    shader = new QOpenGLShaderProgram;

    size_t error = 0;
    auto vertShaderCode = readFile(vert, error);
    if (error) {
        // log error?
    }
    auto fragShaderCode = readFile(frag, error);
    if (error) {
        // log error
    }

    auto vstatus = shader->addShaderFromSourceCode(QOpenGLShader::Vertex, vertShaderCode.c_str());
    if (!vstatus) {
        std::cout << "unable to add vert shader" << std::endl;
    }
    auto fstatus = shader->addShaderFromSourceCode(QOpenGLShader::Fragment, fragShaderCode.c_str());
    if (!fstatus){
        std::cout << "unable to add frag shader" << std::endl;
    }
    if (vstatus && fstatus) {
        if (!shader->link()) {
            std::cout << "unable to link shaders" << std::endl;
        } else {
            hasShader = true;
        }
    }
    shader->bindAttributeLocation("pos", 0);

#ifdef ENABLE_GL_DBG_OUTPUT
    auto msgs = logger->loggedMessages();
    for (const auto& msg : msgs) {
        std::cout << "Shader creation: " << msg.message().toStdString();
    }
#endif
}

void GLRenderWidget::updateVBOs() {
    if (!vao.isCreated()) {
        vao.create();
    }
    vao.bind();

    vbo.destroy();
    indices.destroy();

    vbo.create();
    vbo.bind();
    vbo.allocate(objectData.vertices.data(), sizeof(glm::vec3) * objectData.vertices.size());

    glEnableVertexAttribArray(0);
    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, 0);


#ifdef ENABLE_GL_DBG_OUTPUT
    auto msgs = logger->loggedMessages();
    for (const auto& msg : msgs) {
        std::cout << "VBO creation: " << msg.message().toStdString();
    }
#endif

    indices.create();
    indices.bind();
    indices.allocate(objectData.indices.data(), sizeof(unsigned int) * objectData.indices.size());

    numVerts = objectData.indices.size();
    dirty = false;
    hasData = true;

    vao.release();
}

void GLRenderWidget::setVolumeTexture(QOpenGLTexture *volume3Dtex) {
    volume = volume3Dtex;
}

void GLRenderWidget::setRegion(float sep,QColor c1, QColor c2){
    regionSeperator=sep;
    regionColor1 =c1;
    regionColor2 =c2;
    hasRegionSeperatorValueAndColors=true;
}