WebSVN – gelsvn – Diff – /trunk/apps/MeshEdit/Renderer.cpp


/*
 *  WireframeRenderer.cpp
 *  GEL
 *
 *  Created by J. Andreas Bærentzen on 20/09/08.
 *  Copyright 2008 __MyCompanyName__. All rights reserved.
 *
 */
 
#include <algorithm>
#include <string>
#include <cstdlib>
#include <CGLA/Mat3x3d.h>
#include <GLGraphics/glsl_shader.h>
#include <HMesh/FaceCirculator.h>
 
#include <GLConsole/GLConsole.h>
 
#include "Renderer.h"
#include "curvature.h"
 
using namespace GLGraphics;
using namespace CGLA;
using namespace HMesh;
using namespace std;
using namespace CVarUtils;
 
GLuint get_noise_texture_id()
{
	static GLuint texname=0;
	static bool was_here = false;
	
	if(!was_here)
	{
		was_here = true;
		int width = 32;
		int height = 32;
		int depth = 32;
		vector<unsigned char> texels(width*height*depth);
		for (int i = 0; i < width*height*depth; ++i)
		{
			int intensity = 255.0 * (float(gel_rand()) / GEL_RAND_MAX);
			texels[i] = (unsigned char) intensity;
		}
		
		glGenTextures(1, &texname);	
		glBindTexture(GL_TEXTURE_3D, texname);	
		glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
		glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
		glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_S, GL_REPEAT);
		glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_T, GL_REPEAT);
		glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_R, GL_REPEAT);
		glTexImage3D(GL_TEXTURE_3D, 0, GL_INTENSITY8, width, height, depth, 0, GL_RED, GL_UNSIGNED_BYTE, &texels[0]);
	}
	
	return texname;
}
 
 
int WireframeRenderer::maximum_face_valency(HMesh::Manifold& m)
{
	int max_val = 0;
	for(FaceIter f = m.faces_begin(); f != m.faces_end(); ++f)
		max_val = max(max_val, no_edges(f));
	return max_val;
}
 
WireframeRenderer::WireframeRenderer(HMesh::Manifold& m, bool smooth): idbuff_renderer(0)
{
	if(GLEW_EXT_geometry_shader4 && maximum_face_valency(m) > 3)
	{
		GLint viewp[4];
		glGetIntegerv(GL_VIEWPORT,viewp);
		idbuff_renderer = new IDBufferWireframeRenderer(viewp[2], viewp[3], m);
	}
	else
	{
		glNewList(display_list,GL_COMPILE);
		if(GLEW_EXT_geometry_shader4)
			draw_triangles_in_wireframe(m,smooth, Vec3f(1,0,0));				
		else
			draw_wireframe_oldfashioned(m,smooth, Vec3f(1,0,0));
		glEndList();
	}
}
 
void WireframeRenderer::draw()
{
	if(idbuff_renderer)
		idbuff_renderer->draw(Vec3f(1,0,0),Vec3f(0.5)); 
	else
		glCallList(display_list);
}
 
void SimpleShaderRenderer::init_shaders(const std::string& vss, 
										const std::string& fss)
{
	vs = create_glsl_shader(GL_VERTEX_SHADER, vss);
	print_glsl_program_log(vs);
	
	fs = create_glsl_shader(GL_FRAGMENT_SHADER, fss);
	print_glsl_program_log(fs);
 
	prog = glCreateProgram();
	
	if(vs) glAttachShader(prog, vs);
	if(fs) glAttachShader(prog, fs);
	
	glLinkProgram(prog);
	print_glsl_program_log(prog);
	
}
 
void SimpleShaderRenderer::compile_display_list(Manifold& m, bool smooth)
{
	glNewList(display_list,GL_COMPILE);
	GLGraphics::draw(m, smooth);
	glEndList();	
}
 
void SimpleShaderRenderer::draw()
{
	GLint old_prog;
	glGetIntegerv(GL_CURRENT_PROGRAM, &old_prog);
	glUseProgram(prog);
	glCallList(display_list);
	glUseProgram(old_prog);
}
 
