Subversion Repositories gelsvn

Rev

Rev 406 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
399 jab 1 
/*
2 
 *  WireframeRenderer.cpp
3 
 *  GEL
4 
 *
5 
 *  Created by J. Andreas Bærentzen on 20/09/08.
6 
 *  Copyright 2008 __MyCompanyName__. All rights reserved.
7 
 *
8 
 */
9 
 
10 
#include <algorithm>
11 
#include <string>
403 jab 12 
#include <CGLA/Mat3x3d.h>
399 jab 13 
#include <GLGraphics/glsl_shader.h>
403 jab 14 
#include <HMesh/FaceCirculator.h>
399 jab 15 
 
403 jab 16 
#include <GLConsole/GLConsole.h>
17 
 
18 
#include "Renderer.h"
19 
#include "curvature.h"
20 
 
399 jab 21 
using namespace GLGraphics;
22 
using namespace CGLA;
23 
using namespace HMesh;
24 
using namespace std;
25 
 
403 jab 26 
GLuint get_noise_texture_id()
27 
{
28 
	static GLuint texname=0;
29 
	static bool was_here = false;
30 
 
31 
	if(!was_here)
32 
	{
33 
		was_here = true;
34 
		int width = 32;
35 
		int height = 32;
36 
		int depth = 32;
37 
		vector<unsigned char> texels(width*height*depth);
38 
		for (int i = 0; i < width*height*depth; ++i)
39 
		{
40 
			int intensity = 255.0 * (float(rand()) / RAND_MAX);
41 
			texels[i] = (unsigned char) intensity;
42 
		}
43 
 
44 
		glGenTextures(1, &texname);
45 
		glBindTexture(GL_TEXTURE_3D, texname);
46 
		glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
47 
		glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
48 
		glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_S, GL_REPEAT);
49 
		glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_T, GL_REPEAT);
50 
		glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_R, GL_REPEAT);
51 
		glTexImage3D(GL_TEXTURE_3D, 0, GL_INTENSITY8, width, height, depth, 0, GL_RED, GL_UNSIGNED_BYTE, &texels[0]);
52 
	}
53 
 
54 
	return texname;
55 
}
56 
 
57 
 
399 jab 58 
int WireframeRenderer::maximum_face_valency(HMesh::Manifold& m)
59 
{
60 
	int max_val = 0;
61 
	for(FaceIter f = m.faces_begin(); f != m.faces_end(); ++f)
62 
		max_val = max(max_val, no_edges(f));
63 
	return max_val;
64 
}
65 
 
403 jab 66 
WireframeRenderer::WireframeRenderer(HMesh::Manifold& m, bool smooth): idbuff_renderer(0)
399 jab 67 
{
68 
	if(GLEW_EXT_geometry_shader4 && maximum_face_valency(m) > 3)
69 
	{
70 
		GLint viewp[4];
71 
		glGetIntegerv(GL_VIEWPORT,viewp);
72 
		idbuff_renderer = new IDBufferWireframeRenderer(viewp[2], viewp[3], m);
73 
	}
74 
	else
75 
	{
76 
		glNewList(display_list,GL_COMPILE);
77 
		if(GLEW_EXT_geometry_shader4)
403 jab 78 
			draw_triangles_in_wireframe(m,smooth, Vec3f(1,0,0));
399 jab 79 
		else
403 jab 80 
			draw_wireframe_oldfashioned(m,smooth, Vec3f(1,0,0));
399 jab 81 
		glEndList();
82 
	}
83 
}
84 
 
85 
void WireframeRenderer::draw()
86 
{
87 
	if(idbuff_renderer)
88 
		idbuff_renderer->draw(Vec3f(1,0,0),Vec3f(0.5));
89 
	else
90 
		glCallList(display_list);
91 
}
92 
 
403 jab 93 
void SimpleShaderRenderer::init_shaders(const std::string& vss,
94 
										const std::string& fss)
