source: GTP/trunk/Lib/Vis/Preprocessing/src/GlRenderer.h @ 2643

Revision 2643, 8.5 KB checked in by mattausch, 17 years ago (diff)

compiling under release internal

  • Property svn:executable set to *
RevLine 
[865]1#ifndef __GLRENDERER_H
2#define __GLRENDERER_H
[492]3
[2176]4#include "ObjectPvs.h"
[492]5#include "Vector3.h"
6#include "Containers.h"
7#include "Halton.h"
[497]8#include "Renderer.h"
[540]9#include "Beam.h"
[492]10
[863]11
[2176]12
[860]13namespace GtpVisibilityPreprocessor {
14
[492]15class SceneGraph;
16class ViewCellsManager;
17class Mesh;
18class MeshInstance;
19class Intersectable;
20class Material;
[512]21class Beam;
[532]22class KdTree;
[538]23class GlRendererBuffer;
[531]24class BeamSampleStatistics;
[1001]25class OcclusionQuery;
26class TransformedMeshInstance;
[1581]27class TriangleIntersectable;
[2176]28class BvhNode;
29class SimpleRayContainer;
[2600]30class SceneGraphLeaf;
[2048]31
[540]32struct VssRayContainer;
[2593]33struct GLUquadric;
[540]34
[2593]35
36struct PvsRenderStatistics
37{
[492]38  float maxError;
39  float sumError;
[713]40  int sumPvsSize;
[492]41  int frames;
42  int errorFreeFrames;
[502]43
[492]44  PvsRenderStatistics() { Reset(); }
45 
[2593]46  void Reset()
47  {
[492]48        maxError = 0.0f;
49        sumError = 0.0f;
50        frames = 0;
51        errorFreeFrames = 0;
[713]52        sumPvsSize = 0;
[492]53  }
54
55  float GetMaxError() { return maxError; }
56  float GetAvgError() { return sumError/frames; }
57  float GetErrorFreeFrames() { return errorFreeFrames/(float)frames; }
[713]58  float GetAvgPvs() { return sumPvsSize/(float)frames; }
[492]59 
60};
61
[2538]62
[2593]63struct PvsCache
64{
65        PvsCache():mViewCell(NULL), mUnfilteredPvsSize(0) {}
[1824]66
[2593]67        void Reset()
68        {
[2643]69                mViewCell = NULL;
70                mPvs.Clear();
[2593]71                filteredBoxes.clear();
72                mUnfilteredPvsSize = 0;
73        }
74
75        ViewCell *mViewCell;
76        ObjectPvs mPvs;
77        int mUnfilteredPvsSize;
78        vector<AxisAlignedBox3> filteredBoxes;
79};
80
81
[811]82struct RenderCostSample {
[496]83
[811]84  RenderCostSample() {}
85
86  void Reset() {
87        mVisibleObjects = 0;
88        mVisiblePixels = 0;
89  }
90 
[991]91  Vector3 mPosition;
92
[811]93  // visible object from the given point
94  int mVisibleObjects;
95
96  // visible pixels
97  int mVisiblePixels;
[1161]98
99  ObjectPvs mPvs;
[811]100 
101};
102
[496]103/** Class encapsulating gl rendering for the scene.
104        There is no gl context binding so the binding is performed in the
105        derived classes
106*/
[497]107class GlRenderer: public Renderer
[492]108{
[2538]109friend class GlobalLinesRenderer;
110friend class ViewCellsManager;
[496]111
[492]112public:
113
114  GlRenderer(SceneGraph *sceneGraph,
[532]115                         ViewCellsManager *viewcells,
116                         KdTree *tree);
[496]117 
[1151]118  GlRenderer() {}
119
[1145]120  virtual ~GlRenderer();
[492]121
[496]122
[1931]123  virtual void RandomViewPoint();
124
[1960]125  void SetupFalseColor(const unsigned int id);
[492]126  void RenderIntersectable(Intersectable *);
[535]127  void RenderViewCell(ViewCell *vc);
[492]128  void RenderMeshInstance(MeshInstance *mi);
[1001]129  void RenderTransformedMeshInstance(TransformedMeshInstance *mi);
[492]130  void RenderMesh(Mesh *m);
131  void SetupMaterial(Material *m);
[502]132  virtual void SetupCamera();
[1581]133
134  void
[2593]135  RenderRays(const VssRayContainer &rays, int colorType = 0, int showDistribution = 15, int maxAge = 9999999);
[1581]136
137  void
138  RenderTriangle(TriangleIntersectable *object);
139
[1585]140  void
141  RenderBox(const AxisAlignedBox3 &box);
142
143  void
144  RenderBvhNode(BvhNode *node);
[1594]145
146  void
147  RenderKdNode(KdNode *node);
148
[497]149  bool
[496]150  RenderScene();
[492]151
[811]152  void
153  _RenderScene();
[589]154
[1983]155  void
[2002]156  _RenderSceneTriangles();
157
[2538]158  void _RenderSceneTrianglesWithDrawArrays();
159
[2002]160  void
[1983]161  RenderViewPoint();
[811]162
[2615]163  void _RenderDynamicObject(SceneGraphLeaf *leaf);
164
[608]165  virtual void
[811]166  SetupProjection(const int w, const int h, const float angle = 70.0f);
[496]167
[2023]168  virtual bool ValidViewPoint();
[496]169 
[1931]170  virtual float
171  GetPixelError(int &pvsSize);
[496]172 
[1931]173  virtual void
174  EvalPvsStat();
[496]175
[2620]176  void PreparePvs(const ObjectPvs &pvs);
177  void _UpdatePvsIndices(KdNode *node, int &indexBufferSize);
178
179       
[2048]180  virtual void EvalPvsStat(const SimpleRayContainer &viewPoints);
181
[1997]182  virtual void InitGL();
[496]183
[1940]184  virtual int GetWidth() const { return 0; }
185  virtual int GetHeight() const { return 0; }
[540]186
[1960]187  unsigned int GetId(const unsigned char r,
188                                         const unsigned char g,
189                                         const unsigned char b) const;
[1151]190
191  inline const bool GetSnapErrorFrames() { return mSnapErrorFrames; }
[2176]192  inline const std::string GetSnapPrefix() { return mSnapPrefix; }
[1151]193
194  inline void SetSnapErrorFrames(bool snapframes) { mSnapErrorFrames = snapframes; }
[2176]195  inline void SetSnapPrefix(const std::string &pref) { mSnapPrefix = pref; }
[1151]196
[1931]197  virtual void ClearErrorBuffer();
198 
[2002]199  virtual float GetAvgPixelError() {
200        return mPvsStat.GetAvgError()*GetWidth()*GetHeight();
201  }
[2008]202
203  virtual float GetMaxPixelError() {
[2543]204          return mPvsStat.GetMaxError()*GetWidth()*GetHeight();
[2008]205  }
[2543]206
[2598]207  void SetViewPoint(const Vector3 &vp) { mViewPoint = vp; }
208  void SetViewDirection(const Vector3 &vd) { mViewDirection = vd; }
209
[2625]210  Vector3 GetViewPoint() const { return mViewPoint; }
[1832]211public:
[1940]212
[2543]213        int mCurrentFrame;
214        int mFrame;
215        bool mWireFrame;
[1931]216
[2543]217        PvsRenderStatistics mPvsStat;
[2017]218
[2620]219        unsigned int mIndexBufferSize;
220
[2543]221        int mPvsStatFrames;
222        struct PvsErrorEntry {
223                PvsErrorEntry() {}
224                float mError;
225                int mPvsSize;
226                Vector3 mPosition;
227                Vector3 mDirection;
228        };
[2050]229
[2543]230        vector<PvsErrorEntry> mPvsErrorBuffer;
[2643]231        bool mComputeGVS;
[2543]232
[1151]233protected:
234
[2600]235        void CreateVertexArrays(SceneGraphLeaf *leaf);
[2538]236        void DeleteVbos();
237        void EnableDrawArrays();
238        void DisableDrawArrays();
[1151]239
[2538]240        void RenderKdLeaf(KdLeaf *leaf);
[1931]241
[1151]242
[2538]243        //////////////////
[1151]244
[2538]245        PvsCache mPvsCache;
[1151]246
[2538]247        unsigned int mVboId;
248        vector<OcclusionQuery *> mOcclusionQueries;
[1151]249
[2538]250        ObjectContainer mObjects;
[1594]251
[2538]252        Vector3 mViewPoint;
253        Vector3 mViewDirection;
[1151]254
[2538]255        int timerId;
256        bool mUseFalseColors;
257        bool mUseForcedColors;
[1151]258
[2538]259        HaltonSequence halton;
260
261
262        bool mDetectEmptyViewSpace;
263        bool mSnapErrorFrames;
264
265        bool mRenderBoxes;
266
267        bool mUseGlLists;
268
269        std::string mSnapPrefix;
270
271        GLUquadric *mSphere;
272
273        KdTree *mKdTree;
274
275        Vector3 *mData;
276        unsigned int *mIndices;
277
278        bool mUseVbos;
[496]279};
280
[2538]281
[1146]282/* Class implementing an OpenGl render buffer.
283*/
[1145]284class GlRendererBuffer: public GlRenderer
[496]285{
[1145]286
[496]287public:
[1151]288
[1968]289        GlRendererBuffer(SceneGraph *sceneGraph,
290                ViewCellsManager *viewcells,
291                KdTree *tree);
[589]292
[1968]293        virtual ~GlRendererBuffer();
[811]294
[1001]295        /** Evaluates render cost of a point sample.
[1968]296        @param sample the render cost sample to be evaluated
297        @param useOcclusionQueries if occlusion queries should be used or item buffer
298        @param threshold number of pixels / samples from where an object is considered visible.
[1001]299        */
[1968]300        virtual void EvalRenderCostSample(RenderCostSample &sample,
301                const bool useOcclusionQueries,
302                const int threshold);
[811]303
[1001]304        /** Evaluates render cost of a number of point samples. The point samples
[1968]305        are distributed uniformly over the defined view space.
[811]306
[1968]307        @param numSamples the number of point samples taken
308        @param samples stores the taken point samples in a container
309        @param useOcclusionQueries if occlusion queries should be used or item buffer
310        @param threshold number of pixels / samples from where an object is considered visible.
[1001]311        */
[1968]312        virtual void SampleRenderCost(const int numSamples,
[2538]313                                                                  vector<RenderCostSample> &samples,
314                                                                  const bool useOcclusionQueries,
315                                                                  const int threshold = 0);
[1145]316        /** Implerment in subclasses.
317        */
[1968]318        virtual void EvalPvsStat();
[1001]319
[2048]320        virtual void EvalPvsStat(const SimpleRayContainer &viewPoints);
[496]321
[1968]322        virtual int GetWidth() const = 0;
323        virtual int GetHeight() const  = 0;
[496]324
[1968]325        virtual void MakeCurrent() = 0;
326        virtual void DoneCurrent() = 0;
[507]327
[2023]328        virtual bool ValidViewPoint();
[507]329
[1968]330        virtual void SampleBeamContributions(
[2538]331                                                                                 Intersectable *sourceObject,
332                                                                                 Beam &beam,
333                                                                                 const int samples,
334                                                                                 BeamSampleStatistics &stat
335                                                                                 );
[507]336
[2538]337        virtual void SampleViewpointContributions(
338                                                                                          Intersectable *sourceObject,
339                                                                                          const Vector3 viewPoint,
340                                                                                          Beam &beam,
341                                                                                          const int desiredSamples,
342                                                                                          BeamSampleStatistics &stat
343                                                                                          );
[540]344
[1968]345        virtual void InitGL();
346        /** Computes rays from information gained with hw sampling-
347        */
348        virtual void ComputeRays(Intersectable *sourceObj, VssRayContainer &rays);
[540]349
[1968]350        virtual int ComputePvs() const = 0;
[713]351
[1968]352        virtual int ComputePvs(ObjectContainer &objects, ObjectContainer &pvs) const = 0;
[1931]353
354
[1145]355protected:
[746]356
[1968]357        unsigned int *mPixelBuffer;
[746]358
[1968]359        static void GenQueries(const int numQueries);
360
361        virtual void SetupProjectionForViewPoint(const Vector3 &viewPoint,
[2538]362                                                                                         const Beam &beam,
363                                                                                         Intersectable *sourceObject);
[1001]364        /** Evaluates query for one direction using item buffer.
365        */
[1968]366        virtual void EvalQueryWithItemBuffer();
[1001]367        /** Evaluates query for one direction using occlusion queries.
368        */
[1968]369        virtual void EvalQueryWithOcclusionQueries();
[496]370};
371
[1146]372
373/** Abstract class for implmenenting a gl render widget.
374*/
[1151]375class GlRendererWidget: public GlRenderer
[1146]376{
377public:
[1968]378
[1151]379        GlRendererWidget(SceneGraph *sceneGraph, ViewCellsManager *vcm, KdTree *kdTree):
380          GlRenderer(sceneGraph, vcm, kdTree)
[1968]381          {}
[1146]382
[1968]383          GlRendererWidget() {}
[1146]384
[1968]385          virtual ~GlRendererWidget() {}
[2538]386         
[1968]387          virtual void Show() {}
[608]388};
389
[1151]390
[1146]391};
[492]392
[1387]393#endif
Note: See TracBrowser for help on using the repository browser.