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

Go to the documentation of this file.

#include "GL3DView.h"

#include <QtGui>
#include <QtOpenGL>

#include "TimeCounter.h"

GLMultiProgramm::GLMultiProgramm()
{
}

void GLMultiProgramm::load(QString &vertexShaderName, QString &loopFragmentShaderName, QString &lastFragmentShaderName)
{
        loopProgramm.load(vertexShaderName, loopFragmentShaderName);
        lastProgramm.load(vertexShaderName, lastFragmentShaderName);
}

void GLMultiProgramm::link()
{
        loopProgramm.link();
        lastProgramm.fragmentShader.maxLoopIterations = loopProgramm.fragmentShader.maxLoopIterations;
        lastProgramm.fragmentShader.loopIterations = loopProgramm.fragmentShader.loopIterations;
        lastProgramm.link();
}

void GLMultiProgramm::free()
{
        loopProgramm.free();
        lastProgramm.free();
}

GL3DView::GL3DView() : GLView()
{
        zRot = 0.0f;
        xRot = -90.0f;
        dist = -3.5f;

        rtSize = 1024;
        rcBigSize = 1024; // TODO: 2048
        rcSmallSize = rcBigSize;
        minFps = 12;

        aspectRatio = 1;

        rcProgramms[0].load(QString("rc_vertex"), QString("rc_fragment_mip_loop"), QString("rc_fragment_mip_last"));
        rcProgramms[1].load(QString("rc_vertex"), QString("rc_fragment_dvr"), QString("rc_fragment_dvr"));
        rtProgramm.load(QString("rt_vertex"), QString("rt_fragment"));

        transferTexture.setTypes(GL_RGBA8, GL_NEAREST);

        rtBoxFrontBuffer.createTexture()->setTypes(GL_RGB10_A2, GL_LINEAR);
        rtBoxBackBuffer.createTexture()->setTypes(GL_RGB10_A2, GL_LINEAR);
        rcSmallBuffer.createTexture()->setTypes(GL_RGBA8, GL_NEAREST);
        rcBigBuffer.createTexture()->setTypes(GL_RGBA8, GL_NEAREST);

        viewChanged = true;
}

GL3DView::~GL3DView()
{
}

void GL3DView::initializeGL()                                                                   // All Setup For OpenGL Goes Here
{
        GLenum glError;

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

        // init opengl state
        glShadeModel(GL_SMOOTH);                                                                        // Enables Smooth Shading
        glClearColor(0.0f, 0.0f, 0.0f, 0.0f);                                           // Black Background and transparent
        glDisable(GL_DEPTH_TEST);                                                                       // Disables Depth Testing
        glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);                      // Really Nice Perspective Calculations
        glEnable(GL_CULL_FACE);

        glMatrixMode(GL_PROJECTION);
        glLoadIdentity();

        glMatrixMode(GL_MODELVIEW);
        glLoadIdentity();

        // link shaders
        rtProgramm.link();
        for(int i = 0;i < shaderCount;++i)
        {
                rcProgramms[i].link();
        }

        // create transfer Texture
        transferTexture.create(4096);
        loadTransferFunction();

        // create buffers
        rtBoxFrontBuffer.create(rtSize, rtSize);
        rtBoxBackBuffer.create(rtSize, rtSize);
        rcSmallBuffer.create(rcSmallSize, rcSmallSize);
        rcBigBuffer.create(rcBigSize, rcBigSize);

        glError = glGetError();
        if(glError != GL_NO_ERROR)
        {
                qDebug() << "initializeGL3D error: " << (char*)gluErrorString(glError);
        }

        //qDebug() << "STATE: initilizeGL 3D";
}

void GL3DView::uninitializeGL()
{
        GLenum glError;

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

        for(int i = 0;i < shaderCount;++i)
                rcProgramms[i].free();
        rtProgramm.free();

        transferTexture.free();

        rtBoxFrontBuffer.free();
        rtBoxBackBuffer.free();
        rcSmallBuffer.free();
        rcBigBuffer.free();

        glDisable(GL_CULL_FACE);
        glEnable(GL_DEPTH_TEST);

        glError = glGetError();
        if(glError != GL_NO_ERROR)
        {
                qDebug() << "uninitializeGL3D error: " << (char*)gluErrorString(glError);
        }
}

