glview.cpp

Go to the documentation of this file.

/***************************************************************************
                          glview.cpp  -  description
                             -------------------
    begin                : Fri Nov 5 2004
    copyright            : (C) 2004-2006 by Ben Swerts
    email                : bswerts@users.sourceforge.net
 ***************************************************************************/

/***************************************************************************
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 ***************************************************************************/






// Qt header files
#include <qdatetime.h>
#include <qfiledialog.h>
#include <qimage.h>
#include <qmessagebox.h>
#include <qpoint.h>
#include <qstringlist.h>
#include <qtimer.h>

// Xbrabo header files
#include "glview.h"
#include "quaternion.h"
#include "vector3d.h"


GLView::GLView(QWidget* parent, const char* name) : QGLWidget(parent,name),
  xPos(0.0f),
  yPos(0.0f),
  zPos(0.0f),
  //aspectRatio(1.0f),
  xRot(0.0f),
  yRot(0.0f),
  zRot(0.0f),
  animation(false),
  maxRadius(1.0f),
  currentPerspectiveProjection(baseParameters.perspectiveProjection)
{
  setFocusPolicy(QWidget::StrongFocus); // needed to receive all keystrokes
  orientationQuaternion = new Quaternion<float>(0.0f, 0.0f, 0.0f);
  timer = new QTimer(this);
  connect(timer, SIGNAL(timeout()), this, SLOT(update()));
  setModified(false);
  //resetView(false); // can't call this as it indirectly calles the pure virtual boundingSphereRadius
                      // which is not defined yet for the dervived class which calls this constructor
                      // in its constructor
  updateIndex = staticUpdateIndex - 1; // an update is needed
}

GLView::~GLView()
{
  delete orientationQuaternion;
}

bool GLView::isModified() const
{
  return viewModified;
}

bool GLView::isAnimating() const
{
  return animation;
}

unsigned int GLView::calculateFPS()
{
  unsigned int numFPS = 0;        // the counter for the FPS
  const int nummSec = 5000;             // the number of milliseconds measured
  QTime t;                              // the time object

  bool oldAnimation = animation;
  Quaternion<float> oldOrientation = *orientationQuaternion;

  animation = false;
  t.start();
  while (t.elapsed() < nummSec)
  {
    xRot = 1.00;
    yRot = 1.25;
    zRot = 1.50;
    updateGL();
    numFPS++;
  }

  animation = oldAnimation;
  *orientationQuaternion = oldOrientation;
  updateGL();

  return numFPS*1000/nummSec;
}

void GLView::setParameters(GLBaseParameters params)
{
  baseParameters = params;
  staticUpdateIndex++;
}


void GLView::setModified(const bool status)
{
  if(!status)
  {
    viewModified = false;
    return;
  }
  if(!viewModified)
  {
    viewModified = true;
    emit modified();
  }
  emit changed();
}

void GLView::toggleAnimation()
{
  animation = !animation;
  if(animation)
  {
    xRot = 1.0;
    yRot = 0.0;
    zRot = 0.0;
    updateGL();
  }
  else
    timer->stop();

  emit changed(); // don't call setModified as animation does not get saved/restored
}

void GLView::centerView(const bool update)
{
  xPos = 0.0;
  yPos = 0.0;
  if(update)
    updateGL();
  setModified();
}

void GLView::resetOrientation(const bool update)
{
  orientationQuaternion->eulerToQuaternion(0.0f, 0.0f, 0.0f);
  if(update)
    updateGL();
  setModified();
}

void GLView::zoomFit(const bool update)
{
  maxRadius = boundingSphereRadius();
  if(baseParameters.perspectiveProjection)
  {
    if(width() > height())
      zPos = maxRadius/tan(fieldOfView)/1.5f;
    else
      zPos = maxRadius/tan(fieldOfView)/1.5f * static_cast<float>(height())/static_cast<float>(width());
    if(zPos < 0.1f)
      zPos = 0.1f;
  }
  else
  {
    zPos = 1.0f;
    resizeGL(width(), height());
  }

  updateFog(maxRadius);
  if(update)
    updateGL();
  setModified();
}

void GLView::resetView(const bool update)
{
  centerView(false);
  resetOrientation(false);
  zoomFit(); // calls setModified()
  if(update)
    updateGL();
}

