source: GTP/trunk/Lib/Vis/Preprocessing/src/QtInterface/QtGlRenderer.h @ 2577

#ifndef __QTGLRENDERER_H
#define __QTGLRENDERER_H

#include <QtOpenGL>
#include <QWaitCondition>
#include <QMutex>

#include "Vector3.h"
#include "Containers.h"
#include "Halton.h"
#include "Renderer.h"
#include "GlRenderer.h"
#include "Beam.h"
#include "QtPreprocessorThread.h"
#include "LogReader.h"


class QWidget;



namespace GtpVisibilityPreprocessor {


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


struct VssRayContainer;
struct PvsRenderStatistics; 
struct RenderCostSample;


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

  ~QtGlRendererBuffer() {}

  virtual void MakeCurrent();
  virtual void DoneCurrent();

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

  int ComputePvs() const { return 0; }
  
  float
  GetPixelError(int &pvsSize);
  
  int ComputePvs(ObjectContainer &objects, ObjectContainer &pvs) const;
     
  
  
  
public:
  signals:
  void UpdatePvsErrorItem(int i, GlRendererBuffer::PvsErrorEntry &);
};


class QtRendererControlWidget : public QWidget
{
  Q_OBJECT
public:

  QListWidget *mPvsErrorWidget;

  QtRendererControlWidget(QWidget * parent = 0, Qt::WFlags f = 0);

  QGroupBox *CreateVisualizationPanel(QWidget *parent);

  public slots:

  void FocusNextPvsErrorFrame();
  void UpdatePvsErrorItem(int i,
                                                  GlRendererBuffer::PvsErrorEntry &);

  
  QGroupBox *CreateRenderCostPanel(QWidget *parent);


  signals:

  void ComputeVisibility();
  void StopComputation();
  void SetRandomViewPoint();
  void UpdateAllPvs();
  void SetViewCellGranularity(int);
  void SetTransferFunction(int);
  void SetSceneCut(int);
  void SetTopDistance(int);
  void SetHidingCost(int);
  void SetVisibilityFilterSize(int);
  void SetSpatialFilterSize(int);
  void SetTransparency(int);

  void SetShowRays(bool);
  void SetRenderFilter(bool);
  void SetRenderVisibilityEstimates(bool);
  void SetUseFilter(bool);
  void SetUseSpatialFilter(bool);
  void SetRenderErrors(bool);
  void SetRenderBoxes(bool);
  void SetShowViewCells(bool);
  void SetShowRenderCost(bool);
  void SetShowPvsSizes(bool);
  void SetShowPiercingRays(bool);
  void SetShowWeightedRays(bool);
  void SetShowWeightedCost(bool);
 
  void SetTopView(bool);
  void SetCutViewCells(bool);
  void SetCutScene(bool);

  void SetHideByCost(bool);
  void SetUseTransparency(bool);

  void SetShowDistanceWeightedTriangles(bool);
  void SetShowWeightedTriangles(bool);
  void SetShowDistanceWeightedPvs(bool);
};


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

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

        bool mTopView;
        bool mRenderViewCells;
        bool mCutViewCells;
        bool mCutScene;
        bool mHideByCost;
        bool mRenderErrors;
        bool mRenderFilter;
        bool mRenderVisibilityEstimates;
        bool mUseFilter;
        bool mUseSpatialFilter;
        bool mShowRenderCost;
        bool mShowPiercingRays;
        bool mShowWeightedRays;
        bool mShowRays;

        bool mShowPvsSizes;
        float mSpatialFilterSize;

        Plane3 mSceneCutPlane;
        float mHidingCost;

        float mTopDistance;

        float mTransparency;
        bool mUseTransparency;

        bool mShowWeightedCost;

        bool mShowDistanceWeightedTriangles;
        bool mShowDistanceWeightedPvs;
        bool mShowWeightedTriangles;

        /// the current number of samples
        int mSamples;
        /// the next number of samples where we record the data
        int mNextSamples;
        bool mRecordHist;

        // some statistics
        int mPvsSize;
        float mRenderError;
        float mTransferFunction;

        unsigned int mIndexBufferSize;

        bool mAssignImportanceByRelativeValue;

        Vector3 mDummyViewPoint;

        QtRendererControlWidget *mControlWidget;

        QtPreprocessorThread *mPreprocessorThread;

        int mCurrentSamples;

        ViewCellHistoryContainer mCurrentHist;
        ViewCellHistoryContainer mCompareHist;


        QtGlRendererWidget(SceneGraph *sceneGraph,
                ViewCellsManager *viewcells,
                KdTree *tree,
                QWidget * parent = 0, const QGLWidget * shareWidget = 0, Qt::WFlags f = 0
                );

        QtGlRendererWidget() {};

        void FillNewContainer(const ViewCellContainer &viewCells, ViewCellInfoContainer &infos);


        void SetThread(QtPreprocessorThread *t) {
                mPreprocessorThread = t;
        }
        void RenderRenderCost();

        virtual void SetupCamera();

        void initializeGL() {
                InitGL();
        }

        virtual void InitGL();

        void resizeGL(int w, int h);
        void paintGL();
        void timerEvent(QTimerEvent *event);
        void mousePressEvent(QMouseEvent *);
        void mouseReleaseEvent(QMouseEvent *);
        void mouseMoveEvent(QMouseEvent *);

        void keyPressEvent(QKeyEvent * e);

        void RenderPvs();

        float RenderErrors();
        void RenderInfo();

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

        // virtual void
        //  SetupProjection(const int w, const int h, const float angle = 70.0f);

        virtual void
                SetupCameraProjection(const int w, const int h, const float angle = 70.0f);

        void
                RenderViewCells();


        virtual void Show() {
                show();
        }

        bool PvsChanged(ViewCell *viewcell) const;

        void ComputeMaxValues(const ViewCellContainer &viewCells,
                                                  int &maxPvs, 
                                                  int &maxPiercingRays, 
                                                  float &maxRelativeRays, 
                                                  float &maxRcCost);

        void AssignImportanceByRelativeValue(const ViewCellContainer &viewCells,
                                                                                 int &maxPvs, 
                                                                                 int &maxPiercingRays, 
                                                                                 float &maxRelativeRays, 
                                                                                 float &maxRcCost);

        void AssignColorByComparison(const ViewCellContainer &viewcells,
                                                                 const ViewCellInfoContainer &info1, 
                                                                 const ViewCellInfoContainer &info2);


        /////////

        //QMutex mMutex;


