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

 //  GEL
 //
 //  Created by J. Andreas Bærentzen on 09/10/13.
 //
 //
+#include <thread>
-#define _CRT_SECURE_NO_WARNINGS
+#include <unistd.h>
 #include <GL/glew.h>
 #include <functional>
 #include "MeshEditor.h"
 #include <string>
 #include <iostream>
 #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>
             VertexAttributeVector<Mat3x3d> curvature_tensors(mani.allocated_vertices());
             VertexAttributeVector<Vec3d> min_curv_direction(mani.allocated_vertices());
             VertexAttributeVector<Vec3d> max_curv_direction(mani.allocated_vertices());
             VertexAttributeVector<Vec2d> curvature(mani.allocated_vertices());
-            //    curvature_tensors_from_edges(mani, curvature_tensors);
-            //    for(int i=0;i<3; ++i)
-            //        smooth_curvature_tensors(mani,curvature_tensors);
-            //    curvature_from_tensors(mani, curvature_tensors,
-            //                        min_curv_direction,
-            //                        max_curv_direction,
-            //                        curvature);
-            //    void console_refit_polar(MeshEditor* me, const std::vector<std::string> & args)
-            //    {
-            //        if(wantshelp(args)) {
-            //            me->printf("usage: simplify.polar <mesh 1> <mesh 2> <iter>");
-            //            return;
-            //        }
-            //        int m1=1;
-            //        int m2=2;
-            //        int iter=1;
-            //        int dim = 64;
-            //        if(args.size() > 0){
-            //            istringstream a0(args[0]);
-            //            a0 >> m1;
-            //        }
-            //        if(args.size() > 1){
-            //            istringstream a0(args[1]);
-            //            a0 >> m2;
-            //        }
-            //        if(args.size() > 2){
-            //            istringstream a0(args[2]);
-            //            a0 >> iter;
-            //        }
-            //
-            //        if(args.size() > 3){
-            //            istringstream a0(args[3]);
-            //            a0 >> dim;
-            //        }
-            //
-            //
-            //
-            //        me->save_active_mesh();
-            //
-            //        smooth_and_refit(get_vis_obj(m1-1).mesh() , get_vis_obj(m2-1).mesh(), iter, dim);
-            //    }
-            //
             curvature_paraboloids(mani,
                                   min_curv_direction,
                                   max_curv_direction,
             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_smooth(me->active_mesh());
             return;
+        }
+        void console_stitch(MeshEditor* me, const std::vector<std::string> & args)
+        {
+            if(wantshelp(args)) {
+                me->printf("usage: cleanup.stitch <rad>");
+                me->printf("Stitches faces");
+                return;
+            }
+            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(), r * rad);
+            return;
+        }
+        void console_remove_duplicates(MeshEditor* me, const std::vector<std::string> & args)
+        {
+            if(wantshelp(args)) {
+                me->printf("usage: cleanup.remove_duplicates <rad>");
+                me->printf("Removes duplicate vertices and incident faces");
+                return;
+            }
+            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);
+            remove_duplicates(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");
                 me->harmonics_analyze_mesh();
                 return;
+            }
-        //    void console_partial_reconstruct(MeshEditor* me, const std::vector<std::string> & args)
+        void console_partial_reconstruct(MeshEditor* me, const std::vector<std::string> & args)
-        //    {
+        {
-        //        if(args.size() != 3)
+            if(args.size() != 3)
-        //            me->printf("usage: haramonics.partial_reconstruct <e0> <e1> <s>");
+                me->printf("usage: haramonics.partial_reconstruct <e0> <e1> <s>");
-        //
-        //        if(wantshelp(args)) {
+            if(wantshelp(args)) {
-        //            me->printf("Reconstruct from projections onto eigenvectors. The two first arguments indicate");
+                me->printf("Reconstruct from projections onto eigenvectors. The two first arguments indicate");
-        //            me->printf("the eigenvector interval that we reconstruct from. The last argument is the ");
+                me->printf("the eigenvector interval that we reconstruct from. The last argument is the ");
-        //            me->printf("scaling factor. Thus, for a vertex, v, the formula for computing the position, p, is:");
+                me->printf("scaling factor. Thus, for a vertex, v, the formula for computing the position, p, is:");
-        //            me->printf("for (i=e0; i<=e1;++i) p += proj[i] * Q[i][v] * s;");
+                me->printf("for (i=e0; i<=e1;++i) p += proj[i] * Q[i][v] * s;");
-        //            me->printf("where proj[i] is the 3D vector containing the x, y, and z projections of the mesh onto");
+                me->printf("where proj[i] is the 3D vector containing the x, y, and z projections of the mesh onto");
-        //            me->printf("eigenvector i. Q[i][v] is the v'th coordinate of the i'th eigenvector.");
+                me->printf("eigenvector i. Q[i][v] is the v'th coordinate of the i'th eigenvector.");
-        //            me->printf("Note that if vertex coordinates are not first reset, the result is probably unexpected.");
+                me->printf("Note that if vertex coordinates are not first reset, the result is probably unexpected.");
-        //        }
+            }
-        //        me->save_active_mesh();
+            me->save_active_mesh();
-        //
-        //        if(args.size() != 3)
+            if(args.size() != 3)
-        //            return;
+                return;
-        //
-        //        int E0,E1;
+            int E0,E1;
-        //        float scale;
+            float scale;
-        //        istringstream a0(args[0]);
+            istringstream a0(args[0]);
-        //        a0 >> E0;
+            a0 >> E0;
-        //        istringstream a1(args[1]);
+            istringstream a1(args[1]);
-        //        a1 >> E1;
+            a1 >> E1;
-        //        istringstream a2(args[2]);
+            istringstream a2(args[2]);
-        //        a2 >> scale;
+            a2 >> scale;
-        //        me->harmonics_partial_reconstruct(E0,E1,scale);
+            me->harmonics_partial_reconstruct(E0,E1,scale);
-        //        return;
+            return;
-        //    }
+        }
-        //
-        //    void console_reset_shape(MeshEditor* me, const std::vector<std::string> & args)
+        void console_reset_shape(MeshEditor* me, const std::vector<std::string> & args)
-        //    {
+        {
-        //        if(wantshelp(args))
+            if(wantshelp(args))
-        //        {
+            {
-        //            me->printf("usage: harmonics.reset_shape ");
+                me->printf("usage: harmonics.reset_shape ");
-        //            me->printf("Simply sets all vertices to 0,0,0. Call this before doing partial_reconstruct");
+                me->printf("Simply sets all vertices to 0,0,0. Call this before doing partial_reconstruct");
-        //            me->printf("unless you know what you are doing.");
+                me->printf("unless you know what you are doing.");
-        //            return;
+                return;
-        //        }
+            }
-        //        me->save_active_mesh();
+            me->save_active_mesh();
-        //        me->harmonics_reset_shape();
+            me->harmonics_reset_shape();
-        //        return;
+            return;
-        //    }
+        }
         void console_close_holes(MeshEditor* me, const std::vector<std::string> & args)