void GLView::saveImage()
{
  QStringList saveFormats = QImage::outputFormatList();
  QStringList::Iterator it = saveFormats.begin();
  while(it != saveFormats.end())
  {
    if((*it) == "JPEG")
      *it = "JPEG (*.jpg)";
    else
      *it += " (*."+(*it).lower()+")";  // 'BMP' -> 'BMP (*.bmp)'
    it++;
  }

  /*
  QFileDialog saveDialog("", QString::null, this, 0, true);
  saveDialog.setFilters(saveFormats);
  saveDialog.setSelectedFilter("PNG (*.png)");
  saveDialog.setCaption(tr("Choose a filename and format"));
  saveDialog.setMode(QFileDialog::AnyFile);
  if(saveDialog.exec() != QDialog::Accepted)
    return;
  QString filename = saveDialog.selectedFile();
  if(filename.isEmpty())
    return;
  */
  // this way does not allow to set the selected filter. maybe put PNG at the top manually. now BMP is the default
  QString selectedFilter;
  QString filename = QFileDialog::getSaveFileName(0, saveFormats.join(";;"), 0, 0, tr("Choose a filename and format"), &selectedFilter);
  if(filename.isEmpty())
    return;

  //QString extension = saveDialog.selectedFilter();
  //extension = extension.mid(extension.find("."));
  //extension = extension.remove(")");
  //qDebug("extension: "+extension);
  QString extension = selectedFilter.mid(selectedFilter.find(".")).remove(")");

  if(filename.contains(extension) == 0)
    filename += extension;

  //QString format = saveDialog.selectedFilter();
  //format = format.left(format.find(" "));
  QString format = selectedFilter.left(selectedFilter.find(" "));

  // generate an image from the OpenGL view
  // -> It is possible to get a transparant image when using grabFrameBuffer(true)
  QImage image = grabFrameBuffer();

  // save it
  if(!image.save(filename, format))
    QMessageBox::warning(this, tr("Save image"), tr("An error occured. Image is not saved"));
}


void GLView::initializeGL()
{
  GLfloat lightAmbient[] = {0.2f, 0.2f, 0.2f, 0.0f};
  GLfloat lightDiffuse[] = {0.5f, 0.5f, 0.5f, 0.0f};
  GLfloat lightSpecular[] = {1.0f, 1.0f, 1.0f, 0.0f};

  updateGLSettings();

  //glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, GL_FALSE);         // disable twosided lighting (default)
  //glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, GL_FALSE);     // disable local viewpoint (default)
  //glLightModelfv(GL_LIGHT_MODEL_AMBIENT, lightAmbient);     // set the ambient light (default)
  glLightfv(GL_LIGHT0, GL_AMBIENT, lightAmbient);     // enable ambient
  glLightfv(GL_LIGHT0, GL_DIFFUSE, lightDiffuse);     // enable diffuse
  glLightfv(GL_LIGHT0, GL_SPECULAR, lightSpecular);    // enable specular
  glEnable(GL_LIGHTING);                // enable lighting
  glEnable(GL_LIGHT0);                  // enable light 0

  glEnable(GL_AUTO_NORMAL);
  glEnable(GL_NORMALIZE); // maybe this copes with the non-uniform scaling of the bonds => nope

  glColorMaterial(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE);
  glEnable(GL_COLOR_MATERIAL);

  glEnable(GL_DITHER);                  // enable dithering (default)
  glEnable(GL_DEPTH_TEST);              // use the depth buffer for hidden surface removal

  glCullFace(GL_BACK);                 // we will only see the outsides of objects
  glEnable(GL_CULL_FACE);               // => enable culling

  //glHint(GL_POLYGON_SMOOTH_HINT, GL_NICEST);                // antialiasing method
  //glBlendFunc(GL_SRC_ALPHA_SATURATE, GL_ONE);               // set the proper blending mode
  glHint(GL_LINE_SMOOTH_HINT, GL_NICEST);
  //glEnable(GL_LINE_SMOOTH);
  glHint(GL_POINT_SMOOTH_HINT, GL_NICEST);
  //glEnable(GL_POINT_SMOOTH);

  // transparancy setup
  glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

  glFogi(GL_FOG_MODE, GL_LINEAR);

  glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);        // color interpolation method
}

void GLView::resizeGL(int w, int h)
{
  glViewport(0, 0, w, h);
  glMatrixMode(GL_PROJECTION);
  glLoadIdentity();
  //aspectRatio = static_cast<float>(w) / static_cast<float>(h);
  setPerspective(); // calls gluPerspective or glOrtho depending on the prespective setting
  glMatrixMode(GL_MODELVIEW);
}

