source: GTP/trunk/Lib/Vis/Preprocessing/src/GlRenderer.cpp @ 1608

Revision 1608, 15.4 KB checked in by bittner, 18 years ago (diff)

vsp osp tests
  • Property svn:executable set to *
Line 
1#include "Mesh.h"
2#include "glInterface.h"
3#include "OcclusionQuery.h"
4#include "GlRenderer.h"
5#include "ViewCellsManager.h"
6#include "SceneGraph.h"
7#include "Pvs.h"
8#include "Viewcell.h"
9#include "Beam.h"
10#include "KdTree.h"
11#include "Environment.h"
12#include "Triangle3.h"
13#include "IntersectableWrapper.h"
14#include "BvHierarchy.h"
15#include "KdTree.h"
16
17//#include <Cg/cg.h>
18//#include <Cg/cgGL.h>
19
20
21namespace GtpVisibilityPreprocessor {
22
23
24static bool arbQuerySupport = false;
25static bool nvQuerySupport = false;
26
27
28static void InitExtensions()
29{
30        GLenum err = glewInit();
31
32        if (GLEW_OK != err)
33        {
34                // problem: glewInit failed, something is seriously wrong
35                cerr << "Error: " << glewGetErrorString(err) << endl;
36                exit(1);
37        }
38
39        if (GLEW_ARB_occlusion_query)
40                arbQuerySupport = true;
41       
42        if (GLEW_NV_occlusion_query)
43                nvQuerySupport = true;
44       
45
46        if  (!arbQuerySupport && !nvQuerySupport)
47        {
48                cout << "I require the GL_ARB_occlusion_query or the GL_NV_occlusion_query OpenGL extension to work.\n";
49                exit(1);
50        }
51}
52
53
54GlRenderer::GlRenderer(SceneGraph *sceneGraph,
55                                           ViewCellsManager *viewCellsManager,
56                                           KdTree *tree):
57  Renderer(sceneGraph, viewCellsManager),
58  mKdTree(tree)
59{
60  mSceneGraph->CollectObjects(&mObjects);
61
62  //  mViewCellsManager->GetViewPoint(mViewPoint);
63
64  mViewPoint = mSceneGraph->GetBox().Center();
65  mViewDirection = Vector3(0,0,1);
66
67  //  mViewPoint = Vector3(991.7, 187.8, -271);
68  //  mViewDirection = Vector3(0.9, 0, -0.4);
69
70  //  timerId = startTimer(10);
71  // debug coords for atlanta
72  //  mViewPoint = Vector3(3473, 6.778, -1699);
73  //  mViewDirection = Vector3(-0.2432, 0, 0.97);
74 
75  mFrame = 0;
76  mWireFrame = false;
77  Environment::GetSingleton()->GetBoolValue("Preprocessor.detectEmptyViewSpace", mDetectEmptyViewSpace);
78  mSnapErrorFrames = true;
79  mSnapPrefix = "snap/";
80  mUseForcedColors = false;
81  mRenderBoxes = false;
82  mUseGlLists = true;
83  //mUseGlLists = false;
84}
85
86GlRenderer::~GlRenderer()
87{
88  cerr<<"gl renderer destructor..\n";
89 
90  //CLEAR_CONTAINER(sQueries);
91  CLEAR_CONTAINER(mOcclusionQueries);
92
93  cerr<<"done."<<endl;
94}
95
96
97void
98GlRenderer::RenderTriangle(TriangleIntersectable *object)
99{
100  Triangle3 &t = object->GetItem();
101  glBegin(GL_TRIANGLES);
102  glVertex3f(t.mVertices[0].x, t.mVertices[0].y, t.mVertices[0].z);
103  glVertex3f(t.mVertices[1].x, t.mVertices[1].y, t.mVertices[1].z);
104  glVertex3f(t.mVertices[2].x, t.mVertices[2].y, t.mVertices[2].z);
105  glEnd();
106}
107
108void
109GlRenderer::RenderIntersectable(Intersectable *object)
110{
111  if (object->Mailed())
112        return;
113  object->Mail();
114 
115  glPushAttrib(GL_CURRENT_BIT);
116  if (mUseFalseColors)
117        SetupFalseColor(object->mId);
118 
119
120  switch (object->Type()) {
121  case Intersectable::MESH_INSTANCE:
122        RenderMeshInstance((MeshInstance *)object);
123        break;
124  case Intersectable::VIEW_CELL:
125        RenderViewCell(dynamic_cast<ViewCell *>(object));
126        break;
127  case Intersectable::TRANSFORMED_MESH_INSTANCE:
128        RenderTransformedMeshInstance(dynamic_cast<TransformedMeshInstance *>(object));
129        break;
130  case Intersectable::TRIANGLE_INTERSECTABLE:
131        RenderTriangle(dynamic_cast<TriangleIntersectable *>(object));
132        break;
133  case Intersectable::BVH_INTERSECTABLE: {
134
135       
136        BvhNode *node = (dynamic_cast<BvhIntersectable *>(object))->GetItem();
137
138        if (mRenderBoxes)
139          RenderBox(node->GetBoundingBox());
140        else
141          RenderBvhNode(node);
142        break;
143  }
144  case Intersectable::KD_INTERSECTABLE: {
145        KdNode *node = (dynamic_cast<KdIntersectable *>(object))->GetItem();
146
147        if (mRenderBoxes)
148          RenderBox(mKdTree->GetBox(node));
149        else
150          RenderKdNode(node);
151        break;
152  }
153       
154  default:
155        cerr<<"Rendering this object not yet implemented\n";
156        break;
157  }
158
159  glPopAttrib();
160}
161
162void
163GlRenderer::RenderRays(const VssRayContainer &rays)
164{
165  VssRayContainer::const_iterator it = rays.begin(), it_end = rays.end();
166
167  glBegin(GL_LINES);
168  for (; it != it_end; ++it) {
169        VssRay *ray = *it;
170        float importance = log10(1e3*ray->mWeightedPvsContribution)/3.0f;
171        //      cout<<"w="<<ray->mWeightedPvsContribution<<" r="<<ray->mWeightedPvsContribution;
172        glColor3f(importance, importance, importance);
173        glVertex3fv(&ray->mOrigin.x);
174        glVertex3fv(&ray->mTermination.x);
175  }
176  glEnd();
177}
178
179void
180GlRenderer::RenderViewCell(ViewCell *vc)
181{
182  if (vc->GetMesh()) {
183
184        if (!mUseFalseColors) {
185          if (vc->GetValid())
186                glColor3f(0,1,0);
187          else
188                glColor3f(0,0,1);
189        }
190       
191        RenderMesh(vc->GetMesh());
192  } else {
193        // render viewcells in the subtree
194        if (!vc->IsLeaf()) {
195          ViewCellInterior *vci = (ViewCellInterior *) vc;
196
197          ViewCellContainer::iterator it = vci->mChildren.begin();
198          for (; it != vci->mChildren.end(); ++it) {
199                RenderViewCell(*it);
200          }
201        } else {
202          //      cerr<<"Empty viewcell mesh\n";
203        }
204  }
205}
206
207
208void
209GlRenderer::RenderMeshInstance(MeshInstance *mi)
210{
211  RenderMesh(mi->GetMesh());
212}
213
214
215void
216GlRenderer::RenderTransformedMeshInstance(TransformedMeshInstance *mi)
217{
218        // apply world transform before rendering
219        Matrix4x4 m;
220        mi->GetWorldTransform(m);
221
222        glPushMatrix();
223/* cout << "\n";
224        for (int i = 0; i < 4; ++ i)
225                for (int j = 0; j < 4; ++ j)
226                        cout << m.x[i][j] << " "; cout << "\n"*/
227
228        glMultMatrixf((float *)m.x);
229
230        /*GLfloat dummy[16];
231        glGetFloatv(GL_MODELVIEW_MATRIX, dummy);
232        for (int i = 0; i < 16; ++ i)
233                cout << dummy[i] << " ";
234        cout << endl;*/
235        RenderMesh(mi->GetMesh());
236       
237        glPopMatrix();
238}
239
240
241void
242GlRenderer::SetupFalseColor(const int id)
243{
244  // swap bits of the color
245  glColor3ub(id&255, (id>>8)&255, (id>>16)&255);
246}
247
248
249int GlRenderer::GetId(int r, int g, int b) const
250{
251        return r + (g << 8) + (b << 16);
252}
253
254void
255GlRenderer::SetupMaterial(Material *m)
256{
257  if (m)
258        glColor3fv(&(m->mDiffuseColor.r));
259}
260
261void
262GlRenderer::RenderMesh(Mesh *mesh)
263{
264  int i = 0;
265
266  if (!mUseFalseColors && !mUseForcedColors)
267        SetupMaterial(mesh->mMaterial);
268 
269  for (i=0; i < mesh->mFaces.size(); i++) {
270        if (mWireFrame)
271          glBegin(GL_LINE_LOOP);
272        else
273          glBegin(GL_POLYGON);
274
275        Face *face = mesh->mFaces[i];
276        for (int j = 0; j < face->mVertexIndices.size(); j++) {
277          glVertex3fv(&mesh->mVertices[face->mVertexIndices[j]].x);
278        }
279        glEnd();
280  }
281}
282       
283void
284GlRenderer::InitGL()
285{
286  mSphere = (GLUquadric *)gluNewQuadric();
287 
288  glMatrixMode(GL_PROJECTION);
289  glLoadIdentity();
290 
291  glMatrixMode(GL_MODELVIEW);
292  glLoadIdentity();
293
294  glEnable(GL_CULL_FACE);
295  glShadeModel(GL_FLAT);
296  glEnable(GL_DEPTH_TEST);
297  glEnable(GL_CULL_FACE);
298 
299  InitExtensions();
300 
301#if 0
302  GLfloat mat_ambient[]   = {  0.5, 0.5, 0.5, 1.0  };
303  /*  mat_specular and mat_shininess are NOT default values     */
304  GLfloat mat_diffuse[]   = {  1.0, 1.0, 1.0, 1.0  };
305  GLfloat mat_specular[]  = {  0.3, 0.3, 0.3, 1.0  };
306  GLfloat mat_shininess[] = {  1.0  };
307 
308  GLfloat light_ambient[]  = {  0.2, 0.2, 0.2, 1.0  };
309  GLfloat light_diffuse[]  = {  0.4, 0.4, 0.4, 1.0  };
310  GLfloat light_specular[] = {  0.3, 0.3, 0.3, 1.0  };
311 
312  GLfloat lmodel_ambient[] = {  0.3, 0.3, 0.3, 1.0  };
313 
314 
315  // default Material
316  glMaterialfv(GL_FRONT, GL_AMBIENT, mat_ambient);
317  glMaterialfv(GL_FRONT, GL_DIFFUSE, mat_diffuse);
318  glMaterialfv(GL_FRONT, GL_SPECULAR, mat_specular);
319  glMaterialfv(GL_FRONT, GL_SHININESS, mat_shininess);
320
321  // a light
322  glLightfv(GL_LIGHT0, GL_AMBIENT, light_ambient);
323  glLightfv(GL_LIGHT0, GL_DIFFUSE, light_diffuse);
324  glLightfv(GL_LIGHT0, GL_SPECULAR, light_specular);
325 
326  glLightfv(GL_LIGHT1, GL_AMBIENT, light_ambient);
327  glLightfv(GL_LIGHT1, GL_DIFFUSE, light_diffuse);
328  glLightfv(GL_LIGHT1, GL_SPECULAR, light_specular);
329 
330  glLightModelfv(GL_LIGHT_MODEL_AMBIENT, lmodel_ambient);
331 
332  glEnable(GL_LIGHTING);
333  glEnable(GL_LIGHT0);
334  glEnable(GL_LIGHT1);
335 
336 
337  // set position of the light
338  GLfloat infinite_light[] = {  1.0, 0.8, 1.0, 0.0  };
339  glLightfv (GL_LIGHT0, GL_POSITION, infinite_light);
340 
341  // set position of the light2
342  GLfloat infinite_light2[] = {  -0.3, 1.5, 1.0, 0.0  };
343  glLightfv (GL_LIGHT1, GL_POSITION, infinite_light2);
344 
345  glColorMaterial( GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE);
346  //   glColorMaterial( GL_FRONT_AND_BACK, GL_SPECULAR);
347  glEnable(GL_COLOR_MATERIAL);
348 
349  glShadeModel( GL_FLAT );
350 
351  glDepthFunc( GL_LESS );
352  glEnable( GL_DEPTH_TEST );
353#endif
354
355  glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE );
356
357  glEnable( GL_NORMALIZE );
358 
359  glClearColor(0.0f, 0.0f, 1.0f, 1.0f);
360}
361
362
363void
364GlRenderer::SetupProjection(const int w, const int h, const float angle)
365{
366  glViewport(0, 0, w, h);
367  glMatrixMode(GL_PROJECTION);
368  glLoadIdentity();
369  gluPerspective(angle, 1.0, 0.1, 2.0*Magnitude(mSceneGraph->GetBox().Diagonal()));
370  glMatrixMode(GL_MODELVIEW);
371}
372
373
374
375void
376GlRenderer::SetupCamera()
377{
378  Vector3 target = mViewPoint + mViewDirection;
379
380  Vector3 up(0,1,0);
381 
382  if (abs(DotProd(mViewDirection, up)) > 0.99f)
383        up = Vector3(1, 0, 0);
384 
385  glLoadIdentity();
386  gluLookAt(mViewPoint.x, mViewPoint.y, mViewPoint.z,
387                        target.x, target.y, target.z,
388                        up.x, up.y, up.z);
389}
390
391void
392GlRenderer::_RenderScene()
393{
394  ObjectContainer::const_iterator oi = mObjects.begin();
395
396  for (; oi != mObjects.end(); oi++)
397        RenderIntersectable(*oi);
398}
399
400bool
401GlRenderer::RenderScene()
402{
403  static int glList = -1;
404  if (mUseGlLists) {
405        if (glList == -1) {
406          glList = glGenLists(1);
407          glNewList(glList, GL_COMPILE);
408          _RenderScene();
409          glEndList();
410        }
411        glCallList(glList);
412  } else
413        _RenderScene();
414       
415 
416  return true;
417}
418
419
420void
421GlRendererBuffer::EvalQueryWithItemBuffer(
422                                                                                  //RenderCostSample &sample
423                                                                           )
424{
425        // read back the texture
426        glReadPixels(0, 0,
427                                GetWidth(), GetHeight(),
428                                GL_RGBA,
429                                GL_UNSIGNED_BYTE,
430                                mPixelBuffer);
431               
432                       
433        unsigned int *p = mPixelBuffer;
434                       
435        for (int y = 0; y < GetHeight(); y++)
436        {
437                for (int x = 0; x < GetWidth(); x++, p++)
438                {
439                        unsigned int id = (*p) & 0xFFFFFF;
440
441                        if (id != 0xFFFFFF)
442                                ++ mObjects[id]->mCounter;
443                }
444        }
445}
446
447
448
449/****************************************************************/
450/*               GlRendererBuffer implementation                */
451/****************************************************************/
452
453
454
455GlRendererBuffer::GlRendererBuffer(SceneGraph *sceneGraph,
456                                                                   ViewCellsManager *viewcells,
457                                                                   KdTree *tree):
458GlRenderer(sceneGraph, viewcells, tree) 
459{
460        mPixelBuffer = NULL;
461
462        // implement width and height in subclasses
463}
464
465
466void
467GlRendererBuffer::EvalQueryWithOcclusionQueries(
468                                                                           //RenderCostSample &sample
469                                                                           )
470{
471        glDepthFunc(GL_LEQUAL);
472               
473        glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
474        glDepthMask(GL_FALSE);
475
476
477        // simulate detectemptyviewspace using backface culling
478        if (mDetectEmptyViewSpace)
479        {
480                glEnable(GL_CULL_FACE);
481                //cout << "culling" << endl;
482        }
483        else
484        {
485                //cout << "not culling" << endl;
486                glDisable(GL_CULL_FACE);
487        }
488
489       
490        //const int numQ = 1;
491        const int numQ = (int)mOcclusionQueries.size();
492       
493        //glFinish();
494#if 0
495        //-- now issue queries for all objects
496        for (int j = 0; j < (int)mObjects.size(); ++ j)
497        {
498                mOcclusionQueries[j]->BeginQuery();
499                RenderIntersectable(mObjects[j]);
500                mOcclusionQueries[j]->EndQuery();
501
502                unsigned int pixelCount;
503
504                pixelCount = mOcclusionQueries[j]->GetQueryResult();
505                mObjects[j]->mCounter += pixelCount;
506        }
507#else
508
509        int q = 0;
510
511        //-- now issue queries for all objects
512        for (int j = 0; j < (int)mObjects.size(); j += q)
513        {       
514                for (q = 0; ((j + q) < (int)mObjects.size()) && (q < numQ); ++ q)
515                {
516                        //glFinish();
517                        mOcclusionQueries[q]->BeginQuery();
518                       
519                        RenderIntersectable(mObjects[j + q]);
520               
521                        mOcclusionQueries[q]->EndQuery();
522                        //glFinish();
523                }
524                //cout << "q: " << q << endl;
525                // collect results of the queries
526                for (int t = 0; t < q; ++ t)
527                {
528                        unsigned int pixelCount;
529               
530                        //-- reenable other state
531#if 0
532                        bool available;
533
534                        do
535                        {
536                                available = mOcclusionQueries[t]->ResultAvailable();
537                               
538                                if (!available) cout << "W";
539                        }
540                        while (!available);
541#endif
542
543                        pixelCount = mOcclusionQueries[t]->GetQueryResult();
544
545                        //if (pixelCount > 0)
546                        //      cout <<"o="<<j+q<<" q="<<mOcclusionQueries[q]->GetQueryId()<<" pc="<<pixelCount<<" ";
547                        mObjects[j + t]->mCounter += pixelCount;
548                }
549
550                //j += q;
551        }
552#endif
553        //glFinish();
554        glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
555        glDepthMask(GL_TRUE);
556       
557        glEnable(GL_CULL_FACE);
558}
559
560
561void
562GlRendererBuffer::RandomViewPoint()
563{
564  // do not use this function since it could return different viewpoints for
565  // different executions of the algorithm
566
567  //  mViewCellsManager->GetViewPoint(mViewPoint);
568
569  while (1) {
570        Vector3 pVector = Vector3(halton.GetNumber(1),
571                                                          halton.GetNumber(2),
572                                                          halton.GetNumber(3));
573       
574        mViewPoint =  mViewCellsManager->GetViewSpaceBox().GetPoint(pVector);
575        ViewCell *v = mViewCellsManager->GetViewCell(mViewPoint);
576        if (v && v->GetValid())
577          break;
578        // generate a new vector
579        halton.GenerateNext();
580  }
581 
582  Vector3 dVector = Vector3(2*M_PI*halton.GetNumber(4),
583                                                        M_PI*halton.GetNumber(5),
584                                                        0.0f);
585 
586  mViewDirection = Normalize(Vector3(sin(dVector.x),
587                                                                         //                                                                      cos(dVector.y),
588                                                                         0.0f,
589                                                                         cos(dVector.x)));
590  halton.GenerateNext();
591}
592
593
594void
595GlRenderer::RenderBox(const AxisAlignedBox3 &box)
596{
597
598  glBegin(GL_LINE_LOOP);
599  glVertex3d(box.Min().x, box.Max().y, box.Min().z );
600  glVertex3d(box.Max().x, box.Max().y, box.Min().z );
601  glVertex3d(box.Max().x, box.Min().y, box.Min().z );
602  glVertex3d(box.Min().x, box.Min().y, box.Min().z );
603  glEnd();
604
605  glBegin(GL_LINE_LOOP);
606  glVertex3d(box.Min().x, box.Min().y, box.Max().z );
607  glVertex3d(box.Max().x, box.Min().y, box.Max().z );
608  glVertex3d(box.Max().x, box.Max().y, box.Max().z );
609  glVertex3d(box.Min().x, box.Max().y, box.Max().z );
610  glEnd();
611
612  glBegin(GL_LINE_LOOP);
613  glVertex3d(box.Max().x, box.Min().y, box.Min().z );
614  glVertex3d(box.Max().x, box.Min().y, box.Max().z );
615  glVertex3d(box.Max().x, box.Max().y, box.Max().z );
616  glVertex3d(box.Max().x, box.Max().y, box.Min().z );
617  glEnd();
618
619  glBegin(GL_LINE_LOOP);
620  glVertex3d(box.Min().x, box.Min().y, box.Min().z );
621  glVertex3d(box.Min().x, box.Min().y, box.Max().z );
622  glVertex3d(box.Min().x, box.Max().y, box.Max().z );
623  glVertex3d(box.Min().x, box.Max().y, box.Min().z );
624  glEnd();
625
626  glBegin(GL_LINE_LOOP);
627  glVertex3d(box.Min().x, box.Min().y, box.Min().z );
628  glVertex3d(box.Max().x, box.Min().y, box.Min().z );
629  glVertex3d(box.Max().x, box.Min().y, box.Max().z );
630  glVertex3d(box.Min().x, box.Min().y, box.Max().z );
631  glEnd();
632
633  glBegin(GL_LINE_LOOP);
634  glVertex3d(box.Min().x, box.Max().y, box.Min().z );
635  glVertex3d(box.Max().x, box.Max().y, box.Min().z );
636  glVertex3d(box.Max().x, box.Max().y, box.Max().z );
637  glVertex3d(box.Min().x, box.Max().y, box.Max().z );
638
639  glEnd();
640
641}
642
643void
644GlRenderer::RenderBvhNode(BvhNode *node)
645{
646  if (node->IsLeaf()) {
647        BvhLeaf *leaf = (BvhLeaf *) node;
648        for (int i=0; i < leaf->mObjects.size(); i++)
649          RenderIntersectable(leaf->mObjects[i]);
650  } else {
651        BvhInterior *in = (BvhInterior *)node;
652        RenderBvhNode(in->GetBack());
653        RenderBvhNode(in->GetFront());
654  }
655
656  //cout << "leaf obj " << i << endl;
657
658}
659
660void
661GlRenderer::RenderKdNode(KdNode *node)
662{
663  if (node->IsLeaf()) {
664        KdLeaf *leaf = (KdLeaf *) node;
665        for (int i=0; i < leaf->mObjects.size(); i++) {
666          RenderIntersectable(leaf->mObjects[i]);
667        }
668  } else {
669        KdInterior *in = (KdInterior *)node;
670        RenderKdNode(in->mBack);
671        RenderKdNode(in->mFront);
672  }
673 
674}
675
676}
Note: See TracBrowser for help on using the repository browser.