399 jab 95 
{
96 
	vs = create_glsl_shader(GL_VERTEX_SHADER, vss);
97 
	print_glsl_program_log(vs);
403 jab 98 
 
399 jab 99 
	fs = create_glsl_shader(GL_FRAGMENT_SHADER, fss);
100 
	print_glsl_program_log(fs);
403 jab 101 
 
399 jab 102 
	prog = glCreateProgram();
103 
 
104 
	if(vs) glAttachShader(prog, vs);
105 
	if(fs) glAttachShader(prog, fs);
106 
 
107 
	glLinkProgram(prog);
108 
	print_glsl_program_log(prog);
403 jab 109 
 
110 
}
111 
 
112 
void SimpleShaderRenderer::compile_display_list(Manifold& m, bool smooth)
113 
{
399 jab 114 
	glNewList(display_list,GL_COMPILE);
403 jab 115 
	GLGraphics::draw(m, smooth);
116 
	glEndList();
399 jab 117 
}
118 
 
119 
void SimpleShaderRenderer::draw()
120 
{
121 
	GLint old_prog;
122 
	glGetIntegerv(GL_CURRENT_PROGRAM, &old_prog);
123 
	glUseProgram(prog);
124 
	glCallList(display_list);
125 
	glUseProgram(old_prog);
126 
}
127 
 
128 
const string ReflectionLineRenderer::vss =
129 
"varying vec3 n;\n"
130 
"varying vec3 v;\n"
131 
"\n"
132 
"void main(void)\n"
133 
"{\n"
134 
"	gl_Position = ftransform();\n"
135 
"	v = vec3(gl_ModelViewMatrix * gl_Vertex);\n"
136 
"	n = normalize(gl_NormalMatrix * gl_Normal);\n"
137 
"}\n";
138 
 
139 
 
140 
const string ReflectionLineRenderer::fss =
141 
"uniform float detail;\n"
142 
"\n"
143 
"varying vec3 n;\n"
144 
"varying vec3 v;\n"
145 
"\n"
146 
"void main(void)\n"
147 
"{\n"
148 
"	// calculate the reflection\n"
149 
"	vec3 r = normalize(2.0*dot(-v, n)*n + v);\n"
401 jab 150 
"	vec3 viewer_lightdir = vec3(0, 0, 1.0);\n"
151 
"   float diff  = dot(n,viewer_lightdir);\n"
399 jab 152 
"	\n"
153 
"	vec2 r2 = normalize(vec2(r[0], r[2]));\n"
154 
"	vec2 x = vec2(1, 0);\n"
155 
"	float angle = acos(dot(r2, x));\n"
156 
"	\n"
157 
"	// decide if we hit a white or black ring, based on y value\n"
401 jab 158 
"	gl_FragColor = diff * vec4(0.5,0.5,0.4,0.0) + smoothstep(0.8, 1.0,cos(13.0*angle)) * vec4(0.5,0.5,0.6,0.0);\n"
399 jab 159 
"}\n";
160 
 
161 
const string IsophoteLineRenderer::vss =
162 
"varying vec3 n;\n"
163 
"varying vec3 v;\n"
164 
"\n"
165 
"void main(void)\n"
166 
"{\n"
167 
"	gl_Position = ftransform();\n"
168 
"	v = vec3(gl_ModelViewMatrix * gl_Vertex);\n"
169 
"	n = normalize(gl_NormalMatrix * gl_Normal);\n"
170 
"}\n";
171 
 
172 
 
173 
const string IsophoteLineRenderer::fss =
174 
"uniform float detail;\n"
175 
"\n"
176 
"varying vec3 n;\n"
177 
"varying vec3 v;\n"
178 
"\n"
179 
"void main(void)\n"
180 
"{\n"
401 jab 181 
"	vec3 viewer_lightdir = vec3(0, 0, 1.0);\n"
182 
"	vec3 isophote_lightdir = viewer_lightdir;\n"
183 
"	float angle = acos(dot(n, isophote_lightdir));\n"
184 
"   float diff  = dot(n,viewer_lightdir);\n"
399 jab 185 
"	\n"
186 
"	// decide if we hit a white or black ring, based on y value\n"
401 jab 187 
"	gl_FragColor = diff * vec4(0.5,0.5,0.4,0.0) + smoothstep(0.8, 1.0,cos(20.0*angle)) * vec4(0.5,0.5,0.6,0.0);\n"
399 jab 188 
"}\n";
189 
 
