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 =  d+s;\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)
    {
        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 *= 0.003;
        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 = 10.0 * s_norm;\n"
    "		vec4 stripe_col = abs(stripe_signal) < 3.14 ? vec4(-1.0,0,0,0) : vec4(.9,.9,.9,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";
    
    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);
        
    }
 
 
 
    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;
    
    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", "");
        }
        draw_adf();
    }
    
    
    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();
    }
    
 
    
}
 
 
 

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

Subversion Repositories gelsvn

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