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

Revision 2743, 11.9 KB checked in by mattausch, 16 years ago (diff)
Line 
1#ifndef __QTGLRENDERER_H
2#define __QTGLRENDERER_H
3
4#include <QtOpenGL>
5#include <QWaitCondition>
6#include <QMutex>
7
8#include "Vector3.h"
9#include "Containers.h"
10#include "Halton.h"
11#include "Renderer.h"
12#include "GlRenderer.h"
13#include "Beam.h"
14#include "QtPreprocessorThread.h"
15#include "LogReader.h"
16#include "Material.h"
17#include "common.h"
18
19
20class QWidget;
21
22
23#define REMOVE_TEMPORARY 1
24
25
26namespace GtpVisibilityPreprocessor {
27
28
29class SceneGraph;
30class ViewCellsManager;
31class Mesh;
32class MeshInstance;
33class Intersectable;
34class Material;
35class Beam;
36class KdTree;
37class GlRendererBuffer;
38class BeamSampleStatistics;
39class OcclusionQuery;
40class TransformedMeshInstance;
41class ObjectPlacer;
42
43
44struct VssRayContainer;
45struct PvsRenderStatistics;
46struct RenderCostSample;
47
48//class LogWriter;
49
50
51
52class QtGlRendererBuffer
53: public QObject, public QGLPixelBuffer, public GlRendererBuffer
54{
55        Q_OBJECT
56public:
57        QtGlRendererBuffer(int w, int h,
58                                           SceneGraph *sceneGraph,
59                                           ViewCellsManager *viewcells,
60                                           KdTree *tree);
61
62        ~QtGlRendererBuffer() {}
63
64        virtual void MakeLive();
65        virtual void DoneLive();
66
67        virtual int GetWidth() const { return width(); }
68        virtual int GetHeight() const { return height(); }
69
70        int ComputePvs() const { return 0; }
71
72        void RenderPvs(const ObjectPvs &pvs);
73
74        float GetPixelError(int &pvsSize, int pass);
75
76        int ComputePvs(ObjectContainer &objects, ObjectContainer &pvs) const;
77
78
79       
80public:
81
82signals:
83        void UpdatePvsErrorItem(int i, GlRendererBuffer::PvsErrorEntry &);
84};
85
86
87class QtRendererControlWidget : public QWidget
88{
89  Q_OBJECT
90public:
91
92  QListWidget *mPvsErrorWidget;
93
94  QtRendererControlWidget(QWidget * parent = 0, Qt::WFlags f = 0);
95
96  QGroupBox *CreateVisualizationPanel(QWidget *parent);
97  QGroupBox *CreateTrafoPanel(QWidget *parent);
98
99  public slots:
100
101  void FocusNextPvsErrorFrame();
102  void UpdatePvsErrorItem(int i, GlRendererBuffer::PvsErrorEntry &);
103
104 
105  QGroupBox *CreateRenderCostPanel(QWidget *parent);
106  QGroupBox *CreateRayVisualizationPanel(QWidget *parent);
107
108
109  signals:
110 
111  void ReplayViewPoints();
112  void UpdateDynamicObjects();
113  void DeleteDynamicObject();
114  void ComputeVisibility();
115  void StopComputation();
116  void SetRandomViewPoint();
117  void StoreStatistics();
118  void ComputeGVS();
119  void NextObject();
120  void UpdateAllPvs();
121  void SetViewCellGranularity(int);
122  void SetTransferFunction(int);
123  void SetSceneCut(int);
124  void SetTopDistance(int);
125  void SetMaxRenderCost(int);
126  void SetHidingCost(int);
127  void SetVisibilityFilterSize(int);
128  void SetSpatialFilterSize(int);
129  void SetTransparency(int);
130
131  void SetShowRays(bool);
132  void SetRenderFilter(bool);
133  void SetRenderVisibilityEstimates(bool);
134  void SetUseFilter(bool);
135  void SetUseSpatialFilter(bool);
136  void SetRenderErrors(bool);
137  void SetRenderBoxes(bool);
138  void SetShowViewCells(bool);
139  void SetShowRenderCost(bool);
140  void SetShowPvsSizes(bool);
141  void SetShowWireFrame(bool);
142  void SetShowPiercingRays(bool);
143  void SetShowWeightedRays(bool);
144  void SetShowComparison(bool);
145  void SetShowWeightedCost(bool);
146 
147  void SetTopView(bool);
148  void SetCutViewCells(bool);
149  void SetCutScene(bool);
150
151  void SetHideByCost(bool);
152  void SetUseTransparency(bool);
153
154  void SetShowDistanceWeightedTriangles(bool);
155  void SetShowWeightedTriangles(bool);
156  void SetShowDistanceWeightedPvs(bool);
157
158  void UseConstColorForRayViz(bool);
159  void UseRayLengthForRayViz(bool);
160  void SetShowContribution(bool);
161  void SetShowDistribution(bool);
162
163  void SetShowDistribution1(bool);
164  void SetShowDistribution2(bool);
165  void SetShowDistribution3(bool);
166  void SetShowDistribution4(bool);
167
168  void SetTranslation(bool);
169  void SetRotation(bool);
170  void SetScale(bool);
171};
172
173
174class QtGlRendererWidget: public QGLWidget, public GlRendererWidget
175{
176        Q_OBJECT
177public:
178
179        // point of the last mouse click used for movement in the scene
180        Vector3 mousePoint;
181
182        bool mTopView;
183        bool mRenderViewCells;
184        bool mCutViewCells;
185        bool mCutScene;
186        bool mHideByCost;
187        bool mRenderErrors;
188        bool mRenderFilter;
189        bool mRenderVisibilityEstimates;
190        bool mUseFilter;
191        bool mUseSpatialFilter;
192        bool mShowRenderCost;
193        bool mShowPiercingRays;
194        bool mShowWeightedRays;
195        bool mUseStandardColors;
196        bool mShowRays;
197
198        bool mShowPvsSizes;
199        bool mShowComparison;
200        float mSpatialFilterSize;
201
202        Plane3 mSceneCutPlane;
203        float mHidingCost;
204
205        float mTopDistance;
206
207        float mTransparency;
208        bool mUseTransparency;
209
210        bool mShowWeightedCost;
211
212        bool mShowDistanceWeightedTriangles;
213        bool mShowDistanceWeightedPvs;
214        bool mShowWeightedTriangles;
215       
216        int mShowDistribution;
217
218        bool mReplayMode;
219
220        // some statistics
221        int mPvsSize;
222        float mRenderError;
223        float mTransferFunction;
224
225        Vector3 mDummyViewPoint;
226
227        int mRayVisualizationMethod;
228        int mTrafoType;
229
230        QtRendererControlWidget *mControlWidget;
231
232        QtPreprocessorThread *mPreprocessorThread;
233
234        ViewCellInfoContainer mCompareInfo;
235
236        int mCurrentPvsCost;
237
238        bool mUseRandomColorPerPvsObject;
239
240        int mUpdateTimerId;
241        int mReplayTimerId;
242
243        ObjectPlacer *mPlacer;
244
245        int mCurrentDynamicObjectIdx;
246
247        bool mExportFrameBuffer;
248
249        float mMaxRenderCost;
250
251        DynamicObjectsContainer mDynamicPvsObjects;
252
253        QtGlRendererWidget(SceneGraph *sceneGraph,
254                               ViewCellsManager *viewcells,
255                                           KdTree *tree,
256                                           QWidget * parent = 0,
257                                           const QGLWidget *shareWidget = 0,
258                                           Qt::WFlags f = 0);
259
260        QtGlRendererWidget() {};
261
262        ~QtGlRendererWidget();
263
264        void SetThread(QtPreprocessorThread *t)
265        {
266                mPreprocessorThread = t;
267        }
268
269        void RenderRenderCost();
270
271        virtual void SetupCamera();
272
273        void initializeGL()
274        {
275                InitGL();
276        }
277
278        virtual void InitGL();
279
280        void resizeGL(int w, int h);
281        void paintGL();
282        void timerEvent(QTimerEvent *event);
283        void mousePressEvent(QMouseEvent *);
284        void mouseReleaseEvent(QMouseEvent *);
285        void mouseMoveEvent(QMouseEvent *);
286
287        void keyPressEvent(QKeyEvent * e);
288
289        void VisualizePvs();
290
291        float RenderErrors();
292        void RenderInfo();
293
294        virtual int GetWidth() const { return width(); }
295        virtual int GetHeight() const { return height(); }
296
297        virtual void SetupCameraProjection(const int w,
298                                                                           const int h,
299                                                                           const float angle = 70.0f);
300
301        void RenderViewCells();
302
303        virtual void Show() { show(); }
304
305        bool PvsChanged(ViewCell *viewcell) const;
306
307        void ComputeMaxValues(const ViewCellContainer &viewCells,
308                                                  int &maxPvs,
309                                                  int &maxPiercingRays,
310                                                  float &maxRelativeRays,
311                                                  float &maxRcCost);
312
313        void AssignImportanceByRelativeValue(const ViewCellContainer &viewCells,
314                                                                                 int &maxPvs,
315                                                                                 int &maxPiercingRays,
316                                                                                 float &maxRelativeRays,
317                                                                                 float &maxRcCost);
318
319        void AssignColorByComparison(const ViewCellContainer &viewcells,
320                                                                 const ViewCellInfoContainer &compareInfo);
321
322        void WriteViewCellInfos();
323        /** Unproject x/y screen coordinates.
324        */
325        Vector3 Unproject(int x, int y);
326       
327        int FindDynamicObject(float x, float y);
328
329        void LoadObjects();
330        void LoadObject(const std::string &filename);
331
332public slots:
333       
334        /** Replay the view points stored in the view points list.
335        */
336        void ReplayViewPoints();
337        void UpdateDynamicObjects();
338        void DeleteDynamicObject();
339        void UpdateAllPvs();
340        void ComputeVisibility();
341        void StopComputation();
342        void SetRandomViewPoint();
343        void StoreStatistics();
344       
345        //void LoadObject();
346        void NextObject();
347
348        void SetRenderErrors(bool b) {
349                mRenderErrors = b;
350                updateGL();
351        }
352
353        void ComputeGVS() {
354                mComputeGVS = true;
355                updateGL();
356        }
357
358        void SetRenderBoxes(bool b) {
359                mRenderBoxes = b;
360                updateGL();
361        }
362
363        void SetRenderFilter(bool b) {
364                mRenderFilter = b;
365                updateGL();
366        }
367
368        void SetRenderVisibilityEstimates(bool b) {
369                mRenderVisibilityEstimates = b;
370                updateGL();
371        }
372
373        void SetUseFilter(bool b) {
374                mUseFilter = b;
375                mPvsCache.Reset();
376                updateGL();
377        }
378
379        void SetUseSpatialFilter(bool b) {
380                mUseSpatialFilter = b;
381                mPvsCache.Reset();
382                updateGL();
383        }
384
385
386        void
387                SetViewCellGranularity(int number);
388
389        void SetTransferFunction(int number)
390        {
391                mTransferFunction = number/1000.0f;
392                updateGL();
393        }
394
395        void SetVisibilityFilterSize(int number);
396
397        void
398                SetSpatialFilterSize(int number);
399
400        void
401                SetSceneCut(int cut);
402
403        void
404                SetTopDistance(int dist);
405
406        void
407                SetMaxRenderCost(int dist);
408
409        void
410                SetTransparency(int dist);
411
412        void
413                SetHidingCost(int dist);
414
415        void SetShowViewCells(bool b) {
416                mRenderViewCells = b;
417                updateGL();
418        }
419
420        void SetShowRays(bool b) {
421                mShowRays = b;
422                updateGL();
423        }
424
425        void SetShowRenderCost(bool b) {
426                mShowRenderCost = b;
427                updateGL();
428        }
429
430        void SetShowPvsSizes(bool b) {
431                mShowPvsSizes = b;
432                updateGL();
433        }
434
435        void SetShowComparison(bool b) {
436                mShowComparison = b;
437                updateGL();
438        }
439
440        void SetShowPiercingRays(bool b) {
441                mShowPiercingRays = b;
442                updateGL();
443        }
444
445        void SetShowWireFrame(bool b) {
446                mUseStandardColors = b;
447                updateGL();
448        }
449       
450
451        void SetShowWeightedRays(bool b) {
452                mShowWeightedRays = b;
453                updateGL();
454        }
455
456        void SetTopView(bool b) {
457                mTopView = b;
458                updateGL();
459        }
460
461        void SetCutViewCells(bool b) {
462                mCutViewCells = b;
463                updateGL();
464        }
465        void SetCutScene(bool b) {
466                mCutScene = b;
467                updateGL();
468        }
469
470        void SetHideByCost(bool b) {
471                mHideByCost = b;
472                updateGL();
473        }
474
475        void SetUseTransparency(bool b) {
476                mUseTransparency = b;
477                updateGL();
478        }
479
480        void SetShowWeightedCost(bool b)
481        {
482                mShowWeightedCost = b;
483                updateGL();
484        }
485
486        void SetShowDistanceWeightedPvs(bool b)
487        {
488                mShowDistanceWeightedPvs = b;
489                updateGL();
490        }
491
492
493        void SetShowDistanceWeightedTriangles(bool b)
494        {
495                mShowDistanceWeightedTriangles = b;
496                updateGL();
497        }
498       
499        void SetShowWeightedTriangles(bool b)
500        {
501                mShowWeightedTriangles = b;
502                updateGL();
503        }
504
505        void UseConstColorForRayViz(bool b)
506        {
507                mRayVisualizationMethod = 0;
508        }
509   
510        void UseRayLengthForRayViz(bool b)
511        {
512                mRayVisualizationMethod = 1;
513        }
514
515        void SetShowContribution(bool b)
516        {
517                mRayVisualizationMethod = 2;
518        }
519   
520        void SetShowDistribution(bool b)
521        {
522                mRayVisualizationMethod = 3;
523        }
524
525        void SetTranslation(bool b)
526        {
527                mTrafoType = 0;
528        }
529
530        void SetScale(bool b)
531        {
532                mTrafoType = 1;
533        }
534       
535        void SetRotation(bool b)
536        {
537                mTrafoType = 2;
538        }
539
540        void SetShowDistribution1(bool b)
541        {
542                if (b)
543                        mShowDistribution |= 1;
544                else
545                        mShowDistribution ^= 1;
546
547                std::cout << "b: "
548                                  << (mShowDistribution & 1) << " "
549                                  << (mShowDistribution & 2) << " "
550                                  << (mShowDistribution & 4) << " "
551                                  << (mShowDistribution & 8) << std::endl;
552        }
553
554       
555        void SetShowDistribution2(bool b)
556        {
557                if (b)
558                        mShowDistribution |= 2;
559                else
560                        mShowDistribution ^= 2;
561        }
562
563       
564        void SetShowDistribution3(bool b)
565        {
566                if (b)
567                        mShowDistribution |= 4;
568                else
569                        mShowDistribution ^= 4;
570        }
571       
572        void SetShowDistribution4(bool b)
573        {
574                if (b)
575                        mShowDistribution |= 8;
576                else
577                        mShowDistribution ^= 8;
578        }
579
580       
581        /** Prepare pvs for rendering.
582        */
583        virtual void PreparePvs(const ObjectPvs &pvs);
584        /** Internal method rendering the pvs if it has been properly prepared.
585        */
586        void _RenderPvs();
587
588        float ComputeRenderCost(ViewCell *vc);
589
590
591        /////////
592
593signals:
594        void PvsUpdated();
595};
596
597
598class QtGlDebuggerWidget: public QGLWidget
599{
600        Q_OBJECT
601public:
602    QtGlDebuggerWidget(QtGlRendererBuffer *buf, QWidget *parent = NULL);
603    ~QtGlDebuggerWidget();
604    void initializeGL();
605    void resizeGL(int w, int h);
606    void paintGL();
607    void timerEvent(QTimerEvent *) { update(); }
608    void mousePressEvent(QMouseEvent *) { killTimer(timerId); }
609    void mouseReleaseEvent(QMouseEvent *) { timerId = startTimer(20); }
610
611    void initCommon();
612    void initPbuffer();
613
614 
615         QtGlRendererBuffer *mRenderBuffer;
616
617         Beam mBeam;
618         int mSamples;
619         Intersectable *mSourceObject;
620
621private:
622
623    GLuint dynamicTexture;
624    int timerId;
625};
626
627
628extern QtGlDebuggerWidget *debuggerWidget;
629
630};
631
632#endif
Note: See TracBrowser for help on using the repository browser.