403 jab 190 
const string ToonRenderer::vss =
399 jab 191 
"varying vec3 n;\n"
192 
"varying vec3 v;\n"
193 
"\n"
194 
"void main(void)\n"
195 
"{\n"
196 
"	gl_Position = ftransform();\n"
197 
"	v = vec3(gl_ModelViewMatrix * gl_Vertex);\n"
198 
"	n = normalize(gl_NormalMatrix * gl_Normal);\n"
199 
"}\n";
200 
 
403 jab 201 
const string ToonRenderer::fss =
399 jab 202 
"varying vec3 n;\n"
203 
"varying vec3 v;\n"
204 
"\n"
205 
"void main(void)\n"
206 
"{\n"
207 
"	vec3 l = normalize(-v);\n"
208 
"	vec3 e = l;\n"
209 
"	vec3 r = normalize(2.0*dot(l, n)*n - l);\n"
210 
"	\n"
211 
"	vec4 a = vec4(0.0,0.1,.3,1.0);\n"
403 jab 212 
"   float dot_ln = abs(dot(l, n));\n"
213 
"	vec4 d = vec4(0.7,0.7,0.0,1.0) * 0.25 * (smoothstep(0.23,0.25,dot_ln)+smoothstep(0.45,0.47,dot_ln)+smoothstep(0.7,0.72,dot_ln)+smoothstep(0.9,0.92,dot_ln));\n"
214 
"	vec4 s = vec4(0.5,0.3,0.4,1.0)*smoothstep(0.96,0.98,dot(r, e));\n"
399 jab 215 
"	\n"
403 jab 216 
"	gl_FragColor =  d+s;\n"
399 jab 217 
"}\n";
218 
 
403 jab 219 
 
220 
void GlazedRenderer::draw()
221 
{
222 
	GLint old_prog;
223 
	glGetIntegerv(GL_CURRENT_PROGRAM, &old_prog);
224 
	glUseProgram(prog);
225 
	glBindTexture(GL_TEXTURE_3D, get_noise_texture_id());
226 
	glUniform1iARB(glGetUniformLocationARB(prog, "noise_tex"),0);
227 
	glUniform1fARB(glGetUniformLocationARB(prog, "noise_scale"),12.0/bsphere_rad);
228 
	glCallList(display_list);
229 
	glUseProgram(old_prog);
230 
}
231 
 
232 
 
233 
 
401 jab 234 
const string GlazedRenderer::vss =
235 
"varying vec3 n;\n"
236 
"varying vec3 v;\n"
403 jab 237 
"varying vec3 v_obj;\n"
401 jab 238 
"\n"
239 
"void main(void)\n"
240 
"{\n"
241 
"	gl_Position = ftransform();\n"
403 jab 242 
"   v_obj = gl_Vertex.xyz;\n"
401 jab 243 
"	v = vec3(gl_ModelViewMatrix * gl_Vertex);\n"
244 
"	n = normalize(gl_NormalMatrix * gl_Normal);\n"
245 
"}\n"
246 
"\n";
247 
 
