Changeset 1148 for GTP/trunk/Lib/Vis/QtRenderer

Timestamp:

07/25/06 01:39:35 (18 years ago)

Author:

mattausch

Message:

 

Location:

GTP/trunk/Lib/Vis/QtRenderer

Files:

• QtGlRenderer .cpp (deleted)
• QtGlRenderer.cpp (added)
• QtGlRenderer.h (modified) (2 diffs)

GTP/trunk/Lib/Vis/QtRenderer/QtGlRenderer.h

@@ -1 @@
-#ifndef __GLRENDERER_H
-#define __GLRENDERER_H
-
-
-
+#ifndef __QTGLRENDERER_H
+#define __QTGLRENDERER_H
+
+#include <QtOpenGL>
+#include <QWaitCondition>
+
+//#include <QGLPixelBuffer>
+
+#include "Vector3.h"
+#include "Containers.h"
+#include "Halton.h"
+#include "Renderer.h"
+#include "GlRenderer.h"
+#include "Beam.h"
+
+class QWidget;
 
 namespace GtpVisibilityPreprocessor {
 
-class GlRenderer: public Renderer
+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
 {
-
-public:
-  ObjectContainer mObjects;
-   
-  Vector3 mViewPoint;
-  Vector3 mViewDirection;
-
-  int timerId;
-  bool mUseFalseColors;
-  bool mUseForcedColors;
-
-  HaltonSequence halton;
-  
-  int mFrame;
-  bool mWireFrame;
-  
-  bool mDetectEmptyViewSpace;
-  bool mSnapErrorFrames;
-
-  bool mUseGlLists;
-  
-  string mSnapPrefix;
-
-  KdTree *mKdTree;
-
-  //QWaitCondition mRenderingFinished;
-  
-  vector<OcclusionQuery *> mOcclusionQueries;
-  
-  GlRenderer(SceneGraph *sceneGraph,
-                         ViewCellsManager *viewcells,
-                         KdTree *tree);
-  
-  virtual ~GlRenderer();
-
-
-  void SetupFalseColor(const int id);
-  void RenderIntersectable(Intersectable *);
-  void RenderViewCell(ViewCell *vc);
-  void RenderMeshInstance(MeshInstance *mi);
-  void RenderTransformedMeshInstance(TransformedMeshInstance *mi);
-  void RenderMesh(Mesh *m);
-  void SetupMaterial(Material *m);
-  virtual void SetupCamera();
-  
-  bool
-  RenderScene();
-
-  void
-  _RenderScene();
-
-
-  virtual void
-  SetupProjection(const int w, const int h, const float angle = 70.0f);
-
-  
-  
-
-  void InitGL();
-
-  virtual int GetWidth() const = 0;
-  virtual int GetHeight() const = 0;
-
-  int GetId(int r, int g, int b) const;
-};
-
-
-/* Class implementing an OpenGl render buffer.
-*/
-class GlRendererBuffer: public GlRenderer
-{
-
-//Q_OBJECT
-public:
-GlRendererBuffer(SceneGraph *sceneGraph,
-                                 ViewCellsManager *viewcells,
-                                 KdTree *tree);
-
+        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.
+        @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);
+                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.
+        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)
-        {}
-
-        /** Implerment in subclasses.
-        */
-        void EvalPvsStat() {};
-
-        void ClearErrorBuffer();
-  
-
-  virtual int GetWidth() const { return 0; }
-  virtual int GetHeight() const { return 0; }
-
-
-  void RandomViewPoint();
+                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,
@@ -151 +111 @@
 
   int ComputePvs(ObjectContainer &objects, ObjectContainer &pvs) const;
-
-  PvsRenderStatistics mPvsStat;
+     
    
-  int mPvsStatFrames;
-  struct PvsErrorEntry {
-          PvsErrorEntry() {}
-          float mError;
-          int mPvsSize;
-          Vector3 mPosition;
-          Vector3 mDirection;
-  };
-  
-  vector<PvsErrorEntry> mPvsErrorBuffer;
-
-  
-protected:
-        unsigned int *mPixelBuffer;
-  
-        static void GenQueries(const int numQueries);
-        
+private:
+        
         void SetupProjectionForViewPoint(const Vector3 &viewPoint, 
                                                                          const Beam &beam, 
-
                                                                          Intersectable *sourceObject);
 
-        /** Evaluates query for one direction using item buffer.
-        */
-        void EvalQueryWithItemBuffer();
-        /** Evaluates query for one direction using occlusion queries.
-        */
-        void EvalQueryWithOcclusionQueries();
-
-public:
-        // matt: remove qt dependencies
- // signals:
-//      void UpdatePvsErrorItem(int i, GlRendererBuffer::PvsErrorEntry &);
-};
-
-
-/** Abstract class for implmenenting a gl render widget.
-*/
-class GlRenderWidget
+
+public:
+  signals:
+        void UpdatePvsErrorItem(int i, GlRendererBuffer::PvsErrorEntry &);
+};
+
+
+class RendererControlWidget : public QWidget
 {
-public:
-        
-        GlRenderWidget(SceneGraph *sceneGraph, ViewCellsManager *vcm, KdTree *kdTree):
-          mSceneGraph(sceneGraph), mViewCellsManager(vcm), mKdTree(kdTree)
-        {
-        }
-
-        
-        GlRenderWidget() {}
-
-    virtual ~GlRenderWidget() {}
-
-        //virtual void Create() {}
-        virtual void Show() {}
-        
-
-protected:
-
-
-        SceneGraph *mSceneGraph;
-        ViewCellsManager *mViewCellsManager;
-        KdTree *mKdTree;
-};
+  Q_OBJECT
+public:
+
+  QListWidget *mPvsErrorWidget;
+
+  RendererControlWidget(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 GlRendererWidget : public QGLWidget, public GlRenderer
+{
+  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;
+
+  RendererControlWidget *mControlWidget;
+  
+  GlRendererWidget(SceneGraph *sceneGraph,
+                                   ViewCellsManager *viewcells,
+                                   KdTree *tree,
+                                   QWidget * parent = 0, const QGLWidget * shareWidget = 0, Qt::WFlags f = 0
+                                   );
+
+
+  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();
+  }
+
+
+};
+
+
+extern GlRendererWidget *rendererWidget;
+
+class GlDebuggerWidget : public QGLWidget
+{
+        Q_OBJECT
+public:
+    GlDebuggerWidget(QtGlRendererBuffer *buf, QWidget *parent = NULL);
+    ~GlDebuggerWidget();
+    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 GlDebuggerWidget *debuggerWidget;
 
 };