void GLView::paintGL()
{
  if(staticUpdateIndex != updateIndex)
    updateGLSettings();

  Quaternion<float> changeQuaternion(xRot, yRot, zRot);
  Quaternion<float> tempQuaternion = *orientationQuaternion;
  *orientationQuaternion = tempQuaternion*changeQuaternion;  // no *= operator implemented yet => calling default constructor?
  Vector3D<float> axis;
  float angle;
  orientationQuaternion->getAxisAngle(axis, angle);

  if(!animation)
  {
    xRot = 0.0f;
    yRot = 0.0f;
    zRot = 0.0f;
  }

  //if(baseParameters.antialias)
  //{
  //  glClear(GL_COLOR_BUFFER_BIT);
  //}
  //else
  //{
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
  //}

  glLoadIdentity();
  //qDebug("GlView::xPos = %f, yPos = %f, zPos = %f", xPos, yPos, zPos);
  //qDebug("GlView::orientationQuaternion = (%f, %f, %f, %f)",orientationQuaternion->x(),orientationQuaternion->y(),orientationQuaternion->z(),orientationQuaternion->w());
  if(baseParameters.perspectiveProjection)
    gluLookAt(0.0f, 0.0f, zPos, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f);
  else
    resizeGL(width(), height());
  glPushMatrix();
  glTranslatef(xPos, yPos, 0.0f);
  glRotatef(angle, axis.x(), axis.y(), axis.z());

  drawScene(); // pure virtual

  glPopMatrix();
  glFlush(); // drawing is complete => send for execution
  if(animation)
    timer->start(redrawWait, true);
}

void GLView::mousePressEvent(QMouseEvent* e)
{
  if(e->button() & Qt::LeftButton) // only track mousemoves for the left button
  {
    mousePosition = e->pos(); // set the starting position of the move
    startingClick = true;
  }
  else
    e->ignore();
}

void GLView::mouseMoveEvent(QMouseEvent* e)
{
  if(e->state() & Qt::LeftButton) // only track mousemoves for the left button
  {
    QPoint newPosition = e->pos(); // the mouse moved from mousePosition to newPosition

    if(e->state() & Qt::ShiftButton) // shift has precedence over control
    {
      if(abs(newPosition.y() - mousePosition.y()) > abs(newPosition.x() - mousePosition.x()))
        translateZ(newPosition.y() - mousePosition.y());
      else
        zRot = -180.0f * static_cast<float>(newPosition.x() - mousePosition.x()) / static_cast<float>(width()); // z-rotation of entire system
    }
    else if(e->state() & Qt::ControlButton)
    {
      translateXY(newPosition.x() - mousePosition.x(), newPosition.y() - mousePosition.y());
    }
    else
    {
      yRot = 180.0f * static_cast<float>(newPosition.x() - mousePosition.x()) / static_cast<float>(width());
      xRot = 180.0f * static_cast<float>(newPosition.y() - mousePosition.y()) / static_cast<float>(height());
    }
    setModified();
    mousePosition = newPosition;
    updateGL();
    startingClick = false;
  }
  else
    e->ignore();
}

void GLView::mouseReleaseEvent(QMouseEvent* e)
{
  if(e->button() & Qt::LeftButton) // only track mousemoves for the left button
  {
    if(startingClick)
    {
      clicked(mousePosition);
    }
  }
  else
    e->ignore(); //event will be handled by the parent widget
}

void GLView::keyPressEvent(QKeyEvent* e)
{
  switch(e->key())
  {
    case Qt::Key_Left :   if(e->state() & Qt::ShiftButton)
                            zRot = 5.0f; // rotate counterclockwise
                          else if(e->state() & Qt::ControlButton)
                            translateXY(-5, 0);
                          else
                            yRot = -5.0f; // rotate left
                          break;

    case Qt::Key_Up     : if(e->state() & Qt::ShiftButton)
                            translateZ(-5);
                          else if(e->state() & Qt::ControlButton)
                            translateXY(0, -5);
                          else
                             xRot = -5.0f; // rotate up
                          break;

    case Qt::Key_Right  : if(e->state() & Qt::ShiftButton)
                            zRot = -5.0f; // rotate clockwise
                          else if(e->state() & Qt::ControlButton)
                            translateXY(5, 0);
                          else
                            yRot =  5.0f; // rotate right
                          break;

    case Qt::Key_Down   : if(e->state() & Qt::ShiftButton)
                            translateZ(5);
                          else if(e->state() & Qt::ControlButton)
                            translateXY(0, 5);
                          else
                            xRot = 5.0f; // rotate down
                          break;

    default:              e->ignore();
                          return;
  }
  setModified();
  updateGL();
}

void GLView::wheelEvent(QWheelEvent* e)
{
  translateZ(-e->delta()/4); // abs(e->delta()) is always WHEELDELTA == 120
  setModified();
  updateGL();
  e->accept();
}

