source: GTP/trunk/Lib/Vis/Preprocessing/src/QtInterface/QtGlViewer.cpp @ 2569

// ===================================================================
// $Id$

// Qt headers
#include <QtGui>
#include <QtOpenGL>

// C++ standard headers
#include <cmath>

// local headers
#include "common.h"
#include "QtGlViewer.h"
#include "QtGlRenderer.h"
#include "Trackball.h"
#include "RssPreprocessor.h"
#include "SceneGraph.h"


namespace GtpVisibilityPreprocessor {

QtGlRendererWidget *renderer;

QtGlViewer::QtGlViewer(QWidget *parent,
                                           QtGlRendererWidget *renderer):
  QGLWidget(parent), mRenderer(renderer)
{
        scale = 1.0f;
        mWireframe = false;
        mModelMatrix = IdentityMatrix();

        trackball(manipulatorLastQuat, 0.0f, 0.0f, 0.0f, 0.0f);
        //connect(renderer, SIGNAL(PvsUpdated()), this, SLOT(updateGL()));
        //connect(renderer, SIGNAL(cutupdated), this, SLOT(updateGL()));

        const int delay = 250; // in milliseconds
        timerId = startTimer(delay);
}
  
QSize
QtGlViewer::minimumSizeHint() const
{
  return QSize(100, 100);
}

QSize
QtGlViewer::sizeHint() const {
  return QSize(500, 500);
}
  
// This method has to be rendefined by all renderer implementations
void
QtGlViewer::RenderScene()
{
        ++ mRenderer->mFrame;
        
        //glDisable(GL_DEPTH_TEST);

        mRenderer->mDummyViewPoint = mDummyViewPoint;
        glColor3f(0.8f, 0.8f, 0.8f);
        mRenderer->RenderPvs();
        
//      if (mRenderer->mShowRays) {
//        RssPreprocessor *p = (RssPreprocessor *)
//                      mRenderer->mViewCellsManager->GetPreprocessor();
//        if (p->mRssTree) {
//                      VssRayContainer rays;
//                      p->mRssTree->CollectRays(rays, 10000);
//                      mRenderer->RenderRays(rays);
//        }
//      }

        if (mRenderer->mShowRenderCost) 
          mRenderer->RenderRenderCost();

        // render into the right side of the window buffer
        if (mRenderer->mRenderViewCells)
                mRenderer->RenderViewCells();

        mRenderer->RenderViewPoint();

        glColor3f(1.0f, 1.0f, 1.0f);
        mRenderer->RenderInfo();
}


void
QtGlViewer::initializeGL()
{  
  const char *vendorString, *rendererString, *versionString, *extString;

  // get GL info
  vendorString = (const char *) glGetString(GL_VENDOR);
  rendererString = (const char *) glGetString(GL_RENDERER);
  versionString = (const char *) glGetString(GL_VERSION);
  extString = (const char *) glGetString(GL_EXTENSIONS);
  
  Debug << "Info: GL Vendor = "<<vendorString<<endl
        << "Info: GL Renderer = "<<rendererString<<endl
        << "Info: GL Version = "<<versionString<<endl
        << "Info: GL Extensions = "<<extString<<endl<<flush;


  return;
}

void
QtGlViewer::paintGL()
{
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
        glLoadIdentity();

        //float m[4][4];
        Matrix4x4 m;

        glLoadIdentity();
        gluLookAt(0.0, 0.0, 1.0,  /* eye is at (0,0,30) */
                      0.0, 0.0, 0.0,  /* center is at (0,0,0) */
                      0.0, 1.0, 0.);  /* up is in positive Y direction */

        build_rotmatrix(m.x, manipulatorLastQuat);
        glMultMatrixf((float *)m.x);

        float s = scale * 20.0f / Magnitude(mRenderer->mSceneGraph->GetBox().Diagonal());
        glScalef(s, s, s);

        // TODO: determine model matrix for establishing right rendering order for transparency
        Vector3 t = -mRenderer->mSceneGraph->GetBox().Center();
        glTranslatef(t.x, t.y, t.z);

        /*mDummyViewPoint = -t;
        mDummyViewPoint /= s;

        //glGetFloatv(GL_MODELVIEW_MATRIX, m1);
*/
        m.Invert();

        mModelMatrix *= m;
        mDummyViewPoint = mModelMatrix * Vector3(0, 0, 0);

        //mDummyViewPoint 
        //cout << "view point: " << mDummyViewPoint << endl;
        RenderScene();
}

void
QtGlViewer::resizeGL(int width, int height)
{
  glViewport(0, 0, width, height);
  
  glMatrixMode(GL_PROJECTION);
  glLoadIdentity();
  gluPerspective(70.0, 1.0, 0.1, 100.0);
  //  glOrtho(-0.5*width/height, +0.5*width/height, 0.5, -0.5, 4.0, 15.0);
  glMatrixMode(GL_MODELVIEW);
}


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

void
QtGlViewer::keyPressEvent ( QKeyEvent * e )
{
  switch (e->key()) {
  case Qt::Key_W:
                mWireframe  = !mWireframe;
                updateGL();
  default:
                e->ignore();
                break;
  }
  updateGL();
}

void
QtGlViewer::mouseMoveEvent(QMouseEvent *event)
{
  int dx = event->x() - lastPos.x();
  int dy = event->y() - lastPos.y();  
  
  if (event->modifiers() & Qt::CTRL)
                {
                        scale = scale*(1.0f - dy/(float)height());
                        if (scale < 0.01f)
                                scale = 0.01f;
                        updateGL();
                }
  else {
                float W = width();
                float H = height();
                int x = event->x();
                int lastX = lastPos.x();
                int y = event->y();
                int lastY = lastPos.y();
        
                float quat[4];
                trackball(quat,
                                                        (2.0 * lastX - W) / W,
                                                        (H - 2.0 * lastY) / H,
                                                        (2.0 * x - W) / W,
                                                        (H - 2.0 * y) / H
                                                        );
                add_quats(quat, manipulatorLastQuat, manipulatorLastQuat);
  }
  
  lastPos = event->pos();
  updateGL();
}

void QtGlViewer::timerEvent(QTimerEvent *event) 
{
        update();
}


}