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 <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;
 
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(rand()) / 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 CVar<float> gamma("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 CVar<float> gamma("display.ambient_occlusion_renderer.gamma",1.5);
	glUniform1fARB(glGetUniformLocationARB(prog, "gamma"), gamma);
	static CVar<int> lighton("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 CVar<float> gamma("display.patina_renderer.gamma",1.5);
	glUniform1fARB(glGetUniformLocationARB(prog, "gamma"), gamma);
	static CVar<int> lighton("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 CVar<float> curvature_lines_scale("display.line_field_renderer.line_length", .015f);
	static CVar<float> noise_scale("display.line_field_renderer.noise_scale", 12.0f/r);
	static CVar<float> noise_amplitude("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.25,0.5,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*noise_amplitude;\n"
"	gl_FragColor.a = 1.0;\n"
"}\n";
 

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

Subversion Repositories gelsvn

(root)/trunk/apps/MeshEdit/Renderer.cpp @ 410 – Rev 406 → 409