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


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

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

Subversion Repositories gelsvn

(root)/trunk/apps/MeshEdit/Renderer.cpp @ 448 – Rev 412 → 417