const string ReflectionLineRenderer::vss = 
"varying vec3 n;\n"
"varying vec3 v;\n"
"\n"
"void main(void)\n"
"{\n"
"	gl_Position = ftransform();\n"
"	v = vec3(gl_ModelViewMatrix * gl_Vertex);\n"
"	n = normalize(gl_NormalMatrix * gl_Normal);\n"
"}\n";
 
 
const string ReflectionLineRenderer::fss = 
"uniform float detail;\n"
"\n"
"varying vec3 n;\n"
"varying vec3 v;\n"
"\n"
"void main(void)\n"
"{\n"
"	// calculate the reflection\n"
"	vec3 r = normalize(2.0*dot(-v, n)*n + v);\n"
"	vec3 viewer_lightdir = vec3(0, 0, 1.0);\n"
"   float diff  = dot(n,viewer_lightdir);\n"
"	\n"
"	vec2 r2 = normalize(vec2(r[0], r[2]));\n"
"	vec2 x = vec2(1, 0);\n"
"	float angle = acos(dot(r2, x));\n"
"	\n"
"	// decide if we hit a white or black ring, based on y value\n"
"	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"
"}\n";
 
const string IsophoteLineRenderer::vss = 
"varying vec3 n;\n"
"varying vec3 v;\n"
"\n"
"void main(void)\n"
"{\n"
"	gl_Position = ftransform();\n"
"	v = vec3(gl_ModelViewMatrix * gl_Vertex);\n"
"	n = normalize(gl_NormalMatrix * gl_Normal);\n"
"}\n";
 
 
const string IsophoteLineRenderer::fss = 
"uniform float detail;\n"
"\n"
"varying vec3 n;\n"
"varying vec3 v;\n"
"\n"
"void main(void)\n"
"{\n"
"	vec3 viewer_lightdir = vec3(0, 0, 1.0);\n"
"	vec3 isophote_lightdir = viewer_lightdir;\n"
"	float angle = acos(dot(n, isophote_lightdir));\n"
"   float diff  = dot(n,viewer_lightdir);\n"
"	\n"
"	// decide if we hit a white or black ring, based on y value\n"
"	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"
"}\n";
 
const string ToonRenderer::vss = 
"varying vec3 n;\n"
"varying vec3 v;\n"
"\n"
"void main(void)\n"
"{\n"
"	gl_Position = ftransform();\n"
"	v = vec3(gl_ModelViewMatrix * gl_Vertex);\n"
"	n = normalize(gl_NormalMatrix * gl_Normal);\n"
"}\n";
 
const string ToonRenderer::fss = 
"varying vec3 n;\n"
"varying vec3 v;\n"
"\n"
"void main(void)\n"
"{\n"
"	vec3 l = normalize(-v);\n"
"	vec3 e = l;\n"
"	vec3 r = normalize(2.0*dot(l, n)*n - l);\n"
"	\n"
"	vec4 a = vec4(0.0,0.1,.3,1.0);\n"
"   float dot_ln = abs(dot(l, n));\n"
"	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"
"	vec4 s = vec4(0.5,0.3,0.4,1.0)*smoothstep(0.96,0.98,dot(r, e));\n"
"	\n"
"	gl_FragColor =  d+s;\n"
"}\n";
 
 
void GlazedRenderer::draw()
{
	GLint old_prog;
	glGetIntegerv(GL_CURRENT_PROGRAM, &old_prog);
	glUseProgram(prog);
	glBindTexture(GL_TEXTURE_3D, get_noise_texture_id());
	glUniform1iARB(glGetUniformLocationARB(prog, "noise_tex"),0);
	glUniform1fARB(glGetUniformLocationARB(prog, "noise_scale"),12.0/bsphere_rad);
	glCallList(display_list);
	glUseProgram(old_prog);
}
 
 
 
const string GlazedRenderer::vss = 
"varying vec3 n;\n"
"varying vec3 v;\n"
"varying vec3 v_obj;\n"
"\n"
"void main(void)\n"
"{\n"
"	gl_Position = ftransform();\n"
"   v_obj = gl_Vertex.xyz;\n"
"	v = vec3(gl_ModelViewMatrix * gl_Vertex);\n"
"	n = normalize(gl_NormalMatrix * gl_Normal);\n"
"}\n"
"\n";
 
