src/OpenGLWidget.cpp

Go to the documentation of this file.

#include "Volume.h"
#include "OpenGLWidget.h"
#include <QtGui/QWidget>
#include <iostream>
#include <algorithm>
//#include <QtDebug>

using namespace std;


// switches
bool         OpenGLWidget::m_textureCreated       = false;
bool         OpenGLWidget::m_librariesInitialised = false;

// texture-handles
unsigned int OpenGLWidget::m_textureHandle3d = 0;
unsigned int OpenGLWidget::m_textureHandle1d = 0;

// volume dimensions
int          OpenGLWidget::m_dimX = 0;
int          OpenGLWidget::m_dimY = 0;
int          OpenGLWidget::m_dimZ = 0;

// rotation of rendered volume
float        OpenGLWidget::m_xRot = 0.0;
float        OpenGLWidget::m_yRot = 0.0;
float        OpenGLWidget::m_zRot = 0.0;

// window size
int          OpenGLWidget::m_viewWidth  = OPENGL_SLICE_VIEW_SIZE;
int          OpenGLWidget::m_viewHeight = OPENGL_SLICE_VIEW_SIZE;

int          OpenGLWidget::m_view3DWidth  = OPENGL_3D_VIEW_SIZE;
int          OpenGLWidget::m_view3DHeight = OPENGL_3D_VIEW_SIZE;

// mouse-position
int          OpenGLWidget::m_lastXPosition = 0;
int          OpenGLWidget::m_lastYPosition = 0;

//int          OpenGLWidget::m_showView = SHOW_FRONT_SIDE;
int          OpenGLWidget::m_showView = SHOW_VOLUME;



OpenGLWidget::OpenGLWidget( QWidget *parent, QGLWidget* shareWidget) : QGLWidget(parent, shareWidget)
{
  cout << "Creating new OpenGLWidget..."<< endl;

  m_Axis = 0;
  m_AxisValue = 0;
  m_textureCoord = 0;
  m_rayStepSize = 0.0;
  m_mbPressed = false;
  m_ka = m_kd = m_ks = m_kg = 0.0;

  m_clearColor = QColor("black");

  // Timer for Animation (replace for glutIdle)
/*  QTimer *idleTimer = new QTimer(this);
  connect(idleTimer, SIGNAL(timeout()), this, SLOT(updateGL()));
  idleTimer->start();
  */
}


OpenGLWidget::~OpenGLWidget()
{
  release();
  deleteBuffers();
  unloadShader();
}


void OpenGLWidget::deleteBuffers()
{
  cout << "deleting buffers..." << endl;

  // front-side
  glDeleteFramebuffersEXT( 1, &m_fsFbo );
  glDeleteRenderbuffersEXT( 1, &m_fsRenderBuffer );
  glDeleteTextures( 1, &m_fsRenderTexture );

  // back-side
  glDeleteFramebuffersEXT( 1, &m_bsFbo );
  glDeleteRenderbuffersEXT( 1, &m_bsRenderBuffer );
  glDeleteTextures( 1, &m_bsRenderTexture );
}


void OpenGLWidget::initGlew()
{
        // Initialize GLEW
        cout << "- Initializing GLEW ..." << endl;
        GLenum err = glewInit();

        if (err != GLEW_OK)
        {
                // glewInit failed, something is seriously wrong
                cerr << "Error initializing GLEW: " << glewGetErrorString(err) << endl;
                return;
        }
        cout << "- GLEW initialized." << endl << endl;
}


void OpenGLWidget::initDevIL()
{
  // Initialize DevIL (an image library)
        cout << "- Initializing DevIL ..." << endl;
        ilInit();

        if (ilGetError() != IL_NO_ERROR)
        {
                cerr << "Error initializing DevIL" << endl;
                return;
        }

        ilEnable(IL_ORIGIN_SET);
        ilOriginFunc(IL_ORIGIN_LOWER_LEFT);
        cout << "- DevIL initialized." << endl << endl;
}


const int OpenGLWidget::GetNextPowerOfTwo( const int iNumber )
{
        int iPowerOfTwo = 1;

        while (iPowerOfTwo < iNumber)
                iPowerOfTwo = iPowerOfTwo * 2;

        return iPowerOfTwo;
}


void OpenGLWidget::release()
{
  cout << "release..." << endl;

  if ( m_textureHandle3d != 0 )
  {
    cout << "- deleting texture" << endl;
    glDeleteTextures( 1, &m_textureHandle3d );
    m_textureHandle3d = 0;
    m_textureCreated = false;
  }

  m_textureCoord = 0;
}


void OpenGLWidget::initializeGL()
{
        cout << "initializeGL... " << endl;
        // qDebug() << "init";


  if ( !m_librariesInitialised )
  {
          initGlew();  // Initialize Glew Extension Wrangler
          initDevIL(); // Initialize Image Library Lib (for textures)

    if ( !glewIsSupported( "GL_VERSION_2_0" ) )
    {
      cout << "OpenGL-Version 2.0 not supported!" << endl;
      exit( 1 );
    }

    m_librariesInitialised = true;
  }

  if ( m_Axis == RENDER_3D_VIEW || m_Axis == NO_RENDER_3D_VIEW )
  {
    if ( !createBuffers() )
    {
      cout << "Creation of FBO's failed! Exiting now..." << endl;
      exit( 1 );
    }

    if ( !loadShader() )
    {
      cout << "Loading of shaders failed! Exiting now..." << endl;
      exit( 1 );
    }
  }



        // GL Init
/*      glShadeModel( GL_SMOOTH );
        glClearDepth( 1.0f );
        glEnable( GL_DEPTH_TEST );
        glDepthFunc( GL_LEQUAL );
  glViewport( 0, 0, this->m_viewWidth, this->m_viewHeight );
/
    qglClearColor(m_clearColor);
//      glEnable(GL_DEPTH_TEST);
        glEnable(GL_CULL_FACE);
*/

  qglClearColor( m_clearColor );

        glMatrixMode(GL_PROJECTION);
        glLoadIdentity();

        glMatrixMode(GL_MODELVIEW);
        glLoadIdentity ();
}


void OpenGLWidget::resizeGL(int width, int height)
{
        cout << "resizeGL... " << endl;

  if ( m_Axis == OPENGL_3D_VIEW )
  {
    this->m_view3DWidth  = width;
    this->m_view3DHeight = height;
  }
  else
  {
    this->m_viewWidth  = width;
    this->m_viewHeight = height;
  }


        int side = qMin(width, height);
        glViewport( (width - side)/2, (height - side)/2, side, side );

        glMatrixMode(GL_PROJECTION);
        glLoadIdentity();

        glMatrixMode(GL_MODELVIEW);
        glLoadIdentity();
}

void OpenGLWidget::setLightValue ( LIGHT_MODEL model, float value )
{
  switch(model)
  {
  case ambient: m_ka = value;
    break;

  case diffuse: m_kd = value;
    break;

  case specular: m_ks = value;
    break;

  case gloss: m_kg = value;
    break;

  default: // do nothing
    break;
  }

  if ( m_Axis == OPENGL_3D_VIEW )
    this->updateGL();
}


