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

Revision 2679, 11.5 KB checked in by mattausch, 17 years ago (diff)

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