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

 #include <vector>
 #include <algorithm>
 #include <queue>
 #include <GLGraphics/Console.h>
+#include <GLGraphics/glsl_shader.h>
+#include <GLGraphics/ShadowBuffer.h>
 #include <CGLA/eigensolution.h>
 #include <CGLA/Vec2d.h>
 #include <CGLA/Vec3d.h>
 #include <CGLA/Mat3x3d.h>
             cc_smooth(me->active_mesh());
             return;
+        }
+        void console_root_cc_subdivide(MeshEditor* me, const std::vector<std::string> & args)
+        {
+            if(wantshelp(args)) {
+                me->printf("usage: subdivide.catmull_clark ");
+                me->printf("Does one step of Catmull-Clark subdivision");
+                return;
+            }
+            me->save_active_mesh();
+            rootCC_subdivide(me->active_mesh(),me->active_mesh());
+            return;
+        }
         void console_loop_subdivide(MeshEditor* me, const std::vector<std::string> & args)
+        {
             if(wantshelp(args)) {
                 me->printf("usage: subdivide.loop");
                 me->printf("Does one step of Loop subdivision");
             loop_split(me->active_mesh(),me->active_mesh());
             loop_smooth(me->active_mesh());
             return;
+        }
         void console_stitch(MeshEditor* me, const std::vector<std::string> & args)
+        {
             if(wantshelp(args)) {
-                me->printf("usage: cleanup.stitch");
+                me->printf("usage: cleanup.stitch <rad>");
                 me->printf("Stitches faces");
                 return;
+            }
-            me->save_active_mesh();
+            double r = 0.001;
+            if(args.size() > 0){
+                istringstream a0(args[0]);
+                a0 >> r;
+            }
+            me->save_active_mesh();
+            Manifold& m = me->active_mesh();
+            Vec3d c;
+            float rad;
+            bsphere(m, c, rad);
-            stitch_mesh(me->active_mesh());
+            stitch_mesh(me->active_mesh(), r * rad);
             return;
+        }
+        void console_remove_val2(MeshEditor* me, const std::vector<std::string> & args)
+        {
+            if(wantshelp(args)) {
+                me->printf("usage: cleanup.remove_val2");
+                me->printf("Removes valence 2 vertices");
+                return;
+            }
+            me->save_active_mesh();
+            Manifold& m = me->active_mesh();
+            remove_valence_two_vertices(m);
+            return;
+        }
         void console_root3_subdivide(MeshEditor* me, const std::vector<std::string> & args)
+        {
             if(wantshelp(args)) {
                 me->printf("usage: subdivide.root3");
                 me->printf("Does one step of sqrt(3) subdivision");
                 Walker w = m.walker(hid);
                 DebugRenderer::edge_colors[hid] = Vec3f(1.0-max(dist[w.vertex()],dist[w.opp().vertex()])/max_dist,0,0);
+            }
             return;
+        }
+        const Vec3f& get_color(int i)
+        {
+            static Vec3f ctable[100000];
+            static bool was_here;
+            gel_srand(0);
+            if(!was_here)
+            {
+                was_here = true;
+                ctable[0] = Vec3f(0);
+                for(int j=1;j<100000;++j)
+                    ctable[j] = Vec3f(0.3)+0.7*normalize(Vec3f(gel_rand(),gel_rand(),gel_rand()));
+                ctable[3] = Vec3f(1,0,0);
+                ctable[4] = Vec3f(0,1,0);
+                ctable[5] = Vec3f(0,0,1);
+                ctable[6] = Vec3f(1,0,1);
+            }
+            return ctable[i%100000];
+        }
         void console_info(MeshEditor* me, const std::vector<std::string> & args)
+        {
             if(wantshelp(args))
+            {
                 me->printf("usage:  info");
             stringstream bbox_corners;
             bbox_corners << p0 << " - " << p7 << endl;
             me->printf("Bounding box corners : %s", bbox_corners.str().c_str());
             map<int,int> val_hist;
+            Manifold& m = me->active_mesh();
+            for(HalfEdgeID h: m.halfedges())
+                DebugRenderer::edge_colors[h] = Vec3f(0.3);
-            for(VertexIDIterator vi = me->active_mesh().vertices_begin(); vi != me->active_mesh().vertices_end(); ++vi)
+            for(VertexID v: m.vertices())
+            {
-                int val = valency(me->active_mesh(), *vi);
+                int val = valency(m,v);
-                if(val_hist.find(val) == val_hist.end())
+                DebugRenderer::vertex_colors[v] = get_color(val);
-                    val_hist[val] = 0;
                 ++val_hist[val];
+                if(val != 4)
+                    circulate_vertex_ccw(m, v, [&](HalfEdgeID h){
+                        Walker w = m.walker(h);
+                        DebugRenderer::edge_colors[h] = Vec3f(1);
+                        DebugRenderer::edge_colors[w.opp().halfedge()] = Vec3f(1);
+                        while(valency(m, w.vertex())==4) {
+                            w = w.next().opp().next();
+                            DebugRenderer::edge_colors[w.halfedge()] = Vec3f(1);
+                            DebugRenderer::edge_colors[w.opp().halfedge()] = Vec3f(1);
+                        }
+                    });
+            }
+            map<int, int> ngon_hist;
+            for(FaceID f: m.faces()) {
+                int ne = no_edges(m, f);
+                ++ngon_hist[ne];
+                DebugRenderer::face_colors[f] = 0.7*get_color(ne);
+            }
             me->printf("Valency histogam");
             for(map<int,int>::iterator iter = val_hist.begin(); iter != val_hist.end(); ++iter)
+            {
-                stringstream vhl;
-                vhl << iter->first << ", " << iter->second;
                 me->printf("%d, %d", iter->first, iter->second);
+            }
+            me->printf("Ngon histogam");
+            for(map<int,int>::iterator iter = ngon_hist.begin(); iter != ngon_hist.end(); ++iter)
+            {
+                me->printf("%d, %d", iter->first, iter->second);
+            }
             me->printf("Mesh contains %d faces", me->active_mesh().no_faces());
             me->printf("Mesh contains %d halfedges", me->active_mesh().no_halfedges());
             me->printf("Mesh contains %d vertices", me->active_mesh().no_vertices());
             return;
+        }
             me->active_mesh().cleanup();
             return;
+        }
+        void console_flip_orientation(MeshEditor* me, const std::vector<std::string> & args)
+        {
+            if(wantshelp(args)){
+                me->printf("usage: cleanup.flip_orientation");
+                me->printf("reorients all faces - flipping normal direction");
+                return;
+            }
+            me->save_active_mesh();
+            flip_orientation(me->active_mesh());
+            return;
+        }
         void console_undo(MeshEditor* me, const std::vector<std::string> & args)
+        {
             if(wantshelp(args)) {
                 me->printf("usage:  undo");
                 me->printf("This function undoes one operation. Repeated undo does nothing");
             return;
+        }
         else {
             switch(key) {
+                    case 'R':
+                {
+                    theConsole.key_up();
+                    theConsole.keyboard(13);
+                    active_visobj().post_create_display_list();
+                }
+                    break;
                 case 'q': exit(0);
                 case '\033':
                     console_visible = false;
                     break;
                 case '1':
     void MeshEditor::release_mesh()
+    {
         dragging = false;
+    }
     mutex parallel_work;
     void MeshEditor::display(int scale){
+        // Clear screen.
         glClearColor(1, 1, 1, 0);
         glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
-//        parallel_work.lock();
+        //        parallel_work.lock();
-//        active_visobj().post_create_display_list();
+        //        active_visobj().post_create_display_list();
+        // Display object.
         active_visobj().display(display_render_mode, theConsole, display_smooth_shading, display_gamma);
+        // Draw console
         if(console_visible)
+        {
             glUseProgram(0);
             theConsole.display(scale);
+        }
+        // Static variable controlling whether we render shadow at all.
+        static Console::variable<int> shadow_enable(0);
+        shadow_enable.reg(theConsole, "display.shadow.enable", "");
+        if(shadow_enable) {
+            // Static variables that control the shadow display created and linked to console
+            static Console::variable<float> zenith(1.571);
+            static Console::variable<float> azimuth(0);
+            static Console::variable<float> shadow_alpha(0.3);
+            azimuth.reg(theConsole, "display.shadow.azimuth", "");
+            zenith.reg(theConsole, "display.shadow.zenith", "");
+            shadow_alpha.reg(theConsole, "display.shadow.shadow_alpha", "");
+            // Shadow buffer (really a frame buffer object)
+            static ShadowBuffer sb;
+            // String containing fragment program for shadow rendering
+            static string shadow_shdr_fp = "#version 120\n"
+            "    uniform sampler2DShadow shadow_map;\n"
+            "    uniform mat4 Mat;\n"
+            "   uniform float shadow_alpha;\n"
+            "    varying vec4 ep;\n"
+            "    void main()\n"
+            "    {\n"
+            "        vec4 light_pos =  Mat * ep;\n"
+            "        light_pos.z = max(0.001,min(0.999,light_pos.z-0.003));\n"
+            "        if(light_pos.x <=0 || light_pos.x >=1 || light_pos.y <=0 || light_pos.y>=1) gl_FragColor = vec4(1);"
-//        parallel_work.unlock();
+            "   else      gl_FragColor= vec4(1.0-shadow_alpha)+shadow_alpha*0.25*(shadow2D(shadow_map, light_pos.xyz+vec3(0.001,-0.001,0))+shadow2D(shadow_map, light_pos.xyz+vec3(0.001,0.001,0))+shadow2D(shadow_map, light_pos.xyz-vec3(0.001,0.001,0))+shadow2D(shadow_map, light_pos.xyz+vec3(-0.001,0.001,0)));\n"
+            "    }\n";
+            // Shader program for shadow rendering is compiled and linked.
+            static GLuint prog = 0;
+            if(!prog)
+            {
+                GLuint vp = create_glsl_shader(GL_VERTEX_SHADER,"#version 120\n varying vec4 ep; void main(){ep = gl_Vertex; gl_Position = ftransform();}");
+                GLuint fp = create_glsl_shader(GL_FRAGMENT_SHADER, shadow_shdr_fp);
+                prog = glCreateProgram();
+                glAttachShader(prog, vp);
+                glAttachShader(prog, fp);
+                glLinkProgram(prog);
+            }
+            // Setup OpenGL state for lighting - used when rendering 3D object casting shadow
+            Vec4f lpos = Vec4f(cos(azimuth)*cos(zenith),sin(zenith),sin(azimuth)*cos(zenith),0);
+            glLightfv(GL_LIGHT0, GL_POSITION, lpos.get());
+            Vec4f mamb(.8,.8,.8,0);
+            Vec4f lamb(.4,.4,.5,0);
+            glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, mamb.get());
+            glLightfv(GL_LIGHT0, GL_AMBIENT, lamb.get());
+            // Get old viewport dimensions. Setup rendering to FBO and set viewport
+            // dimensions for rendering shadows.
+            GLint viewp[4];
+            glGetIntegerv(GL_VIEWPORT, viewp);
+            sb.enable();
+            glViewport(0, 0, 1024, 1024);
+            // Setup object transformations using old school GL.
+            Mat4x4f m;
+            float r = active_visobj().get_bsphere_radius();
+            glMatrixMode(GL_MODELVIEW);
+            glPushMatrix();
+            glLoadIdentity();
+            glMatrixMode(GL_PROJECTION);
+            glPushMatrix();
+            glLoadIdentity();
+            glOrtho(-2*r, 2*r, -2*r, 2*r, -2*r, 2*r);
+            gluLookAt(0.1*r*cos(azimuth)*cos(zenith),0.1*r*sin(zenith),0.1*r*sin(azimuth)*cos(zenith), 0,0,0, 0,1,0);
+            // Copy the transformation matrix to user code.
+            glGetFloatv(GL_PROJECTION_MATRIX, m.get());
+            // Draw the object in light space.
+            draw(active_visobj().mesh());
+            // Restore transformation matrices.
+            glPopMatrix();
+            glMatrixMode(GL_MODELVIEW);
+            glPopMatrix();
+            // Restore the usual on screen framebuffer.
+            glBindFramebuffer(GL_DRAW_FRAMEBUFFER, 0);
+            glDrawBuffer(GL_BACK);
+            glViewport(0, 0, viewp[2], viewp[3]);
+            // Use shadow: bind the shadow texture to unit 0.
+            sb.bind_textures(0);
+            // Use the shadow rendering shader program.
+            glUseProgram(prog);
+            active_visobj().view_control().set_gl_modelview();
+            glUniform1i(glGetUniformLocation(prog, "shadow_map"), 0);
+            glUniform1f(glGetUniformLocation(prog, "shadow_alpha"), shadow_alpha);
+            m = translation_Mat4x4f(Vec3f(0.5)) * scaling_Mat4x4f(Vec3f(0.5)) * transpose(m);
+            glUniformMatrix4fv(glGetUniformLocation(prog, "Mat"), 1, 1, m.get());
+            // Setup blending such that the shadow is alpha blended with model.
+            glDepthFunc(GL_LEQUAL);
+            glEnable(GL_BLEND);
+            glBlendFunc(GL_ZERO, GL_SRC_COLOR);
+            // Draw ground plane for shadows.
+            Vec3d p0, p7;
+            bbox(active_visobj().mesh(), p0, p7);
+            glBegin(GL_QUADS);
+            glVertex3f(-100*r, p0[1],-100*r);
+            glVertex3f(-100*r, p0[1],100*r);
+            glVertex3f(100*r, p0[1],100*r);
+            glVertex3f(100*r, p0[1],-100*r);
+            glEnd();
+            // Draw model again ... just to add shadow.
+            draw(active_visobj().mesh());
+            // Disable blending and shader program.
+            glDisable(GL_BLEND);
+            glUseProgram(0);
+        }
+        //        parallel_work.unlock();
-//        std::this_thread::sleep_for(std::chrono::milliseconds(10));
+        //        std::this_thread::sleep_for(std::chrono::milliseconds(10));
+    }
     void MeshEditor::reshape(int w, int h) {
         for(VisObj& v : vo)
             v.view_control().reshape(w, h);
         register_console_function("cleanup.close_holes", console_close_holes,"");
         register_console_function("load_mesh", console_reload,"");
         register_console_function("add_mesh", console_add_mesh,"");
         register_console_function("cleanup.stitch", console_stitch,"");
+        register_console_function("cleanup.remove_val2", console_remove_val2, "");
+        register_console_function("cleanup.flip_orientation", console_flip_orientation,"");
         register_console_function("cleanup.remove_caps", console_remove_caps,"");
         register_console_function("cleanup.remove_needles", console_remove_needles,"");
         register_console_function("triangulate", console_triangulate,"");
         register_console_function("refine.split_edges", console_refine_edges,"");
         register_console_function("refine.split_faces", console_refine_faces,"");
         register_console_function("subdivide.catmull_clark", console_cc_subdivide,"");
+        register_console_function("subdivide.rootcc", console_root_cc_subdivide,"");
         register_console_function("subdivide.loop", console_loop_subdivide,"");
         register_console_function("subdivide.root3", console_root3_subdivide,"");
         register_console_function("subdivide.doo_sabin", console_doosabin_subdivide,"");
         register_console_function("subdivide.butterfly", console_butterfly_subdivide,"");
         register_console_function("save_mesh", console_save,"");

Subversion Repositories gelsvn

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