void OpenGLWidget::paintXAxis()
{
  /* paint yz-plane

    map texture with correct aspect ratio:
    if y > z => y = longEdge; z = shortEdge (implemented using min/max instead)
      => yOffset

    if y < z => y = shortEdge; z = longEdge (implemented using min/max instead)
      => xOffset
  */

  float xOffset = 0.0f;
  float yOffset = 0.0f;

  float delta = max( m_dimY, m_dimZ ) - min( m_dimY, m_dimZ );

  if ( m_dimY > m_dimZ ) yOffset = 2 * ( delta / max( m_dimY, m_dimZ ) );
  if ( m_dimY < m_dimZ ) xOffset = 2 * ( delta / max( m_dimY, m_dimZ ) );

  //cout << "X xOffset: " << xOffset << endl;
  //cout << "X yOffset: " << yOffset << endl;

  //draw quad with texture taken from 3d volume
        glBegin(GL_QUADS);
    // A
          glTexCoord3f ( m_textureCoord, 0.0f, 0.0f);
          glVertex3f(  -1.0f, -1.0f, -1.0f  );

    // B
          glTexCoord3f( m_textureCoord, 1.0f, 0.0f);
          glVertex3f(   1.0f - xOffset, -1.0f, -1.0f  );

          // C
    glTexCoord3f( m_textureCoord, 1.0f, 1.0f);
          glVertex3f(   1.0f - xOffset, 1.0f - yOffset, -1.0f  );

          // D
    glTexCoord3f( m_textureCoord, 0.0f, 1.0f);
          glVertex3f(  -1.0f, 1.0f - yOffset, -1.0f  );
        glEnd();

}


void OpenGLWidget::paintYAxis()
{
  // paint xz-plane

  // map texture with correct aspect ratio:
  float xOffset = 0.0f;
  float yOffset = 0.0f;

  float delta = max( m_dimX, m_dimZ ) - min( m_dimX, m_dimZ );

  if ( m_dimX > m_dimZ ) yOffset = 2 * ( delta / max( m_dimX, m_dimZ ) );
  if ( m_dimX < m_dimZ ) xOffset = 2 * ( delta / max( m_dimX, m_dimZ ) );

  //cout << "Y xOffset: " << xOffset << endl;
  //cout << "Y yOffset: " << yOffset << endl;


  //draw quad with texture taken from 3d volume
        glBegin(GL_QUADS);
          glTexCoord3f( 0.0f,  m_textureCoord, 0.0f);
          glVertex3f(  -1.0f, -1.0f, -1.0f  );

          glTexCoord3f( 1.0f,  m_textureCoord, 0.0f);
          glVertex3f(   1.0f - xOffset, -1.0f, -1.0f  );

          glTexCoord3f( 1.0f, m_textureCoord, 1.0f);
          glVertex3f(   1.0f - xOffset, 1.0f - yOffset, -1.0f  );

          glTexCoord3f( 0.0f, m_textureCoord, 1.0f);
          glVertex3f(  -1.0f, 1.0f - yOffset, -1.0f  );
        glEnd();
}


void OpenGLWidget::paintZAxis()
{
  // paint xy-plane

  // map texture with correct aspect ratio:
  float xOffset = 0.0f;
  float yOffset = 0.0f;

  float delta = max( m_dimX, m_dimY ) - min( m_dimX, m_dimY );

  if ( m_dimX > m_dimY ) yOffset = 2 * ( delta / max( m_dimX, m_dimY ) );
  if ( m_dimX < m_dimY ) xOffset = 2 * ( delta / max( m_dimX, m_dimY ) );

  //cout << "Z xOffset: " << xOffset << endl;
  //cout << "Z yOffset: " << yOffset << endl;

//draw quad with texture taken from 3d volume
        glBegin(GL_QUADS);
          glTexCoord3f( 0.0f,  0.0f, m_textureCoord);
          glVertex3f(  -1.0f, -1.0f, -1.0f  );

          glTexCoord3f( 1.0f,  0.0f, m_textureCoord);
          glVertex3f(   1.0f - xOffset, -1.0f, -1.0f  );

          glTexCoord3f( 1.0f, 1.0f, m_textureCoord);
          glVertex3f(   1.0f - xOffset, 1.0f - yOffset, -1.0f  );

          glTexCoord3f( 0.0f, 1.0f, m_textureCoord);
          glVertex3f(  -1.0f, 1.0f - yOffset, -1.0f  );
        glEnd();
}


void OpenGLWidget::paintGL()
{
//  cout << "paintGL..." << endl;

        // m_Axis[0..SLIDER_RANGE] -> m_textureCoord[0..1]
        m_textureCoord = m_AxisValue / SLIDER_RANGE;

        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
        glPushMatrix();

        if ( m_textureCreated )   // texture is created
        {
                if( GLEW_EXT_texture3D )  // graphics hw supports 3d textures
                {
                        glEnable( GL_TEXTURE_3D );
      glBindTexture( GL_TEXTURE_3D, m_textureHandle3d );

                        GLenum glError = glGetError();
                        if (glError != GL_NO_ERROR)
                        {
                                cerr<<"Error binding texture: " << gluErrorString(glError) << endl;
                        }

                        switch ( m_Axis )
                        {
        case X_AXIS: // x-axis
          paintXAxis();
          break;

        case Y_AXIS: // y-axis
          paintYAxis();
          break;

        case Z_AXIS: // z-axis
          paintZAxis();
          break;

        case NO_RENDER_3D_VIEW:
          // no file open -> do not render 3D-view
          break;

        case RENDER_3D_VIEW:
          renderView();
          break;

        default: // unkonwn
          break;
                        }

                }
                else // 3d texture not supported
                {
      cout << "- 3D-texture not supported on your hardware!" << endl;
                }
        }
        glPopMatrix();

}


float OpenGLWidget::toRad( float grad )
{
  return (float)(2*PI* grad /360 );
}