const string GlazedRenderer::fss =
"uniform sampler3D noise_tex;\n"
"uniform float noise_scale;\n"
"varying vec3 n;\n"
"varying vec3 v;\n"
"varying vec3 v_obj;\n"
"\n"
"vec4 glazed_shader(vec4 mat_col,  vec4 light_col, vec3 light_dir)\n"
"{\n"
"	vec3 e = normalize(-v);\n"
"	vec3 r = normalize(2.0*dot(e, n)*n - e);\n"
"	float d = max(0.05,dot(light_dir, n));\n"
"	vec4 diff = mat_col * light_col *d; 	\n"
"	vec4 refl = smoothstep(0.7,0.75,dot(r,light_dir)) * light_col;\n"
"	return 0.15*refl + diff;\n"
"}\n"
"\n"
"void main(void)\n"
"{\n"
"	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"
" + vec4(0.05) * texture3D(noise_tex, 500.0*v_obj).x;\n"
"	\n"
"	vec3 light0_dir = vec3(0.0,1.0,0.0);\n"
"	vec4 light0_col = vec4(0.7,0.9,1.0,1.0);\n"
"	\n"
"	vec3 light1_dir = vec3(0.0,0.0,1.0);\n"
"	vec4 light1_col = vec4(1.0,1.0,0.7,1.0);\n"
"	\n"
"	gl_FragColor = \n"
"	0.5*glazed_shader(mat_col, light0_col, light0_dir)+\n"
"	0.5*glazed_shader(mat_col, light1_col, light1_dir);\n"
"	\n"
"	gl_FragColor.a = 1.0;\n"
"}\n";
 
 
const string ScalarFieldRenderer::vss =
"	attribute float scalar;\n"
"	varying vec3 normal;\n"
"	varying float s;\n"
"	\n"
"	void main(void)\n"
"	{\n"
"		gl_Position =  ftransform();\n"
"		normal = normalize(gl_NormalMatrix * gl_Normal);\n"
"		s=scalar;\n"
"	}\n";
 
const string ScalarFieldRenderer::fss = 	
"	varying vec3 normal;\n"
"	varying float s;\n"
"	uniform float scalar_max;\n"
"   uniform float gamma;\n"
"	const vec3 light_dir = vec3(0,0,1);\n"
"	\n"
"	void main()\n"
"	{\n"
"		float dot_ln = max(0.0,dot(light_dir, normal));\n"
"		\n"
"		float s_norm = s/scalar_max;\n"
"		float stripe_signal = 100.0 * s_norm;\n"
"		vec4 stripe_col = abs(stripe_signal) < 3.14 ? vec4(0,0,0,0) : vec4(.1,.1,.1,0);\n"
"		\n"
"		gl_FragColor = s_norm * vec4(-1,0,1,0);\n"
"       gl_FragColor *= dot_ln;\n"
"       gl_FragColor.r = pow(gl_FragColor.r, 1.0/gamma);\n"
"       gl_FragColor.g = pow(gl_FragColor.g, 1.0/gamma);\n"
"       gl_FragColor.b = pow(gl_FragColor.b, 1.0/gamma);\n"
"		gl_FragColor += stripe_col * smoothstep(0.8,1.0,cos(stripe_signal));\n"
"	}\n";
 
ScalarFieldRenderer::ScalarFieldRenderer(HMesh::Manifold& m, bool smooth,
										 std::vector<double>& field, double max_val):
SimpleShaderRenderer(vss,fss)
{
	
	GLint old_prog;
	glGetIntegerv(GL_CURRENT_PROGRAM, &old_prog);
	glUseProgram(prog);
	
	GLuint scalar_attrib = glGetAttribLocation(prog, "scalar");
	glUniform1fARB(glGetUniformLocationARB(prog, "scalar_max"), max_val);
	
	static float& gamma = CreateCVar("display.scalar_field_renderer.gamma",2.2f);
	glUniform1fARB(glGetUniformLocationARB(prog, "gamma"), gamma);
	glNewList(display_list,GL_COMPILE);
	
	for(FaceIter f=m.faces_begin(); f != m.faces_end(); ++f)
	{
		FaceCirculator fc(f);
		if(!smooth) 
			glNormal3fv(normal(f).get());
		if(no_edges(f)== 3) 
			glBegin(GL_TRIANGLES);
		else 
			glBegin(GL_POLYGON);
		
		while(!fc.end())
		{
			Vec3d n(normal(fc.get_vertex()));
			if(smooth) 
				glNormal3dv(n.get());
			int i = fc.get_vertex()->touched;
			glVertexAttrib1d(scalar_attrib, field[i]);
			glVertex3fv(fc.get_vertex()->pos.get());
			++fc;
		}
		glEnd();
	}
	glEndList();	
	glUseProgram(old_prog);
	
}
 