void GL3DView::paintGL()
{
        LONGLONG startCount;
        GLenum glError;

        if(volumeDesc->volumeTexture != 0)
        {
                //if(transferFunctionDesc->hasChanged || viewChanged || volumeDesc->hasChanged)
                //{
                        if(transferFunctionDesc->hasChanged)
                        {
                                transferFunctionDesc->hasChanged = false;
                                loadTransferFunction();
                        }

                        if(viewChanged || volumeDesc->hasChanged)
                        {
                                viewChanged = false;
                                drawColorCubes();
                        }

                        if(volumeDesc->hasChanged || stateDesc->shaderChanged)
                        {
                                stateDesc->shaderChanged = false;
                                volumeDesc->hasChanged = false;

                                GLuint maxNeededSteps;
                                GLuint maxLoopStepsPerIteration, maxLastStepsPerIteration;
                                GLuint loopStepsPerIteration, lastStepsPerIteration;

                                maxNeededSteps = volumeDesc->maxSideLength;
                                maxLoopStepsPerIteration = rcProgramms[stateDesc->shaderIndex].loopProgramm.fragmentShader.maxLoopIterations;
                                maxLastStepsPerIteration = rcProgramms[stateDesc->shaderIndex].lastProgramm.fragmentShader.maxLoopIterations;

                                qDebug() << "max needed steps: " << maxNeededSteps << " | max loop iterations: " << maxLoopStepsPerIteration << " | max last iterations: " << maxLastStepsPerIteration;

                                loopIterations = ((maxNeededSteps - maxLastStepsPerIteration) + maxLoopStepsPerIteration - 1) / maxLoopStepsPerIteration;
                                loopStepsPerIteration = maxLoopStepsPerIteration;
                                lastStepsPerIteration = maxNeededSteps - loopStepsPerIteration * loopIterations;

                                qDebug() << "loop iterations: " << loopIterations << " | loop steps: " << loopStepsPerIteration << " | last steps: " << lastStepsPerIteration;

                                rcProgramms[stateDesc->shaderIndex].lastProgramm.fragmentShader.loopIterations = lastStepsPerIteration;
                                rcProgramms[stateDesc->shaderIndex].lastProgramm.link();

                                glFinish();
                        }

                        startCount = TimeCounter_read();

                        drawVolume(&rcSmallBuffer);

                        float fps = 1000000.0f / TimeCounter_getDiffInUs(TimeCounter_read(), startCount);
                        if(fps < minFps && rcSmallSize > 128)
                        {
                                rcSmallSize /= 2;
                                rcSmallBuffer.create(rcSmallSize, rcSmallSize);
                                qDebug() << "speed 3d draw to slow: " << fps << "fps | reduced size to: " << rcSmallSize;
                        }
                        else if(fps > minFps * 5 && rcSmallSize < rcBigSize)
                        {
                                rcSmallSize *= 2;
                                rcSmallBuffer.create(rcSmallSize, rcSmallSize);
                                qDebug() << "speed 3d draw to \"fast\": " << fps << "fps | increased size to: " << rcSmallSize;
                        }

                        glBindTexture(GL_TEXTURE_2D, rcSmallBuffer.getTexture()->getTexture());
                        /*parent->updateGL();
                }
                else
                {
                        startCount = TimeCounter_read();

                        drawVolume(&rcBigBuffer);

                        glFinish();
                        float fps = 1000000.0f / TimeCounter_getDiffInUs(TimeCounter_read(), startCount);
                        qDebug() << "quality image: " << fps << "fps";

                        glBindTexture(GL_TEXTURE_2D, rcBigBuffer.getTexture()->getTexture());
                }*/

                glClear(GL_COLOR_BUFFER_BIT);
                glUseProgram(rtProgramm.programm);
                //glBindTexture(GL_TEXTURE_2D, rcSmallBuffer.getTexture()->getTexture());
                glUniform1i(glGetUniformLocation(rtProgramm.programm, "rcTexture"), 0);
                glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
                glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);

                glBegin(GL_QUADS);
                        glTexCoord2i(0, 0);
                        glVertex3f(-1, -1, 0);
                        glTexCoord2i(1, 0);
                        glVertex3f(1, -1, 0);
                        glTexCoord2i(1, 1);
                        glVertex3f(1, 1, 0);
                        glTexCoord2i(0, 1);
                        glVertex3f(-1, 1, 0);
                glEnd();

                glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
                glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
                glUseProgram(0);
        }
        else
        {
                glClear(GL_COLOR_BUFFER_BIT);
        }

        glError = glGetError();
        if(glError != GL_NO_ERROR)
        {
                qDebug() << "paintGL3D error end: " << (char*)gluErrorString(glError);
        }
}