void OpenGLWidget::createInvRotMatrix()
{

  float phi = toRad( m_xRot );
/*
  cout << "cos: " << cos( (float)(PI/2) ) << endl;
  cout << "cos: " << cos( (float)(2*PI * 90 /360 ) ) << endl;
  cout << "cos: " << cos( toRad(90) ) << endl;
*/
  Matrix rotXMtx( 1.0, 0.0, 0.0, 0.0,
                  0.0, cos(phi), -sin(phi), 0.0,
                  0.0, sin(phi),  cos(phi), 0.0,
                  0.0, 0.0, 0.0, 1.0);

  phi = toRad( m_yRot );
  Matrix rotYMtx( cos(phi), 0.0, sin(phi), 0.0,
                  0.0, 1.0, 0.0, 0.0,
                  -sin(phi), 0.0,  cos(phi), 0.0,
                  0.0, 0.0, 0.0, 1.0);

  phi = toRad( m_zRot );
  Matrix rotZMtx( cos(phi), -sin(phi), 0.0, 0.0,
                  sin(phi), cos(phi), 0.0, 0.0,
                  0.0, 0.0,  1.0, 0.0,
                  0.0, 0.0, 0.0, 1.0);

  // ( A * B )^-1 = B^-1 * A^-1

  //m_invRotMatrix = rotXMtx; // z ok
  //m_invRotMatrix = rotYMtx; // z ok, x dreht sich mit
  //m_invRotMatrix = rotZMtx; // z ok, y ok, 
/*
  rotXMtx = rotXMtx.GetInverse();
  rotYMtx = rotYMtx.GetInverse();
  rotZMtx = rotZMtx.GetInverse();
*/
  //m_invRotMatrix = rotZMtx * rotYMtx * rotXMtx;
  m_invRotMatrix = rotXMtx * rotYMtx * rotZMtx;

  m_invRotMatrix.translate( Vector( 0.5, 0.5, 0.5) );


  // find max dimension
  float maxDim = 0.0;

  if ( m_dimX > m_dimY )
    if ( m_dimX > m_dimZ )
      maxDim = m_dimX;
    else
      maxDim = m_dimZ;
  else  // x < y
    if ( m_dimY > m_dimZ )
      maxDim = m_dimY;
    else
      maxDim = m_dimZ;

  float scaleX = m_dimX / maxDim;
  float scaleY = m_dimY / maxDim;
  float scaleZ = m_dimZ / maxDim;

/*
  cout << "scaleX: " << scaleX
    << ", scaleY: " << scaleY
    << ", scaleZ: " << scaleZ
    << endl;
*/
    m_invRotMatrix.scale( Vector(scaleX, scaleY, scaleZ) );



  //m_invRotMatrix = m_invRotMatrix.GetTransposed();
  m_invRotMatrix = m_invRotMatrix.GetInverse();
/*
  Matrix help = m_invRotMatrix.GetTransposed();
  float elem = 0.0;
  cout << "inv-rot-Matrix: " << endl;
  for (int i=0; i<16; i++)
  {
    cout << help.Get( i ) << " ";

    if ( i==3 || i==7 || i==11 || i==15 )
      cout << "" << endl;
  }
  */
}


void OpenGLWidget::renderView()
{
//  cout << "renderView..." << endl;

  if ( glIsEnabled( GL_TEXTURE_3D ) )
    glDisable( GL_TEXTURE_3D );

  // gl setup
  glViewport( 0, 0, this->m_view3DWidth, this->m_view3DHeight );

  glShadeModel( GL_SMOOTH );

  glEnable( GL_DEPTH_TEST );
        glDepthFunc( GL_LEQUAL );

        glClearColor( 0.0, 0.0, 0.0, 0.0 );
        glClearDepth( 1.0f );
  glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );

  glLoadIdentity();
/*
  glRotated( m_xRot, 1.0, 0.0, 0.0 );
  glRotated( m_yRot, 0.0, 1.0, 0.0 );
  glRotated( m_zRot, 0.0, 0.0, 1.0 );

  glTranslatef( -0.5f, -0.5f, -0.5f );
  //glScaled( 10.0, 10.0, 10.0 );
*/

  // render bounding-cubes
  renderFrontSideBuffer();
  renderBackSideBuffer();

  //testRenderedToBuffer();

  // do raycasting
  if ( m_showView == SHOW_VOLUME )
    doRaycasting();
  else
    testRenderedToBuffer();

  // done rendering
  glDisable( GL_DEPTH_TEST );
}


void OpenGLWidget::doRaycasting()
{
  
  createInvRotMatrix();

  glPushMatrix();

  glMatrixMode( GL_MODELVIEW );
  glLoadIdentity();


  // enable shader
  glUseProgram( m_shaderProgram );

  glEnable( GL_BLEND );
  glBlendFunc( GL_SRC_ALPHA, GL_ZERO );

  // set parameters
  int loc_renderMode = glGetUniformLocation( m_shaderProgram, "renderMode" );
  glUniform1i( loc_renderMode, m_renderMode );

  m_stepSize  = glGetUniformLocation( m_shaderProgram, "numberOfSamplesPerRay" );
  glUniform1f( m_stepSize, m_rayStepSize );

  float volumeDiagonal = sqrt( (float)(m_dimX^2 + m_dimY^2 + m_dimZ^2) );
  GLint loc_diagonal = glGetUniformLocation( m_shaderProgram, "maxRayLength" );
  glUniform1f( loc_diagonal, volumeDiagonal );

  // set dimensions
/*  float m = 0.2;
  float vsX = m;
  float vsY = m;
  float vsZ = m;*/

  float vsX = (float) 1 / m_dimX;
  float vsY = (float) 1 / m_dimY;
  float vsZ = (float) 1 / m_dimZ;

  /*
  cout << "vsX: " << vsX << endl;
  cout << "vsY: " << vsY << endl;
  cout << "vsZ: " << vsZ << endl;
*/

  GLint loc_vsX = glGetUniformLocation( m_shaderProgram, "vsX" );
  glUniform1f( loc_vsX, vsX );

  GLint loc_vsY = glGetUniformLocation( m_shaderProgram, "vsY" );
  glUniform1f( loc_vsY, vsY );

  GLint loc_vsZ = glGetUniformLocation( m_shaderProgram, "vsZ" );
  glUniform1f( loc_vsZ, vsZ );
/*
  GLint loc_vsX = glGetUniformLocation( m_shaderProgram, "vsX" );
  glUniform1f( loc_vsX, (float)(1/m_dimX) );

  GLint loc_vsY = glGetUniformLocation( m_shaderProgram, "vsY" );
  glUniform1f( loc_vsY, (float)(1/m_dimY) );

  GLint loc_vsZ = glGetUniformLocation( m_shaderProgram, "vsZ" );
  glUniform1f( loc_vsZ, (float)(1/m_dimZ) );
/*
  cout << " ks: " << m_ks << endl;
  cout << " ka: " << m_ka << endl;
  cout << " kd: " << m_kd << endl;
  cout << " kg: " << m_kg << endl;
*/
  // set phong-params
  GLint loc_ka = glGetUniformLocation( m_shaderProgram, "ka" );
  glUniform1f( loc_ka, m_ka );

  GLint loc_kd = glGetUniformLocation( m_shaderProgram, "kd" );
  glUniform1f( loc_kd, m_kd );

  GLint loc_ks = glGetUniformLocation( m_shaderProgram, "ks" );
  glUniform1f( loc_ks, m_ks );

  GLint loc_kg = glGetUniformLocation( m_shaderProgram, "pn" );
  glUniform1f( loc_kg, m_kg );

  GLint loc_invRotMat = glGetUniformLocation( m_shaderProgram, "invRotMatrix" );
  glUniformMatrix4fv( loc_invRotMat, 1, 0, m_invRotMatrix.Get() );

  //glBlendFunc( GL_ONE, GL_ZERO );

  //glEnable( GL_TEXTURE_2D );
  //glTranslatef( -1.0, -1.0, 0.0 );

  m_volume    = glGetUniformLocation( m_shaderProgram, "volume"    );
  m_frontSide = glGetUniformLocation( m_shaderProgram, "frontSide" );
  m_backSide  = glGetUniformLocation( m_shaderProgram, "backSide"  );
  m_tf        = glGetUniformLocation( m_shaderProgram, "tf"        );

  glActiveTexture( GL_TEXTURE0 );
  glEnable( GL_TEXTURE_3D );
  glBindTexture( GL_TEXTURE_3D, m_textureHandle3d );
  glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_NONE);
  glUniform1i( m_volume, 0 );

  glActiveTexture( GL_TEXTURE1 );
  glEnable( GL_TEXTURE_2D );
  glBindTexture( GL_TEXTURE_2D, m_fsRenderTexture );
  glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_NONE);
  glUniform1i( m_frontSide, 1 );

  glActiveTexture( GL_TEXTURE2 );
  glEnable( GL_TEXTURE_2D );
  glBindTexture( GL_TEXTURE_2D, m_bsRenderTexture );
  glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_NONE);
  glUniform1i( m_backSide, 2 );

  glActiveTexture( GL_TEXTURE3 );
  glEnable( GL_TEXTURE_1D );
  //glTexParameterf( GL_TEXTURE_3D, GL_TEXTURE_BORDER_COLOR, 0.0f );
  glBindTexture( GL_TEXTURE_3D, m_textureHandle1d );
  glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_NONE);
  glUniform1i( m_tf, 3 );