void GLView::translateZ(const int amount)
{
  // a zoom over a distance of the height of the OpenGL window should translate
  // in half the size of the molecule
  if(amount != 0)
  {
    float zoomFactor = static_cast<float>(amount)/height(); // percentage
    if(baseParameters.perspectiveProjection)
      zoomFactor *= 2.0f * maxRadius;
    zPos += zoomFactor;
    if(zPos < 0.1f)
      zPos = 0.1f;
    if(!baseParameters.perspectiveProjection)
      resizeGL(width(), height()); // zooming for ortho projection is in fact direct scaling of the view
  }
}

void GLView::translateXY(const int amountX, const int amountY)
{
  if(amountX != 0)
    xPos += amountX < 0 ? -0.1f : 0.1f;
  if(amountY != 0)
    yPos += amountY > 0 ? -0.1f : 0.1f;
}

void GLView::clicked(const QPoint&)
{
}

void GLView::updateGLSettings()
{
  updateIndex = staticUpdateIndex;

  GLfloat lightPosition[] = {baseParameters.lightPositionX, baseParameters.lightPositionY, baseParameters.lightPositionZ, 0.0f};
  GLfloat materialSpecular[] = {baseParameters.materialSpecular/100.0f, baseParameters.materialSpecular/100.0f, baseParameters.materialSpecular/100.0f, 0.0f};
  GLfloat materialShininess[] = {baseParameters.materialShininess};

  glLightfv(GL_LIGHT0, GL_POSITION, lightPosition); // set light position for directional light
  glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, materialSpecular);
  glMaterialfv(GL_FRONT_AND_BACK, GL_SHININESS, materialShininess);

  //qglClearColor(baseParameters.backgroundColor);
  qglClearColor(QColor(baseParameters.backgroundColor));

  if(baseParameters.smoothShading)
    glShadeModel(GL_SMOOTH);
  else
    glShadeModel(GL_FLAT);

  if(baseParameters.antialias)
  {
    //polygon antialiasing is way to slow.
    //glEnable(GL_BLEND);
    //glEnable(GL_POLYGON_SMOOTH);
    //glDisable(GL_DEPTH_TEST);
    // antialiasing for lines and points.
    glEnable(GL_LINE_SMOOTH);
    glEnable(GL_POINT_SMOOTH);
  }
  else
  {
    //glDisable(GL_BLEND);
    //glDisable(GL_POLYGON_SMOOTH);
    //glEnable(GL_DEPTH_TEST);
    glDisable(GL_LINE_SMOOTH);
    glDisable(GL_POINT_SMOOTH);
  }

  if(baseParameters.depthCue)
    glEnable(GL_FOG);
  else
    glDisable(GL_FOG);

  updateProjection(); // pure virtual which takes care of a change in projection

  resizeGL(width(), height());
}

void GLView::updateFog(const float radius)
{
  makeCurrent();
  GLfloat fogStart = zPos;
  GLfloat fogEnd = zPos + 2.0*radius;
  //qDebug("setting fog from %f to %f",fogStart, fogEnd);
  glFogf(GL_FOG_START, fogStart);
  glFogf(GL_FOG_END, fogEnd);
}

void GLView::updateProjection()
{
  if(currentPerspectiveProjection == baseParameters.perspectiveProjection)
    return;

  resizeGL(width(), height());
  zoomFit();

  currentPerspectiveProjection = baseParameters.perspectiveProjection;
}

void GLView::setPerspective()
{
  GLfloat aspectRatio = static_cast<float>(width()) / static_cast<float>(height());
  if(baseParameters.perspectiveProjection)
    gluPerspective(fieldOfView, aspectRatio, 0.1f, 100.0f); // originally 0.01f and 100.0f but artifacts from intersecting triangles
                                                            // are greatly reduced. Problem was the inaccuracy of the Z-buffer
                                                            // best results are obtained with a ratio near/far as low as possible
  else
    glOrtho(-maxRadius*aspectRatio*zPos, maxRadius*aspectRatio*zPos, -maxRadius*zPos, maxRadius*zPos, -maxRadius, maxRadius);
}


int GLView::staticUpdateIndex = 0;
const int GLView::redrawWait = 33;
const float GLView::fieldOfView = 60.0f;

//  OpenGLParameters GLMoleculeView::parameters = {1.0, 1.0, 1.0, QColor(255, 255, 255), 0.80, 100.0,
//                                                 QColor(0, 0, 0), false, true, true, 5, true, 0, 0.2, 3.0};
GLBaseParameters GLView::baseParameters = {1.0f, 1.0f, 1.0f, 0xffffff, 0.80f, 100.0f,
                                           0x000000, false, true, false, true};

---