248 
const string GlazedRenderer::fss =
403 jab 249 
"uniform sampler3D noise_tex;\n"
250 
"uniform float noise_scale;\n"
401 jab 251 
"varying vec3 n;\n"
252 
"varying vec3 v;\n"
403 jab 253 
"varying vec3 v_obj;\n"
401 jab 254 
"\n"
255 
"vec4 glazed_shader(vec4 mat_col,  vec4 light_col, vec3 light_dir)\n"
256 
"{\n"
257 
"	vec3 e = normalize(-v);\n"
258 
"	vec3 r = normalize(2.0*dot(e, n)*n - e);\n"
259 
"	float d = max(0.05,dot(light_dir, n));\n"
260 
"	vec4 diff = mat_col * light_col *d; 	\n"
261 
"	vec4 refl = smoothstep(0.7,0.75,dot(r,light_dir)) * light_col;\n"
262 
"	return 0.15*refl + diff;\n"
263 
"}\n"
264 
"\n"
265 
"void main(void)\n"
266 
"{\n"
403 jab 267 
"	vec4 mat_col = vec4(0.9,1.0,0.4,1.0) + vec4(-0.1,-0.1,0.12,0.0) * texture3D(noise_tex, noise_scale*v_obj).x\n"
268 
" + vec4(0.05) * texture3D(noise_tex, 500.0*v_obj).x;\n"
401 jab 269 
"	\n"
270 
"	vec3 light0_dir = vec3(0.0,1.0,0.0);\n"
271 
"	vec4 light0_col = vec4(0.7,0.9,1.0,1.0);\n"
272 
"	\n"
273 
"	vec3 light1_dir = vec3(0.0,0.0,1.0);\n"
274 
"	vec4 light1_col = vec4(1.0,1.0,0.7,1.0);\n"
275 
"	\n"
276 
"	gl_FragColor = \n"
277 
"	0.5*glazed_shader(mat_col, light0_col, light0_dir)+\n"
278 
"	0.5*glazed_shader(mat_col, light1_col, light1_dir);\n"
279 
"	\n"
280 
"	gl_FragColor.a = 1.0;\n"
281 
"}\n";
282 
 
283 
 
403 jab 284 
const string ScalarFieldRenderer::vss =
285 
"	attribute float scalar;\n"
286 
"	varying vec3 normal;\n"
287 
"	varying float s;\n"
288 
"	\n"
289 
"	void main(void)\n"
290 
"	{\n"
291 
"		gl_Position =  ftransform();\n"
292 
"		normal = normalize(gl_NormalMatrix * gl_Normal);\n"
293 
"		s=scalar;\n"
294 
"	}\n";
401 jab 295 
 
403 jab 296 
const string ScalarFieldRenderer::fss =
297 
"	varying vec3 normal;\n"
298 
"	varying float s;\n"
299 
"	uniform float scalar_max;\n"
300 
"   uniform float gamma;\n"
301 
"	const vec3 light_dir = vec3(0,0,1);\n"
302 
"	\n"
303 
"	void main()\n"
304 
"	{\n"
305 
"		float dot_ln = max(0.0,dot(light_dir, normal));\n"
306 
"		\n"
307 
"		float s_norm = s/scalar_max;\n"
308 
"		float stripe_signal = 100.0 * s_norm;\n"
309 
"		vec4 stripe_col = abs(stripe_signal) < 3.14 ? vec4(0,0,0,0) : vec4(.1,.1,.1,0);\n"
310 
"		\n"
311 
"		gl_FragColor = s_norm * vec4(-1,0,1,0);\n"
312 
"       gl_FragColor *= dot_ln;\n"
313 
"       gl_FragColor.r = pow(gl_FragColor.r, 1.0/gamma);\n"
314 
"       gl_FragColor.g = pow(gl_FragColor.g, 1.0/gamma);\n"
315 
"       gl_FragColor.b = pow(gl_FragColor.b, 1.0/gamma);\n"
316 
"		gl_FragColor += stripe_col * smoothstep(0.8,1.0,cos(stripe_signal));\n"
317 
"	}\n";
318 
 
319 
ScalarFieldRenderer::ScalarFieldRenderer(HMesh::Manifold& m, bool smooth,
406 jab 320 
										 std::vector<double>& field, double max_val):