/*  float pos[] = { 1.0, 1.0, 1.0, 1.0 };
  glLightfv( GL_LIGHT0, GL_POSITION, pos );
  glEnable( GL_LIGHTING );
  glEnable( GL_LIGHT0 );
*/
  //glActiveTexture( GL_TEXTURE1 );
  drawQuad();

  //glDisable( GL_TEXTURE_2D );
  glDisable( GL_BLEND );
/*
  glDisable( GL_LIGHTING );
  glDisable( GL_LIGHT0 );
*/
  glUseProgram( 0 );

  glPopMatrix();
}


void OpenGLWidget::drawQuad()
{
  glBegin(GL_QUADS);
          //glColor3f( 1.0, 1.0, 1.0 );
  glMultiTexCoord2f( GL_TEXTURE0, 0, 0 );
  glMultiTexCoord2f( GL_TEXTURE1, 0, 0 );
  glMultiTexCoord2f( GL_TEXTURE2, 0, 0 );
  glVertex2f( -1.0f, -1.0f );
  //glVertex3f( -1.0f, -1.0f, -1.0f  );

  glMultiTexCoord2f( GL_TEXTURE0, 1, 0 );
  glMultiTexCoord2f( GL_TEXTURE1, 1, 0 );
  glMultiTexCoord2f( GL_TEXTURE2, 1, 0 );
  glVertex2f(  1.0f, -1.0f );
  //glVertex3f(  1.0f, -1.0f, -1.0f  );

  glMultiTexCoord2f( GL_TEXTURE0, 1, 1 );
  glMultiTexCoord2f( GL_TEXTURE1, 1, 1 );
  glMultiTexCoord2f( GL_TEXTURE2, 1, 1 );
  glVertex2f(  1.0f,  1.0f );
  //glVertex3f(  1.0f,  1.0f, -1.0f  );

  glMultiTexCoord2f( GL_TEXTURE0, 0, 1 );
  glMultiTexCoord2f( GL_TEXTURE1, 0, 1 );
  glMultiTexCoord2f( GL_TEXTURE2, 0, 1 );
  glVertex2f( -1.0f,  1.0f );
  //glVertex3f( -1.0f,  1.0f, -1.0f  );

/*
    glNormal3f(  0.0, 0.0, 1.0 );
    glTexCoord2f( 0.0, 0.0 ); glVertex3f( -1.0f, -1.0f, -1.0f  );
    glTexCoord2f( 1.0, 0.0 ); glVertex3f(  1.0f, -1.0f, -1.0f  );
          glTexCoord2f( 1.0, 1.0 ); glVertex3f(  1.0f,  1.0f, -1.0f  );
    glTexCoord2f( 0.0, 1.0 ); glVertex3f( -1.0f,  1.0f, -1.0f  );
*/
  glEnd();
}


void OpenGLWidget::drawBoundingCube( float x, float y, float z )
{

  glBegin(GL_QUADS);
          glColor4f( 1.0, 0.0, 0.0, 1.0 ); glVertex3f(     x, 0.0f, 0.0f  );
          glColor4f( 0.0, 0.0, 0.0, 1.0 ); glVertex3f(  0.0f, 0.0f, 0.0f  );
    glColor4f( 0.0, 1.0, 0.0, 1.0 ); glVertex3f(  0.0f,    y, 0.0f  );
    glColor4f( 1.0, 1.0, 0.0, 1.0 ); glVertex3f(     x,    y, 0.0f  );

          glColor4f( 0.0, 0.0, 1.0, 1.0 ); glVertex3f(  0.0f, 0.0f,    z  );
          glColor4f( 1.0, 0.0, 1.0, 1.0 ); glVertex3f(     x, 0.0f,    z  );
          glColor4f( 1.0, 1.0, 1.0, 1.0 ); glVertex3f(     x,    y,    z  );
          glColor4f( 0.0, 1.0, 1.0, 1.0 ); glVertex3f(  0.0f,    y,    z  );

          glColor4f( 0.0, 0.0, 1.0, 1.0 ); glVertex3f(  0.0f, 0.0f,    z  );
    glColor4f( 0.0, 0.0, 0.0, 1.0 ); glVertex3f(  0.0f, 0.0f, 0.0f  );
          glColor4f( 1.0, 0.0, 0.0, 1.0 ); glVertex3f(     x, 0.0f, 0.0f  );
    glColor4f( 1.0, 0.0, 1.0, 1.0 ); glVertex3f(     x, 0.0f,    z  );

          glColor4f( 0.0, 1.0, 1.0, 1.0 ); glVertex3f(  0.0f,    y,    z  );
          glColor4f( 1.0, 1.0, 1.0, 1.0 ); glVertex3f(     x,    y,    z  );
          glColor4f( 1.0, 1.0, 0.0, 1.0 ); glVertex3f(     x,    y, 0.0f  );
    glColor4f( 0.0, 1.0, 0.0, 1.0 ); glVertex3f(  0.0f,    y, 0.0f  );

          glColor4f( 0.0, 0.0, 0.0, 1.0 ); glVertex3f(  0.0f, 0.0f, 0.0f  );
    glColor4f( 0.0, 0.0, 1.0, 1.0 ); glVertex3f(  0.0f, 0.0f,    z  );
          glColor4f( 0.0, 1.0, 1.0, 1.0 ); glVertex3f(  0.0f,    y,    z  );
    glColor4f( 0.0, 1.0, 0.0, 1.0 ); glVertex3f(  0.0f,    y, 0.0f  );

          glColor4f( 1.0, 0.0, 1.0, 1.0 ); glVertex3f(     x, 0.0f,    z  );
    glColor4f( 1.0, 0.0, 0.0, 1.0 ); glVertex3f(     x, 0.0f, 0.0f  );
          glColor4f( 1.0, 1.0, 0.0, 1.0 ); glVertex3f(     x,    y, 0.0f  );
          glColor4f( 1.0, 1.0, 1.0, 1.0 ); glVertex3f(     x,    y,    z  );
  glEnd();
}


