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

#ifndef __QTGLRENDERER_H
#define __QTGLRENDERER_H

#include <QtOpenGL>
#include <QWaitCondition>

#include "Vector3.h"
#include "Containers.h"
#include "Halton.h"
#include "Renderer.h"
#include "GlRenderer.h"
#include "Beam.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 __declspec(dllexport) QtGlRendererBuffer: public QObject, public QGLPixelBuffer, public GlRendererBuffer
{
        Q_OBJECT

public:
        QtGlRendererBuffer(const int w,
                                           const int h,
                                           SceneGraph *sceneGraph,
                                           ViewCellsManager *viewcells,
                                           KdTree *tree);

        ~QtGlRendererBuffer();

        /** Evaluates render cost of a point sample.
        @param sample the render cost sample to be evaluated
        @param useOcclusionQueries if occlusion queries should be used or item buffer
        @param threshold number of pixels / samples from where an object is considered visible.
        */
        void EvalRenderCostSample(RenderCostSample &sample,
                const bool useOcclusionQueries,
                const int threshold);

        /** Evaluates render cost of a number of point samples. The point samples
        are distributed uniformly over the defined view space.

        @param numSamples the number of point samples taken
        @param samples stores the taken point samples in a container
        @param useOcclusionQueries if occlusion queries should be used or item buffer
        @param threshold number of pixels / samples from where an object is considered visible.
        */
        void SampleRenderCost(const int numSamples, 
                vector<RenderCostSample> &samples,
                const bool useOcclusionQueries,
                const int threshold = 0);

        void
                EvalPvsStat();

        void
                ClearErrorBuffer();

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

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

        float GetPixelError(int &pvsSize);

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


private:

        void SetupProjectionForViewPoint(const Vector3 &viewPoint, 
                                                                         const Beam &beam, 
                                                                         Intersectable *sourceObject);


public:
signals:
        void UpdatePvsErrorItem(int i, GlRendererBuffer::PvsErrorEntry &);
};


class __declspec(dllexport) QtRendererControlWidget : public QWidget
{
        Q_OBJECT
public:

        QListWidget *mPvsErrorWidget;

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

public slots:

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

signals:

        void SetViewCellGranularity(int);
        void SetSceneCut(int);
        void SetTopDistance(int);
        void SetVisibilityFilterSize(int);
        void SetSpatialFilterSize(int);

        void SetRenderFilter(bool);
        void SetUseFilter(bool);
        void SetUseSpatialFilter(bool);
        void SetRenderErrors(bool);
        void SetShowViewCells(bool);
        void SetShowRenderCost(bool);
        void SetShowPvsSizes(bool);
        void SetTopView(bool);
        void SetCutViewCells(bool);
        void SetCutScene(bool);


};


class __declspec(dllexport) 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 mRenderErrors;
        bool mRenderFilter;
        bool mUseFilter;
        bool mUseSpatialFilter;
        bool mShowRenderCost;

        bool mShowPvsSizes;
        float mSpatialFilterSize;

        Plane3 mSceneCutPlane;
        float mTopDistance;

        // some statistics
        int mPvsSize;
        float mRenderError;

        QtRendererControlWidget *mControlWidget;

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

        QtGlRendererWidget() {};

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

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

        void
                RenderViewCells();

public slots:

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

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

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

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


        void
                SetViewCellGranularity(int number);

        void
                SetVisibilityFilterSize(int number);

        void
                SetSpatialFilterSize(int number);

        void
                SetSceneCut(int cut);

        void
                SetTopDistance(int dist);

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

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

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

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

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

        // matt: dummy function, must be provided by bittner
        void RenderRenderCost() {}

};


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