321 
SimpleShaderRenderer(vss,fss)
403 jab 322 
{
323 
 
324 
	GLint old_prog;
325 
	glGetIntegerv(GL_CURRENT_PROGRAM, &old_prog);
326 
	glUseProgram(prog);
327 
 
328 
	GLuint scalar_attrib = glGetAttribLocation(prog, "scalar");
329 
	glUniform1fARB(glGetUniformLocationARB(prog, "scalar_max"), max_val);
330 
 
409 jrf 331 
	static CVar<float> gamma("display.scalar_field_renderer.gamma",2.2f);
403 jab 332 
	glUniform1fARB(glGetUniformLocationARB(prog, "gamma"), gamma);
333 
	glNewList(display_list,GL_COMPILE);
334 
 
335 
	for(FaceIter f=m.faces_begin(); f != m.faces_end(); ++f)
336 
	{
337 
		FaceCirculator fc(f);
338 
		if(!smooth)
339 
			glNormal3fv(normal(f).get());
340 
		if(no_edges(f)== 3)
341 
			glBegin(GL_TRIANGLES);
342 
		else
343 
			glBegin(GL_POLYGON);
344 
 
345 
		while(!fc.end())
346 
		{
347 
			Vec3d n(normal(fc.get_vertex()));
348 
			if(smooth)
349 
				glNormal3dv(n.get());
350 
			int i = fc.get_vertex()->touched;
351 
			glVertexAttrib1d(scalar_attrib, field[i]);
352 
			glVertex3fv(fc.get_vertex()->pos.get());
353 
			++fc;
354 
		}
355 
		glEnd();
356 
	}
357 
	glEndList();
358 
	glUseProgram(old_prog);
359 
 
360 
}
361 
 
406 jab 362 
const string AmbientOcclusionRenderer::vss =
363 
"	attribute float scalar;\n"
364 
"	varying vec3 normal;\n"
365 
"	varying float s;\n"
366 
"	\n"
367 
"	void main(void)\n"
368 
"	{\n"
369 
"		gl_Position =  ftransform();\n"
370 
"		normal = normalize(gl_NormalMatrix * gl_Normal);\n"
371 
"		s=scalar;\n"
372 
"	}\n";
403 jab 373 
 
406 jab 374 
const string AmbientOcclusionRenderer::fss =
375 
"	varying vec3 normal;\n"
376 
"	varying float s;\n"
377 
"	uniform float scalar_max;\n"
378 
"   uniform float gamma;\n"
379 
"   uniform bool lighton;\n"
380 
"	const vec3 light_dir = vec3(0,0,1);\n"
381 
"	\n"
382 
"	void main()\n"
383 
"	{\n"
384 
"		float dot_ln = max(0.0,dot(light_dir, normal));\n"
385 
"		\n"
386 
"		float s_norm = min(1.0,s/scalar_max+1.0);\n"
387 
"		\n"
388 
"		gl_FragColor = s_norm * vec4(1.0);\n"
389 
"       if(lighton) gl_FragColor *= dot_ln;\n"
390 
"       gl_FragColor.r = pow(gl_FragColor.r, 1.0/gamma);\n"
391 
"       gl_FragColor.g = pow(gl_FragColor.g, 1.0/gamma);\n"
392 
"       gl_FragColor.b = pow(gl_FragColor.b, 1.0/gamma);\n"
393 
"	}\n";
403 jab 394 
 
406 jab 395 
AmbientOcclusionRenderer::AmbientOcclusionRenderer(HMesh::Manifold& m, bool smooth,
396 
												   std::vector<double>& field, double max_val):