void OpenGLWidget::drawBackSideCube()
{
  glBegin(GL_QUADS);
          glColor3f( 1.0, 0.0, 0.0 ); glVertex3f(  1.0f, 0.0f, 0.0f  );
          glColor3f( 1.0, 1.0, 1.0 ); glVertex3f(  0.0f, 0.0f, 0.0f  );
          //glColor3f( 0.0, 0.0, 0.0 ); glVertex3f(  0.0f, 0.0f, 0.0f  );
    glColor3f( 0.0, 1.0, 0.0 ); glVertex3f(  0.0f, 1.0f, 0.0f  );
    glColor3f( 1.0, 1.0, 0.0 ); glVertex3f(  1.0f, 1.0f, 0.0f  );

          glColor3f( 0.0, 0.0, 1.0 ); glVertex3f(  0.0f, 0.0f, 1.0f  );
          glColor3f( 1.0, 0.0, 1.0 ); glVertex3f(  1.0f, 0.0f, 1.0f  );
          glColor3f( 0.0, 0.0, 0.0 ); glVertex3f(  1.0f, 1.0f, 1.0f  );
          //glColor3f( 1.0, 1.0, 1.0 ); glVertex3f(  1.0f, 1.0f, 1.0f  );
          glColor3f( 0.0, 1.0, 1.0 ); glVertex3f(  0.0f, 1.0f, 1.0f  );

          glColor3f( 0.0, 0.0, 1.0 ); glVertex3f(  0.0f, 0.0f, 1.0f  );
    glColor3f( 1.0, 1.0, 1.0 ); glVertex3f(  0.0f, 0.0f, 0.0f  );
    //glColor3f( 0.0, 0.0, 0.0 ); glVertex3f(  0.0f, 0.0f, 0.0f  );
          glColor3f( 1.0, 0.0, 0.0 ); glVertex3f(  1.0f, 0.0f, 0.0f  );
    glColor3f( 1.0, 0.0, 1.0 ); glVertex3f(  1.0f, 0.0f, 1.0f  );

          glColor3f( 0.0, 1.0, 1.0 ); glVertex3f(  0.0f, 1.0f, 1.0f  );
          glColor3f( 0.0, 0.0, 0.0 ); glVertex3f(  1.0f, 1.0f, 1.0f  );
          //glColor3f( 1.0, 1.0, 1.0 ); glVertex3f(  1.0f, 1.0f, 1.0f  );
          glColor3f( 1.0, 1.0, 0.0 ); glVertex3f(  1.0f, 1.0f, 0.0f  );
    glColor3f( 0.0, 1.0, 0.0 ); glVertex3f(  0.0f, 1.0f, 0.0f  );

          glColor3f( 1.0, 1.0, 1.0 ); glVertex3f(  0.0f, 0.0f, 0.0f  );
          //glColor3f( 0.0, 0.0, 0.0 ); glVertex3f(  0.0f, 0.0f, 0.0f  );
    glColor3f( 0.0, 0.0, 1.0 ); glVertex3f(  0.0f, 0.0f, 1.0f  );
          glColor3f( 0.0, 1.0, 1.0 ); glVertex3f(  0.0f, 1.0f, 1.0f  );
    glColor3f( 0.0, 1.0, 0.0 ); glVertex3f(  0.0f, 1.0f, 0.0f  );

          glColor3f( 1.0, 0.0, 1.0 ); glVertex3f(  1.0f, 0.0f, 1.0f  );
    glColor3f( 1.0, 0.0, 0.0 ); glVertex3f(  1.0f, 0.0f, 0.0f  );
          glColor3f( 1.0, 1.0, 0.0 ); glVertex3f(  1.0f, 1.0f, 0.0f  );
          glColor3f( 0.0, 0.0, 0.0 ); glVertex3f(  1.0f, 1.0f, 1.0f  );
          //glColor3f( 1.0, 1.0, 1.0 ); glVertex3f(  1.0f, 1.0f, 1.0f  );
  glEnd();
}


void OpenGLWidget::drawCube()
{
  glBegin(GL_QUADS);
    // back-side
          glColor3f( 1.0, 0.0, 0.0 );
    glNormal3f(  0.0, 0.0, -1.0 );
    glTexCoord2f( 0.0, 0.0 ); glVertex3f(  1.0f, 0.0f, 0.0f  );
    glTexCoord2f( 0.0, 1.0 ); glVertex3f(  0.0f, 0.0f, 0.0f  );
          glTexCoord2f( 1.0, 0.0 ); glVertex3f(  0.0f, 1.0f, 0.0f  );
    glTexCoord2f( 1.0, 1.0 ); glVertex3f(  1.0f, 1.0f, 0.0f  );

    // front-side
          glColor3f( 0.0, 1.0, 0.0 );
    glNormal3f(  0.0, 0.0, 1.0 );
          glTexCoord2f( 0.0, 0.0 ); glVertex3f(  0.0f, 0.0f, 1.0f  );
          glTexCoord2f( 0.0, 1.0 ); glVertex3f(  1.0f, 0.0f, 1.0f  );
          glTexCoord2f( 1.0, 0.0 ); glVertex3f(  1.0f, 1.0f, 1.0f  );
          glTexCoord2f( 1.0, 1.0 ); glVertex3f(  0.0f, 1.0f, 1.0f  );

    // bottom-side
          glColor3f( 0.0, 0.0, 1.0 );
    glNormal3f(  0.0, -1.0, 0.0 );
          glTexCoord2f( 0.0, 0.0 ); glVertex3f(  0.0f, 0.0f, 1.0f  );
    glTexCoord2f( 0.0, 1.0 ); glVertex3f(  0.0f, 0.0f, 0.0f  );
          glTexCoord2f( 1.0, 0.0 ); glVertex3f(  1.0f, 0.0f, 0.0f  );
    glTexCoord2f( 1.0, 1.0 ); glVertex3f(  1.0f, 0.0f, 1.0f  );

    // top-side
          glColor3f( 1.0, 1.0, 0.0 );
    glNormal3f(  0.0, 1.0, 0.0 );
          glTexCoord2f( 0.0, 0.0 ); glVertex3f(  0.0f, 1.0f, 1.0f  );
          glTexCoord2f( 0.0, 1.0 ); glVertex3f(  1.0f, 1.0f, 1.0f  );
          glTexCoord2f( 1.0, 0.0 ); glVertex3f(  1.0f, 1.0f, 0.0f  );
    glTexCoord2f( 1.0, 1.0 ); glVertex3f(  0.0f, 1.0f, 0.0f  );

    // left-side
          glColor3f( 0.0, 1.0, 1.0 );
    glNormal3f(  -1.0, 0.0, 0.0 );
    glTexCoord2f( 0.0, 0.0 ); glVertex3f(  0.0f, 0.0f, 0.0f  );
    glTexCoord2f( 0.0, 1.0 ); glVertex3f(  0.0f, 0.0f, 1.0f  );
          glTexCoord2f( 1.0, 0.0 ); glVertex3f(  0.0f, 1.0f, 1.0f  );
    glTexCoord2f( 1.0, 1.0 ); glVertex3f(  0.0f, 1.0f, 0.0f  );

    // right-side
          glColor3f( 0.0, 0.0, 0.0 );
    glNormal3f(  1.0, 0.0, 0.0 );
          glTexCoord2f( 0.0, 0.0 ); glVertex3f(  1.0f, 0.0f, 1.0f  );
    glTexCoord2f( 0.0, 1.0 ); glVertex3f(  1.0f, 0.0f, 0.0f  );
          glTexCoord2f( 1.0, 0.0 ); glVertex3f(  1.0f, 1.0f, 0.0f  );
          glTexCoord2f( 1.0, 1.0 ); glVertex3f(  1.0f, 1.0f, 1.0f  );
  glEnd();
}


