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

// ===================================================================
// $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"
#include "ViewCellsManager.h"


namespace GtpVisibilityPreprocessor {

QtGlRendererWidget *renderer;

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

        //setWindowTitle("PVS visualization");
        setWindowTitle("Global View Cell Visualization");

        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 
{
        // set viewer size here
        return QSize(512, 320);

        //return QSize(512, 384);
        //return QSize(640, 480);
}
  
// This method has to be rendefined by all renderer implementations
void QtGlViewer::RenderScene()
{
        GLfloat mat_ambient[]   = {  0.5, 0.5, 0.5, 1.0  };
        
        // mat_specular and mat_shininess are NOT default values
        GLfloat mat_diffuse[]   = {  1.0, 1.0, 1.0, 1.0  };
        GLfloat mat_specular[]  = {  0.3, 0.3, 0.3, 1.0  };
        GLfloat mat_shininess[] = {  1.0  };

        GLfloat light_ambient[]  = {  0.2, 0.2, 0.2, 1.0  };
        GLfloat light_diffuse[]  = {  0.4, 0.4, 0.4, 1.0  };
        GLfloat light_specular[] = {  0.3, 0.3, 0.3, 1.0  };

        GLfloat lmodel_ambient[] = {0.3, 0.3, 0.3, 1.0};


        // set position of the light
        GLfloat infinite_light[] = {1.0, 0.8, 1.0, 0.0};
        glLightfv (GL_LIGHT0, GL_POSITION, infinite_light);

        // set position of the light2
        GLfloat infinite_light2[] = {-0.3, 1.5, 1.0, 0.0};
        glLightfv (GL_LIGHT1, GL_POSITION, infinite_light2);

        // default material
        /*glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, mat_ambient);
        glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, mat_diffuse);
        glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, mat_specular);
        glMaterialfv(GL_FRONT_AND_BACK, GL_SHININESS, mat_shininess);
*/
        // a light
        glLightfv(GL_LIGHT0, GL_AMBIENT, light_ambient);
        glLightfv(GL_LIGHT0, GL_DIFFUSE, light_diffuse);
        glLightfv(GL_LIGHT0, GL_SPECULAR, light_specular);
        
        glLightfv(GL_LIGHT1, GL_AMBIENT, light_ambient);
        glLightfv(GL_LIGHT1, GL_DIFFUSE, light_diffuse);
        glLightfv(GL_LIGHT1, GL_SPECULAR, light_specular);
        
        glLightModelfv(GL_LIGHT_MODEL_AMBIENT, lmodel_ambient);

        //GLfloat infinite_light2[] = {-0.3, 1.5f, 1.0f, 0.0f};
        //glLightfv (GL_LIGHT1, GL_POSITION, infinite_light2);
        //glColor3f(1.0f, 1.0f, 1.0f);
        glColor3f(0.8f, 0.8f, 0.8f);
        
        glColorMaterial(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE);
        glEnable(GL_COLOR_MATERIAL);

        ++ mRenderer->mFrame;
        
        glEnable(GL_DEPTH_TEST);
        glDepthMask(GL_TRUE);

        glCullFace(GL_BACK);
        glShadeModel(GL_FLAT);

        glDisable(GL_BLEND);

        mRenderer->mDummyViewPoint = mDummyViewPoint;
        
        glEnable(GL_NORMALIZE);
        glEnable(GL_LIGHTING);
        glEnable(GL_LIGHT0);
        glEnable(GL_LIGHT1);

        mRenderer->VisualizePvs();
        
        glDisable(GL_LIGHTING);

        if (0 && mRenderer->mShowRays) 
        {
                mRenderer->RenderRays(mRenderer->mViewCellsManager->mVizBuffer.GetRays());
        }

        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;


        glEnable(GL_LIGHTING);
        glEnable(GL_LIGHT0);
        //glEnable(GL_LIGHT1);

        // set position of the light
        GLfloat infinite_light[] = {0, -1.0, 0, 1.0f};
        glLightfv(GL_LIGHT0, GL_POSITION, infinite_light);

  return;
}

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

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

        glLoadIdentity();
        gluLookAt(0.0f, 0.0f, 15.0f,  // eye is at (0,0,30) 
                      0.0f, 0.0f, 0.0f,  // center is at (0,0,0) 
                      0.0f, 1.0f, 0.0f); // 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_V:
                mRenderer->mRenderViewCells = !mRenderer->mRenderViewCells;
                updateGL();
                break;

  case Qt::Key_W:
                mWireframe = !mWireframe;
                updateGL();
                break;

  default:
                e->ignore();
                cerr << "unknown key" << endl;
                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();
        }


}