source: trunk/VUT/GtpVisibilityPreprocessor/src/GlRenderer.h @ 572

#ifndef __RENDERER_H
#define __RENDERER_H

#include <QtOpenGL>
#include <QWaitCondition>
//#include <QGLPixelBuffer>

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

class SceneGraph;
class ViewCellsManager;
class Mesh;
class MeshInstance;
class Intersectable;
class Material;
class Beam;
class KdTree;
class QWidget;
class GlRendererBuffer;
class BeamSampleStatistics;

struct VssRayContainer;

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;
  bool mWireFrame;
  
bool mDetectEmptyViewSpace;

  KdTree *mKdTree;

  QWaitCondition mRenderingFinished;
  
  
  GlRenderer(SceneGraph *sceneGraph,
                         ViewCellsManager *viewcells,
                         KdTree *tree);
  
  ~GlRenderer();


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

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

  
  
  float
  GetPixelError();

  void InitGL();

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

  int GetId(int r, int g, int b) const;
};


class GlRendererBuffer : public QGLPixelBuffer, public GlRenderer
{
public:
        GlRendererBuffer(const int w,
                                         const int h,
                                         SceneGraph *sceneGraph,
                                         ViewCellsManager *viewcells,
                                         KdTree *tree);

  
  void
  EvalPvsStat();

  void
  ClearErrorBuffer();
  

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


  void RandomViewPoint();
  void SampleBeamContributions(
                                                           Intersectable *sourceObject,
                                                           Beam &beam,
                                                           const int samples,
                                                           BeamSampleStatistics &stat
                                                           );

  void
  SampleViewpointContributions(
                                                           Intersectable *sourceObject,
                                                           const Vector3 viewPoint,
                                                           Beam &beam,
                                                           const int desiredSamples,
                                                           BeamSampleStatistics &stat
                                                           );

  void InitGL();

  /** Computes rays from information gained with hw sampling-
  */
  void ComputeRays(Intersectable *sourceObj, VssRayContainer &rays);

  int ComputePvs() const;


  int ComputePvs(ObjectContainer &objects, ObjectContainer &pvs) const;

  PvsRenderStatistics mPvsStat;
   
  int mPvsStatFrames;
  vector<float> mPvsErrorBuffer;
private:
        
        static void GenQueries(const int numQueries);
        
        void SetupProjectionForViewPoint(const Vector3 &viewPoint, 
                                                                         const Beam &beam, 
                                                                         Intersectable *sourceObject);
};



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

  // point of the last mouse click used for movement in the scene
  Vector3 mousePoint;

  bool mTopView;
  
  GlRendererWidget(SceneGraph *sceneGraph,
                                   ViewCellsManager *viewcells,
                                   KdTree *tree,
                                   QWidget * parent = 0, const QGLWidget * shareWidget = 0, Qt::WFlags f = 0
                                   ):
        GlRenderer(sceneGraph, viewcells, tree), QGLWidget(parent, shareWidget, f)
  {
        mTopView = false;
  }

  virtual void SetupCamera();

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

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

  void keyPressEvent ( QKeyEvent * e ) ;
  
  float
  RenderErrors();

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


extern GlRendererWidget *rendererWidget;

class GlDebuggerWidget : public QGLWidget
{
        Q_OBJECT
public:
    GlDebuggerWidget(GlRendererBuffer *buf, QWidget *parent = NULL);
    ~GlDebuggerWidget();
    void initializeGL();
    void resizeGL(int w, int h);
    void paintGL();
    void timerEvent(QTimerEvent *) { update(); }
    void mousePressEvent(QMouseEvent *) { killTimer(timerId); }
    void mouseReleaseEvent(QMouseEvent *) { timerId = startTimer(20); }

    void initCommon();
    void initPbuffer();

         GlRendererBuffer *mRenderBuffer;

         Beam mBeam;
         int mSamples;
         Intersectable *mSourceObject;
private:
    GLuint dynamicTexture;
    int timerId;
};

extern GlDebuggerWidget *debuggerWidget;

#endif