bool OpenGLWidget::createBuffers()
{

  // --- FRONT SIDE ---

  // --- setup FBO
  glGenFramebuffersEXT( 1, &m_fsFbo );
  glBindFramebufferEXT( GL_FRAMEBUFFER_EXT, m_fsFbo );

  // setup render-buffer
  glGenRenderbuffersEXT( 1, &m_fsRenderBuffer );

  glBindRenderbufferEXT( GL_RENDERBUFFER_EXT, m_fsRenderBuffer );
  glRenderbufferStorageEXT( GL_RENDERBUFFER_EXT, GL_DEPTH_COMPONENT, this->m_view3DWidth, this->m_view3DHeight );
  glFramebufferRenderbufferEXT( GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, m_fsRenderBuffer );

  // setup texture
  glGenTextures( 1, &m_fsRenderTexture );

  glBindTexture( GL_TEXTURE_2D, m_fsRenderTexture );
  glTexImage2D( GL_TEXTURE_2D, 0, GL_RGBA8, this->m_view3DWidth, this->m_view3DHeight, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL );

  glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
  glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
  glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
  glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);

  glFramebufferTexture2DEXT( GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, m_fsRenderTexture, 0 );

  GLenum fboStatus = glCheckFramebufferStatusEXT( GL_FRAMEBUFFER_EXT );

  if ( fboStatus != GL_FRAMEBUFFER_COMPLETE_EXT )
  {
    cout << " - FBO-setup failed!" << endl;
    cout << "   Error-Code" << glCheckFramebufferStatusEXT( GL_FRAMEBUFFER_EXT ) << endl;
    // Error-Codes:
    // 36053 == 0x8CD5 == FRAMEBUFFER_COMPLETE_EXT                       <- if everything ok
    // 36054 == 0x8CD6 == FRAMEBUFFER_INCOMPLETE_ATTACHMENT_EXT          <- something incomplete (zero-sized width/heigth?)
    // 36055 == 0x8CD7 == FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_EXT  <- misssing some attachement
    // 36060 == 0x8CDC == FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT         <- no texture
    // 36061 == 0x8CDD == FRAMEBUFFER_UNSUPPORTED_EXT                    <- if no filter for texture defined

    return false;
  }
  else
    cout << " - FBO-setup successful" << endl;


  // --- BACK SIDE ---

  // --- setup FBO
  glGenFramebuffersEXT( 1, &m_bsFbo );
  glBindFramebufferEXT( GL_FRAMEBUFFER_EXT, m_bsFbo );

  // setup render-buffer
  glGenRenderbuffersEXT( 1, &m_bsRenderBuffer );

  glBindRenderbufferEXT( GL_RENDERBUFFER_EXT, m_bsRenderBuffer );
  glRenderbufferStorageEXT( GL_RENDERBUFFER_EXT, GL_DEPTH_COMPONENT, this->m_view3DWidth, this->m_view3DHeight );
  glFramebufferRenderbufferEXT( GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, m_bsRenderBuffer );

  // setup texture
  glGenTextures( 1, &m_bsRenderTexture );

  glBindTexture( GL_TEXTURE_2D, m_bsRenderTexture );
  glTexImage2D( GL_TEXTURE_2D, 0, GL_RGBA8, this->m_view3DWidth, this->m_view3DHeight, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL );

  glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
  glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
  glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
  glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);

  glFramebufferTexture2DEXT( GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, m_bsRenderTexture, 0 );

  fboStatus = glCheckFramebufferStatusEXT( GL_FRAMEBUFFER_EXT );

  if ( fboStatus != GL_FRAMEBUFFER_COMPLETE_EXT )
  {
    cout << " - FBO-setup failed!" << endl;
    cout << "   Error-Code" << glCheckFramebufferStatusEXT( GL_FRAMEBUFFER_EXT ) << endl;
    return false;
  }
  else
    cout << " - FBO-setup successful" << endl;

  return true;
}


void OpenGLWidget::renderFrontSideBuffer()
{
  glPushMatrix();

  // --- bind framebuffer
  glBindFramebufferEXT( GL_FRAMEBUFFER_EXT, m_fsFbo );
  glPushAttrib( GL_VIEWPORT_BIT );
  glViewport( 0, 0, this->m_viewWidth, this->m_viewHeight );

  // render
        glClearColor( 0.0, 0.0, 0.0, 0.0 );
  glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );


  glLoadIdentity();

  glRotated( m_xRot, 1.0, 0.0, 0.0 );
  glRotated( m_yRot, 0.0, 1.0, 0.0 );
  glRotated( m_zRot, 0.0, 0.0, 1.0 );

  glTranslatef( -0.5f, -0.5f, -0.5f );
  //glScaled( 10.0, 10.0, 10.0 );

  glEnable( GL_CULL_FACE );
        glCullFace( GL_FRONT );


  // find max dimension
  float maxDim = 0.0;

  if ( m_dimX > m_dimY )
    if ( m_dimX > m_dimZ )
      maxDim = m_dimX;
    else
      maxDim = m_dimZ;
  else  // x < y
    if ( m_dimY > m_dimZ )
      maxDim = m_dimY;
    else
      maxDim = m_dimZ;

  float x = m_dimX / maxDim;
  float y = m_dimY / maxDim;
  float z = m_dimZ / maxDim;
/*
  cout << "x: " << x
    << ", y: " << y
    << ", z: " << z
    << endl;
*/
  drawBoundingCube( x, y, z );

  glDisable( GL_CULL_FACE );

  // unbind framebuffer
  glPopAttrib();
  glBindFramebufferEXT( GL_FRAMEBUFFER_EXT, 0 );

  glPopMatrix();
}


void OpenGLWidget::renderBackSideBuffer()
{
  glPushMatrix();

  // --- bind framebuffer
  glBindFramebufferEXT( GL_FRAMEBUFFER_EXT, m_bsFbo );
  glPushAttrib( GL_VIEWPORT_BIT );
  glViewport( 0, 0, this->m_viewWidth, this->m_viewHeight );

  // render
        glClearColor( 0.0, 0.0, 0.0, 0.0 );
  glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );

  glLoadIdentity();

  glRotated( m_xRot, 1.0, 0.0, 0.0 );
  glRotated( m_yRot, 0.0, 1.0, 0.0 );
  glRotated( m_zRot, 0.0, 0.0, 1.0 );

  glTranslatef( -0.5f, -0.5f, -0.5f );
  //glScaled( 10.0, 10.0, 10.0 );

  glEnable( GL_CULL_FACE );
        glCullFace( GL_BACK );


  // find max dimension
  float maxDim = 0.0;

  if ( m_dimX > m_dimY )
    if ( m_dimX > m_dimZ )
      maxDim = m_dimX;
    else
      maxDim = m_dimZ;
  else  // x < y
    if ( m_dimY > m_dimZ )
      maxDim = m_dimY;
    else
      maxDim = m_dimZ;

  float x = m_dimX / maxDim;
  float y = m_dimY / maxDim;
  float z = m_dimZ / maxDim;
