WebSVN – gelsvn – Diff – /branches/GEL_github/src/GLGraphics/ManifoldRenderer.cpp

  * For license and list of authors, see ../../doc/intro.pdf
  * ----------------------------------------------------------------------- */
 #include "ManifoldRenderer.h"
-//#include <GLUT/GLUT.h>
+#include <GLUT/GLUT.h>
 #include <algorithm>
 #include <string>
 #include <cstdlib>
 #include "../Geometry/TriMesh.h"
     "	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"
+    "	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)
+    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);
         glEnd();
         glLineWidth(1);
         Vec3d c;
         float r;
         bsphere(m, c, r);
-        r *= 0.003f;
+        r *= rad;
         for(auto vid : m.vertices())
+        {
             Vec3d p = m.pos(vid);
             Vec3f c = vertex_colors[vid];
             glColor3f(c[0], c[1], c[2]);
     "		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"
     "       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"
+    "		float stripe_signal = 50.0 * s_norm;\n"
-    "		vec4 stripe_col = abs(stripe_signal) < 3.14 ? vec4(-1.0,0,0,0) : vec4(.9,.9,.9,0);\n"
+    "		vec4 stripe_col = vec4(.9,.9,.9,0);\n"
     "		\n"
-    "		gl_FragColor = s_norm * vec4(-1,0,1,0);\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 += stripe_col * smoothstep(0.8,1.0,cos(stripe_signal));\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)
+    {
         //    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);
+    }
     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"
             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_adf();
+        draw_esum();
+    }
     void HarmonicsRenderer::parse_key(unsigned char key)
+    {
+        }
         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();
+    }
+}

Subversion Repositories gelsvn

(root)/branches/GEL_github/src/GLGraphics/ManifoldRenderer.cpp @ 684 – Rev 667 → 676