397 
SimpleShaderRenderer(vss,fss)
398 
{
403 jab 399 
	GLint old_prog;
400 
	glGetIntegerv(GL_CURRENT_PROGRAM, &old_prog);
401 
	glUseProgram(prog);
402 
 
406 jab 403 
	GLuint scalar_attrib = glGetAttribLocation(prog, "scalar");
404 
	glUniform1fARB(glGetUniformLocationARB(prog, "scalar_max"), max_val);
403 jab 405 
 
406 jab 406 
	static CVar<float> gamma("display.ambient_occlusion_renderer.gamma",1.5);
407 
	glUniform1fARB(glGetUniformLocationARB(prog, "gamma"), gamma);
408 
	static CVar<int> lighton("display.ambient_occlusion_renderer.light",1);
409 
	glUniform1iARB(glGetUniformLocationARB(prog, "lighton"), lighton);
403 jab 410 
	glNewList(display_list,GL_COMPILE);
406 jab 411 
 
403 jab 412 
	for(FaceIter f=m.faces_begin(); f != m.faces_end(); ++f)
413 
	{
414 
		FaceCirculator fc(f);
415 
		if(!smooth)
416 
			glNormal3fv(normal(f).get());
417 
		if(no_edges(f)== 3)
418 
			glBegin(GL_TRIANGLES);
419 
		else
420 
			glBegin(GL_POLYGON);
406 jab 421 
 
403 jab 422 
		while(!fc.end())
423 
		{
424 
			Vec3d n(normal(fc.get_vertex()));
425 
			if(smooth)
426 
				glNormal3dv(n.get());
427 
			int i = fc.get_vertex()->touched;
406 jab 428 
			glVertexAttrib1d(scalar_attrib, field[i]);
403 jab 429 
			glVertex3fv(fc.get_vertex()->pos.get());
430 
			++fc;
431 
		}
432 
		glEnd();
433 
	}
434 
	glEndList();
435 
	glUseProgram(old_prog);
406 jab 436 
 
437 
}
403 jab 438 
 
406 jab 439 
const string CopperRenderer::vss =
440 
"	attribute float scalar;\n"
441 
"	varying vec3 normal;\n"
442 
"varying vec3 v_obj;\n"
443 
"	varying float s;\n"
444 
"	\n"
445 
"	void main(void)\n"
446 
"	{\n"
447 
"		gl_Position =  ftransform();\n"
448 
"		normal = normalize(gl_NormalMatrix * gl_Normal);\n"
449 
"		s=scalar;\n"
450 
"       v_obj = gl_Vertex.xyz;\n"
451 
"	}\n";
452 
 
453 
const string CopperRenderer::fss =
454 
"uniform sampler3D noise_tex;\n"
455 
"uniform float noise_scale;\n"
456 
"	varying vec3 normal;\n"
457 
"   varying vec3 v_obj;\n"
458 
"	varying float s;\n"
459 
"	uniform float scalar_max;\n"
460 
"	const vec3 light_dir = vec3(0,0,1);\n"
461 
"	\n"
462 
"   float turb(vec3 x) { return 0.25*(texture3D(noise_tex,0.12*noise_scale*x).x+\n"
463 
"			texture3D(noise_tex,0.531*noise_scale*x).x+\n"
464 
"			texture3D(noise_tex,0.098*noise_scale*x).x+\n"
465 
"			texture3D(noise_tex,1.0121*noise_scale*x).x);}\n"
466 
"	void main()\n"
467 
"	{\n"
468 
"		float diff = max(0.0,dot(light_dir, normal));\n"
469 
"	    vec3 r = normalize(2.0*dot(light_dir, normal)*normal - light_dir);\n"
470 
"		float spec = pow(dot(r, normal),20.0);\n"
471 
"		\n"
472 
"		float s_norm = 0.95*s/scalar_max+0.05*turb(v_obj);\n"
473 
"       vec4 copper =  vec4(1,0.70,.5,1);\n"
474 
"       vec4 corroded =  vec4(0.43,0.59,0.5,1)+vec4(0.15,0.15,0.15,1.0)*abs(0.5+0.5*turb(v_obj));\n"
475 
"		vec4 material = copper*smoothstep(0.15,0.25,s_norm) + \n"
476 
"		corroded*smoothstep(0.25,0.15,s_norm)*smoothstep(-0.3,-0.05,s_norm);\n"
477 
"		gl_FragColor = material*diff+smoothstep(0.15,0.25,s_norm)*vec4(0.3,0.3,0.3,1)*spec;\n"
478 
"	}\n";
479 
 
480 
CopperRenderer::CopperRenderer(HMesh::Manifold& m, bool smooth,
481 
							   std::vector<double>& field, double max_val, float _bsphere_rad):