/*
  cout << "x: " << x
    << ", y: " << y
    << ", z: " << z
    << endl;
*/
  drawBoundingCube( x, y, z );

  //drawBoundingCube( 1.0, 1.0, 1.0 );

  glDisable( GL_CULL_FACE );

/*
  glEnable( GL_CULL_FACE );
        glCullFace( GL_FRONT );

  drawBackSideCube();

  glDisable( GL_CULL_FACE );
*/
  // unbind framebuffer
  glPopAttrib();
  glBindFramebufferEXT( GL_FRAMEBUFFER_EXT, 0 );

  glPopMatrix();
}


void OpenGLWidget::testRenderedToBuffer()
{
  // map rendered-to-texture to quad
  glClearColor( 0.0, 0.0, 0.0, 0.0 );
  glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );

  glLoadIdentity();
  glColor4f( 1.0f, 1.0f, 1.0f, 1.0f );

  //glActiveTexture( GL_TEXTURE0 );

  if ( m_showView == SHOW_BACK_SIDE )
    glBindTexture( GL_TEXTURE_2D, m_bsRenderTexture );
  else
    glBindTexture( GL_TEXTURE_2D, m_fsRenderTexture );

  glEnable( GL_TEXTURE_2D );

        glBegin(GL_QUADS);
          glTexCoord2f( 0.0f,  0.0f );
          glVertex3f(  -1.0f, -1.0f, 0.0f  );

          glTexCoord2f( 1.0f,  0.0f );
          glVertex3f(   1.0f, -1.0f, 0.0f  );

          glTexCoord2f( 1.0f, 1.0f );
          glVertex3f(   1.0f, 1.0f, 0.0f  );

          glTexCoord2f( 0.0f, 1.0f );
          glVertex3f(  -1.0f, 1.0f, 0.0f  );
        glEnd();

  glDisable( GL_TEXTURE_2D );
}



bool OpenGLWidget::loadShader()
{
  cout << "loadShader..." << endl;

  char* vsFile = readShaderFile( "src/raycasting.vert" );
  char* fsFile = readShaderFile( "src/raycasting.frag" );

  if ( vsFile!=NULL && fsFile!=NULL )
  {
    m_vertexShader   = glCreateShader( GL_VERTEX_SHADER );
    m_fragmentShader = glCreateShader( GL_FRAGMENT_SHADER );

    const char* c_vsFile = vsFile;
    const char* c_fsFile = fsFile;

    glShaderSource( m_vertexShader,   1, &c_vsFile, NULL );
    glShaderSource( m_fragmentShader, 1, &c_fsFile, NULL );

    free( vsFile );
    free( fsFile );

    glCompileShader( m_vertexShader   );
    glCompileShader( m_fragmentShader );

        printShaderInfoLog(m_vertexShader);
      printShaderInfoLog(m_fragmentShader);

    m_shaderProgram = glCreateProgram();
    glAttachShader( m_shaderProgram, m_vertexShader   );
    glAttachShader( m_shaderProgram, m_fragmentShader );

    glLinkProgram( m_shaderProgram );
    printProgramInfoLog(m_shaderProgram);


    //glUseProgram( m_shaderProgram );

    glUseProgram( 0 );

    return true;
  }
  return false;
}


void OpenGLWidget::unloadShader()
{
  cout << "unloadShader..." << endl;

  // TODO: unload shaders here!

  // use fixed-function again
  glUseProgram( 0 );

}

char* OpenGLWidget::readShaderFile( char* shaderFile ) {

        FILE *file;
        char *content = NULL;
        int   count   = 0;

        if ( shaderFile!=NULL ) {
                fopen_s( &file, shaderFile, "rt" );

                if (file != NULL) {
      fseek( file, 0, SEEK_END );
      count = ftell( file );
      rewind( file );

                        if ( count > 0 ) {
                                content = (char*) malloc( sizeof(char) * (count+1) );
                                count   = (int) fread( content, sizeof(char), count, file );
                                content[count] = '\0';
                        }
                        fclose( file );
                }
        }
        return content;
}


void OpenGLWidget::GenerateGradientTexture( const QGradientStops &gStops )
{
/*
  // TEST
  QGradientStop gs;
  for ( int i=0; i<gStops.size(); i++ )
  {
    gs = gStops.at(i);

    qreal r = gs.first;
    QColor c = gs.second;

    cout << "gs: "
      << "r: " << r
      << ", c: " <<
      "( " << c.red()   <<
      ", " << c.green() <<
      ", " << c.blue()  <<
      ", " << c.alpha() <<
      ")" << endl;
  }
*/


  // generate texture from gradient
  QPolygonF pts;
  pts << QPointF( 0, 0 ) << QPointF( TF_TEXTURE_SIZE - 1, 0 );

  QGradient g;
  g = QLinearGradient(pts.at(0), pts.at(1));
  g.setSpread(QGradient::PadSpread);

  for(int i = 0; i < gStops.size(); i++)
  {
    g.setColorAt(gStops.at(i).first, gStops.at(i).second);
  }

  QImage image = QImage(TF_TEXTURE_SIZE, 1, QImage::Format_ARGB32);
  image.fill(Qt::transparent);

  // paint to QImage
  QPainter p(&image);

  // paint gradient to QImage
  p.fillRect(image.rect(), g);

  // TEST -> Save image to file to check texture
  //image.save("tf_texture.tiff", "TIFF");
  //image.save("tf_texture.png", "PNG");

  //QImage alphaImage = image.alphaChannel();
  //alphaImage.save("tf_alpha.png", "PNG");

    //for(int i = 0; i < image.bytesPerLine(); i++)
   //{
     //QRgb* a = (QRgb*) image.scanLine(0);
     //printf("%d\n", qAlpha(*a) );

  // generate 1d-texture from QImage
  QImage texture = QGLWidget::convertToGLFormat( image );

  //texture.save("GLTEXTURE.TIFF", "TIFF");

  glTexImage1D(GL_TEXTURE_1D, 0, 4, texture.width(), 0, GL_RGBA, GL_UNSIGNED_BYTE, texture.bits() );

  // set 1d parameter
  glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
        glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);

  glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_WRAP_S, GL_CLAMP );

  GLfloat bCol[] = { 0.0, 0.0, 0.0, 1.0 };
  glTexParameterfv(GL_TEXTURE_1D, GL_TEXTURE_BORDER_COLOR, bCol );

  if ( m_Axis == OPENGL_3D_VIEW )
    this->updateGL();
}