const string AmbientOcclusionRenderer::vss =
"	attribute float scalar;\n"
"	varying vec3 normal;\n"
"	varying float s;\n"
"	\n"
"	void main(void)\n"
"	{\n"
"		gl_Position =  ftransform();\n"
"		normal = normalize(gl_NormalMatrix * gl_Normal);\n"
"		s=scalar;\n"
"	}\n";
 
const string AmbientOcclusionRenderer::fss = 	
"	varying vec3 normal;\n"
"	varying float s;\n"
"	uniform float scalar_max;\n"
"   uniform float gamma;\n"
"   uniform bool lighton;\n"
"	const vec3 light_dir = vec3(0,0,1);\n"
"	\n"
"	void main()\n"
"	{\n"
"		float dot_ln = max(0.0,dot(light_dir, normal));\n"
"		\n"
"		float s_norm = min(1.0,s/scalar_max+1.0);\n"
"		\n"
"		gl_FragColor = s_norm * vec4(1.0);\n"
"       if(lighton) gl_FragColor *= dot_ln;\n"
"       gl_FragColor.r = pow(gl_FragColor.r, 1.0/gamma);\n"
"       gl_FragColor.g = pow(gl_FragColor.g, 1.0/gamma);\n"
"       gl_FragColor.b = pow(gl_FragColor.b, 1.0/gamma);\n"
"	}\n";
 
AmbientOcclusionRenderer::AmbientOcclusionRenderer(HMesh::Manifold& m, bool smooth,
												   std::vector<double>& field, double max_val):
SimpleShaderRenderer(vss,fss)
{	
	GLint old_prog;
	glGetIntegerv(GL_CURRENT_PROGRAM, &old_prog);
	glUseProgram(prog);
	
	GLuint scalar_attrib = glGetAttribLocation(prog, "scalar");
	glUniform1fARB(glGetUniformLocationARB(prog, "scalar_max"), max_val);
	
	static float& gamma = CreateCVar("display.ambient_occlusion_renderer.gamma",1.5f);
	glUniform1fARB(glGetUniformLocationARB(prog, "gamma"), gamma);
	static int& lighton = CreateCVar("display.ambient_occlusion_renderer.light",1);
	glUniform1iARB(glGetUniformLocationARB(prog, "lighton"), lighton);
	glNewList(display_list,GL_COMPILE);
	
	for(FaceIter f=m.faces_begin(); f != m.faces_end(); ++f)
	{
		FaceCirculator fc(f);
		if(!smooth) 
			glNormal3fv(normal(f).get());
		if(no_edges(f)== 3) 
			glBegin(GL_TRIANGLES);
		else 
			glBegin(GL_POLYGON);
		
		while(!fc.end())
		{
			Vec3d n(normal(fc.get_vertex()));
			if(smooth) 
				glNormal3dv(n.get());
			int i = fc.get_vertex()->touched;
			glVertexAttrib1d(scalar_attrib, field[i]);
			glVertex3fv(fc.get_vertex()->pos.get());
			++fc;
		}
		glEnd();
	}
	glEndList();	
	glUseProgram(old_prog);
	
}
 
const string CopperRenderer::vss =
"	attribute float scalar;\n"
"	varying vec3 normal;\n"
"varying vec3 v_obj;\n"
"	varying float s;\n"
"	\n"
"	void main(void)\n"
"	{\n"
"		gl_Position =  ftransform();\n"
"		normal = normalize(gl_NormalMatrix * gl_Normal);\n"
"		s=scalar;\n"
"       v_obj = gl_Vertex.xyz;\n"
"	}\n";
 