482 
SimpleShaderRenderer(vss,fss), bsphere_rad(_bsphere_rad)
483 
{
484 
	GLint old_prog;
485 
	glGetIntegerv(GL_CURRENT_PROGRAM, &old_prog);
486 
	glUseProgram(prog);
487 
 
488 
	GLuint scalar_attrib = glGetAttribLocation(prog, "scalar");
489 
	glUniform1fARB(glGetUniformLocationARB(prog, "scalar_max"), max_val);
490 
 
491 
	static CVar<float> gamma("display.patina_renderer.gamma",1.5);
492 
	glUniform1fARB(glGetUniformLocationARB(prog, "gamma"), gamma);
493 
	static CVar<int> lighton("display.patina_renderer.light",1);
494 
	glUniform1iARB(glGetUniformLocationARB(prog, "lighton"), lighton);
495 
	glUniform1iARB(glGetUniformLocationARB(prog, "noise_tex"),0);
496 
	glUniform1fARB(glGetUniformLocationARB(prog, "noise_scale"),12.0/bsphere_rad);
497 
 
498 
	glNewList(display_list,GL_COMPILE);
499 
	for(FaceIter f=m.faces_begin(); f != m.faces_end(); ++f)
500 
	{
501 
		FaceCirculator fc(f);
502 
		if(!smooth)
503 
			glNormal3fv(normal(f).get());
504 
		if(no_edges(f)== 3)
505 
			glBegin(GL_TRIANGLES);
506 
		else
507 
			glBegin(GL_POLYGON);
508 
 
509 
		while(!fc.end())
510 
		{
511 
			Vec3d n(normal(fc.get_vertex()));
512 
			if(smooth)
513 
				glNormal3dv(n.get());
514 
			int i = fc.get_vertex()->touched;
515 
			glVertexAttrib1d(scalar_attrib, field[i]);
516 
			glVertex3fv(fc.get_vertex()->pos.get());
517 
			++fc;
518 
		}
519 
		glEnd();
520 
	}
521 
	glEndList();
522 
	glUseProgram(old_prog);
523 
 
403 jab 524 
}
525 
 
406 jab 526 
void CopperRenderer::draw()
403 jab 527 
{
528 
	GLint old_prog;
529 
	glGetIntegerv(GL_CURRENT_PROGRAM, &old_prog);
530 
	glUseProgram(prog);
406 jab 531 
	glBindTexture(GL_TEXTURE_3D, get_noise_texture_id());
532 
	glCallList(display_list);
533 
	glUseProgram(old_prog);
534 
}
535 
 
536 
LineFieldRenderer::LineFieldRenderer(HMesh::Manifold& m, bool smooth, vector<Vec3d>& lines, float _r):
537 
	SimpleShaderRenderer(vss,fss), r(_r)
538 
{
539 
	GLint old_prog;
540 
	glGetIntegerv(GL_CURRENT_PROGRAM, &old_prog);
541 
	glUseProgram(prog);
409 jrf 542 
	static CVar<float> curvature_lines_scale("display.line_field_renderer.line_length", .015f);
543 
	static CVar<float> noise_scale("display.line_field_renderer.noise_scale", 12.0f/r);
544 
	static CVar<float> noise_amplitude("display.line_field_renderer.noise_amplitude", .06f);
403 jab 545 
	glUniform1fARB(glGetUniformLocationARB(prog, "scale_line"),curvature_lines_scale);
546 
	glUniform1fARB(glGetUniformLocationARB(prog, "noise_scale"),noise_scale);
547 
	glUniform1fARB(glGetUniformLocationARB(prog, "noise_amplitude"),noise_amplitude);
406 jab 548 
	glUniform1iARB(glGetUniformLocationARB(prog, "noise_tex"),0);
549 
	GLuint direction = glGetAttribLocation(prog, "direction");
550 
	glNewList(display_list,GL_COMPILE);
551 
	for(FaceIter f=m.faces_begin(); f != m.faces_end(); ++f)
552 
	{
553 
		FaceCirculator fc(f);
554 
		if(!smooth)
555 
			glNormal3fv(normal(f).get());
556 
		if(no_edges(f)== 3)
557 
			glBegin(GL_TRIANGLES);
558 
		else
559 
			glBegin(GL_POLYGON);
560 
		while(!fc.end())
561 
		{
562 
			Vec3d n(normal(fc.get_vertex()));
563 
			if(smooth)
564 
				glNormal3dv(n.get());
565 
			int i = fc.get_vertex()->touched;
566 
			Vec3d d = lines[i];
567 
			d = normalize(d-n*dot(n,d));
568 
			glVertexAttrib3dv(direction, d.get());
569 
			glVertex3fv(fc.get_vertex()->pos.get());
570 
			++fc;
571 
		}
572 
		glEnd();
573 
	}
403 jab 574 
 
406 jab 575 
	glBindTexture(GL_TEXTURE_3D, 0);
576 
	glEndList();
577 
	glUseProgram(old_prog);
578 
 
579 
}
580 
 
