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

#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"
#include "Material.h"
#include "common.h"


class QWidget;


#define REMOVE_TEMPORARY 1


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;
class ObjectPlacer;


struct VssRayContainer;
struct PvsRenderStatistics; 
struct RenderCostSample;

//class LogWriter;



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

        ~QtGlRendererBuffer() {}

        virtual void MakeLive();
        virtual void DoneLive();

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

        int ComputePvs() const { return 0; }

        void RenderPvs(const ObjectPvs &pvs);

        float GetPixelError(int &pvsSize, int pass);

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

        /** quick hack in order to be able to render gvs based triangle pvs.
        */
        void RenderTrianglePvs();

        
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);
  QGroupBox *CreateTrafoPanel(QWidget *parent);

  public slots:

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

  
  QGroupBox *CreateRenderCostPanel(QWidget *parent);
  QGroupBox *CreateRayVisualizationPanel(QWidget *parent);


  signals:
  
  void ReplayViewPoints();
  void UpdateDynamicObjects();
  void DeleteDynamicObject();
  void ComputeVisibility();
  void StopComputation();
  void SetRandomViewPoint();
  void StoreStatistics();
  void ComputeGVS();
  void NextObject();
  void UpdateAllPvs();
  void SetViewCellGranularity(int);
  void SetTransferFunction(int);
  void SetSceneCut(int);
  void SetTopDistance(int);
  void SetMaxRenderCost(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 SetShowWireFrame(bool);
  void SetShowPiercingRays(bool);
  void SetShowWeightedRays(bool);
  void SetShowComparison(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);

  void UseConstColorForRayViz(bool);
  void UseRayLengthForRayViz(bool);
  void SetShowContribution(bool);
  void SetShowDistribution(bool);

  void SetShowDistribution1(bool);
  void SetShowDistribution2(bool);
  void SetShowDistribution3(bool);
  void SetShowDistribution4(bool);

  void SetTranslation(bool);
  void SetRotation(bool);
  void SetScale(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 mUseStandardColors;
        bool mShowRays;

        bool mShowPvsSizes;
        bool mShowComparison;
        float mSpatialFilterSize;

        Plane3 mSceneCutPlane;
        float mHidingCost;

        float mTopDistance;

        float mTransparency;
        bool mUseTransparency;

        bool mShowWeightedCost;

        bool mShowDistanceWeightedTriangles;
        bool mShowDistanceWeightedPvs;
        bool mShowWeightedTriangles;
        
        int mShowDistribution;

        bool mReplayMode;

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

        Vector3 mDummyViewPoint;

        int mRayVisualizationMethod;
        int mTrafoType;

        QtRendererControlWidget *mControlWidget;

        QtPreprocessorThread *mPreprocessorThread;

        ViewCellInfoContainer mCompareInfo;

        int mCurrentPvsCost;

        vector<RgbColor> mColors;

        bool mUseRandomColorPerPvsObject;

        int mUpdateTimerId;
        int mReplayTimerId;

        ObjectPlacer *mPlacer;

        int mCurrentDynamicObjectIdx;

        bool mExportFrameBuffer;

        float mMaxRenderCost;

        DynamicObjectsContainer mDynamicPvsObjects;

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

        QtGlRendererWidget() {};

        ~QtGlRendererWidget();

        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 VisualizePvs();

        float RenderErrors();
        void RenderInfo();

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

        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 &compareInfo);

        void WriteViewCellInfos();
        /** Unproject x/y screen coordinates.
        */
        Vector3 Unproject(int x, int y);
        
        int FindDynamicObject(float x, float y);

        void LoadObjects();
        void LoadObject(const std::string &filename);

public slots:
        
        /** Replay the view points stored in the view points list.
        */
        void ReplayViewPoints();
        void UpdateDynamicObjects();
        void DeleteDynamicObject();
        void UpdateAllPvs();
        void ComputeVisibility();
        void StopComputation();
        void SetRandomViewPoint();
        void StoreStatistics();
        
        //void LoadObject();
        void NextObject();

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

        void ComputeGVS() {
                mComputeGVS = true;
                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
                SetMaxRenderCost(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 SetShowComparison(bool b) {
                mShowComparison = b;
                updateGL();
        }

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

        void SetShowWireFrame(bool b) {
                mUseStandardColors = 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 UseConstColorForRayViz(bool b)
        {
                mRayVisualizationMethod = 0;
        }
    
        void UseRayLengthForRayViz(bool b)
        {
                mRayVisualizationMethod = 1;
        }

        void SetShowContribution(bool b)
        {
                mRayVisualizationMethod = 2;
        }
    
        void SetShowDistribution(bool b)
        {
                mRayVisualizationMethod = 3;
        }

        void SetTranslation(bool b)
        {
                mTrafoType = 0;
        }

        void SetScale(bool b)
        {
                mTrafoType = 1;
        }
        
        void SetRotation(bool b)
        {
                mTrafoType = 2;
        }

        void SetShowDistribution1(bool b)
        {
                if (b)
                        mShowDistribution |= 1;
                else
                        mShowDistribution ^= 1;

                std::cout << "b: " 
                                  << (mShowDistribution & 1) << " " 
                                  << (mShowDistribution & 2) << " " 
                                  << (mShowDistribution & 4) << " " 
                                  << (mShowDistribution & 8) << std::endl; 
        }

        
        void SetShowDistribution2(bool b)
        {
                if (b)
                        mShowDistribution |= 2;
                else
                        mShowDistribution ^= 2;
        }

        
        void SetShowDistribution3(bool b)
        {
                if (b)
                        mShowDistribution |= 4;
                else
                        mShowDistribution ^= 4;
        }
        
        void SetShowDistribution4(bool b)
        {
                if (b)
                        mShowDistribution |= 8;
                else
                        mShowDistribution ^= 8;
        }

        
        /** Prepare pvs for rendering.
        */
        virtual void PreparePvs(const ObjectPvs &pvs);
        /** Internal method rendering the pvs if it has been properly prepared.
        */
        void _RenderPvs();
        /** Render pvs using false colors.
        */
        void _RenderColoredPvs();

        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