const string CopperRenderer::fss =
"uniform sampler3D noise_tex;\n"
"uniform float noise_scale;\n"
"	varying vec3 normal;\n"
"   varying vec3 v_obj;\n"
"	varying float s;\n"
"	uniform float scalar_max;\n"
"	const vec3 light_dir = vec3(0,0,1);\n"
"	\n"
"   float turb(vec3 x) { return 0.25*(texture3D(noise_tex,0.12*noise_scale*x).x+\n"
"			texture3D(noise_tex,0.531*noise_scale*x).x+\n"
"			texture3D(noise_tex,0.098*noise_scale*x).x+\n"
"			texture3D(noise_tex,1.0121*noise_scale*x).x);}\n"
"	void main()\n"
"	{\n"
"		float diff = max(0.0,dot(light_dir, normal));\n"
"	    vec3 r = normalize(2.0*dot(light_dir, normal)*normal - light_dir);\n"
"		float spec = pow(dot(r, normal),20.0);\n"
"		\n"
"		float s_norm = 0.95*s/scalar_max+0.05*turb(v_obj);\n"
"       vec4 copper =  vec4(1,0.70,.5,1);\n"
"       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"
"		vec4 material = copper*smoothstep(0.15,0.25,s_norm) + \n"
"		corroded*smoothstep(0.25,0.15,s_norm)*smoothstep(-0.3,-0.05,s_norm);\n"
"		gl_FragColor = material*diff+smoothstep(0.15,0.25,s_norm)*vec4(0.3,0.3,0.3,1)*spec;\n"
"	}\n";
 
CopperRenderer::CopperRenderer(HMesh::Manifold& m, bool smooth,
							   std::vector<double>& field, double max_val, float _bsphere_rad): 
SimpleShaderRenderer(vss,fss), bsphere_rad(_bsphere_rad)
{
	GLint old_prog;
	glGetIntegerv(GL_CURRENT_PROGRAM, &old_prog);
	glUseProgram(prog);
	
	GLuint scalar_attrib = glGetAttribLocation(prog, "scalar");
	glUniform1fARB(glGetUniformLocationARB(prog, "scalar_max"), max_val);
	
	static float& gamma = CreateCVar("display.patina_renderer.gamma",1.5f);
	glUniform1fARB(glGetUniformLocationARB(prog, "gamma"), gamma);
	static int& lighton = CreateCVar("display.patina_renderer.light",1);
	glUniform1iARB(glGetUniformLocationARB(prog, "lighton"), lighton);
	glUniform1iARB(glGetUniformLocationARB(prog, "noise_tex"),0);
	glUniform1fARB(glGetUniformLocationARB(prog, "noise_scale"),12.0/bsphere_rad);
 
	glNewList(display_list,GL_COMPILE);
	for(FaceIter f=m.faces_begin(); f != m.faces_end(); ++f)
	{
		FaceCirculator fc(f);
		if(!smooth) 
			glNormal3fv(normal(f).get());
		if(no_edges(f)== 3) 
			glBegin(GL_TRIANGLES);
		else 
			glBegin(GL_POLYGON);
		
		while(!fc.end())
		{
			Vec3d n(normal(fc.get_vertex()));
			if(smooth) 
				glNormal3dv(n.get());
			int i = fc.get_vertex()->touched;
			glVertexAttrib1d(scalar_attrib, field[i]);
			glVertex3fv(fc.get_vertex()->pos.get());
			++fc;
		}
		glEnd();
	}
	glEndList();	
	glUseProgram(old_prog);
	
}
 
void CopperRenderer::draw()
{
	GLint old_prog;
	glGetIntegerv(GL_CURRENT_PROGRAM, &old_prog);
	glUseProgram(prog);
	glBindTexture(GL_TEXTURE_3D, get_noise_texture_id());
	glCallList(display_list);
	glUseProgram(old_prog);
}
 
LineFieldRenderer::LineFieldRenderer(HMesh::Manifold& m, bool smooth, vector<Vec3d>& lines, float _r): 
	SimpleShaderRenderer(vss,fss), r(_r)
{
	GLint old_prog;
	glGetIntegerv(GL_CURRENT_PROGRAM, &old_prog);
	glUseProgram(prog);	
	static float& curvature_lines_scale = CreateCVar("display.line_field_renderer.line_length", .015f);
	static float& noise_scale = CreateCVar("display.line_field_renderer.noise_scale", 12.0f/r);
	static float& noise_amplitude = CreateCVar("display.line_field_renderer.noise_amplitude", .06f);
	glUniform1fARB(glGetUniformLocationARB(prog, "scale_line"),curvature_lines_scale);
	glUniform1fARB(glGetUniformLocationARB(prog, "noise_scale"),noise_scale);
	glUniform1fARB(glGetUniformLocationARB(prog, "noise_amplitude"),noise_amplitude);	
	glUniform1iARB(glGetUniformLocationARB(prog, "noise_tex"),0);
	GLuint direction = glGetAttribLocation(prog, "direction");	
	glNewList(display_list,GL_COMPILE);
	for(FaceIter f=m.faces_begin(); f != m.faces_end(); ++f)
	{
		FaceCirculator fc(f);
		if(!smooth) 
			glNormal3fv(normal(f).get());
		if(no_edges(f)== 3) 
			glBegin(GL_TRIANGLES);
		else 
			glBegin(GL_POLYGON);
		while(!fc.end())
		{
			Vec3d n(normal(fc.get_vertex()));
			if(smooth) 
				glNormal3dv(n.get());
			int i = fc.get_vertex()->touched;
			Vec3d d = lines[i];
			d = normalize(d-n*dot(n,d));
			glVertexAttrib3dv(direction, d.get());
			glVertex3fv(fc.get_vertex()->pos.get());
			++fc;
		}
		glEnd();
	}
	
	glBindTexture(GL_TEXTURE_3D, 0);
	glEndList();	
	glUseProgram(old_prog);
 
}
 