void GL3DView::resizeGL(int width, int height)
{
        GLenum glError;

        glError = glGetError();
        if(glError != GL_NO_ERROR)
        {
                qDebug() << "resizeGL3D: an error was still registered: " << (char*)gluErrorString(glError);
        }
        glViewport(0, 0, width, height);

        this->width = width;
        this->height = height;
        aspectRatio = (GLfloat)width / (GLfloat)height;

        viewChanged = true;
}

void GL3DView::mousePressEvent(QMouseEvent *event)
{
        lastPos = event->pos();
}

void GL3DView::mouseMoveEvent(QMouseEvent *event)
{
        int dx = event->x() - lastPos.x();
        int dy = event->y() - lastPos.y();

        if(event->buttons() & Qt::LeftButton) {
                zRot += dx;
                xRot += dy;
                viewChanged = true;
                parent->updateGL();
        }
        lastPos = event->pos();
}

void GL3DView::wheelEvent(QWheelEvent *event)
{
        float newDist;

        newDist = dist + event->delta() / 200.0;
        if(newDist > -1.6f)
        {
                newDist = -1.6f;
        }
        if(newDist != dist)
        {
                dist = newDist;
                viewChanged = true;
                parent->updateGL();
        }
}

void GL3DView::setColorVertex(GLfloat x, GLfloat y, GLfloat z)
{
        x = x * volumeDesc->xNormLength + volumeDesc->xNormOffset;
        y = y * volumeDesc->yNormLength + volumeDesc->yNormOffset;
        z = z * volumeDesc->zNormLength + volumeDesc->zNormOffset;
        glColor3f(x, y, z);

        x = x * 2 - 1;
        y = y * 2 - 1;
        z = z * 2 - 1;
        glVertex3f(x, y, z);
}

void GL3DView::drawCube()
{
        GLfloat xStartClip = 0.0f;

        glBegin(GL_QUADS);
                setColorVertex(1, 1, 0);
                setColorVertex(xStartClip, 1, 0);
                setColorVertex(xStartClip, 1, 1);
                setColorVertex(1, 1, 1);

                setColorVertex(1, 0, 1);
                setColorVertex(xStartClip, 0, 1);
                setColorVertex(xStartClip, 0, 0);
                setColorVertex(1, 0, 0);

                setColorVertex(1, 1, 1);
                setColorVertex(xStartClip, 1, 1);
                setColorVertex(xStartClip, 0, 1);
                setColorVertex(1, 0, 1);

                setColorVertex(1, 0, 0);
                setColorVertex(xStartClip, 0, 0);
                setColorVertex(xStartClip, 1, 0);
                setColorVertex(1, 1, 0);

                setColorVertex(xStartClip, 1, 1);
                setColorVertex(xStartClip, 1, 0);
                setColorVertex(xStartClip, 0, 0);
                setColorVertex(xStartClip, 0, 1);

                setColorVertex(1, 1, 0);
                setColorVertex(1, 1, 1);
                setColorVertex(1, 0, 1);
                setColorVertex(1, 0, 0);
        glEnd();

        glColor3f(1.0f, 1.0f, 1.0f);
}