581 
void LineFieldRenderer::draw()
582 
{
583 
	GLint old_prog;
584 
	glGetIntegerv(GL_CURRENT_PROGRAM, &old_prog);
585 
	glUseProgram(prog);
403 jab 586 
	glBindTexture(GL_TEXTURE_3D, get_noise_texture_id());
587 
	glCallList(display_list);
406 jab 588 
	glBindTexture(GL_TEXTURE_3D, 0);
403 jab 589 
	glUseProgram(old_prog);
590 
}
591 
 
592 
const string LineFieldRenderer::vss =
593 
"attribute vec3 direction;\n"
594 
"varying vec3 n;\n"
595 
"varying vec3 dir_obj;\n"
596 
"varying vec3 v_obj;\n"
597 
"\n"
598 
"void main(void)\n"
599 
"{\n"
600 
"	gl_Position = ftransform();\n"
601 
"   v_obj = gl_Vertex.xyz;\n"
602 
"	dir_obj = direction;\n"
603 
"	n = normalize(gl_NormalMatrix * gl_Normal);\n"
604 
"}\n";
605 
 
606 
const string LineFieldRenderer::fss =
607 
"uniform sampler3D noise_tex;\n"
608 
"uniform float scale_line;\n"
609 
"uniform float noise_amplitude;\n"
610 
"uniform float noise_scale;\n"
611 
"varying vec3 n;\n"
612 
"varying vec3 dir_obj;\n"
613 
"varying vec3 v_obj;\n"
614 
"\n"
615 
"float tex(vec3 p) {return smoothstep(0.25,0.5,texture3D(noise_tex, p).x);}\n"
616 
"void main(void)\n"
617 
"{\n"
618 
"   float I = "
619 
"             tex(noise_scale*v_obj + 6.0*scale_line*dir_obj) + \n"
620 
"             tex(noise_scale*v_obj - 6.0*scale_line*dir_obj) + \n"
621 
"             tex(noise_scale*v_obj + 5.0*scale_line*dir_obj) + \n"
622 
"             tex(noise_scale*v_obj - 5.0*scale_line*dir_obj) + \n"
623 
"             tex(noise_scale*v_obj + 4.0*scale_line*dir_obj) + \n"
624 
"             tex(noise_scale*v_obj - 4.0*scale_line*dir_obj) + \n"
625 
"             tex(noise_scale*v_obj + 3.0*scale_line*dir_obj) + \n"
626 
"             tex(noise_scale*v_obj - 3.0*scale_line*dir_obj) + \n"
627 
"             tex(noise_scale*v_obj + 2.0*scale_line*dir_obj) + \n"
628 
"             tex(noise_scale*v_obj - 2.0*scale_line*dir_obj) + \n"
629 
"             tex(noise_scale*v_obj + 1.0*scale_line*dir_obj) + \n"
630 
"             tex(noise_scale*v_obj - 1.0*scale_line*dir_obj) + \n"
631 
"			  tex(noise_scale*v_obj); \n"
632 
"	\n"
633 
"   float diff = max(0.0,dot(n,vec3(0.0, 0.0, 1.0)));\n"
634 
"	gl_FragColor.rgb = vec3(1)*diff*I*noise_amplitude;\n"
635 
"	gl_FragColor.a = 1.0;\n"
636 
"}\n";