void LineFieldRenderer::draw()
{
	GLint old_prog;
	glGetIntegerv(GL_CURRENT_PROGRAM, &old_prog);
	glUseProgram(prog);
	glBindTexture(GL_TEXTURE_3D, get_noise_texture_id());
	glCallList(display_list);
	glBindTexture(GL_TEXTURE_3D, 0);
	glUseProgram(old_prog);	
}
 
const string LineFieldRenderer::vss = 
"attribute vec3 direction;\n"
"varying vec3 n;\n"
"varying vec3 dir_obj;\n"
"varying vec3 v_obj;\n"
"\n"
"void main(void)\n"
"{\n"
"	gl_Position = ftransform();\n"
"   v_obj = gl_Vertex.xyz;\n"
"	dir_obj = direction;\n"
"	n = normalize(gl_NormalMatrix * gl_Normal);\n"
"}\n";
 
const string LineFieldRenderer::fss =
"uniform sampler3D noise_tex;\n"
"uniform float scale_line;\n"
"uniform float noise_amplitude;\n"
"uniform float noise_scale;\n"
"varying vec3 n;\n"
"varying vec3 dir_obj;\n"
"varying vec3 v_obj;\n"
"\n"
"float tex(vec3 p) {return smoothstep(0.23,0.25,texture3D(noise_tex, p).x);}\n"
"void main(void)\n"
"{\n"
"   float I = "
"             tex(noise_scale*v_obj + 6.0*scale_line*dir_obj) + \n"
"             tex(noise_scale*v_obj - 6.0*scale_line*dir_obj) + \n"
"             tex(noise_scale*v_obj + 5.0*scale_line*dir_obj) + \n"
"             tex(noise_scale*v_obj - 5.0*scale_line*dir_obj) + \n"
"             tex(noise_scale*v_obj + 4.0*scale_line*dir_obj) + \n"
"             tex(noise_scale*v_obj - 4.0*scale_line*dir_obj) + \n"
"             tex(noise_scale*v_obj + 3.0*scale_line*dir_obj) + \n"
"             tex(noise_scale*v_obj - 3.0*scale_line*dir_obj) + \n"
"             tex(noise_scale*v_obj + 2.0*scale_line*dir_obj) + \n"
"             tex(noise_scale*v_obj - 2.0*scale_line*dir_obj) + \n"
"             tex(noise_scale*v_obj + 1.0*scale_line*dir_obj) + \n"
"             tex(noise_scale*v_obj - 1.0*scale_line*dir_obj) + \n"
"			  tex(noise_scale*v_obj); \n"
"	\n"
"   float diff = max(0.0,dot(n,vec3(0.0, 0.0, 1.0)));\n"
"	gl_FragColor.rgb = vec3(1)*diff*I*(1.0/13.0);\n"
"	gl_FragColor.a = 1.0;\n"
"}\n";
 
const string DualVertexRenderer::vss = 
"#version 120\n"
"#extension GL_EXT_gpu_shader4 : enable\n"
"varying vec4 diffuseIn;\n"
"varying vec3 normalIn;\n"
"void main(void)\n"
"{\n"
"   diffuseIn = gl_Color;\n"
"   normalIn = normalize(gl_NormalMatrix*gl_Normal);\n"
"   gl_Position =  ftransform();\n"
"}\n";
 