public slots:

        void UpdateAllPvs();
        void ComputeVisibility();
        void StopComputation();
        void SetRandomViewPoint();

        void SetRenderErrors(bool b) {
                mRenderErrors = b;
                updateGL();
        }

        void SetRenderBoxes(bool b) {
                mRenderBoxes = b;
                updateGL();
        }

        void SetRenderFilter(bool b) {
                mRenderFilter = b;
                updateGL();
        }

        void SetRenderVisibilityEstimates(bool b) {
                mRenderVisibilityEstimates = b;
                updateGL();
        }

        void SetUseFilter(bool b) {
                mUseFilter = b;
                mPvsCache.Reset();
                updateGL();
        }

        void SetUseSpatialFilter(bool b) {
                mUseSpatialFilter = b;
                mPvsCache.Reset();
                updateGL();
        }


        void
                SetViewCellGranularity(int number);

        void SetTransferFunction(int number) 
        {
                mTransferFunction = number/1000.0f;
                updateGL();
        }

        void SetVisibilityFilterSize(int number);

        void
                SetSpatialFilterSize(int number);

        void
                SetSceneCut(int cut);

        void
                SetTopDistance(int dist);

        void
                SetTransparency(int dist);

        void
                SetHidingCost(int dist);

        void SetShowViewCells(bool b) {
                mRenderViewCells = b;
                updateGL();
        }

        void SetShowRays(bool b) {
                mShowRays = b;
                updateGL();
        }

        void SetShowRenderCost(bool b) {
                mShowRenderCost = b;
                updateGL();
        }

        void SetShowPvsSizes(bool b) {
                mShowPvsSizes = b;
                updateGL();
        }

        void SetShowPiercingRays(bool b) {
                mShowPiercingRays = b;
                updateGL();
        }

        void SetShowWeightedRays(bool b) {
                mShowWeightedRays = b;
                updateGL();
        }

        void SetTopView(bool b) {
                mTopView = b;
                updateGL();
        }

        void SetCutViewCells(bool b) {
                mCutViewCells = b;
                updateGL();
        }
        void SetCutScene(bool b) {
                mCutScene = b;
                updateGL();
        }

        void SetHideByCost(bool b) {
                mHideByCost = b;
                updateGL();
        }

        void SetUseTransparency(bool b) {
                mUseTransparency = b;
                updateGL();
        }

        void SetShowWeightedCost(bool b) 
        {
                mShowWeightedCost = b;
                updateGL();
        }

        void SetShowDistanceWeightedPvs(bool b) 
        {
                mShowDistanceWeightedPvs = b;
                updateGL();
        }


        void SetShowDistanceWeightedTriangles(bool b) 
        {
                mShowDistanceWeightedTriangles = b;
                updateGL();
        }
        
        void SetShowWeightedTriangles(bool b) 
        {
                mShowWeightedTriangles = b;
                updateGL();
        }


        void _RenderPvs();

        void _UpdatePvsIndices();

        void _UpdatePvsIndices(KdNode *node, int &indexBufferSize);

        float ComputeRenderCost(ViewCell *vc);

        /////////

signals:
        void PvsUpdated();
};


class QtGlDebuggerWidget: public QGLWidget
{
        Q_OBJECT
public:
    QtGlDebuggerWidget(QtGlRendererBuffer *buf, QWidget *parent = NULL);
    ~QtGlDebuggerWidget();
    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();

  
         QtGlRendererBuffer *mRenderBuffer;

         Beam mBeam;
         int mSamples;
         Intersectable *mSourceObject;

private:

    GLuint dynamicTexture;
    int timerId;
};


extern QtGlDebuggerWidget *debuggerWidget;

};

#endif