// ===================================================================
// $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;
	trackball(manipulatorLastQuat, 0.0f, 0.0f, 0.0f, 0.0f);
	connect(renderer, SIGNAL(PvsUpdated()), this, SLOT(updateGL()));
}
  
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++;
	
	// render into the right side of the window buffer
	if (mRenderer->mRenderViewCells) 
	  mRenderer->RenderViewCells();
	
	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();

	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];

  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, manipulatorLastQuat);
  glMultMatrixf(&m[0][0]);

  float s = scale*20.0f/Magnitude(mRenderer->mSceneGraph->GetBox().Diagonal());
  glScalef(s, s, s);
  
  Vector3 t = -mRenderer->mSceneGraph->GetBox().Center();
  glTranslatef(t.x, t.y, t.z);

	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.01)
				scale = 0.01;
			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();
}
}