const string DualVertexRenderer::gss = 
"#version 120\n"
"#extension GL_EXT_gpu_shader4 : enable\n"
"#extension GL_EXT_geometry_shader4 : enable\n"
"\n"
"varying in vec4 diffuseIn[3];\n"
"varying in vec3 normalIn[3];\n"
"varying vec4 diffuse[3];\n"
"varying float f;\n"
"varying vec3 normal;\n"
"void main(void)\n"
"{\n"
"  diffuse[0] = diffuseIn[0];\n"
"  diffuse[1] = diffuseIn[1];\n"
"  diffuse[2] = diffuseIn[2];\n"
"\n"
"  f = diffuseIn[0].a;\n"
"  gl_Position = gl_PositionIn[0];\n"
"  normal = normalIn[0];\n"
"  EmitVertex();\n"
"	\n"
"  f = diffuseIn[1].a;\n"
"  gl_Position = gl_PositionIn[1];\n"
"  normal = normalIn[1];\n"
"  EmitVertex();\n"
"\n"
"  f = diffuseIn[2].a;\n"
"  gl_Position = gl_PositionIn[2];\n"
"  normal = normalIn[2];\n"
"  EmitVertex();\n"
"\n"
"  EndPrimitive();\n"
"}\n";
 
const string DualVertexRenderer::fss =
"#version 120\n"
"#extension GL_EXT_gpu_shader4 : enable\n"
"\n"
"varying float f;\n"
"varying vec4 diffuse[3];\n"
"varying vec3 normal;\n"
"\n"
"void main(void)\n"
"{\n"
"   float col_idx=0;\n"
"   if(f>diffuse[0].g && f<diffuse[0].b)\n"
"      col_idx = diffuse[0].r;\n"
"   else if(f>diffuse[1].g && f<diffuse[1].b)\n"
"      col_idx = diffuse[1].r;\n"
"   else if(f>diffuse[2].g && f<diffuse[2].b)\n"
"      col_idx = diffuse[2].r;\n"
"   vec4 col = col_idx < .5 ? vec4(1,0,0,0) : vec4(0,0,1,0);\n"
"\n"
" 	gl_FragColor =col*dot(normal, vec3(0,0,1));\n"
"}\n";
 
 
 
 
	DualVertexRenderer::DualVertexRenderer(HMesh::Manifold& m, std::vector<Vec4d>& field)
	{		
		// Create the program
		static GLuint prog = glCreateProgram();
 
		static bool was_here = false;
		if(!was_here)
		{
			was_here = true;
			// Create s	haders directly from file
			static GLuint vs = create_glsl_shader(GL_VERTEX_SHADER, vss);
			static GLuint gs = create_glsl_shader(GL_GEOMETRY_SHADER_EXT, gss);
			static GLuint fs = create_glsl_shader(GL_FRAGMENT_SHADER, fss);
			
			// Attach all shaders
			if(vs) glAttachShader(prog, vs);
			if(gs) glAttachShader(prog, gs);
			if(fs) glAttachShader(prog, fs);
			
			// Specify input and output for the geometry shader. Note that this must be
			// done before linking the program.
			glProgramParameteriEXT(prog,GL_GEOMETRY_INPUT_TYPE_EXT,GL_TRIANGLES);
			glProgramParameteriEXT(prog,GL_GEOMETRY_VERTICES_OUT_EXT,3);
			glProgramParameteriEXT(prog,GL_GEOMETRY_OUTPUT_TYPE_EXT,GL_TRIANGLE_STRIP);
			
			// Link the program object and print out the info log
			glLinkProgram(prog);
		}
		
		
		
		GLint old_prog;
		glGetIntegerv(GL_CURRENT_PROGRAM, &old_prog);
		
		glNewList(display_list,GL_COMPILE);
		glUseProgram(prog);
		for(FaceIter f=m.faces_begin(); f != m.faces_end(); ++f)
		{
			FaceCirculator fc(f);
			if(no_edges(f) != 3) 
				continue;
			else 
				glBegin(GL_TRIANGLES);
			
			while(!fc.end())
			{
				Vec3d n(normal(fc.get_vertex()));
				glNormal3dv(n.get());
				int i = fc.get_vertex()->touched;
				glColor4dv(field[i].get());
				glVertex3fv(fc.get_vertex()->pos.get());
				++fc;
			}
			glEnd();
		}
		glUseProgram(old_prog);
		glEndList();	
		
	}
 
 
	
 
Generated by GNU Enscript 1.6.6.
 
 
 

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

Subversion Repositories gelsvn

(root)/trunk/apps/MeshEdit/Renderer.cpp @ 521 – Rev 417 → 456