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;
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(random()) / 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";
 

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

Subversion Repositories gelsvn

(root)/trunk/apps/MeshEdit/Renderer.cpp @ 413 – Rev 409 → 412