#ifndef __RENDERER_H
#define __RENDERER_H

#include <QtOpenGL>
#include <QWaitCondition>

#include "Vector3.h"
#include "Containers.h"
#include "Halton.h"
#include "Renderer.h"

class SceneGraph;
class ViewCellsManager;
class Mesh;
class MeshInstance;
class Intersectable;
class Material;

struct PvsRenderStatistics {
  
  float maxError;
  float sumError;
  int frames;
  int errorFreeFrames;
  
  PvsRenderStatistics() { Reset(); }
  
  void Reset() {
	maxError = 0.0f;
	sumError = 0.0f;
	frames = 0;
	errorFreeFrames = 0;
  }

  float GetMaxError() { return maxError; }
  float GetAvgError() { return sumError/frames; }
  float GetErrorFreeFrames() { return errorFreeFrames/(float)frames; }
  
};


/** Class encapsulating gl rendering for the scene.
	There is no gl context binding so the binding is performed in the
	derived classes
*/

class GlRenderer: public Renderer
{

public:
  ObjectContainer mObjects;
   
  Vector3 mViewPoint;
  Vector3 mViewDirection;

  int timerId;
  bool mUseFalseColors;

  HaltonSequence halton;
  
  int mFrame;
  
  QWaitCondition mRenderingFinished;
  
  
  GlRenderer(SceneGraph *sceneGraph,
			 ViewCellsManager *viewcells);
  
  ~GlRenderer();


  void SetupFalseColor(const int id);
  void RenderIntersectable(Intersectable *);
  void RenderMeshInstance(MeshInstance *mi);
  void RenderMesh(Mesh *m);
  void SetupMaterial(Material *m);
  void SetupCamera();
  void RandomViewPoint();
  
  bool
  RenderScene();

  void
  SetupProjection(const int w, const int h);

  
  
  float
  GetPixelError();

  void InitGL();

  virtual int GetWidth() const = 0;
  virtual int GetHeight() const = 0;
};


class GlRendererBuffer : public QGLPixelBuffer, public GlRenderer
{

public:
  int mPvsStatFrames;
  vector<float> mPvsErrorBuffer;
  
  PvsRenderStatistics mPvsStat;


  GlRendererBuffer(const int w,
				   const int h,
				   SceneGraph *sceneGraph,
				   ViewCellsManager *viewcells):
	QGLPixelBuffer(QSize(w, h)), GlRenderer(sceneGraph, viewcells) {

	mPvsStatFrames = 10000;
	mPvsErrorBuffer.resize(mPvsStatFrames);
	ClearErrorBuffer();

	makeCurrent();
	InitGL();
	
  }
  
  void
  EvalPvsStat();

  void
  ClearErrorBuffer();

  

  virtual int GetWidth() const { return width(); }
  virtual int GetHeight() const { return height(); }

};



class GlRendererWidget : public QGLWidget, public GlRenderer
{
  Q_OBJECT
public:

  GlRendererWidget(SceneGraph *sceneGraph,
				   ViewCellsManager *viewcells,
				   QWidget * parent = 0, const QGLWidget * shareWidget = 0, Qt::WFlags f = 0
				   ):
	GlRenderer(sceneGraph, viewcells), QGLWidget(parent, shareWidget, f)
  {}

  Vector3 mousePoint;
  
  void initializeGL() {
	InitGL();
  }
  void resizeGL(int w, int h);
  void paintGL();
  void timerEvent(QTimerEvent *) {
	  update();
  }

  void mousePressEvent(QMouseEvent *);
  void mouseReleaseEvent(QMouseEvent *);
  void mouseMoveEvent(QMouseEvent *);

  float
  RenderErrors();

  virtual int GetWidth() const { return width(); }
  virtual int GetHeight() const { return height(); }

};


extern GlRendererWidget *rendererWidget;

#endif