bool OpenGLWidget::create3DTexture( Volume *volume )
{
        glGenTextures( 1, &m_textureHandle3d );

        GLenum glError = glGetError();
        if (glError != GL_NO_ERROR)
        {
                cerr<<"Error generating texture: " << gluErrorString(glError) << endl;
        }
        else if ( m_textureHandle3d )
        {

    if( GLEW_EXT_texture3D )
                {
                        //bind texture
                        glBindTexture(GL_TEXTURE_3D, m_textureHandle3d);

                        glError = glGetError();
                        if (glError != GL_NO_ERROR)
                        {
                                cerr << "Could not bind texture: " << gluErrorString(glError) << endl;
                        }
                        else
                        {
                                // Get Size of 3D Volume
        int iTextureWidth  = volume->getSizeX();
                                int iTextureHeight = volume->getSizeY();
                                int iTextureDepth  = volume->getSizeZ();

        m_dimX = volume->getSizeX();
        m_dimY = volume->getSizeY();
        m_dimZ = volume->getSizeZ();

                                // Extend textures to a power of two if no GLEW_ARB_... available
                                if (!GLEW_ARB_texture_non_power_of_two)
                                {
          cout << "expand volume-tex to next power of two..." << endl;
                                        iTextureWidth  = GetNextPowerOfTwo( volume->getSizeX() );
                                        iTextureHeight = GetNextPowerOfTwo( volume->getSizeY() );
                                        iTextureDepth  = GetNextPowerOfTwo( volume->getSizeZ() );
                                }

                                // upload texture

                                glTexImage3D(GL_TEXTURE_3D_EXT, 0, GL_LUMINANCE,            // target, LOD, internalFormat (?)
                     iTextureWidth, iTextureHeight, iTextureDepth,  // width, heigth, depth
                     0, GL_LUMINANCE, GL_FLOAT,     // border, format, type
                     (void *) volume->getVolume()   // volume
                     );

        // why do we need glTexSubImage3D?
        glTexSubImage3D(GL_TEXTURE_3D_EXT, 0,   // target, LOD
                        0, 0, 0,                // xoffset, yoffset, zoffset,
                        iTextureWidth, iTextureHeight, iTextureDepth,         // width, heigth, depth
                        GL_LUMINANCE, GL_FLOAT, (void *) volume->getVolume()  // format, type, volume
                        );

        /* org:
        glTexImage3D(GL_TEXTURE_3D_EXT, 0, GL_LUMINANCE, iTextureWidth, iTextureHeight, iTextureDepth, 0, GL_LUMINANCE, GL_FLOAT, NULL);
                                glTexSubImage3D(GL_TEXTURE_3D_EXT, 0,   // target, LOD
                        0, 0, 0,                // xoffset, yoffset, zoffset,
                        iTextureWidth, iTextureHeight, iTextureDepth,         // width, heigth, depth
                        GL_LUMINANCE, GL_FLOAT, (void *) volume->getVolume()  // format, type, pixel
                        );
*/        

                                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 );
        glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_T, GL_CLAMP );
        glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_R, GL_CLAMP );

        GLfloat bCol[] = { 0.0, 0.0, 0.0, 1.0 };
        glTexParameterfv(GL_TEXTURE_3D, GL_TEXTURE_BORDER_COLOR, bCol );

        glError = glGetError();
                                if (glError != GL_NO_ERROR)
                                {
                                        cerr<<"Could not upload texture: " << gluErrorString(glError) << endl;
                                }

        // finally report texture as created
        m_textureCreated = true;
                        }
                }
                else
                {
      cout << "- 3D-texture not supported on your hardware!" << endl;
                }
        }
  return m_textureCreated;
}

void OpenGLWidget::keyEvent( int key )
{
  /*
  w = 87
  s = 83
  a = 65
  d = 68
  q = 81
  e = 69
  */

  float delta = 2.0f;

  switch ( key )
  {

  case 87: // w
    m_xRot += delta;
    break;

  case 83: // s
    m_xRot -= delta;
    break;

  case 65: // a
    m_zRot += delta;
    break;

  case 68: // d
    m_zRot -= delta;
    break;

  case 81: // q
    m_yRot += delta;
    break;

  case 69: // e
    m_yRot -= delta;
    break;

  case 77: // m
    m_mbPressed = !m_mbPressed;
    break;

  case 89: // y
    ++m_showView;
    if ( m_showView == 4 ) m_showView = 1;
    break;

  default:
    break;
  }
  this->updateGL();
}



// --------------------------- log methods


#define printOpenGLError() printOglError(__FILE__, __LINE__)

int OpenGLWidget::printOglError(char *file, int line)
{
    //
    // Returns 1 if an OpenGL error occurred, 0 otherwise.
    //
    GLenum glErr;
    int    retCode = 0;

    glErr = glGetError();
    while (glErr != GL_NO_ERROR)
    {
        printf("glError in file %s @ line %d: %s\n", file, line, gluErrorString(glErr));
        retCode = 1;
        glErr = glGetError();
    }
    return retCode;
}


void OpenGLWidget::printShaderInfoLog(GLuint obj)
{
    int infologLength = 0;
    int charsWritten  = 0;
    char *infoLog;

        glGetShaderiv(obj, GL_INFO_LOG_LENGTH,&infologLength);

    if (infologLength > 0)
    {
        infoLog = (char *)malloc(infologLength);
        glGetShaderInfoLog(obj, infologLength, &charsWritten, infoLog);
                printf("%s\n",infoLog);
        free(infoLog);
    }
}

void OpenGLWidget::printProgramInfoLog(GLuint obj)
{
    int infologLength = 0;
    int charsWritten  = 0;
    char *infoLog;

        glGetProgramiv(obj, GL_INFO_LOG_LENGTH,&infologLength);

    if (infologLength > 0)
    {
        infoLog = (char *)malloc(infologLength);
        glGetProgramInfoLog(obj, infologLength, &charsWritten, infoLog);
                printf("%s\n",infoLog);
        free(infoLog);
    }
}



void OpenGLWidget::setRenderMode( RENDER_MODE renderMode )
{
  cout << "RenderMode: " << renderMode << endl;

  m_renderMode = renderMode;

  if ( m_Axis == OPENGL_3D_VIEW )
    this->updateGL();
}


void OpenGLWidget::mouseMoveEvent( QMouseEvent *e )
{
  //cout << "mouse moved..." << endl;

  int scale = 1; // 100;

  if ( /* m_mbPressed && */ m_Axis == OPENGL_3D_VIEW )
  {
    int xOffset = e->x() - m_lastXPosition;
    int yOffset = e->y() - m_lastYPosition;

    m_lastXPosition = e->x();
    m_lastYPosition = e->y();

    m_zRot += (float) (xOffset / scale);
    m_xRot += (float) (yOffset / scale);

    this->updateGL();
  }
}

void OpenGLWidget::mousePressEvent( QMouseEvent *e )
{
    //cout << "mouse pressed..." << endl;

    m_lastXPosition = e->x();
    m_lastYPosition = e->y();

    //m_mbPressed = true;
}

void OpenGLWidget::mouseReleaseEvent( QMouseEvent *e )
{
    //cout << "mouse released..." << endl;

    m_lastXPosition = 0;
    m_lastYPosition = 0;

    //m_mbPressed = false;
}

---