+        {
             if(wantshelp(args))
                 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");
+            me->printf("Valency histogram");
             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 histogram");
+            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");
+            }
             me->restore_active_mesh();
             return;
+        }
+        void console_save_trackball(MeshEditor* me, const std::vector<std::string> & args)
+        {
+            if(wantshelp(args)) {
+                me->printf("usage:  display.save_trackball");
+                me->printf("This function saves the trackball to disk");
+                return;
+            }
+            me->save_ball();
+            return;
+        }
+        void console_load_trackball(MeshEditor* me, const std::vector<std::string> & args)
+        {
+            if(wantshelp(args)) {
+                me->printf("usage:  display.load_trackball");
+                me->printf("This function loads the trackball from disk");
+                return;
+            }
+            me->load_ball();
+            return;
+        }
+    }
     void MeshEditor::register_console_function(const std::string& name,
             return;
+        }
         if (console_visible)
+        {
+            static Timer tim;
+            if(key==13)
+                tim.start();
             theConsole.keyboard(key);
             if(key == 13)
+            {
                 active_visobj().post_create_display_list();
+                double t = tim.get_secs();
+                printf("%f seconds",t);
+            }
             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::key_left(){theConsole.key_left();}
     void MeshEditor::key_right(){theConsole.key_right();}
     void MeshEditor::key_home(){theConsole.key_home();}
     void MeshEditor::key_end(){theConsole.key_end();}
     void MeshEditor::grab_ball(TrackBallAction action, const CGLA::Vec2i& pos){
         active_view_control().grab_ball(action, pos);
+    }
     void MeshEditor::roll_ball(const CGLA::Vec2i& pos){
         active_view_control().roll_ball(pos);
+    }
     bool MeshEditor::try_spinning_ball(){
         return active_view_control().try_spin();
+    }
+    void MeshEditor::save_ball() {
+        ofstream ofs("trackball.bin", ios_base::binary);
+        active_view_control().save(ofs);
+    }
+    void MeshEditor::load_ball() {
+        ifstream ifs("trackball.bin", ios_base::binary);
+        active_view_control().load(ifs);
+    }
     bool MeshEditor::grab_mesh(const CGLA::Vec2i& pos)
+    {
         if(depth_pick(pos[0], pos[1], depth))
+        {
             dragging = true;
     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();
+        //        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);"
+            "   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));
+    }
     void MeshEditor::reshape(int w, int h) {
         for(VisObj& v : vo)
             v.view_control().reshape(w, h);
         register_console_function("optimize.maximize_min_angle", console_maximize_min_angle,"");
         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_duplicates", console_remove_duplicates,"");
+        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,"");
         register_console_function("undo", console_undo,"");
         register_console_function("validity", console_valid,"");
         register_console_function("info", console_info,"");
-        //        register_console_function("harmonics.reset_shape", console_reset_shape, "");
+        register_console_function("harmonics.reset_shape", console_reset_shape, "");
         register_console_function("harmonics.analyze", console_analyze, "");
-        //        register_console_function("harmonics.partial_reconstruct", console_partial_reconstruct,"");
+        register_console_function("harmonics.partial_reconstruct", console_partial_reconstruct,"");
         register_console_function("Dijkstra", console_Dijkstra,"");
+        register_console_function("display.save_trackball", console_save_trackball, "Saves trackball to disk");
+        register_console_function("display.load_trackball", console_load_trackball, "Load trackball to disk");
         register_console_function("transform.scale", console_scale, "Scale mesh");
         register_console_function("test", console_test, "Test some shit");
         active.reg(theConsole, "active_mesh", "The active mesh");
         display_render_mode.reg(theConsole, "display.render_mode", "Display render mode");
         brush_size.reg(theConsole, "brush_size", "Size of brush used for editing");

Subversion Repositories gelsvn

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