void GL3DView::loadTransferFunction()
{
        GLint width = transferTexture.getWidth();
        if(width != 4096) {
                GLint scale = 4096 / width;
                unsigned int *scaledTransferTexture = new unsigned int[width];
                for(GLint i = 0;i < width;++i)
                {
                        scaledTransferTexture[i] = transferFunctionDesc->transferFunction[i * scale];
                }
                transferTexture.updateSubImage(0, width, GL_RGBA, GL_UNSIGNED_INT_8_8_8_8, (void*)scaledTransferTexture);
                delete [] scaledTransferTexture;
        }
        else
        {
                transferTexture.updateSubImage(0, 4096, GL_RGBA, GL_UNSIGNED_INT_8_8_8_8, (void*)transferFunctionDesc->transferFunction);
        }
        transferFunctionDesc->hasChanged = false;
        //qDebug() << "transfer function updated";
}

void GL3DView::drawColorCubes()
{
        GLenum glError;

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

        /*GLenum status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT);
        switch (status)
        {
        case GL_FRAMEBUFFER_COMPLETE_EXT:
                qDebug() << "Framebuffer ok";
                break;
        case GL_FRAMEBUFFER_UNSUPPORTED_EXT:
                qDebug() << "Framebuffer unsupported";
                break;
        }*/

        glViewport(0, 0, rtSize, rtSize);

        glMatrixMode(GL_PROJECTION);
        glLoadIdentity();
        // Calculate The Aspect Ratio Of The Window
        gluPerspective(45.0f, aspectRatio, 0.1f, 100.0f);

        glMatrixMode(GL_MODELVIEW);
        glLoadIdentity();
        glTranslatef(0.0f, 0.0f, dist);
        glRotatef(xRot, 1.0f, 0.0f, 0.0f);
        glRotatef(zRot, 0.0f, 0.0f, 1.0f);

        glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, rtBoxFrontBuffer.getBuffer());
        glClear(GL_COLOR_BUFFER_BIT);
        glCullFace(GL_BACK);

        drawCube();

        glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, rtBoxBackBuffer.getBuffer());
        glClear(GL_COLOR_BUFFER_BIT);
        glCullFace(GL_FRONT);

        drawCube();

        glCullFace(GL_BACK);
        glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);

        glMatrixMode(GL_PROJECTION);
        glLoadIdentity();

        glMatrixMode(GL_MODELVIEW);
        glLoadIdentity();

        glViewport(0, 0, width, height);
}

