D:/Timo/Visualisierung/LU/Aufgabe1/src/GLWidget.cpp

Go to the documentation of this file.

#include "glew/glew.h"
#include "GLWidget.h"
#include "TimeCounter.h"

#include <QtDebug>

GLWidget::GLWidget(Ui_MainWindow uiMainWindow, QWidget *parent) : QGLWidget(parent)
{
        QObject::connect(uiMainWindow.action2D, SIGNAL(triggered()), this, SLOT(view2D()));
        QObject::connect(uiMainWindow.action3D, SIGNAL(triggered()), this, SLOT(view3D()));

        QObject::connect(uiMainWindow.actionGroupShader, SIGNAL(triggered(QAction *)), this, SLOT(shaderChanged(QAction *)));

        gl3DView = new GL3DView();
        gl3DView->setData(this, &volumeDesc, &transferFunctionDesc, &stateDesc);
        gl2DView = new GL2DView();
        gl2DView->setData(this, &volumeDesc, &transferFunctionDesc, &stateDesc);
        // TODO: just for faster development -> change to gl2DView
        glCurrentView = gl3DView;

        updateAsked = false;
        timerIdentifier = startTimer(50);
}

GLWidget::~GLWidget()
{
        killTimer(timerIdentifier);
        glCurrentView->uninitializeGL();
        delete gl2DView;
        delete gl3DView;
}

void GLWidget::updateGL()
{
        updateAsked = true;
}

void GLWidget::timerEvent(QTimerEvent *event)
{
        if(updateAsked)
        {
                updateAsked = false;
                QGLWidget::updateGL();
        }
}

QSize GLWidget::minimumSizeHint() const
{
        return QSize(128, 128);
}

QSize GLWidget::sizeHint() const
{
        return QSize(512, 512);
}

void GLWidget::initializeGL()
{
        GLenum glError;

        glError = glGetError();
        if(glError != GL_NO_ERROR)
        {
                qDebug() << "initializeGL: an error was still registered: " << (char*)gluErrorString(glError);
        }

        glError = glewInit();
        if(glError != GLEW_OK)
        {
                // glewInit failed, something is seriously wrong
                qDebug() << "Error initializing GLEW: " << (char*)glewGetErrorString(glError);

                // TODO: take care no other functions are called
        }
        else
        {
                // tell the current view too initialize
                glCurrentView->initializeGL();
        }
}

void GLWidget::paintGL()
{
        static bool benchmark = true;
        static float fps = 0.0f;
        LONGLONG startCount;
        GLenum glError;

        glError = glGetError();
        if(glError != GL_NO_ERROR)
        {
                qDebug() << "paintGL: an error was still registered: " << (char*)gluErrorString(glError);
        }

        /*if(benchmark)
        {
                for(int i = 0;i < 7;++i)
                {
                        startCount = TimeCounter_read();
                        glCurrentView->paintGL();
                        // TODO: with finish we wait until the commands are really executed! remove on end
                        glFinish();

                        if(i > 1) {
                                float tmpFps = (1000000.0f / TimeCounter_getDiffInUs(TimeCounter_read(), startCount));
                                qDebug() << "fps: " << tmpFps;
                                fps     += tmpFps;
                        }
                }

                qDebug() << "avg fps: " << (fps / 5.0f);
                benchmark = false;
        }
        else
        {*/
                //startCount = TimeCounter_read();
                glCurrentView->paintGL();
                // with finish we wait until the commands are really executed! remove if we have problems with user interaction
                /*glFinish();

                qDebug() << "fps: " << (1000000.0f / TimeCounter_getDiffInUs(TimeCounter_read(), startCount));*/
        //}
}

void GLWidget::resizeGL(int width, int height)
{
        lastWidth = width;
        lastHeight = height;
        glCurrentView->resizeGL(width, height);
        update();
}

void GLWidget::mousePressEvent(QMouseEvent *event)
{
        glCurrentView->mousePressEvent(event);
}

void GLWidget::mouseMoveEvent(QMouseEvent *event)
{
        glCurrentView->mouseMoveEvent(event);
}

void GLWidget::wheelEvent(QWheelEvent *event)
{
        glCurrentView->wheelEvent(event);
}

void GLWidget::changeVolume(Volume *volume)
{
        GLenum glError;

        glError = glGetError();
        if(glError != GL_NO_ERROR)
        {
                qDebug() << "changeVolume: an error was still registered: " << (char*)gluErrorString(glError);
        }

        if(volumeDesc.volumeTexture != 0) {
                glDeleteTextures(1, &(volumeDesc.volumeTexture));
                glError = glGetError();
                if(glError != GL_NO_ERROR)
                {
                        qDebug() << "Error deleting texture: " << (char*)gluErrorString(glError);
                        volumeDesc.volumeTexture = 0;
                }
        }

        glGenTextures(1, &(volumeDesc.volumeTexture));
        glError = glGetError();
        if(glError != GL_NO_ERROR)
        {
                qDebug() << "Error generating texture: " << (char*)gluErrorString(glError);
                volumeDesc.volumeTexture = 0;
        }
        else if(volumeDesc.volumeTexture)
        {
                // TODO: test for texture 3D extension
                // bind texture
                glBindTexture(GL_TEXTURE_3D, volumeDesc.volumeTexture);
                glError = glGetError();
                if(glError != GL_NO_ERROR)
                {
                        qDebug() << "Could not bind texture: " << (char*)gluErrorString(glError);
                }
                else
                {
                        // TODO: not power of 2 textures
                        volumeDesc.set(volume->getWidth(), volume->getHeight(), volume->getDepth());

                        qDebug() << "- volume size: " << volumeDesc.realWidth << volumeDesc.realHeight << volumeDesc.realDepth << " | texture size: " << volumeDesc.width << volumeDesc.height << volumeDesc.depth;
        
                        // upload texture
                        glTexImage3D(GL_TEXTURE_3D_EXT, 0, GL_LUMINANCE12, volumeDesc.width, volumeDesc.height, volumeDesc.depth, 0, GL_LUMINANCE, GL_UNSIGNED_SHORT, NULL);
                        glTexSubImage3D(GL_TEXTURE_3D_EXT, 0, volumeDesc.xOffset, volumeDesc.yOffset, volumeDesc.zOffset, volumeDesc.realWidth, volumeDesc.realHeight, volumeDesc.realDepth, GL_LUMINANCE, GL_UNSIGNED_SHORT, (void*)volume->getData());
                        glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
                        glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);

                        glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
                        glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
                        glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);
                        /*glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
                        glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);*/

                        glError = glGetError();
                        if(glError != GL_NO_ERROR)
                        {
                                qDebug() << "Could not upload texture: " << (char*)gluErrorString(glError);
                        }
                }
        }

        updateGL();
}

void GLWidget::changeTransferFunction(unsigned int *transferFunction, int length)
{
        transferFunctionDesc.set(transferFunction, length);
        updateGL();
}

void GLWidget::switchView(GLView *newView)
{
        glCurrentView->uninitializeGL();
        glCurrentView = newView;
        glCurrentView->initializeGL();
        glCurrentView->resizeGL(lastWidth, lastHeight);
        updateGL();
}

void GLWidget::view2D()
{
        if(glCurrentView != gl2DView) {
                qDebug() << "2D view";
                switchView(gl2DView);
        }
}

void GLWidget::view3D()
{
        if(glCurrentView != gl3DView) {
                qDebug() << "3D view";
                switchView(gl3DView);
        }
}

void GLWidget::shaderChanged(QAction *qAction)
{
        // TODO: just when 3d?
        stateDesc.setShaderIndex(qAction->property("ShaderIndex").toInt());
        updateGL();
}

---