WebSVN – gelsvn – Diff – /branches/cpp11-devel/src/GLGraphics/ManifoldRenderer.cpp


/* ----------------------------------------------------------------------- *
 * This file is part of GEL, http://www.imm.dtu.dk/GEL
 * Copyright (C) the authors and DTU Informatics
 * For license and list of authors, see ../../doc/intro.pdf
 * ----------------------------------------------------------------------- */
 
#include "ManifoldRenderer.h"
 
#include <GLUT/GLUT.h>
 
#include <algorithm>
#include <string>
#include <cstdlib>
#include "../Geometry/TriMesh.h"
#include "../CGLA/Mat3x3d.h"
#include "../GLGraphics/glsl_shader.h"
#include "../GLGraphics/draw.h"
#include "../HMesh/Manifold.h"
#include "../HMesh/AttributeVector.h"
#include "../HMesh/curvature.h"
 
using namespace CGLA;
using namespace HMesh;
using namespace std;
using namespace Geometry;
namespace GLGraphics
{    
    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(const Manifold& m)
    {
        int max_val = 0;
        for(FaceIDIterator f = m.faces_begin(); f != m.faces_end(); ++f)
            max_val = max(max_val, no_edges(m, *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)
        {
            glEnable(GL_LIGHTING);
            idbuff_renderer->draw(Vec3f(1,0,0),Vec3f(1));
            glDisable(GL_LIGHTING);
        }
        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(const Manifold& m, bool smooth)
    {
        GLint old_prog;
        glGetIntegerv(GL_CURRENT_PROGRAM, &old_prog);
        glUseProgram(prog);
        glNewList(display_list,GL_COMPILE);
        GLGraphics::draw(m, smooth);
        glEndList();	
        glUseProgram(old_prog);
    }
    
    void SimpleShaderRenderer::draw()
    {
        GLint old_prog;
        glGetIntegerv(GL_CURRENT_PROGRAM, &old_prog);
        glUseProgram(prog);
        glCallList(display_list);
        glUseProgram(old_prog);
    }
    
    const string NormalRenderer::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 NormalRenderer::fss =
    "varying vec3 _n;\n"
    "varying vec3 v;\n"
    "\n"
    "void main(void)\n"
    "{\n"
    "   vec3 n = normalize(_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) * dot_ln;\n"
    "	vec4 s = vec4(0.3)*smoothstep(0.98,0.9999,dot(r, e));\n"
    "	\n"
    "	gl_FragColor =  d+s;\n"
    "}\n";
    
    const string DebugRenderer::vss =
    "varying vec3 _n;\n"
    "varying vec3 v;\n"
    "varying vec3 c;\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"
    "   c = gl_Color.rgb;\n"
    "}\n";
    
    const string DebugRenderer::fss =
    "varying vec3 _n;\n"
    "varying vec3 v;\n"
    "varying vec3 c;\n"
    "\n"
    "void main(void)\n"
    "{\n"
    "   vec3 n = normalize(_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(c,1) * 0.7 * dot_ln;\n"
    "	vec4 s = vec4(c,1) * 0.3 * smoothstep(0.98,0.9999,dot(r, e));\n"
    "	\n"
    "	gl_FragColor =  vec4(c,1);\n"
    "}\n";
    
    HMesh::VertexAttributeVector<CGLA::Vec3f> DebugRenderer::vertex_colors;
    HMesh::HalfEdgeAttributeVector<CGLA::Vec3f> DebugRenderer::edge_colors;
    HMesh::FaceAttributeVector<CGLA::Vec3f> DebugRenderer::face_colors;
 
    
    void DebugRenderer::compile_display_list(const HMesh::Manifold& m, bool smooth, float rad)
    {
        GLint old_prog;
        glGetIntegerv(GL_CURRENT_PROGRAM, &old_prog);
        glUseProgram(prog);
        glNewList(display_list,GL_COMPILE);
        glEnable(GL_POLYGON_OFFSET_FILL);
        glPolygonOffset(1,1);
        for(FaceID f: m.faces()){
            Vec3f c = face_colors[f];
            glColor3f(c[0], c[1], c[2]);
            if(!smooth)
                glNormal3dv(normal(m, f).get());
            if(no_edges(m, f)== 3)
                glBegin(GL_TRIANGLES);
            else
                glBegin(GL_POLYGON);
            
            for(Walker w = m.walker(f); !w.full_circle(); w = w.circulate_face_ccw()){
                Vec3d n = normal(m, w.vertex());
                if(smooth)
                    glNormal3dv(n.get());
                glVertex3dv(m.pos(w.vertex()).get());
            }
            glEnd();
        }
        glLineWidth(2);
        glDisable(GL_POLYGON_OFFSET_FILL);
        glBegin(GL_LINES);
        for(auto hid: m.halfedges())
        {
            Walker w = m.walker(hid);
            Vec3f c = edge_colors[hid];
            glColor3fv(c.get());
            glNormal3dv(normal(m, w.opp().vertex()).get());
            glVertex3dv(m.pos(w.opp().vertex()).get());
            glNormal3dv(normal(m, w.vertex()).get());
            glVertex3dv(m.pos(w.vertex()).get());
        }
        glEnd();
        glLineWidth(1);
        Vec3d c;
        float r;
        bsphere(m, c, r);
        r *= rad;
        for(auto vid : m.vertices())
        {
            Vec3d p = m.pos(vid);
            Vec3f c = vertex_colors[vid];
            glColor3f(c[0], c[1], c[2]);
            glPushMatrix();
            glTranslated(p[0], p[1], p[2]);
            glScalef(r, r, r);
            draw_ball();
            glPopMatrix();
        }
        glEnd();
        glEndList();
        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"
    "   vec3 n = normalize(_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(1.0) + smoothstep(0.8, 1.0,cos(13.0*angle)) * vec4(-1.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 n = normalize(_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(1.0) + smoothstep(0.8, 1.0,cos(20.0*angle)) * vec4(-1.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 n = normalize(_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::compile_display_list(const HMesh::Manifold& m, bool smooth)
    {
        GLint old_prog;
        glGetIntegerv(GL_CURRENT_PROGRAM, &old_prog);
        glUseProgram(prog);
        glNewList(display_list,GL_COMPILE);
        glBindTexture(GL_TEXTURE_3D, get_noise_texture_id());
        glUniform1iARB(glGetUniformLocationARB(prog, "noise_tex"),0);
        float r;
        Vec3d c;
        bsphere(m, c, r);
        glUniform1fARB(glGetUniformLocationARB(prog, "noise_scale"),12.0/r);
        GLGraphics::draw(m, smooth);
        glEndList();
        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 n = normalize(_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"
    "       vec3 normal = normalize(_normal);\n"
    "		float dot_ln = max(0.0,dot(light_dir, normal));\n"
    "		\n"
    "		float s_norm = s/scalar_max;\n"
    "		float stripe_signal = 50.0 * s_norm;\n"
    "		vec4 stripe_col = vec4(.9,.9,.9,0);\n"
    "		\n"
    "		gl_FragColor = max(vec4(0), 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 += 0.2*stripe_col * pow(cos(stripe_signal),70.0);\n"
    "	}\n";
    
    void ScalarFieldRenderer::compile_display_list(const HMesh::Manifold& m, bool smooth,
                                                   HMesh::VertexAttributeVector<double>& field, double max_val, float gamma)
    {
        
        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(FaceIDIterator f = m.faces_begin(); f != m.faces_end(); ++f){
            if(!smooth)
                glNormal3dv(normal(m, *f).get());
            if(no_edges(m, *f)== 3)
                glBegin(GL_TRIANGLES);
            else
                glBegin(GL_POLYGON);
            
            
            for(Walker w = m.walker(*f); !w.full_circle(); w = w.circulate_face_ccw()){
                Vec3d n(normal(m, w.vertex()));
                if(smooth)
                    glNormal3dv(n.get());
                glVertexAttrib1d(scalar_attrib, field[w.vertex()]);
                glVertex3dv(m.pos(w.vertex()).get());
            }
            glEnd();
        }
        glEndList();
        glUseProgram(old_prog);
        
    }
    
    HMesh::VertexAttributeVector<CGLA::Vec2f> CheckerBoardRenderer::param;
 
    const string CheckerBoardRenderer::vss =
    "	attribute vec2 param;\n"
    "	varying vec3 _normal;\n"
    "	varying vec2 uv;\n"
    "	\n"
    "	void main(void)\n"
    "	{\n"
    "		gl_Position =  ftransform();\n"
    "		_normal = normalize(gl_NormalMatrix * gl_Normal);\n"
    "		uv=param;\n"
    "	}\n";
    
    const string CheckerBoardRenderer::fss =
    "	varying vec3 _normal;\n"
    "	varying vec2 uv;\n"
    "   const float pi = 3.14159265359;\n"
    "	const vec3 light_dir = vec3(0,0,1);\n"
    "	\n"
    "	void main()\n"
    "	{\n"
    "       vec3 normal = normalize(_normal);\n"
    "		float dot_ln = max(0.0,dot(light_dir, normal));\n"
    "		vec2 rt = uv;//vec2(length(uv),atan(uv.y, uv.x));\n"
    "		float stripe_signal = smoothstep(-0.001,0.001,sin(2.0*pi*rt.x)*sin(10.0*rt.y));\n"
    "		\n"
    "		gl_FragColor = dot_ln * vec4(0.35,0.25,0.5,0);\n"
   "		gl_FragColor.rgb += 0.7*stripe_signal;\n"
    "	}\n";
    
    void CheckerBoardRenderer::compile_display_list(const HMesh::Manifold& m, bool smooth)
    {
        
        GLint old_prog;
        glGetIntegerv(GL_CURRENT_PROGRAM, &old_prog);
        glUseProgram(prog);
        
        GLuint param_attrib = glGetAttribLocation(prog, "param");
        glNewList(display_list,GL_COMPILE);
 
        for(FaceIDIterator f = m.faces_begin(); f != m.faces_end(); ++f){
            if(!smooth)
                glNormal3dv(normal(m, *f).get());
            if(no_edges(m, *f)== 3)
                glBegin(GL_TRIANGLES);
            else
                glBegin(GL_POLYGON);
            
            
            for(Walker w = m.walker(*f); !w.full_circle(); w = w.circulate_face_ccw()){
                Vec3d n(normal(m, w.vertex()));
                if(smooth)
                    glNormal3dv(n.get());
                glVertexAttrib2fv(param_attrib, param[w.vertex()].get());
                glVertex3dv(m.pos(w.vertex()).get());
            }
            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"
    "	const vec3 light_dir = vec3(0,0,1);\n"
    "	\n"
    "	void main()\n"
    "	{\n"
    "   vec3 normal = normalize(_normal);\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"
    "       gl_FragColor *= dot_ln;\n"
    "       gl_FragColor.r = pow(gl_FragColor.r, 1.0);\n"
    "       gl_FragColor.g = pow(gl_FragColor.g, 1.0);\n"
    "       gl_FragColor.b = pow(gl_FragColor.b, 1.0);\n"
    "	}\n";
    
    void AmbientOcclusionRenderer::compile_display_list(const HMesh::Manifold& m, HMesh::VertexAttributeVector<double>& field, double max_val)
    {	
        GLint old_prog;
        glGetIntegerv(GL_CURRENT_PROGRAM, &old_prog);
        glUseProgram(prog);
        
        GLuint scalar_attrib = glGetAttribLocation(prog, "scalar");
        glUniform1fARB(glGetUniformLocationARB(prog, "scalar_max"), max_val);
        
        glNewList(display_list,GL_COMPILE);
        
        for(FaceIDIterator f = m.faces_begin(); f != m.faces_end(); ++f){
 
            if(no_edges(m, *f)== 3)
                glBegin(GL_TRIANGLES);
            else 
                glBegin(GL_POLYGON);
            
            for(Walker w = m.walker(*f); !w.full_circle(); w = w.circulate_face_ccw())
            {
                Vec3d n(normal(m, w.vertex()));
                glNormal3dv(n.get());
                glVertexAttrib1d(scalar_attrib, field[w.vertex()]);
                glVertex3dv(m.pos(w.vertex()).get());
            }
            glEnd();
        }
        glEndList();	
        glUseProgram(old_prog);
        
    }
    
    
    void LineFieldRenderer::compile_display_list(const HMesh::Manifold& m,HMesh::VertexAttributeVector<CGLA::Vec3d>& lines)
    {
        float r;
        Vec3d c;
        bsphere(m, c, r);
        float noise_scale = 10.0f/r;
        float line_scale = 0.02f;
        
        GLint old_prog;
        glGetIntegerv(GL_CURRENT_PROGRAM, &old_prog);
        glUseProgram(prog);
        glNewList(display_list,GL_COMPILE);
        glUniform1fARB(glGetUniformLocationARB(prog, "line_scale"),line_scale);
        glUniform1fARB(glGetUniformLocationARB(prog, "noise_scale"),noise_scale);
        glUniform1iARB(glGetUniformLocationARB(prog, "noise_tex"),0);
        GLuint direction = glGetAttribLocation(prog, "direction");	
        glBindTexture(GL_TEXTURE_3D, get_noise_texture_id());
 
 
        for(FaceIDIterator f = m.faces_begin(); f != m.faces_end(); ++f){
            if(no_edges(m, *f) == 3)
                glBegin(GL_TRIANGLES);
            else 
                glBegin(GL_POLYGON);
            
            Vec3d n(normal(m, *f));
            Vec3d d0 = lines[m.walker(*f).vertex()];
            d0 = normalize(d0-n*dot(n,d0));
            for(Walker w = m.walker(*f); !w.full_circle(); w = w.circulate_face_ccw()){
                Vec3d n(normal(m, w.vertex()));
                glNormal3dv(n.get());
                
                Vec3d d = lines[w.vertex()];
                d = normalize(d-n*dot(n,d));
                if(dot(d,d0)<0) d=-d;
                glVertexAttrib3dv(direction, d.get());
                glVertex3dv(m.pos(w.vertex()).get());
            }
            glEnd();
        }
 
        glBindTexture(GL_TEXTURE_3D, 0);
        glEndList();	
        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 line_scale;\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.2,0.4,texture3D(noise_tex, p).x);}\n"
    "void main(void)\n"
    "{\n"
    "   vec3 n = normalize(_n);\n"
    "   vec3 d = normalize(dir_obj);\n"
    "   float I = "
    "             tex(noise_scale*v_obj + 6.0*line_scale*d) + \n"
    "             tex(noise_scale*v_obj - 6.0*line_scale*d) + \n"
    "             tex(noise_scale*v_obj + 5.0*line_scale*d) + \n"
    "             tex(noise_scale*v_obj - 5.0*line_scale*d) + \n"
    "             tex(noise_scale*v_obj + 4.0*line_scale*d) + \n"
    "             tex(noise_scale*v_obj - 4.0*line_scale*d) + \n"
    "             tex(noise_scale*v_obj + 3.0*line_scale*d) + \n"
    "             tex(noise_scale*v_obj - 3.0*line_scale*d) + \n"
    "             tex(noise_scale*v_obj + 2.0*line_scale*d) + \n"
    "             tex(noise_scale*v_obj - 2.0*line_scale*d) + \n"
    "             tex(noise_scale*v_obj + 1.0*line_scale*d) + \n"
    "             tex(noise_scale*v_obj - 1.0*line_scale*d) + \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(diff*I/13.0);\n"
    "	gl_FragColor.a = 1.0;\n"
    "}\n";
    
    GLuint HarmonicsRenderer::prog_P0 = 0;
    GLGraphics::Console::variable<float> HarmonicsRenderer::display_harmonics_time;
    GLGraphics::Console::variable<int> HarmonicsRenderer::display_harmonics_diffuse;
    GLGraphics::Console::variable<int> HarmonicsRenderer::display_harmonics_highlight;
 
    GLGraphics::Console::variable<int> HarmonicsRenderer::display_harmonics_e0;
    GLGraphics::Console::variable<int> HarmonicsRenderer::display_harmonics_e1;
    
    string vss =
	"#version 120\n"
	"#extension GL_EXT_gpu_shader4 : enable\n"
	"	\n"
	"	\n"
	"	attribute float eigenvalue;\n"
	"	attribute float eigenvalue2;\n"
	"	varying vec3 normal;\n"
	"	varying float eig;\n"
	"	varying float eig2;\n"
	"	\n"
	"	void main(void)\n"
	"	{\n"
	"		gl_Position =  ftransform();\n"
	"		normal = normalize(gl_NormalMatrix * gl_Normal);\n"
	"		eig = eigenvalue;\n"
	"		eig2 = eigenvalue2;\n"
	"	}\n";
	
	string fss =
	"#version 120\n"
	"#extension GL_EXT_gpu_shader4 : enable\n"
	"	\n"
	"	varying vec3 normal;\n"
	"	varying float eig;\n"
	"	varying float eig2;\n"
	"	uniform float eig_max;\n"
	"	uniform float eig_max2;\n"
	"	uniform bool do_highlight;\n"
	"	uniform bool do_diffuse;\n"
	"	const vec3 light_dir = vec3(0,0,1);\n"
	"	\n"
	" float basef(float x) {return max(0.0,min(1.0,2.0-4.0*abs(x)));\n}"
	"	void main()\n"
	"	{\n"
	"		float dot_ln = max(0.0,dot(light_dir, normal));\n"
	"		\n"
	"		float eig_norm = eig/eig_max;\n"
	"		float stripe_signal = 250 * eig_norm;\n"
	//"		vec4 stripe_col = abs(stripe_signal) < 3.14 ? vec4(1,1,0,0) : vec4(.4,.4,.4,0);\n"
	"		vec4 stripe_col = -vec4(.4,.4,.4,0);\n"
	"		\n"
	"       float alpha = (1.0-eig_norm) * 2.0 * 3.1415926;\n"
	"       float offs = 2.0*3.1415/3.0;\n"
	"		gl_FragColor = vec4(0,0,1,0)*basef(eig_norm)+vec4(0,1,0,0)*basef(eig_norm-0.5)+vec4(1,0,0,0)* basef(eig_norm-1.0);\n"
	"		if(do_diffuse)   gl_FragColor *= dot_ln;\n"
	"		if(do_highlight) gl_FragColor += dot_ln*dot_ln*dot_ln*dot_ln*dot_ln*dot_ln*dot_ln*vec4(.5,.5,.5,0);\n"
	"		gl_FragColor -= vec4(.4,.4,.4,.4)*smoothstep(0.2,0.6,cos(stripe_signal));\n"
	"	}\n";
    
 
    HarmonicsRenderer::HarmonicsRenderer(HMesh::Manifold& _m, HMesh::Harmonics* _h, GLGraphics::Console& cs): m(&_m), h(_h)
    {
        if (prog_P0 == 0) {
            string shader_path = "/Users/jab/GEL/apps/MeshEdit/";
            GLuint vs = create_glsl_shader(GL_VERTEX_SHADER, vss);
            GLuint fs = create_glsl_shader(GL_FRAGMENT_SHADER, fss);
            
            // Create the program
            prog_P0 = glCreateProgram();
            
            // Attach all shaders
            if(vs) glAttachShader(prog_P0, vs);
            if(fs) glAttachShader(prog_P0, fs);
            
            // Link the program object and print out the info log
            glLinkProgram(prog_P0);
            print_glsl_program_log(prog_P0);
            
            // Install program object as part of current state
            glUseProgram(0);
            
            
            display_harmonics_diffuse.reg(cs, "display.harmonics.diffuse", "");
            display_harmonics_time.reg(cs, "display.harmonics.time", "");
            display_harmonics_highlight.reg(cs, "display.harmonics.highlight", "");
            display_harmonics_e0.reg(cs,"display.harmonics.e0","");
            display_harmonics_e1.reg(cs,"display.harmonics.e1","");
        }
        draw_esum();
    }
    
    
    void HarmonicsRenderer::parse_key(unsigned char key)
    {
        switch(key) {
            case '+':
                display_harmonics_time = display_harmonics_time+0.001;
                break;
            case '-':
                display_harmonics_time = display_harmonics_time-0.001;
                break;
            case 'd':
                display_harmonics_diffuse = !display_harmonics_diffuse;
                break;
            case 'h':
                display_harmonics_highlight = !display_harmonics_highlight;
                break;
        }
        
    }
    
    
    
    
    void HarmonicsRenderer::draw_adf()
    {
        VertexAttributeVector<double> F;
        double F_max = h->compute_adf(F, display_harmonics_time);
        cout << "F max" <<  F_max << endl;
        
        glNewList(display_list, GL_COMPILE);
        glUseProgram(prog_P0);
        glUniform1f(glGetUniformLocation(prog_P0,"eig_max"),F_max);//2*M_PI);
        glUniform1i(glGetUniformLocation(prog_P0,"do_diffuse"),display_harmonics_diffuse);
        glUniform1i(glGetUniformLocation(prog_P0,"do_highlight"),display_harmonics_highlight);
        GLuint attrib = glGetAttribLocationARB(prog_P0, "eigenvalue");
        
        glFrontFace(GL_CW);
        for(FaceIDIterator f = m->faces_begin(); f != m->faces_end(); ++f){
            glBegin(GL_TRIANGLES);
            for(Walker w = m->walker(*f); !w.full_circle(); w = w.circulate_face_cw()){
                glVertexAttrib1f(attrib,F[w.vertex()]);
                glNormal3dv(normal(*m, w.vertex()).get());
                glVertex3dv(m->pos(w.vertex()).get());
            }
            glEnd();
        }
        glFrontFace(GL_CCW);
        glUseProgram(0);
        glEndList();
    }
 
    void HarmonicsRenderer::draw_esum()
    {
        VertexAttributeVector<double> F;
        double F_max = h->compute_esum(F, display_harmonics_e0, display_harmonics_e1);
        cout << "F max" <<  F_max << endl;
        
        glNewList(display_list, GL_COMPILE);
        glUseProgram(prog_P0);
        glUniform1f(glGetUniformLocation(prog_P0,"eig_max"),F_max);//2*M_PI);
        glUniform1i(glGetUniformLocation(prog_P0,"do_diffuse"),display_harmonics_diffuse);
        glUniform1i(glGetUniformLocation(prog_P0,"do_highlight"),display_harmonics_highlight);
        GLuint attrib = glGetAttribLocationARB(prog_P0, "eigenvalue");
        
        glFrontFace(GL_CW);
        for(FaceIDIterator f = m->faces_begin(); f != m->faces_end(); ++f){
            glBegin(GL_TRIANGLES);
            for(Walker w = m->walker(*f); !w.full_circle(); w = w.circulate_face_cw()){
                glVertexAttrib1f(attrib,F[w.vertex()]);
                glNormal3dv(normal(*m, w.vertex()).get());
                glVertex3dv(m->pos(w.vertex()).get());
            }
            glEnd();
        }
        glFrontFace(GL_CCW);
        glUseProgram(0);
        glEndList();
    }
 
 
    
}
 
 
 

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

Subversion Repositories gelsvn

(root)/branches/cpp11-devel/src/GLGraphics/ManifoldRenderer.cpp – Rev 665 → 666