Debian Codegraph @

src/vcglib/wrap/gl/splatting_apss/splatrenderer.h

raw
1 /****************************************************************************
2 * MeshLab o o *
3 * A versatile mesh processing toolbox o o *
4 * _ O _ *
5 * Copyright(C) 2005 \/)\/ *
6 * Visual Computing Lab /\/| *
7 * ISTI - Italian National Research Council | *
8 * \ *
9 * All rights reserved. *
10 * *
11 * This program is free software; you can redistribute it and/or modify *
12 * it under the terms of the GNU General Public License as published by *
13 * the Free Software Foundation; either version 2 of the License, or *
14 * (at your option) any later version. *
15 * *
16 * This program is distributed in the hope that it will be useful, *
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
19 * GNU General Public License (http://www.gnu.org/licenses/gpl.txt) *
20 * for more details. *
21 * *
22 ****************************************************************************/
23
24 #ifndef SPLATRENDERER_H
25 #define SPLATRENDERER_H
26
27 #include <QObject>
28 #include <QTextStream>
29 #include <QFile>
30 #include <wrap/gl/trimesh.h>
31 #include <wrap/gl/shaders.h>
32 #include <wrap/gl/trimesh.h>
33 #include <QGLFramebufferObject>
34 #include <vcg/complex/complex.h>
35 #define GL_TEST_ERR\
36 {\
37 GLenum eCode;\
38 if((eCode=glGetError())!=GL_NO_ERROR)\
39 std::cerr << "OpenGL error : " << gluErrorString(eCode) << " in " << __FILE__ << " : " << __LINE__ << std::endl;\
40 }
41
42 class QGLFramebufferObject;
43
44 /*
45 Rendering with Algebraic Point Set Surfaces, by Gael Guennebaud.
46 paper: Algebraic Point Set Surfaces SIGGRAPH '07
47 */
48 template <class MeshType>
49 class SplatRenderer
50 {
51 bool mIsSupported;
52 bool init_called;
53
54 enum {
55 DEFERRED_SHADING_BIT = 0x000001,
56 DEPTH_CORRECTION_BIT = 0x000002,
57 OUTPUT_DEPTH_BIT = 0x000004,
58 BACKFACE_SHADING_BIT = 0x000008,
59 FLOAT_BUFFER_BIT = 0x000010
60 };
61 int mFlags;
62 int mCachedFlags;
63 int mRenderBufferMask;
64 int mSupportedMask;
65
66 //int mCurrentPass;
67 int mBindedPass;
68 GLuint mDummyTexId; // on ATI graphics card we need to bind a texture to get point sprite working !
69 bool mWorkaroundATI;
70 bool mBuggedAtiBlending;
71 GLuint mNormalTextureID;
72 GLuint mDepthTextureID;
73 ProgramVF mShaders[3];
74 QString mShaderSrcs[6];
75 QGLFramebufferObject* mRenderBuffer;
76 float mCachedMV[16];
77 float mCachedProj[16];
78 GLint mCachedVP[4];
79
80 struct UniformParameters
81 {
82 float radiusScale;
83 float preComputeRadius;
84 float depthOffset;
85 float oneOverEwaRadius;
86 vcg::Point2f halfVp;
87 vcg::Point3f rayCastParameter1;
88 vcg::Point3f rayCastParameter2;
89 vcg::Point2f depthParameterCast;
90
91 void loadTo(Program& prg);
92 void update(float* mv, float* proj, GLint* vp);
93 };
94
95 UniformParameters mParams;
96
97 QString loadSource(const QString& func,const QString& file);
98 void configureShaders();
99 void updateRenderBuffer();
100 void enablePass(int n);
101 void drawSplats(std::vector<MeshType*> & , vcg::GLW::ColorMode cm, vcg::GLW::TextureMode tm);
102 void drawSplats(
103 std::vector< std::vector<vcg::Point3f> * > & positions,
104 std::vector< std::vector<vcg::Point3f> * > & normals,
105 std::vector< std::vector<vcg::Point3<unsigned char> > * > & colors,
106 std::vector<float> & radius,
107 vcg::GLW::ColorMode cm, vcg::GLW::TextureMode tm);
108
109
110 public:
111
112 void Clear();
113 void Destroy();
114 bool isSupported() {return mIsSupported;}
115 void Init(QGLWidget *gla);
116 void Render( std::vector<MeshType*> &meshes, vcg::GLW::ColorMode cm, vcg::GLW::TextureMode tm);
117
118 void Render(
119 std::vector< std::vector<vcg::Point3f> * > & positions,
120 std::vector< std::vector<vcg::Point3f> * > & normals,
121 std::vector< std::vector<vcg::Point3<unsigned char> > * > & colors,
122 std::vector<float> & radius,
123 vcg::GLW::ColorMode cm, vcg::GLW::TextureMode tm);
124
125 };// end class
126
127 template <class MeshType>
128 void SplatRenderer<MeshType>:: Destroy(){
129 delete mRenderBuffer;
130 mRenderBuffer = 0;
131 glDeleteTextures(1,&mDepthTextureID);
132 glDeleteTextures(1,&mNormalTextureID);
133 for(int i = 0; i < 3; ++i)
134 this->mShaders[i].prog.Del();
135
136 Clear();
137 }
138
139 template <class MeshType>
140 void SplatRenderer<MeshType>::Clear()
141 {
142 mNormalTextureID = 0;
143 mDepthTextureID = 0;
144 mIsSupported = false;
145 mRenderBuffer = 0;
146 mWorkaroundATI = false;
147 mBuggedAtiBlending = false;
148 mDummyTexId = 0;
149
150 mFlags = DEFERRED_SHADING_BIT | DEPTH_CORRECTION_BIT | FLOAT_BUFFER_BIT | OUTPUT_DEPTH_BIT;
151 mCachedFlags = ~mFlags;
152 // union of bits which controls the render buffer
153 mRenderBufferMask = DEFERRED_SHADING_BIT | FLOAT_BUFFER_BIT;
154
155 init_called = false;
156 }
157
158
159 template <class MeshType>
160 QString SplatRenderer<MeshType>::loadSource(const QString& func,const QString& filename)
161 {
162 QString res;
163 QFile f(":/SplatRenderer/shaders/" + filename);
164 if (!f.open(QFile::ReadOnly))
165 {
166 std::cerr << "failed to load shader file " << filename.toUtf8().data() << "\n";
167 return res;
168 }
169 else qDebug("Succesfully loaded shader func '%s' in file '%s'",qPrintable(func),qPrintable(filename));
170 QTextStream stream(&f);
171 res = stream.readAll();
172 f.close();
173 res = QString("#define __%1__ 1\n").arg(func)
174 + QString("#define %1 main\n").arg(func)
175 + res;
176 return res;
177 }
178 template <class MeshType>
179 void SplatRenderer<MeshType>::configureShaders()
180 {
181 const char* passNames[3] = {"Visibility","Attribute","Finalization"};
182 QString defines = "";
183 if (mFlags & DEFERRED_SHADING_BIT)
184 defines += "#define EXPE_DEFERRED_SHADING\n";
185 if (mFlags & DEPTH_CORRECTION_BIT)
186 defines += "#define EXPE_DEPTH_CORRECTION\n";
187 if (mFlags & OUTPUT_DEPTH_BIT)
188 defines += "#define EXPE_OUTPUT_DEPTH 1\n";
189 if (mFlags & BACKFACE_SHADING_BIT)
190 defines += "#define EXPE_BACKFACE_SHADING\n";
191 if (mWorkaroundATI)
192 defines += "#define EXPE_ATI_WORKAROUND\n";
193
194 QString shading =
195 "vec4 meshlabLighting(vec4 color, vec3 eyePos, vec3 normal)"
196 "{"
197 " normal = normalize(normal);"
198 " vec3 lightVec = normalize(gl_LightSource[0].position.xyz);"
199 " vec3 halfVec = normalize( lightVec - normalize(eyePos) );"
200 " float aux_dot = dot(normal,lightVec);"
201 " float diffuseCoeff = clamp(aux_dot, 0.0, 1.0);"
202 " float specularCoeff = aux_dot>0.0 ? clamp(pow(clamp(dot(halfVec, normal),0.0,1.0),gl_FrontMaterial.shininess), 0.0, 1.0) : 0.0;"
203 " return vec4(color.rgb * ( gl_FrontLightProduct[0].ambient.rgb + diffuseCoeff * gl_FrontLightProduct[0].diffuse.rgb) + specularCoeff * gl_FrontLightProduct[0].specular.rgb, 1.0);"
204 "}\n";
205
206 for (int k=0;k<3;++k)
207 {
208 QString vsrc = shading + defines + mShaderSrcs[k*2+0];
209 QString fsrc = shading + defines + mShaderSrcs[k*2+1];
210 mShaders[k].SetSources(mShaderSrcs[k*2+0]!="" ? vsrc.toUtf8().data() : 0,
211 mShaderSrcs[k*2+1]!="" ? fsrc.toUtf8().data() : 0);
212 mShaders[k].prog.Link();
213 if (mShaderSrcs[k*2+0]!="")
214 {
215 std::string compileinfo = mShaders[k].vshd.InfoLog();
216 if (compileinfo.size()>0)
217 std::cout << "Vertex shader info (" << passNames[k] << ":\n" << compileinfo << "\n";
218 }
219 if (mShaderSrcs[k*2+1]!="")
220 {
221 std::string compileinfo = mShaders[k].fshd.InfoLog();
222 if (compileinfo.size()>0)
223 std::cout << "Fragment shader info (" << passNames[k] << ":\n" << compileinfo << "\n";
224 }
225 std::string linkinfo = mShaders[k].prog.InfoLog();
226 if (linkinfo.size()>0)
227 std::cout << "Link info (" << passNames[k] << ":\n" << linkinfo << "\n";
228 }
229 }
230
231 template <class MeshType>
232 void SplatRenderer<MeshType>::Init(QGLWidget *gla)
233 {
234
235 mIsSupported = true;
236 gla->makeCurrent();
237 // FIXME this should be done in meshlab !!! ??
238 glewInit();
239
240 const char* rs = (const char*)glGetString(GL_RENDERER);
241 QString rendererString("");
242 if(rs)
243 rendererString = QString(rs);
244 mWorkaroundATI = rendererString.startsWith("ATI") || rendererString.startsWith("AMD");
245 // FIXME: maybe some recent HW correctly supports floating point blending...
246 mBuggedAtiBlending = rendererString.startsWith("ATI") || rendererString.startsWith("AMD");
247
248 if (mWorkaroundATI && mDummyTexId==0)
249 {
250 glActiveTexture(GL_TEXTURE0);
251 glGenTextures(1,&mDummyTexId);
252 glBindTexture(GL_TEXTURE_2D, mDummyTexId);
253 glTexImage2D(GL_TEXTURE_2D, 0, GL_LUMINANCE, 4, 4, 0, GL_LUMINANCE, GL_UNSIGNED_BYTE, 0);
254 }
255
256 // let's check the GPU capabilities
257 mSupportedMask = DEPTH_CORRECTION_BIT | BACKFACE_SHADING_BIT;
258 if (!QGLFramebufferObject::hasOpenGLFramebufferObjects ())
259 {
260 mIsSupported = false;
261 return;
262 }
263 if (GLEW_ARB_texture_float)
264 mSupportedMask |= FLOAT_BUFFER_BIT;
265 else
266 std::cout << "Splatting: warning floating point textures are not supported.\n";
267
268 if (GLEW_ARB_draw_buffers && (!mBuggedAtiBlending))
269 mSupportedMask |= DEFERRED_SHADING_BIT;
270 else
271 std::cout << "Splatting: warning deferred shading is not supported.\n";
272
273 if (GLEW_ARB_shadow)
274 mSupportedMask |= OUTPUT_DEPTH_BIT;
275 else
276 std::cerr << "Splatting: warning copy of the depth buffer is not supported.\n";
277
278 mFlags = mFlags & mSupportedMask;
279
280 // load shader source
281 mShaderSrcs[0] = loadSource("VisibilityVP","Raycasting.glsl");
282 mShaderSrcs[1] = loadSource("VisibilityFP","Raycasting.glsl");
283 mShaderSrcs[2] = loadSource("AttributeVP","Raycasting.glsl");
284 mShaderSrcs[3] = loadSource("AttributeFP","Raycasting.glsl");
285 mShaderSrcs[4] = "";
286 mShaderSrcs[5] = loadSource("Finalization","Finalization.glsl");
287
288 //mCurrentPass = 2;
289 mBindedPass = -1;
290 GL_TEST_ERR
291 }
292
293 template <class MeshType>
294 void SplatRenderer<MeshType>::updateRenderBuffer()
295 {
296 if ( (!mRenderBuffer)
297 || (mRenderBuffer->width()!=mCachedVP[2])
298 || (mRenderBuffer->height()!=mCachedVP[3])
299 || ( (mCachedFlags & mRenderBufferMask) != (mFlags & mRenderBufferMask) ))
300 {
301 delete mRenderBuffer;
302 GLenum fmt = (mFlags&FLOAT_BUFFER_BIT) ? GL_RGBA16F_ARB : GL_RGBA;
303 mRenderBuffer = new QGLFramebufferObject(mCachedVP[2], mCachedVP[3],
304 (mFlags&OUTPUT_DEPTH_BIT) ? QGLFramebufferObject::NoAttachment : QGLFramebufferObject::Depth,
305 GL_TEXTURE_RECTANGLE_ARB, fmt);
306
307 if (!mRenderBuffer->isValid())
308 {
309 std::cout << "SplatRenderer: invalid FBO\n";
310 }
311
312 GL_TEST_ERR
313 if (mFlags&DEFERRED_SHADING_BIT)
314 {
315 // in deferred shading mode we need an additional buffer to accumulate the normals
316 if (mNormalTextureID==0)
317 glGenTextures(1,&mNormalTextureID);
318 glBindTexture(GL_TEXTURE_RECTANGLE_ARB, mNormalTextureID);
319 glTexImage2D(GL_TEXTURE_RECTANGLE_ARB, 0, fmt, mCachedVP[2], mCachedVP[3], 0, GL_RGBA, GL_FLOAT, 0);
320 glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
321 glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
322 mRenderBuffer->bind();
323 glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT1_EXT, GL_TEXTURE_RECTANGLE_ARB, mNormalTextureID, 0);
324 mRenderBuffer->release();
325 GL_TEST_ERR
326 }
327
328 if (mFlags&OUTPUT_DEPTH_BIT)
329 {
330 // to output the depth values to the final depth buffer we need to
331 // attach a depth buffer as a texture
332 if (mDepthTextureID==0)
333 glGenTextures(1,&mDepthTextureID);
334 glBindTexture(GL_TEXTURE_RECTANGLE_ARB, mDepthTextureID);
335 glTexImage2D(GL_TEXTURE_RECTANGLE_ARB, 0, GL_DEPTH_COMPONENT24_ARB, mCachedVP[2], mCachedVP[3], 0, GL_DEPTH_COMPONENT, GL_FLOAT, 0);
336 glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
337 glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
338 mRenderBuffer->bind();
339 glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_TEXTURE_RECTANGLE_ARB, mDepthTextureID, 0);
340 mRenderBuffer->release();
341 GL_TEST_ERR
342 }
343 }
344 }
345
346
347 template <class MeshType>
348 void SplatRenderer<MeshType>::Render(std::vector<MeshType*> & meshes, vcg::GLW::ColorMode cm, vcg::GLW::TextureMode tm )
349 {
350 if(meshes.empty()) return;
351
352 GL_TEST_ERR
353
354 /*************** First Pass ***********/
355 // this is the first pass of the frame, so let's update the shaders, buffers, etc...
356 glGetIntegerv(GL_VIEWPORT, mCachedVP);
357 glGetFloatv(GL_MODELVIEW_MATRIX, mCachedMV);
358 glGetFloatv(GL_PROJECTION_MATRIX, mCachedProj);
359
360 updateRenderBuffer();
361 if (mCachedFlags != mFlags)
362 configureShaders();
363
364 mCachedFlags = mFlags;
365
366 mParams.update(mCachedMV, mCachedProj, mCachedVP);
367 //float s = meshes[0]->glw.GetHintParamf(vcg::GLW::HNPPointSize);
368 //if (s>1)
369 // s = pow(s,0.3f);
370 float s = 1.f;
371 mParams.radiusScale *= s;
372
373 // FIXME since meshlab does not set any material properties, let's define some here
374 glDisable(GL_COLOR_MATERIAL);
375 glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, 64);
376 glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, vcg::Point4f(0.3, 0.3, 0.3, 1.).V());
377 glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, vcg::Point4f(0.6, 0.6, 0.6, 1.).V());
378 glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, vcg::Point4f(0.5, 0.5, 0.5, 1.).V());
379
380 mRenderBuffer->bind();
381 if (mFlags&DEFERRED_SHADING_BIT)
382 {
383 GLenum buf[2] = {GL_COLOR_ATTACHMENT0_EXT,GL_COLOR_ATTACHMENT1_EXT};
384 glDrawBuffersARB(2, buf);
385 }
386 glViewport(mCachedVP[0],mCachedVP[1],mCachedVP[2],mCachedVP[3]);
387 glClearColor(0,0,0,0);
388 glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
389
390 //* End Setup of first Pass Now a simple rendering of all the involved meshes.*/
391 mParams.loadTo(mShaders[0].prog);
392 enablePass(0);
393 drawSplats(meshes,cm,tm);
394
395 // begin second pass
396 mParams.loadTo(mShaders[1].prog);
397 enablePass(1);
398
399 drawSplats(meshes,cm,tm);
400
401 //* Start third Pass Setup */
402
403 // this is the last pass: normalization by the sum of weights + deferred shading
404 mRenderBuffer->release();
405 if (mFlags&DEFERRED_SHADING_BIT)
406 glDrawBuffer(GL_BACK);
407
408 enablePass(2);
409
410 // switch to normalized 2D rendering mode
411 glMatrixMode(GL_PROJECTION);
412 glPushMatrix();
413 glLoadIdentity();
414 glMatrixMode(GL_MODELVIEW);
415 glPushMatrix();
416 glLoadIdentity();
417
418 mShaders[2].prog.Uniform("viewport",float(mCachedVP[0]),float(mCachedVP[1]),float(mCachedVP[2]),float(mCachedVP[3]));
419 mShaders[2].prog.Uniform("ColorWeight",GLint(0)); // this is a texture unit
420 glActiveTexture(GL_TEXTURE0);
421 glBindTexture(GL_TEXTURE_RECTANGLE_ARB,mRenderBuffer->texture());
422
423 if (mFlags&DEFERRED_SHADING_BIT)
424 {
425 mShaders[2].prog.Uniform("unproj", mCachedProj[10], mCachedProj[14]);
426 mShaders[2].prog.Uniform("NormalWeight",GLint(1)); // this is a texture unit
427 glActiveTexture(GL_TEXTURE1);
428 glBindTexture(GL_TEXTURE_RECTANGLE_ARB,mNormalTextureID);
429 GL_TEST_ERR
430 }
431
432 if (mFlags&OUTPUT_DEPTH_BIT)
433 {
434 mShaders[2].prog.Uniform("Depth",GLint(2)); // this is a texture unit
435 glActiveTexture(GL_TEXTURE2);GL_TEST_ERR
436 glBindTexture(GL_TEXTURE_RECTANGLE_ARB,mDepthTextureID);GL_TEST_ERR
437 GL_TEST_ERR
438 }
439 else
440 {
441 glDisable(GL_DEPTH_TEST);
442 glDepthMask(GL_FALSE);
443 }
444
445 // draw a quad covering the whole screen
446 vcg::Point3f viewVec(1./mCachedProj[0], 1./mCachedProj[5], -1);
447
448 glBegin(GL_QUADS);
449 glColor3f(1, 0, 0);
450 glTexCoord3f(viewVec.X(),viewVec.Y(),viewVec.Z());
451 glMultiTexCoord2f(GL_TEXTURE1,1.,1.);
452 glVertex3f(1,1,0);
453
454 glColor3f(1, 1, 0);
455 glTexCoord3f(-viewVec.X(),viewVec.Y(),viewVec.Z());
456 glMultiTexCoord2f(GL_TEXTURE1,0.,1.);
457 glVertex3f(-1,1,0);
458
459 glColor3f(0, 1, 1);
460 glTexCoord3f(-viewVec.X(),-viewVec.Y(),viewVec.Z());
461 glMultiTexCoord2f(GL_TEXTURE1,0.,0.);
462 glVertex3f(-1,-1,0);
463
464 glColor3f(1, 0, 1);
465 glTexCoord3f(viewVec.X(),-viewVec.Y(),viewVec.Z());
466 glMultiTexCoord2f(GL_TEXTURE1,1.,0.);
467 glVertex3f(1,-1,0);
468 glEnd();
469 if (!(mFlags&OUTPUT_DEPTH_BIT))
470 {
471 glEnable(GL_DEPTH_TEST);
472 glDepthMask(GL_TRUE);
473 }
474
475 glUseProgram(0);
476
477 // restore matrices
478 glMatrixMode(GL_PROJECTION);
479 glPopMatrix();
480 glMatrixMode(GL_MODELVIEW);
481 glPopMatrix();
482
483 GL_TEST_ERR
484
485 }
486
487
488 template <class MeshType>
489 void SplatRenderer<MeshType>::Render(
490 std::vector< std::vector<vcg::Point3f> * > & positions,
491 std::vector< std::vector<vcg::Point3f> * > & normals,
492 std::vector< std::vector<vcg::Point3<unsigned char> > * > & colors,
493 std::vector<float> & radius, vcg::GLW::ColorMode cm, vcg::GLW::TextureMode tm )
494 {
495 if(positions.empty()) return;
496
497 GL_TEST_ERR
498
499 /*************** First Pass ***********/
500 // this is the first pass of the frame, so let's update the shaders, buffers, etc...
501 glGetIntegerv(GL_VIEWPORT, mCachedVP);
502 glGetFloatv(GL_MODELVIEW_MATRIX, mCachedMV);
503 glGetFloatv(GL_PROJECTION_MATRIX, mCachedProj);
504
505 updateRenderBuffer();
506 if (mCachedFlags != mFlags)
507 configureShaders();
508
509 mCachedFlags = mFlags;
510
511 mParams.update(mCachedMV, mCachedProj, mCachedVP);
512 //float s = meshes[0]->glw.GetHintParamf(vcg::GLW::HNPPointSize);
513 //if (s>1)
514 // s = pow(s,0.3f);
515 float s = 1.f;
516 mParams.radiusScale *= s;
517
518 // FIXME since meshlab does not set any material properties, let's define some here
519 glDisable(GL_COLOR_MATERIAL);
520 glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, 64);
521 glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, vcg::Point4f(0.3, 0.3, 0.3, 1.).V());
522 glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, vcg::Point4f(0.6, 0.6, 0.6, 1.).V());
523 glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, vcg::Point4f(0.5, 0.5, 0.5, 1.).V());
524
525 mRenderBuffer->bind();
526 if (mFlags&DEFERRED_SHADING_BIT)
527 {
528 GLenum buf[2] = {GL_COLOR_ATTACHMENT0_EXT,GL_COLOR_ATTACHMENT1_EXT};
529 glDrawBuffersARB(2, buf);
530 }
531 glViewport(mCachedVP[0],mCachedVP[1],mCachedVP[2],mCachedVP[3]);
532 glClearColor(0,0,0,0);
533 glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
534
535 //* End Setup of first Pass Now a simple rendering of all the involved meshes.*/
536 mParams.loadTo(mShaders[0].prog);
537 enablePass(0);
538 drawSplats(positions,normals,colors,radius,cm,tm);
539
540 // begin second pass
541 mParams.loadTo(mShaders[1].prog);
542 enablePass(1);
543
544 drawSplats(positions,normals,colors,radius,cm,tm);
545
546 //* Start third Pass Setup */
547
548 // this is the last pass: normalization by the sum of weights + deferred shading
549 mRenderBuffer->release();
550 if (mFlags&DEFERRED_SHADING_BIT)
551 glDrawBuffer(GL_BACK);
552
553 enablePass(2);
554
555 // switch to normalized 2D rendering mode
556 glMatrixMode(GL_PROJECTION);
557 glPushMatrix();
558 glLoadIdentity();
559 glMatrixMode(GL_MODELVIEW);
560 glPushMatrix();
561 glLoadIdentity();
562
563 mShaders[2].prog.Uniform("viewport",float(mCachedVP[0]),float(mCachedVP[1]),float(mCachedVP[2]),float(mCachedVP[3]));
564 mShaders[2].prog.Uniform("ColorWeight",GLint(0)); // this is a texture unit
565 glActiveTexture(GL_TEXTURE0);
566 glBindTexture(GL_TEXTURE_RECTANGLE_ARB,mRenderBuffer->texture());
567
568 if (mFlags&DEFERRED_SHADING_BIT)
569 {
570 mShaders[2].prog.Uniform("unproj", mCachedProj[10], mCachedProj[14]);
571 mShaders[2].prog.Uniform("NormalWeight",GLint(1)); // this is a texture unit
572 glActiveTexture(GL_TEXTURE1);
573 glBindTexture(GL_TEXTURE_RECTANGLE_ARB,mNormalTextureID);
574 GL_TEST_ERR
575 }
576
577 if (mFlags&OUTPUT_DEPTH_BIT)
578 {
579 mShaders[2].prog.Uniform("Depth",GLint(2)); // this is a texture unit
580 glActiveTexture(GL_TEXTURE2);GL_TEST_ERR
581 glBindTexture(GL_TEXTURE_RECTANGLE_ARB,mDepthTextureID);GL_TEST_ERR
582 GL_TEST_ERR
583 }
584 else
585 {
586 glDisable(GL_DEPTH_TEST);
587 glDepthMask(GL_FALSE);
588 }
589
590 // draw a quad covering the whole screen
591 vcg::Point3f viewVec(1./mCachedProj[0], 1./mCachedProj[5], -1);
592
593 glBegin(GL_QUADS);
594 glColor3f(1, 0, 0);
595 glTexCoord3f(viewVec.X(),viewVec.Y(),viewVec.Z());
596 glMultiTexCoord2f(GL_TEXTURE1,1.,1.);
597 glVertex3f(1,1,0);
598
599 glColor3f(1, 1, 0);
600 glTexCoord3f(-viewVec.X(),viewVec.Y(),viewVec.Z());
601 glMultiTexCoord2f(GL_TEXTURE1,0.,1.);
602 glVertex3f(-1,1,0);
603
604 glColor3f(0, 1, 1);
605 glTexCoord3f(-viewVec.X(),-viewVec.Y(),viewVec.Z());
606 glMultiTexCoord2f(GL_TEXTURE1,0.,0.);
607 glVertex3f(-1,-1,0);
608
609 glColor3f(1, 0, 1);
610 glTexCoord3f(viewVec.X(),-viewVec.Y(),viewVec.Z());
611 glMultiTexCoord2f(GL_TEXTURE1,1.,0.);
612 glVertex3f(1,-1,0);
613 glEnd();
614 if (!(mFlags&OUTPUT_DEPTH_BIT))
615 {
616 glEnable(GL_DEPTH_TEST);
617 glDepthMask(GL_TRUE);
618 }
619
620 glUseProgram(0);
621
622 // restore matrices
623 glMatrixMode(GL_PROJECTION);
624 glPopMatrix();
625 glMatrixMode(GL_MODELVIEW);
626 glPopMatrix();
627
628 GL_TEST_ERR
629
630 }
631 #if 0
632 void SplatRenderer::Draw(QAction *a, MeshModel &m, RenderMode &rm, QGLWidget * gla)
633 {
634 if (m.vert.RadiusEnabled)
635 {
636 if (mCurrentPass==2)
637 return;
638
639 enablePass(mCurrentPass);
640 /*if (mCurrentPass==1)*/ drawSplats(m, rm);
641 }
642 else if (mCurrentPass==2)
643 {
644 MeshRenderInterface::Draw(a, m, rm, gla);
645 }
646 }
647 #endif
648 template <class MeshType>
649 void SplatRenderer<MeshType>::enablePass(int n)
650 {
651 if (mBindedPass!=n)
652 {
653 if (mBindedPass>=0)
654 mShaders[mBindedPass].prog.Unbind();
655 mShaders[n].prog.Bind();
656 mBindedPass = n;
657
658 // set GL states
659 if (n==0)
660 {
661 glDisable(GL_LIGHTING);
662 // glDisable(GL_POINT_SMOOTH);
663 glEnable(GL_VERTEX_PROGRAM_POINT_SIZE);
664
665 glAlphaFunc(GL_LESS,1);
666 glColorMask(GL_FALSE,GL_FALSE,GL_FALSE,GL_FALSE);
667 glDepthMask(GL_TRUE);
668 glDisable(GL_BLEND);
669 glEnable(GL_ALPHA_TEST);
670 glEnable(GL_DEPTH_TEST);
671
672 // glActiveTexture(GL_TEXTURE0);
673 // glTexEnvf(GL_POINT_SPRITE, GL_COORD_REPLACE, GL_TRUE);
674 // glEnable(GL_POINT_SPRITE_ARB);
675 }
676 if (n==1)
677 {
678 glDisable(GL_LIGHTING);
679 glEnable(GL_POINT_SMOOTH);
680 glActiveTexture(GL_TEXTURE0);
681 glEnable(GL_VERTEX_PROGRAM_POINT_SIZE);
682
683 glColorMask(GL_TRUE,GL_TRUE,GL_TRUE,GL_TRUE);
684 glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE, GL_ONE,GL_ONE);
685 // //glBlendFuncSeparate(GL_ONE, GL_ZERO, GL_ONE,GL_ZERO);
686 // glBlendFunc(GL_ONE,GL_ZERO);
687 glDepthMask(GL_FALSE);
688 glEnable(GL_BLEND);
689 glEnable(GL_DEPTH_TEST);
690 glDisable(GL_ALPHA_TEST);
691
692 // glActiveTexture(GL_TEXTURE0);
693
694 }
695 if ( (n==0) || (n==1) )
696 {
697 // enable point sprite rendering mode
698 glActiveTexture(GL_TEXTURE0);
699 if (mWorkaroundATI)
700 {
701 glBindTexture(GL_TEXTURE_2D, mDummyTexId);
702 glTexImage2D(GL_TEXTURE_2D, 0, GL_LUMINANCE, 2, 2, 0, GL_LUMINANCE, GL_UNSIGNED_BYTE, 0);
703 glPointParameterf(GL_POINT_SPRITE_COORD_ORIGIN, GL_LOWER_LEFT);
704 // hm... ^^^^
705 }
706 glTexEnvf(GL_POINT_SPRITE, GL_COORD_REPLACE, GL_TRUE);
707 glEnable(GL_POINT_SPRITE_ARB);
708 }
709 if (n==2)
710 {
711 glColorMask(GL_TRUE,GL_TRUE,GL_TRUE,GL_TRUE);
712 glDepthMask(GL_TRUE);
713 glDisable(GL_LIGHTING);
714 glDisable(GL_BLEND);
715 }
716 }
717 }
718
719
720 template <class MeshType>
721 void SplatRenderer<MeshType>::drawSplats(
722 std::vector< std::vector<vcg::Point3f> * > & positions,
723 std::vector< std::vector<vcg::Point3f> * > & normals,
724 std::vector< std::vector<vcg::Point3<unsigned char> > * > & colors,
725 std::vector<float> & radius,
726 vcg::GLW::ColorMode cm, vcg::GLW::TextureMode tm)
727 {
728 for(unsigned int ii = 0; ii < positions.size();++ii)
729 {
730
731 glBegin(GL_POINTS);
732 glMultiTexCoord1f(GL_TEXTURE2, radius[ii] );
733
734 for(unsigned int vi= 0;vi< positions[ii]->size() ;++vi){
735 vcg::Point3<unsigned char> co = (*colors[ii])[vi];
736 glColor3ub ( co[0],co[1],co[2]);
737 glNormal((*normals[ii])[vi]);
738 glVertex( (*positions[ii])[vi]);
739 }
740 glEnd();
741 }
742 }
743
744
745 template <class MeshType>
746 void SplatRenderer<MeshType>::drawSplats(std::vector<MeshType*> & meshes, vcg::GLW::ColorMode cm, vcg::GLW::TextureMode tm)
747 {
748
749 // check if we have to use the immediate mode
750 if(meshes.empty()) return;
751 int nV = 0;
752
753 /* temporary patch: If the number of vertices is above IMMEDIATE_MODE_THR,
754 use the immediate mode
755 */
756 const int IMMEDIATE_MODE_THR = 0;
757
758 unsigned int ii = 0;
759 for(; ii < meshes.size();++ii){
760 nV+=meshes[ii]->vn;
761 if((nV>IMMEDIATE_MODE_THR) || (meshes[ii]->vn!=(int) meshes[ii]->vert.size()))
762 break;
763 }
764 bool immediatemode = ii<meshes.size() ;
765
766
767 if(immediatemode){
768 for(unsigned int ii = 0; ii < meshes.size();++ii)
769 {
770 MeshType & m = *meshes[ii];
771 // immediate mode
772
773 if( (cm == vcg::GLW::CMPerFace) && (!vcg::tri::HasPerFaceColor( m)) )
774 cm=vcg::GLW::CMNone;
775 glPushMatrix();
776 glMultMatrix( m.Tr);
777 typename MeshType::VertexIterator vi;
778 glBegin(GL_POINTS);
779 if(cm==vcg::GLW::CMPerMesh)
780 glColor( m.C());
781
782
783 for(vi= m.vert.begin();vi!= m.vert.end();++vi)
784 if(!(*vi).IsD())
785 {
786 glMultiTexCoord1f(GL_TEXTURE2, (*vi).cR());
787 glNormal((*vi).cN());
788 if (cm==vcg::GLW::CMPerVert) glColor((*vi).C());
789 glVertex((*vi).P());
790 }
791 glEnd();
792 glPopMatrix();
793
794 }
795 return;
796 }
797
798 for(unsigned int ii = 0; ii < meshes.size();++ii){
799 MeshType & m = *meshes[ii];
800 // bind the radius
801 glClientActiveTexture(GL_TEXTURE2);
802 glTexCoordPointer(
803 1,
804 GL_FLOAT,
805 size_t(&m.vert[1].R())-size_t(&m.vert[0].R()),
806 &m.vert[0].R()
807 );
808 glEnableClientState(GL_TEXTURE_COORD_ARRAY);
809 glClientActiveTexture(GL_TEXTURE0);
810
811 // draw the vertices
812 vcg::GlTrimesh<MeshType> glw;
813 glw.m = &m;
814 glw.Draw(vcg::GLW::DMPoints,cm,tm);
815
816 glClientActiveTexture(GL_TEXTURE2);
817 glDisableClientState(GL_TEXTURE_COORD_ARRAY);
818 glClientActiveTexture(GL_TEXTURE0);
819 }
820 }
821
822 template <class MeshType>
823 void SplatRenderer<MeshType>::UniformParameters::update(float* mv, float* proj, GLint* vp)
824 {
825 // extract the uniform scale
826 float scale = vcg::Point3f(mv[0],mv[1],mv[2]).Norm();
827
828 radiusScale = scale;
829 preComputeRadius = - std::max(proj[0]*vp[2], proj[5]*vp[3]);
830 depthOffset = 2.0;
831 oneOverEwaRadius = 0.70710678118654;
832 halfVp = vcg::Point2f(0.5*vp[2], 0.5*vp[3]);
833 rayCastParameter1 =vcg::Point3f(2./(proj[0]*vp[2]), 2./(proj[5]*vp[3]), 0.0);
834 rayCastParameter2 =vcg::Point3f(-1./proj[0], -1./proj[5], -1.0);
835 depthParameterCast = vcg::Point2f(0.5*proj[14], 0.5-0.5*proj[10]);
836 }
837 template <class MeshType>
838 void SplatRenderer <MeshType>::UniformParameters::loadTo(Program& prg)
839 {
840 prg.Bind();
841 prg.Uniform("expeRadiusScale",radiusScale);
842 prg.Uniform("expePreComputeRadius",preComputeRadius);
843 prg.Uniform("expeDepthOffset",depthOffset);
844 prg.Uniform("oneOverEwaRadius",oneOverEwaRadius);
845 prg.Uniform("halfVp",halfVp);
846 prg.Uniform("rayCastParameter1",rayCastParameter1);
847 prg.Uniform("rayCastParameter2",rayCastParameter2);
848 prg.Uniform("depthParameterCast",depthParameterCast);
849 }
850
851 #endif
852