void GL3DView::drawVolume(GLFramebuffer *framebuffer)
{
        GLenum glError;

        glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, framebuffer->getBuffer());
        glError = glGetError();
        if(glError != GL_NO_ERROR)
        {
                qDebug() << "paintGL3D error glBindFramebufferEXT: " << (char*)gluErrorString(glError);
        }

        glViewport(0, 0, framebuffer->getWidth(), framebuffer->getHeight());

        glClear(GL_COLOR_BUFFER_BIT);

        //qDebug() << stateDesc->shaderIndex << " " << rcProgramm << " " << rcProgrammStepsPerIteration;

        GLuint rcProgramm, loopStepsPerIteration;

        loopStepsPerIteration = 0;

        if(loopIterations > 0)
        {
                rcProgramm = rcProgramms[stateDesc->shaderIndex].loopProgramm.programm;
                loopStepsPerIteration = rcProgramms[stateDesc->shaderIndex].loopProgramm.fragmentShader.loopIterations;

                glUseProgram(rcProgramm);

                //glActiveTexture(GL_TEXTURE0); // should be standard
                glBindTexture(GL_TEXTURE_3D, volumeDesc->volumeTexture);
                glUniform1i(glGetUniformLocation(rcProgramm, "volumeTexture"), 0);
                glActiveTexture(GL_TEXTURE1);
                glBindTexture(GL_TEXTURE_1D, transferTexture.getTexture());
                glUniform1i(glGetUniformLocation(rcProgramm, "transferTexture"), 1);
                glActiveTexture(GL_TEXTURE2);
                glBindTexture(GL_TEXTURE_2D, rtBoxFrontBuffer.getTexture()->getTexture());
                glUniform1i(glGetUniformLocation(rcProgramm, "frontTexture"), 2);
                glActiveTexture(GL_TEXTURE3);
                glBindTexture(GL_TEXTURE_2D, rtBoxBackBuffer.getTexture()->getTexture());
                glUniform1i(glGetUniformLocation(rcProgramm, "backTexture"), 3);
                glActiveTexture(GL_TEXTURE4);
                glBindTexture(GL_TEXTURE_2D, rcSmallBuffer.getTexture()->getTexture());
                glUniform1i(glGetUniformLocation(rcProgramm, "colorTexture"), 4);
                glUniform1f(glGetUniformLocation(rcProgramm, "stepDist"), volumeDesc->stepDist);

                for(GLuint i = 0;i < loopIterations;++i) {
                        glUniform1i(glGetUniformLocation(rcProgramm, "startStep"), i * loopStepsPerIteration);
                        glBegin(GL_QUADS);
                                glTexCoord2i(0, 0);
                                glVertex3f(-1, -1, 0);
                                glTexCoord2i(1, 0);
                                glVertex3f(1, -1, 0);
                                glTexCoord2i(1, 1);
                                glVertex3f(1, 1, 0);
                                glTexCoord2i(0, 1);
                                glVertex3f(-1, 1, 0);
                        glEnd();

                        glError = glGetError();
                        if(glError != GL_NO_ERROR)
                        {
                                qDebug() << "paintGL3D error glEnd: " << (char*)gluErrorString(glError);
                        }
                        glFinish();
                }
        }

        rcProgramm = rcProgramms[stateDesc->shaderIndex].lastProgramm.programm;

        glUseProgram(rcProgramm);

        //glActiveTexture(GL_TEXTURE0); // should be standard
        glBindTexture(GL_TEXTURE_3D, volumeDesc->volumeTexture);
        glUniform1i(glGetUniformLocation(rcProgramm, "volumeTexture"), 0);
        glActiveTexture(GL_TEXTURE1);
        glBindTexture(GL_TEXTURE_1D, transferTexture.getTexture());
        glUniform1i(glGetUniformLocation(rcProgramm, "transferTexture"), 1);
        glActiveTexture(GL_TEXTURE2);
        glBindTexture(GL_TEXTURE_2D, rtBoxFrontBuffer.getTexture()->getTexture());
        glUniform1i(glGetUniformLocation(rcProgramm, "frontTexture"), 2);
        glActiveTexture(GL_TEXTURE3);
        glBindTexture(GL_TEXTURE_2D, rtBoxBackBuffer.getTexture()->getTexture());
        glUniform1i(glGetUniformLocation(rcProgramm, "backTexture"), 3);
        glActiveTexture(GL_TEXTURE4);
        glBindTexture(GL_TEXTURE_2D, rcSmallBuffer.getTexture()->getTexture());
        glUniform1i(glGetUniformLocation(rcProgramm, "colorTexture"), 4);
        glUniform1f(glGetUniformLocation(rcProgramm, "stepDist"), volumeDesc->stepDist);

        glUniform1i(glGetUniformLocation(rcProgramm, "startStep"), loopIterations * loopStepsPerIteration);
        glBegin(GL_QUADS);
                glTexCoord2i(0, 0);
                glVertex3f(-1, -1, 0);
                glTexCoord2i(1, 0);
                glVertex3f(1, -1, 0);
                glTexCoord2i(1, 1);
                glVertex3f(1, 1, 0);
                glTexCoord2i(0, 1);
                glVertex3f(-1, 1, 0);
        glEnd();

        glError = glGetError();
        if(glError != GL_NO_ERROR)
        {
                qDebug() << "paintGL3D error glEnd: " << (char*)gluErrorString(glError);
        }
        glFinish();

        glUseProgram(0);
        glActiveTexture(GL_TEXTURE0);

        glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
        glViewport(0, 0, width, height);
}

---