Context Navigation

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

Revision 713, 40.6 KB checked in by bittner, 18 years ago (diff)
visibility filter used in glrenderer
Property svn:executable set to ``*

Line
1	#include "Mesh.h"
2	#include "GlRenderer.h"
3	#include "ViewCellsManager.h"
4	#include "SceneGraph.h"
5	#include "Pvs.h"
6	#include "Viewcell.h"
7	#include "Beam.h"
8	#include "KdTree.h"
9	#include "Environment.h"
10
11	#include <GL/glext.h>
12	#include <Cg/cg.h>
13	#include <Cg/cgGL.h>
14
15	#include <QVBoxLayout>
16
17	static CGcontext sCgContext = NULL;
18	static CGprogram sCgFragmentProgram = NULL;
19	static CGprofile sCgFragmentProfile;
20
21	GLuint frontDepthMap;
22	GLuint backDepthMap;
23
24	const int depthMapSize = 512;
25	static vector<int> sQueries;
26
27	GlRendererWidget *rendererWidget = NULL;
28	GlDebuggerWidget *debuggerWidget = NULL;
29
30
31	#ifdef _WIN32
32	PFNGLGENOCCLUSIONQUERIESNVPROC glGenOcclusionQueriesNV;
33	PFNGLBEGINOCCLUSIONQUERYNVPROC glBeginOcclusionQueryNV;
34	PFNGLENDOCCLUSIONQUERYNVPROC glEndOcclusionQueryNV;
35	PFNGLGETOCCLUSIONQUERYUIVNVPROC glGetOcclusionQueryuivNV;
36	#endif
37
38	GlRenderer::GlRenderer(SceneGraph *sceneGraph,
39	ViewCellsManager *viewCellsManager,
40	KdTree *tree):
41	Renderer(sceneGraph, viewCellsManager),
42	mKdTree(tree)
43	{
44	mSceneGraph->CollectObjects(&mObjects);
45	mViewPoint = mSceneGraph->GetBox().Center();
46	mViewDirection = Vector3(0,0,1);
47
48	// timerId = startTimer(10);
49	// debug coords for atlanta
50	// mViewPoint = Vector3(3473, 6.778, -1699);
51	// mViewDirection = Vector3(-0.2432, 0, 0.97);
52
53	mFrame = 0;
54	mWireFrame = false;
55	environment->GetBoolValue("Preprocessor.detectEmptyViewSpace", mDetectEmptyViewSpace);
56	mSnapErrorFrames = false;
57	mSnapPrefix = "";
58
59	}
60
61	GlRenderer::~GlRenderer()
62	{
63	cerr<<"gl renderer destructor..\n";
64	if (sCgFragmentProgram)
65	cgDestroyProgram(sCgFragmentProgram);
66	if (sCgContext)
67	cgDestroyContext(sCgContext);
68	cerr<<"done."<<endl;
69	}
70
71
72	static void handleCgError()
73	{
74	Debug << "Cg error: " << cgGetErrorString(cgGetError()) << endl;
75	exit(1);
76	}
77
78	void
79	GlRenderer::RenderIntersectable(Intersectable *object)
80	{
81
82	glPushAttrib(GL_CURRENT_BIT);
83	if (mUseFalseColors)
84	SetupFalseColor(object->mId);
85
86
87	switch (object->Type()) {
88	case Intersectable::MESH_INSTANCE:
89	RenderMeshInstance((MeshInstance *)object);
90	break;
91	case Intersectable::VIEW_CELL:
92	RenderViewCell(dynamic_cast<ViewCell *>(object));
93	break;
94	default:
95	cerr<<"Rendering this object not yet implemented\n";
96	break;
97	}
98
99	glPopAttrib();
100	}
101
102
103	void
104	GlRenderer::RenderViewCell(ViewCell *vc)
105	{
106	if (vc->GetMesh()) {
107
108	if (!mUseFalseColors) {
109	if (vc->GetValid())
110	glColor3f(0,1,0);
111	else
112	glColor3f(0,0,1);
113	}
114
115	RenderMesh(vc->GetMesh());
116	} else {
117	// render viewcells in the subtree
118	if (!vc->IsLeaf()) {
119	ViewCellInterior vci = (ViewCellInterior ) vc;
120
121	ViewCellContainer::iterator it = vci->mChildren.begin();
122	for (; it != vci->mChildren.end(); ++it) {
123	RenderViewCell(*it);
124	}
125	} else {
126	// cerr<<"Empty viewcell mesh\n";
127	}
128	}
129	}
130
131
132	void
133	GlRenderer::RenderMeshInstance(MeshInstance *mi)
134	{
135	RenderMesh(mi->GetMesh());
136	}
137
138	void
139	GlRenderer::SetupFalseColor(const int id)
140	{
141	// swap bits of the color
142
143	glColor3ub(id&255, (id>>8)&255, (id>>16)&255);
144	}
145
146
147	int GlRenderer::GetId(int r, int g, int b) const
148	{
149	return r + (g << 8) + (b << 16);
150	}
151
152	void
153	GlRenderer::SetupMaterial(Material *m)
154	{
155	if (m)
156	glColor3fv(&(m->mDiffuseColor.r));
157	}
158
159	void
160	GlRenderer::RenderMesh(Mesh *mesh)
161	{
162	int i = 0;
163
164	if (!mUseFalseColors)
165	SetupMaterial(mesh->mMaterial);
166
167	for (i=0; i < mesh->mFaces.size(); i++) {
168	if (mWireFrame)
169	glBegin(GL_LINE_LOOP);
170	else
171	glBegin(GL_POLYGON);
172
173	Face *face = mesh->mFaces[i];
174	for (int j = 0; j < face->mVertexIndices.size(); j++) {
175	glVertex3fv(&mesh->mVertices[face->mVertexIndices[j]].x);
176	}
177	glEnd();
178	}
179	}
180
181	void
182	GlRenderer::InitGL()
183	{
184	glMatrixMode(GL_PROJECTION);
185	glLoadIdentity();
186
187	glMatrixMode(GL_MODELVIEW);
188	glLoadIdentity();
189
190	glEnable(GL_CULL_FACE);
191	glShadeModel(GL_FLAT);
192	glEnable(GL_DEPTH_TEST);
193	glEnable(GL_CULL_FACE);
194
195	glGenOcclusionQueriesNV = (PFNGLGENOCCLUSIONQUERIESNVPROC)
196	wglGetProcAddress("glGenOcclusionQueriesNV");
197	glBeginOcclusionQueryNV = (PFNGLBEGINOCCLUSIONQUERYNVPROC)
198	wglGetProcAddress("glBeginOcclusionQueryNV");
199	glEndOcclusionQueryNV = (PFNGLENDOCCLUSIONQUERYNVPROC)
200	wglGetProcAddress("glEndOcclusionQueryNV");
201	glGetOcclusionQueryuivNV = (PFNGLGETOCCLUSIONQUERYUIVNVPROC)
202	wglGetProcAddress("glGetOcclusionQueryuivNV");
203
204	glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
205
206	}
207
208	void
209	GlRendererWidget::RenderInfo()
210	{
211	QString s;
212	int vc = 0;
213	if (mViewCellsManager)
214	vc = mViewCellsManager->GetViewCells().size();
215	s.sprintf("frame:%04d viewpoint:(%4.1f,%4.1f,%4.1f) dir:(%4.1f,%4.1f,%4.1f) viewcells:%04d",
216	mFrame,
217	mViewPoint.x,
218	mViewPoint.y,
219	mViewPoint.z,
220	mViewDirection.x,
221	mViewDirection.y,
222	mViewDirection.z,
223	vc
224	);
225	renderText(0,20,s);
226	}
227
228
229	void
230	GlRenderer::SetupProjection(const int w, const int h)
231	{
232	glViewport(0, 0, w, h);
233	glMatrixMode(GL_PROJECTION);
234	glLoadIdentity();
235	gluPerspective(70.0, 1.0, 0.1, 2.0*Magnitude(mSceneGraph->GetBox().Diagonal()));
236	glMatrixMode(GL_MODELVIEW);
237	}
238
239	void
240	GlRenderer::SetupCamera()
241	{
242	Vector3 target = mViewPoint + mViewDirection;
243	Vector3 up(0,1,0);
244
245	glLoadIdentity();
246	gluLookAt(mViewPoint.x, mViewPoint.y, mViewPoint.z,
247	target.x, target.y, target.z,
248	up.x, up.y, up.z);
249	}
250
251	void
252	GlRendererBuffer::RandomViewPoint()
253	{
254
255
256	// do not use this function since it could return different viewpoints for
257	// different executions of the algorithm
258
259	//mViewCellsManager->GetViewPoint(mViewPoint);
260
261	while (1) {
262	Vector3 pVector = Vector3(halton.GetNumber(1),
263	halton.GetNumber(2),
264	halton.GetNumber(3));
265
266	mViewPoint = mSceneGraph->GetBox().GetPoint(pVector);
267	ViewCell *v = mViewCellsManager->GetViewCell(mViewPoint);
268	if (v && v->GetValid())
269	break;
270	// generate a new vector
271	halton.GenerateNext();
272	}
273
274
275	Vector3 dVector = Vector3(2M_PIhalton.GetNumber(4),
276	M_PI*halton.GetNumber(5),
277	0.0f);
278
279	mViewDirection = Normalize(Vector3(sin(dVector.x),
280	// cos(dVector.y),
281	0.0f,
282	cos(dVector.x)));
283	halton.GenerateNext();
284	}
285
286
287	GlRendererBuffer::GlRendererBuffer(const int w,
288	const int h,
289	SceneGraph *sceneGraph,
290	ViewCellsManager *viewcells,
291	KdTree *tree):
292	QGLPixelBuffer(QSize(w, h)), GlRenderer(sceneGraph, viewcells, tree) {
293
294	environment->GetIntValue("Preprocessor.pvsRenderErrorSamples", mPvsStatFrames);
295	mPvsErrorBuffer.resize(mPvsStatFrames);
296	ClearErrorBuffer();
297
298	InitGL();
299
300	}
301
302	float
303	GlRendererBuffer::GetPixelError(int &pvsSize)
304	{
305	float pErrorPixels = -1.0f;
306
307	glReadBuffer(GL_BACK);
308
309	// mUseFalseColors = true;
310
311	mUseFalseColors = false;
312
313	static int query = -1;
314	unsigned int pixelCount;
315
316	if (query == -1)
317	glGenOcclusionQueriesNV(1, (unsigned int *)&query);
318
319	if (mDetectEmptyViewSpace) {
320	// now check whether any backfacing polygon would pass the depth test
321	SetupCamera();
322	glClear(GL_COLOR_BUFFER_BIT \| GL_DEPTH_BUFFER_BIT);
323	glEnable( GL_CULL_FACE );
324
325	RenderScene();
326
327	glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
328	glDepthMask(GL_FALSE);
329	glDisable( GL_CULL_FACE );
330
331	glBeginOcclusionQueryNV(query);
332
333	RenderScene();
334
335	glEndOcclusionQueryNV();
336
337	// at this point, if possible, go and do some other computation
338	glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
339	glDepthMask(GL_TRUE);
340	glEnable( GL_CULL_FACE );
341
342	// reenable other state
343	glGetOcclusionQueryuivNV(query,
344	GL_PIXEL_COUNT_NV,
345	&pixelCount);
346
347	if (pixelCount > 0)
348	return -1.0f; // backfacing polygon found -> not a valid viewspace sample
349	} else
350	glDisable( GL_CULL_FACE );
351
352
353	ViewCell *viewcell = NULL;
354
355	PrVs prvs;
356	// mViewCellsManager->SetMaxFilterSize(1);
357	mViewCellsManager->GetPrVS(mViewPoint, prvs);
358	viewcell = prvs.mViewCell;
359
360	// ViewCell *viewcell = mViewCellsManager->GetViewCell(mViewPoint);
361	pvsSize = 0;
362	if (viewcell) {
363	SetupCamera();
364	glClear(GL_COLOR_BUFFER_BIT \| GL_DEPTH_BUFFER_BIT);
365
366	glColorMask(GL_FALSE, GL_TRUE, GL_FALSE, GL_FALSE);
367
368	// Render PVS
369	std::map<Intersectable *,
370	PvsData<Intersectable *>,
371	LtSample<Intersectable *> >::const_iterator it = viewcell->GetPvs().mEntries.begin();
372
373	pvsSize = viewcell->GetPvs().mEntries.size();
374
375	for (; it != viewcell->GetPvs().mEntries.end(); ++ it) {
376	Intersectable object = (it).first;
377	RenderIntersectable(object);
378	}
379
380	// glColorMask(GL_TRUE, GL_FALSE, GL_FALSE, GL_FALSE);
381	glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
382	mUseFalseColors = true;
383
384	glBeginOcclusionQueryNV(query);
385
386	SetupCamera();
387
388	RenderScene();
389
390	glEndOcclusionQueryNV();
391
392
393	unsigned int pixelCount;
394	// reenable other state
395	glGetOcclusionQueryuivNV(query,
396	GL_PIXEL_COUNT_NV,
397	&pixelCount);
398
399	pErrorPixels = ((float)pixelCount)/(GetWidth()*GetHeight());
400	if (mSnapErrorFrames && pErrorPixels > 0.01) {
401
402	char filename[256];
403	sprintf(filename, "error-frame-%04d-%0.5f.png", mFrame, pErrorPixels);
404	QImage im = toImage();
405	im.save(mSnapPrefix + filename, "PNG");
406	if (1) { //0 && mFrame == 1543) {
407	int x,y;
408	int lastIndex = -1;
409	for (y=0; y < im.height(); y++)
410	for (x=0; x < im.width(); x++) {
411	QRgb p = im.pixel(x,y);
412	int index = qRed(p) + (qGreen(p)<<8) + (qBlue(p)<<16);
413	if (qGreen(p) != 255 && index!=0) {
414	if (index != lastIndex) {
415	Debug<<"ei="<<index<<" ";
416	lastIndex = index;
417	}
418	}
419	}
420	}
421
422
423	mUseFalseColors = false;
424	glPushAttrib(GL_CURRENT_BIT);
425	glColor3f(0,1,0);
426	glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
427	SetupCamera();
428	glClear(GL_COLOR_BUFFER_BIT \| GL_DEPTH_BUFFER_BIT);
429
430	// Render PVS
431	std::map<Intersectable *,
432	PvsData<Intersectable *>,
433	LtSample<Intersectable *> >::const_iterator it = viewcell->GetPvs().mEntries.begin();
434
435	for (; it != viewcell->GetPvs().mEntries.end(); ++ it) {
436	Intersectable object = (it).first;
437	RenderIntersectable(object);
438	}
439
440	im = toImage();
441	sprintf(filename, "error-frame-%04d-%0.5f-pvs.png", mFrame, pErrorPixels);
442	im.save(mSnapPrefix + filename, "PNG");
443	glPopAttrib();
444	}
445	glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
446	}
447
448	if (viewcell)
449	mViewCellsManager->DeleteLocalMergeTree(viewcell);
450
451	return pErrorPixels;
452	}
453
454
455	void
456	GlRendererWidget::SetupProjection(const int w, const int h)
457	{
458	if (!mTopView)
459	GlRenderer::SetupProjection(w, h);
460	else {
461	glViewport(0, 0, w, h);
462	glMatrixMode(GL_PROJECTION);
463	glLoadIdentity();
464	gluPerspective(50.0, 1.0, 0.1, 20.0*Magnitude(mSceneGraph->GetBox().Diagonal()));
465	glMatrixMode(GL_MODELVIEW);
466	}
467	}
468
469	float
470	GlRendererWidget::RenderErrors()
471	{
472	float pErrorPixels = -1.0f;
473
474	glReadBuffer(GL_BACK);
475
476	mUseFalseColors = true;
477
478	SetupCamera();
479	glClear(GL_COLOR_BUFFER_BIT \| GL_DEPTH_BUFFER_BIT);
480
481	double eq[4];
482	eq[0] = mSceneCutPlane.mNormal.x;
483	eq[1] = mSceneCutPlane.mNormal.y;
484	eq[2] = mSceneCutPlane.mNormal.z;
485	eq[3] = mSceneCutPlane.mD;
486
487	if (mCutScene) {
488	glClipPlane(GL_CLIP_PLANE0, eq);
489	glEnable(GL_CLIP_PLANE0);
490	}
491
492	if (mDetectEmptyViewSpace)
493	glEnable( GL_CULL_FACE );
494	else
495	glDisable( GL_CULL_FACE );
496
497	ObjectContainer::const_iterator oi = mObjects.begin();
498	for (; oi != mObjects.end(); oi++)
499	RenderIntersectable(*oi);
500
501	ViewCell *viewcell;
502	// viewcell = mViewCellsManager->GetViewCell(mViewPoint);
503
504	PrVs prvs;
505	// mViewCellsManager->SetMaxFilterSize(1);
506	mViewCellsManager->GetPrVS(mViewPoint, prvs);
507	viewcell = prvs.mViewCell;
508
509	QImage im1, im2;
510	QImage diff;
511
512	if (viewcell) {
513	// read back the texture
514	im1 = grabFrameBuffer(true);
515
516	SetupCamera();
517	glClear(GL_COLOR_BUFFER_BIT \| GL_DEPTH_BUFFER_BIT);
518
519	std::map<Intersectable *,
520	PvsData<Intersectable *>,
521	LtSample<Intersectable *> >::const_iterator it = viewcell->GetPvs().mEntries.begin();
522
523	for (; it != viewcell->GetPvs().mEntries.end(); ++ it) {
524	Intersectable object = (it).first;
525	RenderIntersectable(object);
526	}
527
528	// read back the texture
529	im2 = grabFrameBuffer(true);
530
531	diff = im1;
532	int x, y;
533	int errorPixels = 0;
534
535	for (y = 0; y < im1.height(); y++)
536	for (x = 0; x < im1.width(); x++)
537	if (im1.pixel(x, y) == im2.pixel(x, y))
538	diff.setPixel(x, y, qRgba(0,0,0,0));
539	else {
540	diff.setPixel(x, y, qRgba(255,128,128,255));
541	errorPixels++;
542
543	}
544	pErrorPixels = ((float)errorPixels)/(im1.height()*im1.width());
545	}
546
547	// now render the pvs again
548	SetupCamera();
549	glClear(GL_COLOR_BUFFER_BIT \| GL_DEPTH_BUFFER_BIT);
550	mUseFalseColors = false;
551
552	oi = mObjects.begin();
553	for (; oi != mObjects.end(); oi++)
554	RenderIntersectable(*oi);
555
556	// now render im1
557	if (viewcell) {
558	if (1 \|\| mTopView) {
559	mWireFrame = true;
560	RenderIntersectable(viewcell);
561	mWireFrame = false;
562	}
563
564	// init ortographic projection
565	glMatrixMode(GL_PROJECTION);
566	glPushMatrix();
567
568	glLoadIdentity();
569	gluOrtho2D(0, 1.0f, 0, 1.0f);
570
571	glMatrixMode(GL_MODELVIEW);
572	glLoadIdentity();
573
574	bindTexture(diff);
575
576	glPushAttrib(GL_ENABLE_BIT);
577	glEnable( GL_ALPHA_TEST );
578	glDisable( GL_CULL_FACE );
579	glAlphaFunc( GL_GREATER, 0.5 );
580
581	glEnable( GL_TEXTURE_2D );
582	glBegin(GL_QUADS);
583
584	glTexCoord2f(0,0);
585	glVertex3f(0,0,0);
586
587	glTexCoord2f(1,0);
588	glVertex3f( 1, 0, 0);
589
590	glTexCoord2f(1,1);
591	glVertex3f( 1, 1, 0);
592
593	glTexCoord2f(0,1);
594	glVertex3f(0, 1, 0);
595	glEnd();
596
597	glPopAttrib();
598
599	// restore the projection matrix
600	glMatrixMode(GL_PROJECTION);
601	glPopMatrix();
602	glMatrixMode(GL_MODELVIEW);
603	}
604
605	glDisable(GL_CLIP_PLANE0);
606
607	if (viewcell)
608	mViewCellsManager->DeleteLocalMergeTree(viewcell);
609
610	return pErrorPixels;
611	}
612
613
614	bool
615	GlRenderer::RenderScene()
616	{
617	static int glList = -1;
618	if (glList == -1)
619	{
620	glList = glGenLists(1);
621	glNewList(glList, GL_COMPILE);
622	ObjectContainer::const_iterator oi = mObjects.begin();
623	for (; oi != mObjects.end(); oi++)
624	RenderIntersectable(*oi);
625	glEndList();
626	}
627
628	glCallList(glList);
629
630	return true;
631	}
632
633
634	void
635	GlRendererBuffer::ClearErrorBuffer()
636	{
637	for (int i=0; i < mPvsStatFrames; i++) {
638	mPvsErrorBuffer[i].mError = 1.0f;
639	}
640	}
641
642
643	void
644	GlRendererBuffer::EvalPvsStat()
645	{
646	mPvsStat.Reset();
647	halton.Reset();
648
649	makeCurrent();
650	SetupProjection(GetWidth(), GetHeight());
651
652	for (int i=0; i < mPvsStatFrames; i++) {
653	float err;
654	// set frame id for saving the error buffer
655	mFrame = i;
656	RandomViewPoint();
657
658	// atlanta problematic frames: 325 525 691 1543
659	#if 0
660	if (mFrame != 325 &&
661	mFrame != 525 &&
662	mFrame != 691 &&
663	mFrame != 1543)
664	mPvsErrorBuffer[i] = -1;
665	else {
666	Debug<<"frame ="<<mFrame<<" vp="<<mViewPoint<<" vd="<<mViewDirection<<endl;
667	}
668	#endif
669	if (mPvsErrorBuffer[i].mError > 0.0f) {
670	int pvsSize;
671	float error = GetPixelError(pvsSize);
672	mPvsErrorBuffer[i].mError = error;
673	mPvsErrorBuffer[i].mPvsSize = pvsSize;
674
675	cout<<"("<<i<<","<<mPvsErrorBuffer[i].mError<<")";
676	// swapBuffers();
677	}
678
679	err = mPvsErrorBuffer[i].mError;
680
681	if (err >= 0.0f) {
682	if (err > mPvsStat.maxError)
683	mPvsStat.maxError = err;
684	mPvsStat.sumError += err;
685	mPvsStat.sumPvsSize += mPvsErrorBuffer[i].mPvsSize;
686
687	if (err == 0.0f)
688	mPvsStat.errorFreeFrames++;
689	mPvsStat.frames++;
690	}
691	}
692
693	glFinish();
694	doneCurrent();
695
696	cout<<endl<<flush;
697	// mRenderingFinished.wakeAll();
698	}
699
700
701
702
703
704	void
705	GlRendererWidget::mousePressEvent(QMouseEvent *e)
706	{
707	int x = e->pos().x();
708	int y = e->pos().y();
709
710	mousePoint.x = x;
711	mousePoint.y = y;
712
713	}
714
715	void
716	GlRendererWidget::mouseMoveEvent(QMouseEvent *e)
717	{
718	float MOVE_SENSITIVITY = Magnitude(mSceneGraph->GetBox().Diagonal())*1e-3;
719	float TURN_SENSITIVITY=0.1f;
720	float TILT_SENSITIVITY=32.0 ;
721	float TURN_ANGLE= M_PI/36.0 ;
722
723	int x = e->pos().x();
724	int y = e->pos().y();
725
726	if (e->modifiers() & Qt::ControlModifier) {
727	mViewPoint.y += (y-mousePoint.y)*MOVE_SENSITIVITY/2.0;
728	mViewPoint.x += (x-mousePoint.x)*MOVE_SENSITIVITY/2.0;
729	} else {
730	mViewPoint += mViewDirection((mousePoint.y - y)MOVE_SENSITIVITY);
731	float adiff = TURN_ANGLE(x - mousePoint.x)-TURN_SENSITIVITY;
732	float angle = atan2(mViewDirection.x, mViewDirection.z);
733	mViewDirection.x = sin(angle+adiff);
734	mViewDirection.z = cos(angle+adiff);
735	}
736
737	mousePoint.x = x;
738	mousePoint.y = y;
739
740	updateGL();
741	}
742
743	void
744	GlRendererWidget::mouseReleaseEvent(QMouseEvent *)
745	{
746
747
748	}
749
750	void
751	GlRendererWidget::resizeGL(int w, int h)
752	{
753	SetupProjection(w, h);
754	updateGL();
755	}
756
757	void
758	GlRendererWidget::paintGL()
759	{
760	glClear(GL_COLOR_BUFFER_BIT \| GL_DEPTH_BUFFER_BIT);
761
762
763	if (!mRenderViewCells) {
764	RenderErrors();
765	RenderInfo();
766	} else {
767	RenderViewCells();
768
769	mWireFrame = true;
770	RenderScene();
771	mWireFrame = false;
772	RenderInfo();
773	}
774
775	mFrame++;
776	}
777
778
779	void
780	GlRendererWidget::SetupCamera()
781	{
782	if (!mTopView)
783	GlRenderer::SetupCamera();
784	else {
785	if (0) {
786	float dist = Magnitude(mSceneGraph->GetBox().Diagonal())*0.05;
787	Vector3 pos = mViewPoint - dist*Vector3(mViewDirection.x,
788	-1,
789	mViewDirection.y);
790
791	Vector3 target = mViewPoint + dist*mViewDirection;
792	Vector3 up(0,1,0);
793
794	glLoadIdentity();
795	gluLookAt(pos.x, pos.y, pos.z,
796	target.x, target.y, target.z,
797	up.x, up.y, up.z);
798	} else {
799	float dist = Magnitude(mSceneGraph->GetBox().Diagonal())*mTopDistance;
800	Vector3 pos = mViewPoint + dist*Vector3(0,
801	1,
802	0);
803
804	Vector3 target = mViewPoint;
805	Vector3 up(mViewDirection.x, 0, mViewDirection.z);
806
807	glLoadIdentity();
808	gluLookAt(pos.x, pos.y, pos.z,
809	target.x, target.y, target.z,
810	up.x, up.y, up.z);
811
812	}
813	}
814
815	}
816
817	void
818	GlRendererWidget::keyPressEvent ( QKeyEvent * e )
819	{
820	switch (e->key()) {
821	case Qt::Key_T:
822	mTopView = !mTopView;
823	SetupProjection(width(), height());
824	updateGL();
825	break;
826	case Qt::Key_V:
827	mRenderViewCells = !mRenderViewCells;
828	updateGL();
829	break;
830	default:
831	e->ignore();
832	break;
833	}
834	}
835
836
837	RendererControlWidget::RendererControlWidget(QWidget * parent, Qt::WFlags f):
838	QWidget(parent, f)
839	{
840
841	QVBoxLayout *vl = new QVBoxLayout;
842	setLayout(vl);
843
844	QWidget *vbox = new QGroupBox("ViewCells", this);
845	layout()->addWidget(vbox);
846
847	vl = new QVBoxLayout;
848	vbox->setLayout(vl);
849
850	QLabel *label = new QLabel("Granularity");
851	vbox->layout()->addWidget(label);
852
853	QSlider *slider = new QSlider(Qt::Horizontal, vbox);
854	vl->addWidget(slider);
855	slider->show();
856	slider->setRange(1, 200);
857	slider->setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Preferred);
858	slider->setValue(200);
859
860	connect(slider, SIGNAL(valueChanged(int)), SIGNAL(SetViewCellGranularity(int)));
861
862	label = new QLabel("Filter size");
863	vbox->layout()->addWidget(label);
864
865	slider = new QSlider(Qt::Horizontal, vbox);
866	vbox->layout()->addWidget(slider);
867	slider->show();
868	slider->setRange(1, 100);
869	slider->setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Preferred);
870	slider->setValue(3);
871
872	connect(slider, SIGNAL(valueChanged(int)), SIGNAL(SetVisibilityFilterSize(int)));
873
874
875
876	QWidget *hbox = new QWidget(vbox);
877	vl->addWidget(hbox);
878	QHBoxLayout *hlayout = new QHBoxLayout;
879	hbox->setLayout(hlayout);
880
881	QCheckBox *cb = new QCheckBox("Show viewcells", hbox);
882	hlayout->addWidget(cb);
883	cb->setChecked(false);
884	connect(cb, SIGNAL(toggled(bool)), SIGNAL(SetShowViewCells(bool)));
885
886	vbox->resize(800,100);
887
888
889	vbox = new QGroupBox("Rendering", this);
890	layout()->addWidget(vbox);
891
892	vl = new QVBoxLayout;
893	vbox->setLayout(vl);
894
895	slider = new QSlider(Qt::Horizontal, vbox);
896	vbox->layout()->addWidget(slider);
897	slider->show();
898	slider->setRange(0, 1000);
899	slider->setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Preferred);
900	slider->setValue(1000);
901
902	connect(slider, SIGNAL(valueChanged(int)), SIGNAL(SetSceneCut(int)));
903
904
905	cb = new QCheckBox("Cut view cells", vbox);
906	vbox->layout()->addWidget(cb);
907	cb->setChecked(false);
908	connect(cb, SIGNAL(toggled(bool)), SIGNAL(SetCutViewCells(bool)));
909
910	cb = new QCheckBox("Cut scene", vbox);
911	vbox->layout()->addWidget(cb);
912	cb->setChecked(false);
913	connect(cb, SIGNAL(toggled(bool)), SIGNAL(SetCutScene(bool)));
914
915
916	slider = new QSlider(Qt::Horizontal, vbox);
917	vbox->layout()->addWidget(slider);
918	slider->show();
919	slider->setRange(1, 1000);
920	slider->setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Preferred);
921	slider->setValue(500);
922
923	connect(slider, SIGNAL(valueChanged(int)), SIGNAL(SetTopDistance(int)));
924
925
926
927
928	cb = new QCheckBox("Top View", vbox);
929	vbox->layout()->addWidget(cb);
930	cb->setChecked(false);
931	connect(cb, SIGNAL(toggled(bool)), SIGNAL(SetTopView(bool)));
932
933	setWindowTitle("Preprocessor Control Widget");
934	adjustSize();
935	}
936
937	GlRendererWidget::GlRendererWidget(SceneGraph *sceneGraph,
938	ViewCellsManager *viewcells,
939	KdTree *tree,
940	QWidget * parent,
941	const QGLWidget * shareWidget,
942	Qt::WFlags f
943	)
944	:
945	GlRenderer(sceneGraph, viewcells, tree), QGLWidget(parent, shareWidget, f)
946	{
947	mTopView = false;
948	mRenderViewCells = false;
949	mTopDistance = 1.0f;
950	mCutViewCells = false;
951	mCutScene = false;
952
953	RendererControlWidget *cw = new RendererControlWidget(NULL);
954	connect(cw, SIGNAL(SetViewCellGranularity(int)), this, SLOT(SetViewCellGranularity(int)));
955	connect(cw, SIGNAL(SetSceneCut(int)), this, SLOT(SetSceneCut(int)));
956	connect(cw, SIGNAL(SetTopDistance(int)), this, SLOT(SetTopDistance(int)));
957
958	//connect(cw, SIGNAL(SetViewCellGranularity(int)), this, SLOT(SetMaxFilterSize(int)));
959	// connect(cw, SIGNAL(SetVisibilityFilterSize(int)), this, SLOT(SetVisibilityFilterSize(int)));
960	//connect(cw, SIGNAL(SetVisibilityFilterSize(int)), this, SLOT(SetViewCellGranularity(int)));
961
962	connect(cw, SIGNAL(SetShowViewCells(bool)), this, SLOT(SetShowViewCells(bool)));
963	connect(cw, SIGNAL(SetTopView(bool)), this, SLOT(SetTopView(bool)));
964	connect(cw, SIGNAL(SetCutViewCells(bool)), this, SLOT(SetCutViewCells(bool)));
965	connect(cw, SIGNAL(SetCutScene(bool)), this, SLOT(SetCutScene(bool)));
966
967	cw->show();
968	}
969
970	void
971	GlRendererWidget::SetViewCellGranularity(int number)
972	{
973	if (mViewCellsManager)
974	mViewCellsManager->SetMaxFilterSize(number);
975	// mViewCellsManager->CollectViewCells(number);
976	updateGL();
977	}
978
979	void
980	GlRendererWidget::SetVisibilityFilterSize(int number)
981	{
982	if (mViewCellsManager)
983	mViewCellsManager->SetMaxFilterSize(number);
984	updateGL();
985	}
986
987	void
988	GlRendererWidget::SetSceneCut(int number)
989	{
990	// assume the cut plane can only be aligned with xz plane
991	// shift it along y according to number, which is percentage of the bounding
992	// box position
993	if (mViewCellsManager) {
994	AxisAlignedBox3 box = mViewCellsManager->GetViewSpaceBox();
995	Vector3 p = box.Min() + (number/1000.0f)*box.Max();
996	mSceneCutPlane.mNormal = Vector3(0,-1,0);
997	mSceneCutPlane.mD = -DotProd(mSceneCutPlane.mNormal, p);
998	updateGL();
999	}
1000	}
1001
1002	void
1003	GlRendererWidget::SetTopDistance(int number)
1004	{
1005	mTopDistance = number/1000.0f;
1006	updateGL();
1007	}
1008
1009	void
1010	GlRendererWidget::RenderViewCells()
1011	{
1012	mUseFalseColors = true;
1013
1014	SetupCamera();
1015	glEnable(GL_CULL_FACE);
1016	//glDisable(GL_CULL_FACE);
1017	glCullFace(GL_FRONT);
1018	double eq[4];
1019	eq[0] = mSceneCutPlane.mNormal.x;
1020	eq[1] = mSceneCutPlane.mNormal.y;
1021	eq[2] = mSceneCutPlane.mNormal.z;
1022	eq[3] = mSceneCutPlane.mD;
1023
1024	if (mCutViewCells) {
1025	glClipPlane(GL_CLIP_PLANE0, eq);
1026	glEnable(GL_CLIP_PLANE0);
1027	}
1028
1029	int i;
1030	ViewCellContainer &viewcells = mViewCellsManager->GetViewCells();
1031	for (i=0; i < viewcells.size(); i++) {
1032	ViewCell *vc = viewcells[i];
1033	// Mesh *m = vc->GetMesh();
1034	RgbColor c = vc->GetColor();
1035	glColor3f(c.r, c.g, c.b);
1036	RenderViewCell(vc);
1037	}
1038
1039	glDisable(GL_CLIP_PLANE0);
1040
1041	}
1042
1043	void GlRendererBuffer::SampleBeamContributions(Intersectable *sourceObject,
1044	Beam &beam,
1045	const int desiredSamples,
1046	BeamSampleStatistics &stat)
1047	{
1048	// TODO: should be moved out of here (not to be done every time)
1049	// only back faces are interesting for the depth pass
1050	glShadeModel(GL_FLAT);
1051	glDisable(GL_LIGHTING);
1052
1053	// needed to kill the fragments for the front buffer
1054	glEnable(GL_ALPHA_TEST);
1055	glAlphaFunc(GL_GREATER, 0);
1056
1057	// assumes that the beam is constructed and contains kd-tree nodes
1058	// and viewcells which it intersects
1059
1060
1061	// Get the number of viewpoints to be sampled
1062	// Now it is a sqrt but in general a wiser decision could be made.
1063	// The less viewpoints the better for rendering performance, since less passes
1064	// over the beam is needed.
1065	// The viewpoints could actually be generated outside of the bounding box which
1066	// would distribute the 'efective viewpoints' of the object surface and thus
1067	// with a few viewpoints better sample the viewpoint space....
1068
1069	//TODO: comment in
1070	//int viewPointSamples = sqrt((float)desiredSamples);
1071	int viewPointSamples = max(desiredSamples / (GetWidth() * GetHeight()), 1);
1072
1073	// the number of direction samples per pass is given by the number of viewpoints
1074	int directionalSamples = desiredSamples / viewPointSamples;
1075
1076	Debug << "directional samples: " << directionalSamples << endl;
1077	for (int i = 0; i < viewPointSamples; ++ i)
1078	{
1079	Vector3 viewPoint = beam.mBox.GetRandomPoint();
1080
1081	// perhaps the viewpoint should be shifted back a little bit so that it always lies
1082	// inside the source object
1083	// 'ideally' the viewpoints would be distributed on the soureObject surface, but this
1084	// would require more complicated sampling (perhaps hierarchical rejection sampling of
1085	// the object surface is an option here - only the mesh faces which are inside the box
1086	// are considered as candidates)
1087
1088	SampleViewpointContributions(sourceObject,
1089	viewPoint,
1090	beam,
1091	directionalSamples,
1092	stat);
1093	}
1094
1095
1096	// note:
1097	// this routine would be called only if the number of desired samples is sufficiently
1098	// large - for other rss tree cells the cpu based sampling is perhaps more efficient
1099	// distributing the work between cpu and gpu would also allow us to place more sophisticated
1100	// sample distributions (silhouette ones) using the cpu and the jittered once on the GPU
1101	// in order that thios scheme is working well the gpu render buffer should run in a separate
1102	// thread than the cpu sampler, which would not be such a big problem....
1103
1104	// disable alpha test again
1105	glDisable(GL_ALPHA_TEST);
1106	}
1107
1108
1109	void GlRendererBuffer::SampleViewpointContributions(Intersectable *sourceObject,
1110	const Vector3 viewPoint,
1111	Beam &beam,
1112	const int samples,
1113	BeamSampleStatistics &stat)
1114	{
1115	// 1. setup the view port to match the desired samples
1116	glViewport(0, 0, samples, samples);
1117
1118	// 2. setup the projection matrix and view matrix to match the viewpoint + beam.mDirBox
1119	SetupProjectionForViewPoint(viewPoint, beam, sourceObject);
1120
1121
1122	// 3. reset z-buffer to 0 and render the source object for the beam
1123	// with glCullFace(Enabled) and glFrontFace(GL_CW)
1124	// save result to the front depth map
1125	// the front depth map holds ray origins
1126
1127
1128	// front depth buffer must be initialised to 0
1129	float clearDepth;
1130
1131	glGetFloatv(GL_DEPTH_CLEAR_VALUE, &clearDepth);
1132	glClearDepth(0.0f);
1133	glClear(GL_COLOR_BUFFER_BIT \| GL_DEPTH_BUFFER_BIT \| GL_STENCIL_BUFFER_BIT);
1134
1135
1136	//glFrontFace(GL_CW);
1137	glEnable(GL_CULL_FACE);
1138	glCullFace(GL_FRONT);
1139	glColorMask(0, 0, 0, 0);
1140
1141
1142	// stencil is increased where the source object is located
1143	glEnable(GL_STENCIL_TEST);
1144	glStencilFunc(GL_ALWAYS, 0x1, 0x1);
1145	glStencilOp(GL_REPLACE, GL_REPLACE, GL_REPLACE);
1146
1147
1148	#if 0
1149	static int glSourceObjList = -1;
1150	if (glSourceObjList != -1)
1151	{
1152	glSourceObjList = glGenLists(1);
1153	glNewList(glSourceObjList, GL_COMPILE);
1154
1155	RenderIntersectable(sourceObject);
1156
1157	glEndList();
1158	}
1159	glCallList(glSourceObjList);
1160
1161	#else
1162	RenderIntersectable(sourceObject);
1163
1164	#endif
1165
1166	// copy contents of the front depth buffer into depth texture
1167	glBindTexture(GL_TEXTURE_2D, frontDepthMap);
1168	glCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0, depthMapSize, depthMapSize);
1169
1170
1171	// reset clear function
1172	glClearDepth(clearDepth);
1173
1174
1175
1176	// 4. set up the termination depth buffer (= standard depth buffer)
1177	// only rays which have non-zero entry in the origin buffer are valid since
1178	// they realy start on the object surface (this is tagged by setting a
1179	// stencil buffer bit at step 3).
1180
1181	glStencilFunc(GL_EQUAL, 0x1, 0x1);
1182	glStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);
1183
1184	glClear(GL_COLOR_BUFFER_BIT \| GL_DEPTH_BUFFER_BIT);
1185	glDepthMask(1);
1186
1187	glEnable(GL_DEPTH_TEST);
1188
1189	glEnable(GL_CULL_FACE);
1190	glCullFace(GL_BACK);
1191
1192	// setup front depth buffer
1193	glEnable(GL_TEXTURE_2D);
1194
1195	// bind pixel shader implementing the front depth buffer functionality
1196	cgGLBindProgram(sCgFragmentProgram);
1197	cgGLEnableProfile(sCgFragmentProfile);
1198
1199
1200	// 5. render all objects inside the beam
1201	// we can use id based false color to read them back for gaining the pvs
1202
1203	glColorMask(1, 1, 1, 1);
1204
1205
1206	// if objects not stored in beam => extract objects
1207	if (beam.mFlags & !Beam::STORE_OBJECTS)
1208	{
1209	vector<KdNode *>::const_iterator it, it_end = beam.mKdNodes.end();
1210
1211	Intersectable::NewMail();
1212	for (it = beam.mKdNodes.begin(); it != it_end; ++ it)
1213	{
1214	mKdTree->CollectObjects(*it, beam.mObjects);
1215	}
1216	}
1217
1218
1219	// (objects can be compiled to a gl list now so that subsequent rendering for
1220	// this beam is fast - the same hold for step 3)
1221	// Afterwards we have two depth buffers defining the ray origin and termination
1222
1223
1224	#if 0
1225	static int glObjList = -1;
1226	if (glObjList != -1)
1227	{
1228	glObjList = glGenLists(1);
1229	glNewList(glObjList, GL_COMPILE);
1230
1231	ObjectContainer::const_iterator it, it_end = beam.mObjects.end();
1232	for (it = beam.mObjects.begin(); it != it_end; ++ it)
1233	{
1234	// render all objects except the source object
1235	if (*it != sourceObject)
1236	RenderIntersectable(*it);
1237	}
1238
1239	glEndList();
1240	}
1241
1242	glCallList(glObjList);
1243	#else
1244	ObjectContainer::const_iterator it, it_end = beam.mObjects.end();
1245	for (it = beam.mObjects.begin(); it != it_end; ++ it)
1246	{
1247	// render all objects except the source object
1248	if (*it != sourceObject)
1249	RenderIntersectable(*it);
1250	}
1251	#endif
1252
1253
1254
1255	// 6. Use occlusion queries for all viewcell meshes associated with the beam ->
1256	// a fragment passes if the corresponding stencil fragment is set and its depth is
1257	// between origin and termination buffer
1258
1259	// create new queries if necessary
1260	GenQueries((int)beam.mViewCells.size());
1261
1262	// check whether any backfacing polygon would pass the depth test?
1263	// matt: should check both back /front facing because of dual depth buffer
1264	// and danger of cutting the near plane with front facing polys.
1265
1266	glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
1267	glDepthMask(GL_FALSE);
1268	glDisable(GL_CULL_FACE);
1269
1270
1271	ViewCellContainer::const_iterator vit, vit_end = beam.mViewCells.end();
1272
1273	int queryIdx = 0;
1274
1275	for (vit = beam.mViewCells.begin(); vit != vit_end; ++ vit)
1276	{
1277	glBeginOcclusionQueryNV(sQueries[queryIdx ++]);
1278
1279	RenderIntersectable(*vit);
1280
1281	glEndOcclusionQueryNV();
1282	}
1283
1284
1285
1286	// at this point, if possible, go and do some other computation
1287
1288
1289
1290	// 7. The number of visible pixels is the number of sample rays which see the source
1291	// object from the corresponding viewcell -> remember these values for later update
1292	// of the viewcell pvs - or update immediately?
1293
1294	queryIdx = 0;
1295	unsigned int pixelCount;
1296
1297	for (vit = beam.mViewCells.begin(); vit != vit_end; ++ vit)
1298	{
1299	// fetch queries
1300	glGetOcclusionQueryuivNV(sQueries[queryIdx ++],
1301	GL_PIXEL_COUNT_NV,
1302	&pixelCount);
1303	if (pixelCount)
1304	Debug << "view cell " << (*vit)->GetId() << " visible pixels: " << pixelCount << endl;
1305	}
1306
1307
1308	// 8. Copmpute rendering statistics
1309	// In general it is not neccessary to remember to extract all the rays cast. I hope it
1310	// would be sufficient to gain only the intergral statistics about the new contributions
1311	// and so the rss tree would actually store no new rays (only the initial ones)
1312	// the subdivision of the tree would only be driven by the statistics (the glrender could
1313	// evaluate the contribution entropy for example)
1314	// However might be an option to extract/store only those the rays which made a contribution
1315	// (new viewcell has been discovered) or relative contribution greater than a threshold ...
1316
1317	ObjectContainer pvsObj;
1318	stat.pvsSize = ComputePvs(beam.mObjects, pvsObj);
1319
1320	// to gain ray source and termination
1321	// copy contents of ray termination buffer into depth texture
1322	// and compare with ray source buffer
1323	#if 0
1324	VssRayContainer rays;
1325
1326	glBindTexture(GL_TEXTURE_2D, backDepthMap);
1327	glCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0, depthMapSize, depthMapSize);
1328
1329	ComputeRays(Intersectable *sourceObj, rays);
1330
1331	#endif
1332
1333
1334
1335	//-- cleanup
1336
1337
1338	// reset gl state
1339	glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
1340	glDepthMask(GL_TRUE);
1341	glEnable(GL_CULL_FACE);
1342	glDisable(GL_STENCIL_TEST);
1343	cgGLDisableProfile(sCgFragmentProfile);
1344	glDisable(GL_TEXTURE_2D);
1345
1346	// remove objects from beam
1347	if (beam.mFlags & !Beam::STORE_OBJECTS)
1348	beam.mObjects.clear();
1349	}
1350
1351
1352	void GlRendererBuffer::GenQueries(const int numQueries)
1353	{
1354	if ((int)sQueries.size() < numQueries)
1355	{
1356	const int n = numQueries - (int)sQueries.size();
1357	unsigned int *newQueries = new unsigned int[n];
1358
1359	glGenOcclusionQueriesNV(n, (unsigned int *)newQueries);
1360
1361	for (int i = 0; i < n; ++ i)
1362	{
1363	sQueries.push_back(newQueries[i]);
1364	}
1365
1366	delete [] newQueries;
1367	}
1368	}
1369
1370
1371	void GlRendererBuffer::SetupProjectionForViewPoint(const Vector3 &viewPoint,
1372	const Beam &beam,
1373	Intersectable *sourceObject)
1374	{
1375	float left, right, bottom, top, znear, zfar;
1376
1377	beam.ComputePerspectiveFrustum(left, right, bottom, top, znear, zfar,
1378	mSceneGraph->GetBox());
1379
1380	//Debug << left << " " << right << " " << bottom << " " << top << " " << znear << " " << zfar << endl;
1381	glMatrixMode(GL_PROJECTION);
1382	glLoadIdentity();
1383	glFrustum(left, right, bottom, top, znear, zfar);
1384	//glFrustum(-1, 1, -1, 1, 1, 20000);
1385
1386	const Vector3 center = viewPoint + beam.GetMainDirection() * (zfar - znear) * 0.3f;
1387	const Vector3 up =
1388	Normalize(CrossProd(beam.mPlanes[0].mNormal, beam.mPlanes[4].mNormal));
1389
1390	#ifdef _DEBUG
1391	Debug << "view point: " << viewPoint << endl;
1392	Debug << "eye: " << center << endl;
1393	Debug << "up: " << up << endl;
1394	#endif
1395
1396	glMatrixMode(GL_MODELVIEW);
1397	glLoadIdentity();
1398	gluLookAt(viewPoint.x, viewPoint.y, viewPoint.z,
1399	center.x, center.y, center.z,
1400	up.x, up.y, up.z);
1401	}
1402
1403
1404	void GlRendererBuffer::InitGL()
1405	{
1406	makeCurrent();
1407	GlRenderer::InitGL();
1408	#if 1
1409	// initialise dual depth buffer textures
1410	glGenTextures(1, &frontDepthMap);
1411	glBindTexture(GL_TEXTURE_2D, frontDepthMap);
1412
1413	glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT, depthMapSize,
1414	depthMapSize, 0, GL_DEPTH_COMPONENT, GL_UNSIGNED_BYTE, NULL);
1415	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
1416	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
1417	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
1418	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
1419
1420	glGenTextures(1, &backDepthMap);
1421	glBindTexture(GL_TEXTURE_2D, backDepthMap);
1422
1423	glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT, depthMapSize,
1424	depthMapSize, 0, GL_DEPTH_COMPONENT, GL_UNSIGNED_BYTE, NULL);
1425	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
1426	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
1427	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
1428	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
1429
1430	// cg initialization
1431	cgSetErrorCallback(handleCgError);
1432	sCgContext = cgCreateContext();
1433
1434	if (cgGLIsProfileSupported(CG_PROFILE_ARBFP1))
1435	sCgFragmentProfile = CG_PROFILE_ARBFP1;
1436	else
1437	{
1438	// try FP30
1439	if (cgGLIsProfileSupported(CG_PROFILE_FP30))
1440	sCgFragmentProfile = CG_PROFILE_FP30;
1441	else
1442	{
1443	Debug << "Neither arbfp1 or fp30 fragment profiles supported on this system" << endl;
1444	exit(1);
1445	}
1446	}
1447
1448
1449	sCgFragmentProgram = cgCreateProgramFromFile(sCgContext,
1450	CG_SOURCE, "../src/dual_depth.cg",
1451	sCgFragmentProfile,
1452	NULL,
1453	NULL);
1454
1455	if (!cgIsProgramCompiled(sCgFragmentProgram))
1456	cgCompileProgram(sCgFragmentProgram);
1457
1458	cgGLLoadProgram(sCgFragmentProgram);
1459	cgGLBindProgram(sCgFragmentProgram);
1460
1461	Debug << "---- PROGRAM BEGIN ----\n" <<
1462	cgGetProgramString(sCgFragmentProgram, CG_COMPILED_PROGRAM) << "---- PROGRAM END ----\n";
1463
1464	#endif
1465	doneCurrent();
1466	}
1467
1468
1469	void GlRendererBuffer::ComputeRays(Intersectable *sourceObj, VssRayContainer &rays)
1470	{
1471	for (int i = 0; i < depthMapSize * depthMapSize; ++ i)
1472	{
1473	//todo glGetTexImage()
1474	}
1475	}
1476
1477
1478
1479	inline bool ilt(Intersectable obj1, Intersectable obj2)
1480	{
1481	return obj1->mId < obj2->mId;
1482	}
1483
1484
1485	int GlRendererBuffer::ComputePvs(ObjectContainer &objects,
1486	ObjectContainer &pvs) const
1487	{
1488	int pvsSize = 0;
1489	QImage image = toImage();
1490	Intersectable::NewMail();
1491
1492	std::stable_sort(objects.begin(), objects.end(), ilt);
1493
1494	MeshInstance dummy(NULL);
1495
1496	Intersectable *obj = NULL;
1497
1498	for (int x = 0; x < image.width(); ++ x)
1499	{
1500	for (int y = 0; y < image.height(); ++ y)
1501	{
1502	QRgb pix = image.pixel(x, y);
1503	const int id = GetId(qRed(pix), qGreen(pix), qBlue(pix));
1504
1505	dummy.SetId(id);
1506
1507	ObjectContainer::iterator oit =
1508	lower_bound(objects.begin(), objects.end(), &dummy, ilt);
1509
1510
1511	if (//(oit != oit.end()) &&
1512	((*oit)->GetId() == id) &&
1513	!obj->Mailed())
1514	{
1515	obj = *oit;
1516	obj->Mail();
1517	++ pvsSize;
1518	pvs.push_back(obj);
1519	}
1520	}
1521	}
1522
1523	return pvsSize;
1524	}
1525
1526	/***********************************************************************/
1527	/* GlDebuggerWidget implementation */
1528	/***********************************************************************/
1529
1530
1531	GlDebuggerWidget::GlDebuggerWidget(GlRendererBuffer buf, QWidget parent)
1532	: QGLWidget(QGLFormat(QGL::SampleBuffers), parent), mRenderBuffer(buf)
1533	{
1534	// create the pbuffer
1535	//pbuffer = new QGLPixelBuffer(QSize(512, 512), format(), this);
1536	timerId = startTimer(20);
1537	setWindowTitle(("OpenGL pbuffers"));
1538	}
1539
1540
1541	GlDebuggerWidget::~GlDebuggerWidget()
1542	{
1543	mRenderBuffer->releaseFromDynamicTexture();
1544	glDeleteTextures(1, &dynamicTexture);
1545
1546	DEL_PTR(mRenderBuffer);
1547	}
1548
1549
1550	void GlDebuggerWidget::initializeGL()
1551	{
1552	glMatrixMode(GL_PROJECTION);
1553	glLoadIdentity();
1554
1555	glFrustum(-1, 1, -1, 1, 10, 100);
1556	glTranslatef(-0.5f, -0.5f, -0.5f);
1557	glTranslatef(0.0f, 0.0f, -15.0f);
1558	glMatrixMode(GL_MODELVIEW);
1559
1560	glEnable(GL_CULL_FACE);
1561	initCommon();
1562	initPbuffer();
1563
1564	}
1565
1566
1567	void GlDebuggerWidget::resizeGL(int w, int h)
1568	{
1569	glViewport(0, 0, w, h);
1570	}
1571
1572
1573	void GlDebuggerWidget::paintGL()
1574	{
1575	// draw a spinning cube into the pbuffer..
1576	mRenderBuffer->makeCurrent();
1577
1578	BeamSampleStatistics stats;
1579	mRenderBuffer->SampleBeamContributions(mSourceObject, mBeam, mSamples, stats);
1580
1581	glFlush();
1582
1583	// rendering directly to a texture is not supported on X11, unfortunately
1584	mRenderBuffer->updateDynamicTexture(dynamicTexture);
1585
1586	// and use the pbuffer contents as a texture when rendering the
1587	// background and the bouncing cubes
1588	makeCurrent();
1589	glBindTexture(GL_TEXTURE_2D, dynamicTexture);
1590	glClear(GL_COLOR_BUFFER_BIT \| GL_DEPTH_BUFFER_BIT);
1591
1592	// draw the background
1593	glMatrixMode(GL_MODELVIEW);
1594	glPushMatrix();
1595	glLoadIdentity();
1596	glMatrixMode(GL_PROJECTION);
1597	glPushMatrix();
1598	glLoadIdentity();
1599
1600	glPopMatrix();
1601	glMatrixMode(GL_MODELVIEW);
1602	glPopMatrix();
1603	}
1604
1605
1606	void GlDebuggerWidget::initPbuffer()
1607	{
1608	// set up the pbuffer context
1609	mRenderBuffer->makeCurrent();
1610	/*mRenderBuffer->InitGL();
1611
1612	glViewport(0, 0, mRenderBuffer->size().width(), mRenderBuffer->size().height());
1613	glMatrixMode(GL_PROJECTION);
1614	glLoadIdentity();
1615	glOrtho(-1, 1, -1, 1, -99, 99);
1616	glTranslatef(-0.5f, -0.5f, 0.0f);
1617	glMatrixMode(GL_MODELVIEW);
1618	glLoadIdentity();
1619
1620	glClear(GL_DEPTH_BUFFER_BIT \| GL_COLOR_BUFFER_BIT);*/
1621
1622	// generate a texture that has the same size/format as the pbuffer
1623	dynamicTexture = mRenderBuffer->generateDynamicTexture();
1624
1625	// bind the dynamic texture to the pbuffer - this is a no-op under X11
1626	mRenderBuffer->bindToDynamicTexture(dynamicTexture);
1627	makeCurrent();
1628	}
1629
1630	void GlDebuggerWidget::initCommon()
1631	{
1632	glEnable(GL_TEXTURE_2D);
1633	glEnable(GL_DEPTH_TEST);
1634
1635	glClearColor(1.0f, 1.0f, 1.0f, 1.0f);
1636	}

Note: See TracBrowser for help on using the repository browser.

Download in other formats: