Code Cleanup:
authorCampbell Barton <ideasman42@gmail.com>
Mon, 27 Feb 2012 13:47:53 +0000 (13:47 +0000)
committerCampbell Barton <ideasman42@gmail.com>
Mon, 27 Feb 2012 13:47:53 +0000 (13:47 +0000)
* made bmesh_structure.h function names more consistant.
* remove unused code in bmesh_structure.c
* removed 'Edge Flip' operator (missing from bmesh but looked into trunk feature and dont think its worth keeping).
* tagged  some BMESH_TODO's

35 files changed:
release/scripts/presets/keyconfig/maya.py
release/scripts/startup/bl_ui/space_view3d.py
source/blender/bmesh/bmesh.h
source/blender/bmesh/bmesh_class.h
source/blender/bmesh/bmesh_iterators.h
source/blender/bmesh/bmesh_marking.h
source/blender/bmesh/bmesh_operator_api.h
source/blender/bmesh/bmesh_operators.h
source/blender/bmesh/intern/bmesh_construct.c
source/blender/bmesh/intern/bmesh_iterators.c
source/blender/bmesh/intern/bmesh_mods.c
source/blender/bmesh/intern/bmesh_newcore.c
source/blender/bmesh/intern/bmesh_operators.c
source/blender/bmesh/intern/bmesh_queries.c
source/blender/bmesh/intern/bmesh_structure.c
source/blender/bmesh/intern/bmesh_structure.h
source/blender/bmesh/intern/bmesh_walkers_impl.c
source/blender/bmesh/operators/bmo_dissolve.c
source/blender/bmesh/tools/BME_bevel.c
source/blender/editors/include/ED_mesh.h
source/blender/editors/include/ED_uvedit.h
source/blender/editors/include/ED_view3d.h
source/blender/editors/mesh/bmesh_tools.c
source/blender/editors/mesh/loopcut.c
source/blender/editors/mesh/mesh_intern.h
source/blender/editors/mesh/mesh_ops.c
source/blender/editors/space_view3d/view3d_intern.h
source/blender/editors/space_view3d/view3d_select.c
source/blender/editors/transform/transform.h
source/blender/editors/transform/transform_conversions.c
source/blender/editors/uvedit/uvedit_intern.h
source/blender/makesdna/DNA_mesh_types.h
source/blender/modifiers/intern/MOD_util.h
source/blender/windowmanager/intern/wm_gesture.c
source/blenderplayer/bad_level_call_stubs/stubs.c

index 62392e60b2e398e63cc3110ffc01ad95333a4806..d9228514a72f562a72915faa112159b65da4fb9e 100644 (file)
@@ -333,7 +333,7 @@ kmi = km.keymap_items.new('mesh.fill', 'F', 'PRESS', alt=True)
 kmi = km.keymap_items.new('mesh.beautify_fill', 'F', 'PRESS', shift=True, alt=True)
 kmi = km.keymap_items.new('mesh.quads_convert_to_tris', 'T', 'PRESS', ctrl=True)
 kmi = km.keymap_items.new('mesh.tris_convert_to_quads', 'J', 'PRESS', alt=True)
-kmi = km.keymap_items.new('mesh.edge_flip', 'F', 'PRESS', shift=True, ctrl=True)
+# kmi = km.keymap_items.new('mesh.edge_flip', 'F', 'PRESS', shift=True, ctrl=True) # removed since bmesh, can be made into something else?
 kmi = km.keymap_items.new('mesh.rip_move', 'V', 'PRESS')
 kmi = km.keymap_items.new('mesh.merge', 'M', 'PRESS', alt=True)
 kmi = km.keymap_items.new('transform.shrink_fatten', 'S', 'PRESS', ctrl=True, alt=True)
index 64dad996fa0931adfdac89ee208c136b8846d957..aee9c20d25cf2eea945270ff081d118bdc0bb192 100644 (file)
@@ -1720,7 +1720,6 @@ class VIEW3D_MT_edit_mesh_faces(Menu):
 
         layout.operator("mesh.quads_convert_to_tris")
         layout.operator("mesh.tris_convert_to_quads")
-        layout.operator("mesh.edge_flip")
 
         layout.separator()
 
index bf939d3f1cb578f17862f2196f052a2ef7bd5fc5..8871b0909104972391f2c26978f2d65838d19647 100644 (file)
@@ -62,14 +62,7 @@ extern "C" {
  */
 
 /*forward declarations*/
-struct BMesh;
-struct BMVert;
-struct BMEdge;
-struct BMFace;
-struct BMLoop;
-struct BMOperator;
 struct Mesh;
-struct EditMesh;
 
 /*
  * BMHeader
@@ -216,7 +209,7 @@ BMFace *BM_faces_join(BMesh *bm, BMFace **faces, int totface);
  * the nl member to a loop in the newly created edge.*/
 BMFace *BM_face_split(BMesh *bm, BMFace *f,
                       BMVert *v1, BMVert *v2,
-                      struct BMLoop **nl, BMEdge *example);
+                      BMLoop **nl, BMEdge *example);
 
 /* these 2 functions are very similar */
 BMEdge* BM_vert_collapse_faces(BMesh *bm, BMEdge *ke, BMVert *kv, float fac,
@@ -287,13 +280,13 @@ void BM_loop_interp_multires(BMesh *bm, BMLoop *target, BMFace *source);
 void BM_vert_interp_from_face(BMesh *bm, BMVert *v, BMFace *source);
 
 void  BM_data_interp_from_verts(BMesh *bm, BMVert *v1, BMVert *v2, BMVert *v, const float fac);
-void  BM_data_interp_face_vert_edge(BMesh *bm, BMVert *v1, BMVert *v2, BMVert *v, struct BMEdge *e1, const float fac);
+void  BM_data_interp_face_vert_edge(BMesh *bm, BMVert *v1, BMVert *v2, BMVert *v, BMEdge *e1, const float fac);
 void  BM_data_layer_add(BMesh *em, CustomData *data, int type);
 void  BM_data_layer_add_named(BMesh *bm, CustomData *data, int type, const char *name);
 void  BM_data_layer_free(BMesh *em, CustomData *data, int type);
 void  BM_data_layer_free_n(BMesh *bm, CustomData *data, int type, int n);
-float BM_elem_float_data_get(struct CustomData *cd, void *element, int type);
-void  BM_elem_float_data_set(struct CustomData *cd, void *element, int type, const float val);
+float BM_elem_float_data_get(CustomData *cd, void *element, int type);
+void  BM_elem_float_data_set(CustomData *cd, void *element, int type, const float val);
 
 /* get the area of the face */
 float BM_face_area_calc(BMesh *bm, BMFace *f);
index d800fe7bf77534895a45957c50c852c50ea6fe82..87607f4d9e86c480d2229cb88bceb732bde40c21 100644 (file)
 /* bmesh data structures */
 
 /* dissable holes for now, these are ifdef'd because they use more memory and cant be saved in DNA currently */
-#define USE_BMESH_HOLES
+// #define USE_BMESH_HOLES
 
 struct BMesh;
 struct BMVert;
 struct BMEdge;
 struct BMLoop;
 struct BMFace;
-struct BMFlagLayer;
-struct BMLayerType;
-struct BMSubClassLayer;
 
 struct BLI_mempool;
 struct Object;
 
-/*note: it is very important for BMHeader to start with two
-  pointers. this is a requirement of mempool's method of
-  iteration.
-*/
+/* note: it is very important for BMHeader to start with two
+ * pointers. this is a requirement of mempool's method of
+ * iteration.
+ *
+ * hrm. it doesnt but stull works ok, remove the comment above? - campbell.
+ */
 typedef struct BMHeader {
        void *data; /* customdata layers */
        int index; /* notes:
@@ -99,10 +98,10 @@ typedef struct BMLoop {
        struct BMFace *f;
 
        struct BMLoop *radial_next, *radial_prev;
-       
+
        /* these were originally commented as private but are used all over the code */
        /* can't use ListBase API, due to head */
-       struct BMLoop *next, *prev;
+       struct BMLoop *next, *prev; /* next/prev verts around the face */
 } BMLoop;
 
 /* can cast BMFace/BMEdge/BMVert, but NOT BMLoop, since these dont have a flag layer */
index fc914a8c87d78cc0e2637792f036c0614029104a..4cce9ec2afa223a627123bef2481b4580876560f 100644 (file)
@@ -94,11 +94,11 @@ extern const char bm_iter_itype_htype_map[BM_ITYPE_MAX];
 typedef struct BMIter {
        BLI_mempool_iter pooliter;
 
-       struct BMVert *firstvert, *nextvert, *vdata;
-       struct BMEdge *firstedge, *nextedge, *edata;
-       struct BMLoop *firstloop, *nextloop, *ldata, *l;
-       struct BMFace *firstpoly, *nextpoly, *pdata;
-       struct BMesh *bm;
+       BMVert *firstvert, *nextvert, *vdata;
+       BMEdge *firstedge, *nextedge, *edata;
+       BMLoop *firstloop, *nextloop, *ldata, *l;
+       BMFace *firstpoly, *nextpoly, *pdata;
+       BMesh *bm;
        void (*begin)(struct BMIter *iter);
        void *(*step)(struct BMIter *iter);
        union {
@@ -111,8 +111,8 @@ typedef struct BMIter {
        char itype;
 } BMIter;
 
-void *BM_iter_at_index(struct BMesh *bm, const char itype, void *data, int index);
-int   BM_iter_as_array(struct BMesh *bm, const char itype, void *data, void **array, const int len);
+void *BM_iter_at_index(BMesh *bm, const char itype, void *data, int index);
+int   BM_iter_as_array(BMesh *bm, const char itype, void *data, void **array, const int len);
 
 /* private for bmesh_iterators_inline.c */
 void  bmiter__vert_of_mesh_begin(struct BMIter *iter);
index 02935d033547806b08c6676683e9d1e5354e19de..578cc137691ce3cb69eefa3adb6f604b46a0a850 100644 (file)
@@ -41,7 +41,7 @@ void BM_edge_hide_set(BMesh *bm, BMEdge *e, int hide);
 void BM_face_hide_set(BMesh *bm, BMFace *f, int hide);
 
 /* Selection code */
-void BM_elem_select_set(struct BMesh *bm, void *element, int select);
+void BM_elem_select_set(BMesh *bm, void *element, int select);
 
 /* use BM_elem_flag_test(ele, BM_ELEM_SELECT) to test selection */
 
@@ -50,14 +50,14 @@ void BM_mesh_elem_flag_disable_all(BMesh *bm, const char htype, const char hflag
 
 /* individual element select functions, BM_elem_select_set is a shortcut for these
  * that automatically detects which one to use*/
-void BM_vert_select_set(struct BMesh *bm, struct BMVert *v, int select);
-void BM_edge_select_set(struct BMesh *bm, struct BMEdge *e, int select);
-void BM_face_select_set(struct BMesh *bm, struct BMFace *f, int select);
+void BM_vert_select_set(BMesh *bm, BMVert *v, int select);
+void BM_edge_select_set(BMesh *bm, BMEdge *e, int select);
+void BM_face_select_set(BMesh *bm, BMFace *f, int select);
 
-void BM_select_mode_set(struct BMesh *bm, int selectmode);
+void BM_select_mode_set(BMesh *bm, int selectmode);
 
 /* counts number of elements with flag set */
-int BM_mesh_count_flag(struct BMesh *bm, const char htype, const char hflag, int respecthide);
+int BM_mesh_count_flag(BMesh *bm, const char htype, const char hflag, int respecthide);
 
 /* edit selection stuff */
 void    BM_active_face_set(BMesh *em, BMFace *f);
index 24b63815ec83ba3fbea40b30cf1563423e29bc1c..2d4958b13a583438289d374e7ccaa32006e4d30e 100644 (file)
@@ -140,8 +140,7 @@ typedef struct BMOperator {
        int slottype;
        int needflag;
        int flag;
-       struct BMOpSlot slots[BMO_OP_MAX_SLOTS];
-       void (*exec)(struct BMesh *bm, struct BMOperator *op);
+       struct BMOpSlot slots[BMO_OP_MAX_SLOTS]; void (*exec)(BMesh *bm, struct BMOperator *op);
        MemArena *arena;
 } BMOperator;
 
index de92f57bc23d2973c32c958e91e5e6bae44ae321..a4329f86614f85f2da50de274eaa63696a4b343c 100644 (file)
@@ -93,10 +93,9 @@ extern int bmesh_total_ops;
  * to get more useful information (such as the mapping from
  * original to new elements) you should run the dupe op manually.*/
 struct Object;
-struct EditMesh;
 
 #if 0
-void BMO_dupe_from_flag(struct BMesh *bm, int etypeflag, const char hflag);
+void BMO_dupe_from_flag(BMesh *bm, int etypeflag, const char hflag);
 #endif
 void BM_mesh_esubdivideflag(struct Object *obedit, BMesh *bm, int flag, float smooth,
                             float fractal, int beauty, int numcuts, int seltype,
index 399975c2e4813e262f1f28b50255a3b043162a18..dd122dbeab1565ecb78ac275d2788dbdb862caaf 100644 (file)
@@ -205,7 +205,7 @@ BMFace *BM_face_create_ngon(BMesh *bm, BMVert *v1, BMVert *v2, BMEdge **edges, i
                BLI_array_append(edges2, e);
 
                do {
-                       e2 = bmesh_disk_nextedge(e2, v);
+                       e2 = bmesh_disk_edge_next(e2, v);
                        if (e2 != e && BM_ELEM_API_FLAG_TEST(e2, _FLAG_MF)) {
                                v = BM_edge_other_vert(e2, v);
                                break;
index 11944dc1fa25e819965dafc8e9ced05267e104b0..b2945ace8f38cefbbe0aa7153e9ef9d406603dd3 100644 (file)
@@ -197,7 +197,7 @@ void  *bmiter__edge_of_vert_step(BMIter *iter)
        BMEdge *current = iter->nextedge;
 
        if (iter->nextedge)
-               iter->nextedge = bmesh_disk_nextedge(iter->nextedge, iter->vdata);
+               iter->nextedge = bmesh_disk_edge_next(iter->nextedge, iter->vdata);
        
        if (iter->nextedge == iter->firstedge) iter->nextedge = NULL;
 
@@ -214,11 +214,11 @@ void  bmiter__face_of_vert_begin(BMIter *iter)
        init_iterator(iter);
        iter->count = 0;
        if (iter->vdata->e)
-               iter->count = bmesh_disk_count_facevert(iter->vdata);
+               iter->count = bmesh_disk_facevert_count(iter->vdata);
        if (iter->count) {
-               iter->firstedge = bmesh_disk_find_first_faceedge(iter->vdata->e, iter->vdata);
+               iter->firstedge = bmesh_disk_faceedge_find_first(iter->vdata->e, iter->vdata);
                iter->nextedge = iter->firstedge;
-               iter->firstloop = bmesh_radial_find_first_faceloop(iter->firstedge->l, iter->vdata);
+               iter->firstloop = bmesh_radial_faceloop_find_first(iter->firstedge->l, iter->vdata);
                iter->nextloop = iter->firstloop;
        }
 }
@@ -228,10 +228,10 @@ void  *bmiter__face_of_vert_step(BMIter *iter)
 
        if (iter->count && iter->nextloop) {
                iter->count--;
-               iter->nextloop = bmesh_radial_find_next_faceloop(iter->nextloop, iter->vdata);
+               iter->nextloop = bmesh_radial_faceloop_find_next(iter->nextloop, iter->vdata);
                if (iter->nextloop == iter->firstloop) {
-                       iter->nextedge = bmesh_disk_find_next_faceedge(iter->nextedge, iter->vdata);
-                       iter->firstloop = bmesh_radial_find_first_faceloop(iter->nextedge->l, iter->vdata);
+                       iter->nextedge = bmesh_disk_faceedge_find_next(iter->nextedge, iter->vdata);
+                       iter->firstloop = bmesh_radial_faceloop_find_first(iter->nextedge->l, iter->vdata);
                        iter->nextloop = iter->firstloop;
                }
        }
@@ -252,11 +252,11 @@ void  bmiter__loop_of_vert_begin(BMIter *iter)
        init_iterator(iter);
        iter->count = 0;
        if (iter->vdata->e)
-               iter->count = bmesh_disk_count_facevert(iter->vdata);
+               iter->count = bmesh_disk_facevert_count(iter->vdata);
        if (iter->count) {
-               iter->firstedge = bmesh_disk_find_first_faceedge(iter->vdata->e, iter->vdata);
+               iter->firstedge = bmesh_disk_faceedge_find_first(iter->vdata->e, iter->vdata);
                iter->nextedge = iter->firstedge;
-               iter->firstloop = bmesh_radial_find_first_faceloop(iter->firstedge->l, iter->vdata);
+               iter->firstloop = bmesh_radial_faceloop_find_first(iter->firstedge->l, iter->vdata);
                iter->nextloop = iter->firstloop;
        }
 }
@@ -266,10 +266,10 @@ void  *bmiter__loop_of_vert_step(BMIter *iter)
 
        if (iter->count) {
                iter->count--;
-               iter->nextloop = bmesh_radial_find_next_faceloop(iter->nextloop, iter->vdata);
+               iter->nextloop = bmesh_radial_faceloop_find_next(iter->nextloop, iter->vdata);
                if (iter->nextloop == iter->firstloop) {
-                       iter->nextedge = bmesh_disk_find_next_faceedge(iter->nextedge, iter->vdata);
-                       iter->firstloop = bmesh_radial_find_first_faceloop(iter->nextedge->l, iter->vdata);
+                       iter->nextedge = bmesh_disk_faceedge_find_next(iter->nextedge, iter->vdata);
+                       iter->firstloop = bmesh_radial_faceloop_find_first(iter->nextedge->l, iter->vdata);
                        iter->nextloop = iter->firstloop;
                }
        }
@@ -302,7 +302,7 @@ void  *bmiter__loops_of_edge_step(BMIter *iter)
        BMLoop *current = iter->nextloop;
 
        if (iter->nextloop)
-               iter->nextloop = bmesh_radial_nextloop(iter->nextloop);
+               iter->nextloop = bmesh_radial_loop_next(iter->nextloop);
 
        if (iter->nextloop == iter->firstloop)
                iter->nextloop = NULL;
@@ -324,7 +324,7 @@ void  bmiter__loops_of_loop_begin(BMIter *iter)
        init_iterator(iter);
 
        iter->firstloop = l;
-       iter->nextloop = bmesh_radial_nextloop(iter->firstloop);
+       iter->nextloop = bmesh_radial_loop_next(iter->firstloop);
        
        if (iter->nextloop == iter->firstloop)
                iter->nextloop = NULL;
@@ -334,7 +334,7 @@ void  *bmiter__loops_of_loop_step(BMIter *iter)
 {
        BMLoop *current = iter->nextloop;
        
-       if (iter->nextloop) iter->nextloop = bmesh_radial_nextloop(iter->nextloop);
+       if (iter->nextloop) iter->nextloop = bmesh_radial_loop_next(iter->nextloop);
 
        if (iter->nextloop == iter->firstloop) iter->nextloop = NULL;
 
@@ -364,7 +364,7 @@ void  *bmiter__face_of_edge_step(BMIter *iter)
 {
        BMLoop *current = iter->nextloop;
 
-       if (iter->nextloop) iter->nextloop = bmesh_radial_nextloop(iter->nextloop);
+       if (iter->nextloop) iter->nextloop = bmesh_radial_loop_next(iter->nextloop);
 
        if (iter->nextloop == iter->firstloop) iter->nextloop = NULL;
 
index c8423afc4d9e3075337554d91f587961418fa6e5..eb3a7f63c36d0a61268db052d3ca46e7f507bd05 100644 (file)
@@ -56,7 +56,6 @@
  *
  *
  */
-#if 1
 int BM_vert_dissolve(BMesh *bm, BMVert *v)
 {
        const int len = BM_vert_edge_count(v);
@@ -107,7 +106,7 @@ int BM_disk_dissolve(BMesh *bm, BMVert *v)
                /* v->e we keep, what else */
                e = v->e;
                do {
-                       e = bmesh_disk_nextedge(e, v);
+                       e = bmesh_disk_edge_next(e, v);
                        if (!(BM_edge_share_face_count(e, v->e))) {
                                keepedge = e;
                                baseedge = v->e;
@@ -174,7 +173,7 @@ int BM_disk_dissolve(BMesh *bm, BMVert *v)
                                        done = 0;
                                        break;
                                }
-                               e = bmesh_disk_nextedge(e, v);
+                               e = bmesh_disk_edge_next(e, v);
                        } while (e != v->e);
                }
 
@@ -199,37 +198,6 @@ int BM_disk_dissolve(BMesh *bm, BMVert *v)
 
        return TRUE;
 }
-#else
-void BM_disk_dissolve(BMesh *bm, BMVert *v)
-{
-       BMFace *f;
-       BMEdge *e;
-       BMIter iter;
-       int done, len;
-       
-       if (v->e) {
-               done = 0;
-               while (!done) {
-                       done = 1;
-                       
-                       /* loop the edges looking for an edge to dissolv */
-                       for (e = BM_iter_new(&iter, bm, BM_EDGES_OF_VERT, v); e;
-                            e = BM_iter_step(&iter)) {
-                               f = NULL;
-                               len = bmesh_cycle_length(&(e->l->radial));
-                               if (len == 2) {
-                                       f = BM_faces_join_pair(bm, e->l->f, ((BMLoop *)(e->l->radial_next))->f, e);
-                               }
-                               if (f) {
-                                       done = 0;
-                                       break;
-                               }
-                       };
-               }
-               BM_vert_collapse_faces(bm, v->e, v, 1.0, TRUE);
-       }
-}
-#endif
 
 /**
  * BM_faces_join_pair
@@ -414,7 +382,7 @@ BMEdge *BM_vert_collapse_faces(BMesh *bm, BMEdge *ke, BMVert *kv, float fac,
                                const short join_faces, const short kill_degenerate_faces)
 {
        BMEdge *ne = NULL;
-       BMVert *tv = bmesh_edge_getothervert(ke, kv);
+       BMVert *tv = bmesh_edge_other_vert_get(ke, kv);
 
        BMEdge *e2;
        BMVert *tv2;
@@ -450,7 +418,7 @@ BMEdge *BM_vert_collapse_faces(BMesh *bm, BMEdge *ke, BMVert *kv, float fac,
        /* now interpolate the vertex data */
        BM_data_interp_from_verts(bm, kv, tv, kv, fac);
 
-       e2 = bmesh_disk_nextedge(ke, kv);
+       e2 = bmesh_disk_edge_next(ke, kv);
        tv2 = BM_edge_other_vert(e2, kv);
 
        if (join_faces) {
@@ -520,9 +488,9 @@ BMEdge *BM_vert_collapse_edge(BMesh *bm, BMEdge *ke, BMVert *kv,
 
        /* in this case we want to keep all faces and not join them,
         * rather just get rid of the veretex - see bug [#28645] */
-       BMVert *tv  = bmesh_edge_getothervert(ke, kv);
+       BMVert *tv  = bmesh_edge_other_vert_get(ke, kv);
        if (tv) {
-               BMEdge *e2 = bmesh_disk_nextedge(ke, kv);
+               BMEdge *e2 = bmesh_disk_edge_next(ke, kv);
                if (e2) {
                        BMVert *tv2 = BM_edge_other_vert(e2, kv);
                        if (tv2) {
@@ -587,7 +555,7 @@ BMVert *BM_edge_split(BMesh *bm, BMEdge *e, BMVert *v, BMEdge **ne, float percen
                }
        }
 
-       v2 = bmesh_edge_getothervert(e, v);
+       v2 = bmesh_edge_other_vert_get(e, v);
        nv = bmesh_semv(bm, v, e, ne);
        if (nv == NULL) {
                return NULL;
index deaadad2f4c0c5aff301db324bea92cafa84a372..c0a2962221b18278c6147308f1b09e4b482df95b 100644 (file)
@@ -142,8 +142,8 @@ BMEdge *BM_edge_create(BMesh *bm, BMVert *v1, BMVert *v2, const BMEdge *example,
        
        CustomData_bmesh_set_default(&bm->edata, &e->head.data);
        
-       bmesh_disk_append_edge(e, e->v1);
-       bmesh_disk_append_edge(e, e->v2);
+       bmesh_disk_edge_append(e, e->v1);
+       bmesh_disk_edge_append(e, e->v2);
        
        if (example)
                BM_elem_attrs_copy(bm, bm, example, e);
@@ -577,7 +577,7 @@ void BM_face_kill(BMesh *bm, BMFace *f)
                do {
                        l_next = l_iter->next;
 
-                       bmesh_radial_remove_loop(l_iter, l_iter->e);
+                       bmesh_radial_loop_remove(l_iter, l_iter->e);
                        bmesh_kill_only_loop(bm, l_iter);
 
                } while ((l_iter = l_next) != l_first);
@@ -593,8 +593,8 @@ void BM_face_kill(BMesh *bm, BMFace *f)
 void BM_edge_kill(BMesh *bm, BMEdge *e)
 {
 
-       bmesh_disk_remove_edge(e, e->v1);
-       bmesh_disk_remove_edge(e, e->v2);
+       bmesh_disk_edge_remove(e, e->v1);
+       bmesh_disk_edge_remove(e, e->v2);
 
        if (e->l) {
                BMLoop *l = e->l, *lnext, *startl = e->l;
@@ -624,7 +624,7 @@ void BM_vert_kill(BMesh *bm, BMVert *v)
                
                e = v->e;
                while (v->e) {
-                       nexte = bmesh_disk_nextedge(e, v);
+                       nexte = bmesh_disk_edge_next(e, v);
                        BM_edge_kill(bm, e);
                        e = nexte;
                }
@@ -685,7 +685,7 @@ static int bmesh_loop_reverse_loop(BMesh *bm, BMFace *f
 
        for (i = 0, l_iter = l_first; i < len; i++, l_iter = l_iter->next) {
                BMEdge *curedge = l_iter->e;
-               bmesh_radial_remove_loop(l_iter, curedge);
+               bmesh_radial_loop_remove(l_iter, curedge);
                BLI_array_append(edar, curedge);
        }
 
@@ -795,7 +795,7 @@ static int count_flagged_radial(BMesh *bm, BMLoop *l, int flag)
                }
                
                i += BM_ELEM_API_FLAG_TEST(l2->f, flag) ? 1 : 0;
-               l2 = bmesh_radial_nextloop(l2);
+               l2 = bmesh_radial_loop_next(l2);
                if (UNLIKELY(c >= BM_LOOP_RADIAL_MAX)) {
                        BMESH_ASSERT(0);
                        goto error;
@@ -820,7 +820,7 @@ static int UNUSED_FUNCTION(count_flagged_disk)(BMVert *v, int flag)
 
        do {
                i += BM_ELEM_API_FLAG_TEST(e, flag) ? 1 : 0;
-               e = bmesh_disk_nextedge(e, v);
+               e = bmesh_disk_edge_next(e, v);
        } while (e != v->e);
 
        return i;
@@ -850,7 +850,7 @@ static int disk_is_flagged(BMVert *v, int flag)
                        l = l->radial_next;
                } while (l != e->l);
 
-               e = bmesh_disk_nextedge(e, v);
+               e = bmesh_disk_edge_next(e, v);
        } while (e != v->e);
 
        return TRUE;
@@ -1255,7 +1255,7 @@ BMVert *bmesh_semv(BMesh *bm, BMVert *tv, BMEdge *e, BMEdge **re)
        if (bmesh_vert_in_edge(e, tv) == 0) {
                return NULL;
        }
-       ov = bmesh_edge_getothervert(e, tv);
+       ov = bmesh_edge_other_vert_get(e, tv);
 
        /* count valence of v1 */
        valence1 = bmesh_disk_count(ov);
@@ -1266,23 +1266,23 @@ BMVert *bmesh_semv(BMesh *bm, BMVert *tv, BMEdge *e, BMEdge **re)
        nv = BM_vert_create(bm, tv->co, tv);
        ne = BM_edge_create(bm, nv, tv, e, FALSE);
 
-       bmesh_disk_remove_edge(ne, tv);
-       bmesh_disk_remove_edge(ne, nv);
+       bmesh_disk_edge_remove(ne, tv);
+       bmesh_disk_edge_remove(ne, nv);
 
        /* remove e from v2's disk cycle */
-       bmesh_disk_remove_edge(e, tv);
+       bmesh_disk_edge_remove(e, tv);
 
        /* swap out tv for nv in e */
        bmesh_edge_swapverts(e, tv, nv);
 
        /* add e to nv's disk cycl */
-       bmesh_disk_append_edge(e, nv);
+       bmesh_disk_edge_append(e, nv);
 
        /* add ne to nv's disk cycl */
-       bmesh_disk_append_edge(ne, nv);
+       bmesh_disk_edge_append(ne, nv);
 
        /* add ne to tv's disk cycl */
-       bmesh_disk_append_edge(ne, tv);
+       bmesh_disk_edge_append(ne, tv);
 
        /* verify disk cycle */
        edok = bmesh_disk_validate(valence1, ov->e, ov);
@@ -1305,7 +1305,7 @@ BMVert *bmesh_semv(BMesh *bm, BMVert *tv, BMEdge *e, BMEdge **re)
                        l = nextl;
                        l->f->len++;
                        nextl = nextl != nextl->radial_next ? nextl->radial_next : NULL;
-                       bmesh_radial_remove_loop(l, NULL);
+                       bmesh_radial_loop_remove(l, NULL);
 
                        nl = bmesh_create_loop(bm, NULL, NULL, l->f, l);
                        nl->prev = l;
@@ -1449,9 +1449,9 @@ struct BMEdge *bmesh_jekv(BMesh *bm, BMEdge *ke, BMVert *kv, const short check_e
        len = bmesh_disk_count(kv);
        
        if (len == 2) {
-               oe = bmesh_disk_nextedge(ke, kv);
-               tv = bmesh_edge_getothervert(ke, kv);
-               ov = bmesh_edge_getothervert(oe, kv);
+               oe = bmesh_disk_edge_next(ke, kv);
+               tv = bmesh_edge_other_vert_get(ke, kv);
+               ov = bmesh_edge_other_vert_get(oe, kv);
                halt = bmesh_verts_in_edge(kv, tv, oe); /* check for double edge */
                
                if (halt) {
@@ -1469,19 +1469,19 @@ struct BMEdge *bmesh_jekv(BMesh *bm, BMEdge *ke, BMVert *kv, const short check_e
                        }
 
                        /* remove oe from kv's disk cycl */
-                       bmesh_disk_remove_edge(oe, kv);
+                       bmesh_disk_edge_remove(oe, kv);
                        /* relink oe->kv to be oe->t */
                        bmesh_edge_swapverts(oe, kv, tv);
                        /* append oe to tv's disk cycl */
-                       bmesh_disk_append_edge(oe, tv);
+                       bmesh_disk_edge_append(oe, tv);
                        /* remove ke from tv's disk cycl */
-                       bmesh_disk_remove_edge(ke, tv);
+                       bmesh_disk_edge_remove(ke, tv);
 
                        /* deal with radial cycle of k */
                        radlen = bmesh_radial_length(ke->l);
                        if (ke->l) {
                                /* first step, fix the neighboring loops of all loops in ke's radial cycl */
-                               for (i = 0, killoop = ke->l; i < radlen; i++, killoop = bmesh_radial_nextloop(killoop)) {
+                               for (i = 0, killoop = ke->l; i < radlen; i++, killoop = bmesh_radial_loop_next(killoop)) {
                                        /* relink loops and fix vertex pointer */
                                        if (killoop->next->v == kv) {
                                                killoop->next->v = tv;
@@ -1510,7 +1510,7 @@ struct BMEdge *bmesh_jekv(BMesh *bm, BMEdge *ke, BMVert *kv, const short check_e
                                        /* this should be wrapped into a bme_free_radial function to be used by bmesh_KF as well.. */
                                        for (i = 0; i < radlen; i++) {
                                                loops[i] = killoop;
-                                               killoop = bmesh_radial_nextloop(killoop);
+                                               killoop = bmesh_radial_loop_next(killoop);
                                        }
                                        for (i = 0; i < radlen; i++) {
                                                bm->totloop--;
@@ -1537,7 +1537,7 @@ struct BMEdge *bmesh_jekv(BMesh *bm, BMEdge *ke, BMVert *kv, const short check_e
                        BMESH_ASSERT(edok != FALSE);
 
                        /* Validate loop cycle of all faces attached to o */
-                       for (i = 0, l = oe->l; i < radlen; i++, l = bmesh_radial_nextloop(l)) {
+                       for (i = 0, l = oe->l; i < radlen; i++, l = bmesh_radial_loop_next(l)) {
                                BMESH_ASSERT(l->e == oe);
                                edok = bmesh_verts_in_edge(l->v, l->next->v, oe);
                                BMESH_ASSERT(edok != FALSE);
@@ -1641,10 +1641,10 @@ BMFace *bmesh_jfke(BMesh *bm, BMFace *f1, BMFace *f2, BMEdge *e)
 
        /* validate that for each face, each vertex has another edge in its disk cycle that is
         * not e, and not shared. */
-       if ( bmesh_radial_find_face(f1loop->next->e, f2) ||
-            bmesh_radial_find_face(f1loop->prev->e, f2) ||
-            bmesh_radial_find_face(f2loop->next->e, f1) ||
-            bmesh_radial_find_face(f2loop->prev->e, f1) )
+       if ( bmesh_radial_face_find(f1loop->next->e, f2) ||
+            bmesh_radial_face_find(f1loop->prev->e, f2) ||
+            bmesh_radial_face_find(f2loop->next->e, f1) ||
+            bmesh_radial_face_find(f2loop->prev->e, f1) )
        {
                return NULL;
        }
@@ -1697,8 +1697,8 @@ BMFace *bmesh_jfke(BMesh *bm, BMFace *f1, BMFace *f2, BMEdge *e)
                l_iter->f = f1;
        
        /* remove edge from the disk cycle of its two vertices */
-       bmesh_disk_remove_edge(f1loop->e, f1loop->e->v1);
-       bmesh_disk_remove_edge(f1loop->e, f1loop->e->v2);
+       bmesh_disk_edge_remove(f1loop->e, f1loop->e->v1);
+       bmesh_disk_edge_remove(f1loop->e, f1loop->e->v2);
        
        /* deallocate edge and its two loops as well as f2 */
        BLI_mempool_free(bm->toolflagpool, f1loop->e->oflags);
@@ -1747,9 +1747,9 @@ static int bmesh_vert_splice(BMesh *bm, BMVert *v, BMVert *vtarget)
        /* move all the edges from v's disk to vtarget's disk */
        e = v->e;
        while (e != NULL) {
-               bmesh_disk_remove_edge(e, v);
+               bmesh_disk_edge_remove(e, v);
                bmesh_edge_swapverts(e, v, vtarget);
-               bmesh_disk_append_edge(e, vtarget);
+               bmesh_disk_edge_append(e, vtarget);
                e = v->e;
        }
 
@@ -1839,9 +1839,9 @@ static int bmesh_cutvert(BMesh *bm, BMVert *v, BMVert ***vout, int *len)
                }
 
                BLI_assert(e->v1 == v || e->v2 == v);
-               bmesh_disk_remove_edge(e, v);
+               bmesh_disk_edge_remove(e, v);
                bmesh_edge_swapverts(e, v, verts[i]);
-               bmesh_disk_append_edge(e, verts[i]);
+               bmesh_disk_edge_append(e, verts[i]);
        }
 
        BLI_ghash_free(visithash, NULL, NULL);
@@ -1884,7 +1884,7 @@ static int bmesh_edge_splice(BMesh *bm, BMEdge *e, BMEdge *etarget)
                l = e->l;
                BLI_assert(BM_vert_in_edge(etarget, l->v));
                BLI_assert(BM_vert_in_edge(etarget, l->next->v));
-               bmesh_radial_remove_loop(l, e);
+               bmesh_radial_loop_remove(l, e);
                bmesh_radial_append(etarget, l);
        }
 
@@ -1927,7 +1927,7 @@ static int bmesh_cutedge(BMesh *bm, BMEdge *e, BMLoop *cutl)
        }
 
        ne = BM_edge_create(bm, e->v1, e->v2, e, FALSE);
-       bmesh_radial_remove_loop(cutl, e);
+       bmesh_radial_loop_remove(cutl, e);
        bmesh_radial_append(ne, cutl);
        cutl->e = ne;
 
@@ -1968,7 +1968,7 @@ static BMVert *bmesh_urmv_loop(BMesh *bm, BMLoop *sl)
         * will leave the original sv on some *other* fan (not the
         * one-face fan that holds the unglue face). */
        while (sv->e == sl->e || sv->e == sl->prev->e) {
-               sv->e = bmesh_disk_nextedge(sv->e, sv);
+               sv->e = bmesh_disk_edge_next(sv->e, sv);
        }
 
        /* Split all fans connected to the vert, duplicating it for
index 5e9f9c1a332094a0352e535bfb2aefe6a85aa7ed..c83ffca2754f015815f64edd6fe52ab51338e585 100644 (file)
@@ -166,7 +166,7 @@ void BMO_op_init(BMesh *bm, BMOperator *op, const char *opname)
  *
  * Executes a passed in operator. This handles
  * the allocation and freeing of temporary flag
- * layers and starting/stopping the modelling
+ * layers and starting/stopping the modeling
  * loop. Can be called from other operators
  * exec callbacks as well.
  */
@@ -859,7 +859,7 @@ int BMO_vert_edge_flags_count(BMesh *bm, BMVert *v, const short oflag)
                for (i = 0, curedge = v->e; i < len; i++) {
                        if (BMO_elem_flag_test(bm, curedge, oflag))
                                count++;
-                       curedge = bmesh_disk_nextedge(curedge, v);
+                       curedge = bmesh_disk_edge_next(curedge, v);
                }
        }
 
index 6ea6aba821a7e3f1d9d1a5d88843c282dea0be98..957473ab55c11ad59e235b8a01778b52b1d1ee72 100644 (file)
@@ -218,7 +218,7 @@ int BM_verts_in_edge(BMVert *v1, BMVert *v2, BMEdge *e)
 
 BMVert *BM_edge_other_vert(BMEdge *e, BMVert *v)
 {
-       return bmesh_edge_getothervert(e, v);
+       return bmesh_edge_other_vert_get(e, v);
 }
 
 /*
@@ -247,7 +247,7 @@ int BM_edge_face_count(BMEdge *e)
                l_iter = e->l;
                do {
                        count++;
-               } while ((l_iter = bmesh_radial_nextloop(l_iter)) != e->l);
+               } while ((l_iter = bmesh_radial_loop_next(l_iter)) != e->l);
        }
 
        return count;
@@ -277,7 +277,7 @@ int BM_vert_face_count(BMVert *v)
                curedge = v->e;
                do {
                        if (curedge->l) count += BM_edge_face_count(curedge);
-                       curedge = bmesh_disk_nextedge(curedge, v);
+                       curedge = bmesh_disk_edge_next(curedge, v);
                } while (curedge != v->e);
        }
        return count;
@@ -308,7 +308,7 @@ int BM_vert_is_wire(BMesh *UNUSED(bm), BMVert *v)
                        return FALSE;
                }
 
-               curedge = bmesh_disk_nextedge(curedge, v);
+               curedge = bmesh_disk_edge_next(curedge, v);
        } while (curedge != v->e);
 
        return TRUE;
@@ -355,7 +355,7 @@ int BM_vert_is_manifold(BMesh *UNUSED(bm), BMVert *v)
 
        /* count edges while looking for non-manifold edges */
        oe = v->e;
-       for (len = 0, e = v->e; e != oe || (e == oe && len == 0); len++, e = bmesh_disk_nextedge(e, v)) {
+       for (len = 0, e = v->e; e != oe || (e == oe && len == 0); len++, e = bmesh_disk_edge_next(e, v)) {
                if (e->l == NULL) {
                        /* loose edge */
                        return FALSE;
@@ -461,7 +461,7 @@ int BM_face_share_edge_count(BMFace *f1, BMFace *f2)
        
        l_iter = l_first = BM_FACE_FIRST_LOOP(f1);
        do {
-               if (bmesh_radial_find_face(l_iter->e, f2)) {
+               if (bmesh_radial_face_find(l_iter->e, f2)) {
                        count++;
                }
        } while ((l_iter = l_iter->next) != l_first);
@@ -486,7 +486,7 @@ int BM_edge_share_face_count(BMEdge *e1, BMEdge *e2)
                l = e1->l;
                do {
                        f = l->f;
-                       if (bmesh_radial_find_face(e2, f)) {
+                       if (bmesh_radial_face_find(e2, f)) {
                                return TRUE;
                        }
                        l = l->radial_next;
@@ -616,9 +616,9 @@ float BM_vert_edge_angle(BMesh *UNUSED(bm), BMVert *v)
         * get the edges and count them both at once */
 
        if ((e1 = v->e) &&
-               (e2 =  bmesh_disk_nextedge(e1, v)) &&
+               (e2 =  bmesh_disk_edge_next(e1, v)) &&
            /* make sure we come full circle and only have 2 connected edges */
-               (e1 == bmesh_disk_nextedge(e2, v)))
+               (e1 == bmesh_disk_edge_next(e2, v)))
        {
                BMVert *v1 = BM_edge_other_vert(e1, v);
                BMVert *v2 = BM_edge_other_vert(e2, v);
index 509cfbaae61231d2dcc7c5a6de1dbc55d641f2a8..0180257e1b0a53c78b431fa33ea80fa1e8a13aac 100644 (file)
@@ -53,7 +53,7 @@ int bmesh_verts_in_edge(BMVert *v1, BMVert *v2, BMEdge *e)
        return FALSE;
 }
 
-BMVert *bmesh_edge_getothervert(BMEdge *e, BMVert *v)
+BMVert *bmesh_edge_other_vert_get(BMEdge *e, BMVert *v)
 {
        if (e->v1 == v) {
                return e->v2;
@@ -112,10 +112,9 @@ int bmesh_edge_swapverts(BMEdge *e, BMVert *orig, BMVert *newv)
  *
  *             Functions relating to this cycle:
  *
- *                     bmesh_disk_append_edge
- *                     bmesh_disk_remove_edge
- *                     bmesh_disk_nextedge
- *                     bmesh_disk_getpointer
+ *                     bmesh_disk_edge_append
+ *                     bmesh_disk_edge_remove
+ *                     bmesh_disk_edge_next
  *
  *     2: The Radial Cycle - A circle of face edges (bmesh_Loop) around an edge
  *        Base: edge->l->radial structure.
@@ -128,9 +127,9 @@ int bmesh_edge_swapverts(BMEdge *e, BMVert *orig, BMVert *newv)
  *             Functions relating to this cycle:
  *
  *                     bmesh_radial_append
- *                     bmesh_radial_remove_loop
- *                     bmesh_radial_nextloop
- *                     bmesh_radial_find_face
+ *                     bmesh_radial_loop_remove
+ *                     bmesh_radial_loop_next
+ *                     bmesh_radial_face_find
  *
  *
  *     3: The Loop Cycle - A circle of face edges around a polygon.
@@ -151,7 +150,7 @@ int bmesh_edge_swapverts(BMEdge *e, BMVert *orig, BMVert *newv)
  *  cycle order and all non-manifold conditions are represented trivially.
  *
  */
-int bmesh_disk_append_edge(struct BMEdge *e, struct BMVert *v)
+int bmesh_disk_edge_append(struct BMEdge *e, struct BMVert *v)
 {
        if (!v->e) {
                BMDiskLink *dl1 = BM_EDGE_DISK_LINK_GET(e, v);
@@ -177,7 +176,7 @@ int bmesh_disk_append_edge(struct BMEdge *e, struct BMVert *v)
        return TRUE;
 }
 
-void bmesh_disk_remove_edge(struct BMEdge *e, struct BMVert *v)
+void bmesh_disk_edge_remove(struct BMEdge *e, struct BMVert *v)
 {
        BMDiskLink *dl1, *dl2;
 
@@ -199,7 +198,7 @@ void bmesh_disk_remove_edge(struct BMEdge *e, struct BMVert *v)
 }
 
 /*
- *                     bmesh_disk_nextedge
+ *                     bmesh_disk_edge_next
  *
  *     Find the next edge in a disk cycle
  *
@@ -207,7 +206,7 @@ void bmesh_disk_remove_edge(struct BMEdge *e, struct BMVert *v)
  *     Pointer to the next edge in the disk cycle for the vertex v.
  */
 
-struct BMEdge *bmesh_disk_nextedge(struct BMEdge *e, struct BMVert *v)
+struct BMEdge *bmesh_disk_edge_next(struct BMEdge *e, struct BMVert *v)
 {
        if (v == e->v1)
                return e->v1_disk_link.next;
@@ -225,7 +224,7 @@ static BMEdge *bmesh_disk_prevedge(BMEdge *e, BMVert *v)
        return NULL;
 }
 
-BMEdge *bmesh_disk_existedge(BMVert *v1, BMVert *v2)
+BMEdge *bmesh_disk_edge_exists(BMVert *v1, BMVert *v2)
 {
        BMEdge *curedge, *startedge;
        
@@ -237,7 +236,7 @@ BMEdge *bmesh_disk_existedge(BMVert *v1, BMVert *v2)
                                return curedge;
                        }
 
-                       curedge = bmesh_disk_nextedge(curedge, v1);
+                       curedge = bmesh_disk_edge_next(curedge, v1);
                } while (curedge != startedge);
        }
        
@@ -258,7 +257,7 @@ int bmesh_disk_count(struct BMVert *v)
                        return 0;
                }
 
-               e =  bmesh_disk_nextedge(e, v);
+               e =  bmesh_disk_edge_next(e, v);
 
                if (i >= (1 << 20)) {
                        printf("bmesh error: infinite loop in disk cycle!\n");
@@ -286,7 +285,7 @@ int bmesh_disk_validate(int len, BMEdge *e, BMVert *v)
                        return FALSE;
                }
 
-               e2 = bmesh_disk_nextedge(e2, v);
+               e2 = bmesh_disk_edge_next(e2, v);
        } while (e2 != e);
 
        return TRUE;
@@ -301,7 +300,7 @@ int bmesh_disk_validate(int len, BMEdge *e, BMVert *v)
  * faces incident upon this vertex
  */
 
-int bmesh_disk_count_facevert(BMVert *v)
+int bmesh_disk_facevert_count(BMVert *v)
 {
        BMEdge *curedge;
        int count = 0;
@@ -313,8 +312,8 @@ int bmesh_disk_count_facevert(BMVert *v)
        /* first, loop around edge */
        curedge = v->e;
        do {
-               if (curedge->l) count += bmesh_radial_count_facevert(curedge->l, v);
-               curedge = bmesh_disk_nextedge(curedge, v);
+               if (curedge->l) count += bmesh_radial_facevert_count(curedge->l, v);
+               curedge = bmesh_disk_edge_next(curedge, v);
        } while (curedge != v->e);
 
        return count;
@@ -329,30 +328,30 @@ int bmesh_disk_count_facevert(BMVert *v)
  * to it.
  */
 
-struct BMEdge *bmesh_disk_find_first_faceedge(struct BMEdge *e, struct BMVert *v)
+struct BMEdge *bmesh_disk_faceedge_find_first(struct BMEdge *e, struct BMVert *v)
 {
        BMEdge *searchedge = NULL;
        searchedge = e;
        do {
-               if (searchedge->l && bmesh_radial_count_facevert(searchedge->l, v)) {
+               if (searchedge->l && bmesh_radial_facevert_count(searchedge->l, v)) {
                        return searchedge;
                }
 
-               searchedge = bmesh_disk_nextedge(searchedge, v);
+               searchedge = bmesh_disk_edge_next(searchedge, v);
        } while (searchedge != e);
 
        return NULL;
 }
 
-struct BMEdge *bmesh_disk_find_next_faceedge(struct BMEdge *e, struct BMVert *v)
+struct BMEdge *bmesh_disk_faceedge_find_next(struct BMEdge *e, struct BMVert *v)
 {
        BMEdge *searchedge = NULL;
-       searchedge = bmesh_disk_nextedge(e, v);
+       searchedge = bmesh_disk_edge_next(e, v);
        do {
-               if (searchedge->l && bmesh_radial_count_facevert(searchedge->l, v)) {
+               if (searchedge->l && bmesh_radial_facevert_count(searchedge->l, v)) {
                        return searchedge;
                }
-               searchedge = bmesh_disk_nextedge(searchedge, v);
+               searchedge = bmesh_disk_edge_next(searchedge, v);
        } while (searchedge != e);
        return e;
 }
@@ -383,7 +382,7 @@ int bmesh_radial_validate(int radlen, BMLoop *l)
                }
                
                i++;
-       } while ((l_iter = bmesh_radial_nextloop(l_iter)) != l);
+       } while ((l_iter = bmesh_radial_loop_next(l_iter)) != l);
 
        return TRUE;
 }
@@ -396,7 +395,7 @@ int bmesh_radial_validate(int radlen, BMLoop *l)
  * updated (in the case that the edge's link into the radial
  * cycle was the loop which is being removed from the cycle).
  */
-void bmesh_radial_remove_loop(BMLoop *l, BMEdge *e)
+void bmesh_radial_loop_remove(BMLoop *l, BMEdge *e)
 {
        /* if e is non-NULL, l must be in the radial cycle of e */
        if (UNLIKELY(e && e != l->e)) {
@@ -434,7 +433,7 @@ void bmesh_radial_remove_loop(BMLoop *l, BMEdge *e)
  * Finds the first loop of v around radial
  * cycle
  */
-BMLoop *bmesh_radial_find_first_faceloop(BMLoop *l, BMVert *v)
+BMLoop *bmesh_radial_faceloop_find_first(BMLoop *l, BMVert *v)
 {
        BMLoop *l_iter;
        l_iter = l;
@@ -442,23 +441,23 @@ BMLoop *bmesh_radial_find_first_faceloop(BMLoop *l, BMVert *v)
                if (l_iter->v == v) {
                        return l_iter;
                }
-       } while ((l_iter = bmesh_radial_nextloop(l_iter)) != l);
+       } while ((l_iter = bmesh_radial_loop_next(l_iter)) != l);
        return NULL;
 }
 
-BMLoop *bmesh_radial_find_next_faceloop(BMLoop *l, BMVert *v)
+BMLoop *bmesh_radial_faceloop_find_next(BMLoop *l, BMVert *v)
 {
        BMLoop *l_iter;
-       l_iter = bmesh_radial_nextloop(l);
+       l_iter = bmesh_radial_loop_next(l);
        do {
                if (l_iter->v == v) {
                        return l_iter;
                }
-       } while ((l_iter = bmesh_radial_nextloop(l_iter)) != l);
+       } while ((l_iter = bmesh_radial_loop_next(l_iter)) != l);
        return l;
 }
 
-BMLoop *bmesh_radial_nextloop(BMLoop *l)
+BMLoop *bmesh_radial_loop_next(BMLoop *l)
 {
        return l->radial_next;
 }
@@ -512,7 +511,7 @@ void bmesh_radial_append(BMEdge *e, BMLoop *l)
        l->e = e;
 }
 
-int bmesh_radial_find_face(BMEdge *e, BMFace *f)
+int bmesh_radial_face_find(BMEdge *e, BMFace *f)
 {
        BMLoop *l_iter;
        int i, len;
@@ -533,7 +532,7 @@ int bmesh_radial_find_face(BMEdge *e, BMFace *f)
  *
  */
 
-int bmesh_radial_count_facevert(BMLoop *l, BMVert *v)
+int bmesh_radial_facevert_count(BMLoop *l, BMVert *v)
 {
        BMLoop *l_iter;
        int count = 0;
@@ -542,7 +541,7 @@ int bmesh_radial_count_facevert(BMLoop *l, BMVert *v)
                if (l_iter->v == v) {
                        count++;
                }
-       } while ((l_iter = bmesh_radial_nextloop(l_iter)) != l);
+       } while ((l_iter = bmesh_radial_loop_next(l_iter)) != l);
 
        return count;
 }
@@ -584,131 +583,3 @@ int bmesh_loop_validate(BMFace *f)
 
        return TRUE;
 }
-
-
-#if 0
-
-/**
- *                     bmesh_cycle_length
- *
- *     Count the nodes in a cycle.
- *
- *  Returns -
- *     Integer
- */
-
-int bmesh_cycle_length(BMEdge *e, BMVert *v)
-{
-       BMEdge *next, *prev, *cur;
-       int len, vi = v == e->v1 ? 0 : 1;
-       
-       /* should skip 2 forward if v is 1, happily reduces to (v * 2) */
-       prev = *(&e->v1_prev + vi * 2);
-       
-       cur = e;
-       len = 1;
-       while (cur != prev) {
-               vi = cur->v1 == v ? 0 : 1;
-               
-               len++;
-               cur = *(&cur->v1_next + vi * 2);
-       }
-       
-       return len;
-}
-
-/* Begin Disk Cycle routine */
-
-/**
- *                     bmesh_disk_getpointer
- *
- *     Given an edge and one of its vertices, find the apporpriate CycleNode
- *
- *  Returns -
- *     Pointer to bmesh_CycleNode.
- */
-BMNode *bmesh_disk_getpointer(BMEdge *e, BMVert *v)
-{
-       /* returns pointer to the cycle node for the appropriate vertex in this dis */
-       if (e->v1 == v) {
-               return &(e->d1);
-       }
-       else if (e->v2 == v) {
-               return &(e->d2);
-       }
-       return NULL;
-}
-
-/**
- *                     bmesh_disk_next_edgeflag
- *
- *     Searches the disk cycle of v, starting with e, for the
- *  next edge that has either eflag or tflag.
- *
- *     bmesh_Edge pointer.
- */
-
-BMEdge *bmesh_disk_next_edgeflag(BMEdge *e, BMVert *v, int eflag, int tflag)
-{
-       
-       BMNode *diskbase;
-       BMEdge *curedge;
-       int len, ok;
-       
-       if (eflag && tflag) {
-               return NULL;
-       }
-
-       ok = bmesh_vert_in_edge(e, v);
-       if (ok) {
-               diskbase = bmesh_disk_getpointer(e, v);
-               len = bmesh_cycle_length(diskbase);
-               curedge = bmesh_disk_nextedge(e, v);
-               while (curedge != e) {
-                       if (eflag) {
-                               if (curedge->head.eflag1 == eflag) {
-                                       return curedge;
-                               }
-                       }
-
-                       curedge = bmesh_disk_nextedge(curedge, v);
-               }
-       }
-       return NULL;
-}
-
-int bmesh_disk_hasedge(BMVert *v, BMEdge *e)
-{
-       BMNode *diskbase;
-       BMEdge *curedge;
-       int i, len = 0;
-       
-       if (v->e) {
-               diskbase = bmesh_disk_getpointer(v->e, v);
-               len = bmesh_cycle_length(diskbase);
-               
-               for (i = 0, curedge = v->e; i < len; i++) {
-                       if (curedge == e) {
-                               return TRUE;
-                       }
-                       else curedge = bmesh_disk_nextedge(curedge, v);
-               }
-       }
-       return FALSE;
-}
-
-struct BMLoop *bmesh_loop_find_loop(struct BMFace *f, struct BMVert *v)
-{
-       BMLoop *l;
-       int i, len;
-       
-       len = bmesh_cycle_length(f->lbase);
-       for (i = 0, l = f->loopbase; i < len; i++, l = l->next) {
-               if (l->v == v) {
-                       return l;
-               }
-       }
-       return NULL;
-}
-
-#endif
index a569c98d16d1dd28deca75c754af3d8f630e034a..75dbbb9bca6b055720922798192bedcdbcc98532 100644 (file)
 
 struct ListBase;
 
-/* DOUBLE CIRCULAR LINKED LIST FUNCTIONS */
-int bmesh_cycle_length(void *h);
-
 /* LOOP CYCLE MANAGEMENT */
 int bmesh_loop_validate(BMFace *f);
 
 /* DISK CYCLE MANAGMENT */
-int bmesh_disk_append_edge(struct BMEdge *e, struct BMVert *v);
-void bmesh_disk_remove_edge(struct BMEdge *e, struct BMVert *v);
-struct BMEdge *bmesh_disk_nextedge(struct BMEdge *e, struct BMVert *v);
-struct BMNode *bmesh_disk_getpointer(struct BMEdge *e, struct BMVert *v);
-int bmesh_disk_count_facevert(struct BMVert *v);
-struct BMEdge *bmesh_disk_find_first_faceedge(struct BMEdge *e, struct BMVert *v);
-struct BMEdge *bmesh_disk_find_next_faceedge(struct BMEdge *e, struct BMVert *v);
+int     bmesh_disk_edge_append(BMEdge *e, BMVert *v);
+void    bmesh_disk_edge_remove(BMEdge *e, BMVert *v);
+BMEdge *bmesh_disk_edge_next(BMEdge *e, BMVert *v);
+int     bmesh_disk_facevert_count(BMVert *v);
+BMEdge *bmesh_disk_faceedge_find_first(BMEdge *e, BMVert *v);
+BMEdge *bmesh_disk_faceedge_find_next(BMEdge *e, BMVert *v);
 
 /* RADIAL CYCLE MANAGMENT */
-void bmesh_radial_append(struct BMEdge *e, struct BMLoop *l);
-void bmesh_radial_remove_loop(struct BMLoop *l, struct BMEdge *e);
-int bmesh_radial_find_face(struct BMEdge *e, struct BMFace *f);
-struct BMLoop *bmesh_radial_nextloop(struct BMLoop *l);
-int bmesh_radial_count_facevert(struct BMLoop *l, struct BMVert *v);
-struct BMLoop *bmesh_radial_find_first_faceloop(struct BMLoop *l, struct BMVert *v);
-struct BMLoop *bmesh_radial_find_next_faceloop(struct BMLoop *l, struct BMVert *v);
-int bmesh_radial_validate(int radlen, struct BMLoop *l);
+void    bmesh_radial_append(BMEdge *e, BMLoop *l);
+void    bmesh_radial_loop_remove(BMLoop *l, BMEdge *e);
+int     bmesh_radial_face_find(BMEdge *e, BMFace *f);
+BMLoop *bmesh_radial_loop_next(BMLoop *l);
+int     bmesh_radial_facevert_count(BMLoop *l, BMVert *v);
+BMLoop *bmesh_radial_faceloop_find_first(BMLoop *l, BMVert *v);
+BMLoop *bmesh_radial_faceloop_find_next(BMLoop *l, BMVert *v);
+int     bmesh_radial_validate(int radlen, BMLoop *l);
 
 /* EDGE UTILITIES */
-int bmesh_vert_in_edge(struct BMEdge *e, struct BMVert *v);
-int bmesh_verts_in_edge(struct BMVert *v1, struct BMVert *v2, struct BMEdge *e);
-int bmesh_edge_swapverts(struct BMEdge *e, struct BMVert *orig, struct BMVert *newv); /*relink edge*/
-struct BMVert *bmesh_edge_getothervert(struct BMEdge *e, struct BMVert *v);
-struct BMEdge *bmesh_disk_existedge(BMVert *v1, BMVert *v2);
-struct BMEdge *bmesh_disk_next_edgeflag(struct BMEdge *e, struct BMVert *v, int eflag, int tflag);
-int bmesh_disk_validate(int len, struct BMEdge *e, struct BMVert *v);
+int     bmesh_vert_in_edge(BMEdge *e, BMVert *v);
+int     bmesh_verts_in_edge(BMVert *v1, BMVert *v2, BMEdge *e);
+int     bmesh_edge_swapverts(BMEdge *e, BMVert *orig, BMVert *newv); /*relink edge*/
+BMVert *bmesh_edge_other_vert_get(BMEdge *e, BMVert *v);
+BMEdge *bmesh_disk_edge_exists(BMVert *v1, BMVert *v2);
+int            bmesh_disk_validate(int len, BMEdge *e, BMVert *v);
 
 /*EULER API - For modifying structure*/
-struct BMVert *bmesh_mv(struct BMesh *bm, float *vec);
-struct BMEdge *bmesh_me(struct BMesh *bm, struct BMVert *v1, struct BMVert *v2);
-struct BMFace *bmesh_mf(struct BMesh *bm, struct BMVert *v1, struct BMVert *v2, struct BMEdge **elist, int len);
-int bmesh_kv(struct BMesh *bm, struct BMVert *v);
-int bmesh_ke(struct BMesh *bm, struct BMEdge *e);
-int bmesh_kf(struct BMesh *bm, struct BMFace *bply);
-struct BMVert *bmesh_semv(struct BMesh *bm, struct BMVert *tv, struct BMEdge *e, struct BMEdge **re);
-struct BMFace *bmesh_sfme(struct BMesh *bm, struct BMFace *f, struct BMVert *v1,
-                          struct BMVert *v2, struct BMLoop **rl,
+BMVert *bmesh_semv(BMesh *bm, BMVert *tv, BMEdge *e, BMEdge **re);
+BMFace *bmesh_sfme(BMesh *bm, BMFace *f, BMVert *v1,
+                          BMVert *v2, BMLoop **rl,
 #ifdef USE_BMESH_HOLES
                           ListBase *holes,
 #endif
                           BMEdge *example
                           );
 
-struct BMEdge *bmesh_jekv(struct BMesh *bm, struct BMEdge *ke, struct BMVert *kv, const short check_edge_splice);
-int bmesh_loop_reverse(struct BMesh *bm, struct BMFace *f);
-struct BMFace *bmesh_jfke(struct BMesh *bm, struct BMFace *f1, struct BMFace *f2, struct BMEdge *e);
+BMEdge *bmesh_jekv(BMesh *bm, BMEdge *ke, BMVert *kv, const short check_edge_splice);
+int            bmesh_loop_reverse(BMesh *bm, BMFace *f);
+BMFace *bmesh_jfke(BMesh *bm, BMFace *f1, BMFace *f2, BMEdge *e);
 
-struct BMVert *bmesh_urmv(struct BMesh *bm, struct BMFace *sf, struct BMVert *sv);
-//int *bmesh_grkv(struct BMesh *bm, struct BMFace *sf, struct BMVert *kv);
+BMVert *bmesh_urmv(BMesh *bm, BMFace *sf, BMVert *sv);
 
 #endif /* __BMESH_STRUCTURE_H__ */
index e34bf5d88a79ca29280da65c4f9be8b9a6c3f426..15b46cbcdf8d0e56871ebb0c20a57f16a139ec8f 100644 (file)
@@ -157,7 +157,7 @@ static void *shellWalker_step(BMWalker *walker)
                                newState->curedge = curedge;
                        }
                }
-               curedge = bmesh_disk_nextedge(curedge, shellWalk.base);
+               curedge = bmesh_disk_edge_next(curedge, shellWalk.base);
        } while (curedge != shellWalk.curedge);
        
        return shellWalk.curedge;
@@ -282,8 +282,8 @@ static void *islandboundWalker_step(BMWalker *walker)
        
        while (1) {
                l = BM_face_other_loop(e, f, v);
-               if (bmesh_radial_nextloop(l) != l) {
-                       l = bmesh_radial_nextloop(l);
+               if (bmesh_radial_loop_next(l) != l) {
+                       l = bmesh_radial_loop_next(l);
                        f = l->f;
                        e = l->e;
                        if (walker->mask_face && !BMO_elem_flag_test(walker->bm, f, walker->mask_face)) {
@@ -488,7 +488,7 @@ static void *loopWalker_step(BMWalker *walker)
                        if (!l)
                                break;
 
-                       l2 = bmesh_radial_nextloop(l);
+                       l2 = bmesh_radial_loop_next(l);
 
                        if (l2 == l) {
                                break;
index 8b04f2deb65944c5a38b781bdd19b4d80242d6ee..601399b9b963dc0717f03ecf9e1837a58ea073e7 100644 (file)
@@ -53,7 +53,7 @@ static int UNUSED_FUNCTION(check_hole_in_region)(BMesh *bm, BMFace *f)
        for ( ; f2; f2 = BMW_step(&regwalker)) {
                l2 = BM_iter_new(&liter2, bm, BM_LOOPS_OF_FACE, f2);
                for ( ; l2; l2 = BM_iter_step(&liter2)) {
-                       l3 = bmesh_radial_nextloop(l2);
+                       l3 = bmesh_radial_loop_next(l2);
                        if ( BMO_elem_flag_test(bm, l3->f, FACE_MARK) !=
                             BMO_elem_flag_test(bm, l2->f, FACE_MARK))
                        {
@@ -433,8 +433,8 @@ void dummy_exec(BMesh *bm, BMOperator *op)
                                        }
 
                                        if (!found2) {
-                                               bmesh_kf(bm, f);
-                                               bmesh_ke(bm, fe);
+                                               BM_face_kill(bm, f);
+                                               BM_edge_kill(bm, fe);
                                        }
                                } /* else if (f->len == 3) {
                                        BMEdge *ed[3];
index da360d602e484f8d7067f07b1a3eb31141f86cb6..0c1f0454dc5b12c6fb865dd81547d33538830423 100644 (file)
@@ -152,7 +152,7 @@ static int BME_Bevel_Dissolve_Disk(BMesh *bm, BMVert *v)
                }
 
                e = v->e;
-               elast = bmesh_disk_nextedge(e, v);
+               elast = bmesh_disk_edge_next(e, v);
 
                /* BMESH_TODO, figure out if its possible we had a double edge here and need to splice it,
                 * last bool arg */
@@ -274,7 +274,7 @@ static BMVert *BME_bevel_split_edge(BMesh *bm, BMVert *v, BMVert *v1, BMLoop *l,
                        return NULL;
                }
                e1 = v->e; /* we just use the first two edges */
-               e2 = bmesh_disk_nextedge(v->e, v);
+               e2 = bmesh_disk_edge_next(v->e, v);
                if (e1 == e2) {
                        //printf("You need at least two edges to use BME_bevel_split_edge()\n");
                        return NULL;
@@ -459,7 +459,7 @@ static BMVert *BME_bevel_wire(BMesh *bm, BMVert *v, float value, int res, int UN
        BMVert *ov1, *ov2, *v1, *v2;
 
        ov1 = BM_edge_other_vert(v->e, v);
-       ov2 = BM_edge_other_vert(bmesh_disk_nextedge(v->e, v), v);
+       ov2 = BM_edge_other_vert(bmesh_disk_edge_next(v->e, v), v);
 
        /* split the edges */
        v1 = BME_bevel_split_edge(bm, v, ov1, NULL, NULL, value, td);
@@ -542,7 +542,7 @@ static BMLoop *BME_bevel_edge(BMesh *bm, BMLoop *l, float value, int UNUSED(opti
                /* find saved loop pointer */
                l = se->l;
                while (l->f != jf) {
-                       l = bmesh_radial_nextloop(l);
+                       l = bmesh_radial_loop_next(l);
                        BLI_assert(l != se->l);
                }
                l = l->prev;
@@ -588,7 +588,7 @@ static BMLoop *BME_bevel_edge(BMesh *bm, BMLoop *l, float value, int UNUSED(opti
                /* find saved loop pointer */
                l = se->l;
                while (l->f != jf) {
-                       l = bmesh_radial_nextloop(l);
+                       l = bmesh_radial_loop_next(l);
                        BLI_assert(l != se->l);
                }
        }
@@ -964,7 +964,7 @@ static BMesh *BME_bevel_mesh(BMesh *bm, float value, int UNUSED(res), int option
                                        BM_face_split(bm, l->f, l->next->v, l->prev->v, &l, l->e); /* clip this corner off */
                                if(l2->f->len > 3)
                                        BM_face_split(bm, l2->f, l2->next->v, l2->prev->v, &l, l2->e); /* clip this corner off */
-                               curedge = bmesh_disk_nextedge(curedge, v);
+                               curedge = bmesh_disk_edge_next(curedge, v);
                        } while(curedge != v->e);
                        BME_Bevel_Dissolve_Disk(bm, v);
                }
index 12524a9fd2e9ba87a44c87fadb62aaf2f51ca318..fd29ce94827aa98af393c0eb437873ea2990c5cd 100644 (file)
@@ -38,10 +38,6 @@ extern "C" {
 struct ID;
 struct View3D;
 struct ARegion;
-struct EditMesh;
-struct EditVert;
-struct EditEdge;
-struct EditFace;
 struct bContext;
 struct wmOperator;
 struct wmWindowManager;
index 6c74eea3a5eec35fb7127716455368236a280d94..398dca1fe76d1a4f7d40a24f27cd434db3cc880f 100644 (file)
 #define __ED_UVEDIT_H__
 
 struct ARegionType;
-struct EditFace;
+struct BMEditMesh;
+struct BMFace;
+struct BMLoop;
 struct Image;
-struct Main;
 struct ImageUser;
 struct MTFace;
+struct MTexPoly;
+struct Main;
 struct Object;
 struct Scene;
 struct SpaceImage;
 struct bContext;
 struct bNode;
 struct wmKeyConfig;
-struct BMEditMesh;
-struct BMLoop;
-struct BMFace;
-struct MTexPoly;
 
 /* uvedit_ops.c */
 void ED_operatortypes_uvedit(void);
index 9ef4bc1cbd558c40cea91857431100229c495cdb..5627d3df91c2c7e5337cff1e8c3784beef262cf0 100644 (file)
 
 /* ********* exports for space_view3d/ module ********** */
 struct ARegion;
-struct bContext;
-struct BezTriple;
-struct bglMats;
-struct BoundBox;
-struct BPoint;
-struct Nurb;
-struct BezTriple;
-struct BMVert;
 struct BMEdge;
 struct BMFace;
-struct EditVert;
+struct BMVert;
+struct BPoint;
+struct BezTriple;
+struct BezTriple;
+struct BoundBox;
 struct ImBuf;
+struct MVert;
 struct Main;
 struct Nurb;
+struct Nurb;
 struct Object;
-struct rcti;
 struct RegionView3D;
 struct Scene;
 struct View3D;
 struct ViewContext;
-struct wmWindow;
-struct MVert;
-struct wmOperatorType;
+struct bContext;
+struct bglMats;
+struct rcti;
 struct wmOperator;
+struct wmOperatorType;
+struct wmWindow;
 
 /* for derivedmesh drawing callbacks, for view3d_select, .... */
 typedef struct ViewContext {
index a2cd394f86f05bfad11ed3dd50d4e55cd169964e..36ffacef1abfd4aeacce94b819017083e78d1c3a 100644 (file)
@@ -2874,23 +2874,23 @@ typedef struct CutCurve {
 
 /* ******************************************************************** */
 /* Knife Subdivide Tool.  Subdivides edges intersected by a mouse trail
      drawn by user.
-       
      Currently mapped to KKey when in MeshEdit mode.
      Usage:
              Hit Shift K, Select Centers or Exact
              Hold LMB down to draw path, hit RETKEY.
              ESC cancels as expected.
-   
      Contributed by Robert Wenzlaff (Det. Thorn).
-
   2.5 revamp:
   - non modal (no menu before cutting)
   - exit on mouse release
   - polygon/segment drawing can become handled by WM cb later
-
      bmesh port version
-*/
* drawn by user.
+ *
* Currently mapped to KKey when in MeshEdit mode.
* Usage:
* - Hit Shift K, Select Centers or Exact
* - Hold LMB down to draw path, hit RETKEY.
* - ESC cancels as expected.
+ *
* Contributed by Robert Wenzlaff (Det. Thorn).
+ *
* 2.5 Revamp:
*  - non modal (no menu before cutting)
*  - exit on mouse release
*  - polygon/segment drawing can become handled by WM cb later
+ *
* bmesh port version
+ */
 
 #define KNIFE_EXACT            1
 #define KNIFE_MIDPOINT 2
@@ -2903,7 +2903,7 @@ static EnumPropertyItem knife_items[] = {
        {0, NULL, 0, NULL, NULL}
 };
 
-/* seg_intersect() Determines if and where a mouse trail intersects an EditEdge */
+/* bm_edge_seg_isect() Determines if and where a mouse trail intersects an BMEdge */
 
 static float bm_edge_seg_isect(BMEdge *e, CutCurve *c, int len, char mode,
                                struct GHash *gh, int *isected)
@@ -3575,36 +3575,6 @@ void MESH_OT_dissolve_limited(wmOperatorType *ot)
        RNA_def_property_float_default(prop, DEG2RADF(15.0f));
 }
 
-static int edge_flip_exec(bContext *UNUSED(C), wmOperator *UNUSED(op))
-{
-#if 0
-       Object *obedit = CTX_data_edit_object(C);
-       EditMesh *em = BKE_mesh_get_editmesh((Mesh *)obedit->data);
-
-       edge_flip(em);
-
-       DAG_id_tag_update(obedit->data, OB_RECALC_DATA);
-       WM_event_add_notifier(C, NC_GEOM|ND_DATA, obedit->data);
-
-       BKE_mesh_end_editmesh(obedit->data, em);
-#endif
-       return OPERATOR_FINISHED;
-}
-
-void MESH_OT_edge_flip(wmOperatorType *ot)
-{
-       /* identifiers */
-       ot->name = "Edge Flip";
-       ot->idname = "MESH_OT_edge_flip";
-
-       /* api callbacks */
-       ot->exec = edge_flip_exec;
-       ot->poll = ED_operator_editmesh;
-
-       /* flags */
-       ot->flag = OPTYPE_REGISTER|OPTYPE_UNDO;
-}
-
 static int split_mesh_exec(bContext *C, wmOperator *op)
 {
        Object *ob = CTX_data_edit_object(C);
index aee62ef0d29776d689c3a724603c67b723049eb5..4be24e7f781ef46456acd1ae2a66959198b0f054 100644 (file)
@@ -395,56 +395,6 @@ static int ringcut_cancel (bContext *C, wmOperator *op)
        return OPERATOR_CANCELLED;
 }
 
-/* for bmesh this tool is in bmesh_select.c */
-#if 0
-
-static int ringsel_invoke (bContext *C, wmOperator *op, wmEvent *evt)
-{
-       tringselOpData *lcd;
-       EditEdge *edge;
-       int dist = 75;
-       
-       view3d_operator_needs_opengl(C);
-
-       if (!ringsel_init(C, op, 0))
-               return OPERATOR_CANCELLED;
-       
-       lcd = op->customdata;
-       
-       if (lcd->em->selectmode == SCE_SELECT_FACE) {
-               PointerRNA props_ptr;
-               int extend = RNA_boolean_get(op->ptr, "extend");
-
-               ringsel_exit(op);
-
-               WM_operator_properties_create(&props_ptr, "MESH_OT_loop_select");
-               RNA_boolean_set(&props_ptr, "extend", extend);
-               WM_operator_name_call(C, "MESH_OT_loop_select", WM_OP_INVOKE_REGION_WIN, &props_ptr);
-               WM_operator_properties_free(&props_ptr);
-
-               return OPERATOR_CANCELLED;
-       }
-
-       lcd->vc.mval[0] = evt->mval[0];
-       lcd->vc.mval[1] = evt->mval[1];
-       
-       edge = findnearestedge(&lcd->vc, &dist);
-       if(!edge) {
-               ringsel_exit(op);
-               return OPERATOR_CANCELLED;
-       }
-
-       lcd->eed = edge;
-       ringsel_find_edge(lcd, 1);
-
-       ringsel_finish(C, op);
-       ringsel_exit(op);
-
-       return OPERATOR_FINISHED;
-}
-
-#endif
-
 static int ringcut_invoke (bContext *C, wmOperator *op, wmEvent *evt)
 {
        Object *obedit= CTX_data_edit_object(C);
index c75f85a2794e493c3bf1410817d9ceb500b2d9de..98ae8915c414cdec884a3b04af9a00019fee5a21 100644 (file)
@@ -162,7 +162,6 @@ void MESH_OT_beautify_fill(struct wmOperatorType *ot);
 void MESH_OT_quads_convert_to_tris(struct wmOperatorType *ot);
 void MESH_OT_tris_convert_to_quads(struct wmOperatorType *ot);
 void MESH_OT_dissolve_limited(struct wmOperatorType *ot);
-void MESH_OT_edge_flip(struct wmOperatorType *ot);
 void MESH_OT_faces_shade_smooth(struct wmOperatorType *ot);
 void MESH_OT_faces_shade_flat(struct wmOperatorType *ot);
 void MESH_OT_split(struct wmOperatorType *ot);
index c3f749b2c4560b711cb3f2e518a8ee51e633d8f6..4b4083751e79f1a839a63a8b7c9d2e4568d6a661 100644 (file)
@@ -115,7 +115,6 @@ void ED_operatortypes_mesh(void)
        WM_operatortype_append(MESH_OT_quads_convert_to_tris);
        WM_operatortype_append(MESH_OT_tris_convert_to_quads);
        WM_operatortype_append(MESH_OT_dissolve_limited);
-       WM_operatortype_append(MESH_OT_edge_flip);
        WM_operatortype_append(MESH_OT_faces_shade_smooth);
        WM_operatortype_append(MESH_OT_faces_shade_flat);
        WM_operatortype_append(MESH_OT_sort_faces);
@@ -311,7 +310,6 @@ void ED_keymap_mesh(wmKeyConfig *keyconf)
 
        WM_keymap_add_item(keymap, "MESH_OT_quads_convert_to_tris", TKEY, KM_PRESS, KM_CTRL, 0);
        WM_keymap_add_item(keymap, "MESH_OT_tris_convert_to_quads", JKEY, KM_PRESS, KM_ALT, 0);
-       WM_keymap_add_item(keymap, "MESH_OT_edge_flip", FKEY, KM_PRESS, KM_SHIFT|KM_CTRL, 0);
 
        WM_keymap_add_item(keymap, "MESH_OT_rip_move",VKEY, KM_PRESS, 0, 0);
        WM_keymap_add_item(keymap, "MESH_OT_merge", MKEY, KM_PRESS, KM_ALT, 0);
index 40037f82376623a361b948e9b6ccd9d5c3dd8d0a..50dfc17af6fe03a047a5ed0fdab4dcf0056dedbe 100644 (file)
 
 /* internal exports only */
 
-struct bScreen;
 struct ARegion;
+struct ARegionType;
 struct BoundBox;
-struct Object;
 struct DerivedMesh;
-struct wmOperatorType;
-struct bContext;
-struct wmWindowManager;
-struct EditMesh;
+struct Object;
 struct ViewContext;
-struct ARegionType;
-struct bPoseChannel;
 struct bAnimVizSettings;
+struct bContext;
 struct bMotionPath;
+struct bPoseChannel;
+struct bScreen;
 struct wmNDOFMotionData;
+struct wmOperatorType;
+struct wmWindowManager;
 
 #define BL_NEAR_CLIP 0.001
 
index a4a0d332c51f1007b9d1910aef822f0149f3b4a6..dfd8b4a35686d29bf9636ddba6f308878cb8a47d 100644 (file)
@@ -567,6 +567,7 @@ static void do_lasso_select_mesh(ViewContext *vc, int mcords[][2], short moves,
        EDBM_selectmode_flush(vc->em);
 }
 
+/* BMESH_TODO */
 #if 0
 /* this is an exception in that its the only lasso that dosnt use the 3d view (uses space image view) */
 static void do_lasso_select_mesh_uv(int mcords[][2], short moves, short select)
index d2b37c0f3b79648ca0cafd67044cf42bc740248c..3397230b0801c162453078d4640474dad07b0569 100644 (file)
@@ -181,8 +181,6 @@ typedef struct TransDataNla {
 } TransDataNla;
 
 struct LinkNode;
-struct EditEdge;
-struct EditVert;
 struct GHash;
 
 typedef struct TransDataSlideVert {
@@ -201,14 +199,7 @@ typedef struct SlideData {
        
        struct SmallHash vhash;
        struct SmallHash origfaces;
-       
-       /*
-       TransDataSlideUv *slideuv, *suv_last;
-       int totuv, uvlay_tot;
-       struct GHash *vhash, **uvhash;
-       struct EditVert *nearest;
-       struct LinkNode *edgelist, *vertlist;
-       */
+
        int start[2], end[2];
        struct BMEditMesh *em;
        float perc;
@@ -230,8 +221,8 @@ typedef struct TransData {
        struct bConstraint *con;        /* for objects/bones, the first constraint in its constraint stack */
        TransDataExtension *ext;        /* for objects, poses. 1 single malloc per TransInfo! */
        TransDataCurveHandleFlags *hdata; /* for curves, stores handle flags for modification/cancel */
-       void  *extra;            /* extra data (mirrored element pointer, in editmode mesh to EditVert) (editbone for roll fixing) (...) */
-       int  flag;         /* Various flags */
+       void  *extra;            /* extra data (mirrored element pointer, in editmode mesh to BMVert) (editbone for roll fixing) (...) */
+       int  flag;           /* Various flags */
        short  protectflag;      /* If set, copy of Object or PoseChannel protection */
 } TransData;
 
index bb10aa448d643240bab36a6b6e578307ac3cfd84..5598d70ee7036f7da760aa4ab86e328ecde0ebe9 100644 (file)
@@ -1980,8 +1980,7 @@ static void get_edge_center(float cent_r[3], BMesh *bm, BMVert *eve)
        }
 }
 
-/* way to overwrite what data is edited with transform
- * static void VertsToTransData(TransData *td, EditVert *eve, BakeKey *key) */
+/* way to overwrite what data is edited with transform */
 static void VertsToTransData(TransInfo *t, TransData *td, BMEditMesh *em, BMVert *eve, float *bweight)
 {
        td->flag = 0;
index 4ac68ae5a18f8c6a7eb840cad4faaf400cd1e795..0e2154006c18a0ae8686af19fe9409579e42f90c 100644 (file)
@@ -32,8 +32,6 @@
 #ifndef __UVEDIT_INTERN_H__
 #define __UVEDIT_INTERN_H__
 
-struct EditFace;
-struct EditMesh;
 struct MTexPoly;
 struct Image;
 struct MTFace;
index 290defaec0c3e1ec295d1d4de61e29677277ac20..c6eeccadc6223f69ff7a8fbdef339093d5c443a3 100644 (file)
 
 #include "DNA_defs.h" /* USE_BMESH_FORWARD_COMPAT */
 
+struct AnimData;
 struct DerivedMesh;
 struct Ipo;
 struct Key;
-struct Material;
-struct MVert;
+struct MCol;
 struct MEdge;
 struct MFace;
-struct MCol;
-struct MSticky;
-struct Mesh;
-struct OcInfo;
-struct MPoly;
-struct MTexPoly;
 struct MLoop;
-struct MLoopUV;
 struct MLoopCol;
+struct MLoopUV;
+struct MPoly;
+struct MSticky;
+struct MTexPoly;
+struct MVert;
+struct Material;
+struct Mesh;
 struct Multires;
-struct EditMesh;
-struct AnimData;
+struct OcInfo;
 
 typedef struct Mesh {
        ID id;
index 623fe99666854ee88bcf22b47f05de4016c60fed..8641afcb481d1e08c2c22184e7dc0366bd13842a 100644 (file)
@@ -33,7 +33,6 @@
 
 struct CustomData;
 struct DerivedMesh;
-struct EditMesh;
 struct MDeformVert;
 struct ModifierData;
 struct Object;
index e72a2d2427a0c91a5c7fb7890ffe6c84a625b8de..b9b8f57b971383721ce3db59411b54d8ab7c2183 100644 (file)
@@ -230,7 +230,6 @@ static void wm_gesture_draw_circle(wmGesture *gt)
 static void draw_filled_lasso(wmGesture *gt)
 {
        ScanFillVert *v=NULL, *lastv=NULL, *firstv=NULL;
-       /* EditEdge *e; */ /* UNUSED */
        ScanFillFace *efa;
        short *lasso= (short *)gt->customdata;
        int i;
index 0e13778f02cee82fe1d4be6000b3ac047ee0c229..79347c9a4578f3d431bacccf3f2844a1210be5f0 100644 (file)
 
 struct ARegion;
 struct ARegionType;
+struct BMEditMesh;
 struct Base;
 struct Brush;
-struct bNodeTree;
-struct bNodeSocket;
 struct CSG_FaceIteratorDescriptor;
 struct CSG_VertexIteratorDescriptor;
+struct ChannelDriver;
 struct ColorBand;
-struct CurveMapping;
+struct Context;
 struct Curve;
+struct CurveMapping;
 struct DerivedMesh;
 struct EditBone;
-struct EditFace;
-struct EditMesh;
 struct EnvMap;
-struct ID;
 struct FCurve;
+struct Heap;
+struct HeapNode;
+struct ID;
 struct ImBuf;
 struct Image;
 struct ImageUser;
-struct KeyingSetInfo;
 struct KeyingSet;
+struct KeyingSetInfo;
 struct LOD_Decimation_Info;
+struct MCol;
 struct MTex;
 struct Main;
 struct Material;
-struct MCol;
 struct MenuType;
 struct Mesh;
 struct ModifierData;
@@ -79,21 +80,32 @@ struct RenderEngineType;
 struct RenderLayer;
 struct RenderResult;
 struct Scene;
+struct Scene;
 struct ScrArea;
 struct SculptSession;
 struct ShadeInput;
 struct ShadeResult;
+struct SmallHash;
+struct SmallHashIter;
 struct SpaceClip;
 struct SpaceImage;
 struct SpaceNode;
 struct Tex;
 struct TexResult;
 struct Text;
+struct ToolSettings;
+struct View3D;
 struct bAction;
 struct bArmature;
 struct bConstraint;
+struct bConstraintOb;
+struct bConstraintTarget;
+struct bContextDataResult;
 struct bNode;
+struct bNodeSocket;
+struct bNodeTree;
 struct bPoseChannel;
+struct bPythonConstraint;
 struct uiLayout;
 struct wmEvent;
 struct wmKeyConfig;
@@ -101,20 +113,6 @@ struct wmKeyMap;
 struct wmOperator;
 struct wmWindow;
 struct wmWindowManager;
-struct View3D;
-struct ToolSettings;
-struct bContextDataResult;
-struct bConstraintTarget;
-struct bPythonConstraint;
-struct bConstraintOb;
-struct Context;
-struct ChannelDriver;
-struct BMEditMesh;
-struct Heap;
-struct HeapNode;
-struct Scene;
-struct SmallHash;
-struct SmallHashIter;
 
 /*new render funcs */
 void EDBM_selectmode_set(struct BMEditMesh *em) {}
@@ -258,7 +256,6 @@ void WM_keymap_restore_to_default(struct wmKeyMap *keymap){}
 void WM_keymap_restore_item_to_default(struct bContext *C, struct wmKeyMap *keymap, struct wmKeyMapItem *kmi){}
 void WM_keymap_properties_reset(struct wmKeyMapItem *kmi){}
 void WM_keyconfig_update_tag(struct wmKeyMap *keymap, struct wmKeyMapItem *kmi) {}
-int WM_keymap_user_init(struct wmWindowManager *wm, struct wmKeyMap *keymap) {return 0;}
 int WM_keymap_item_compare(struct wmKeyMapItem *k1, struct wmKeyMapItem *k2){return 0;}
 
 
@@ -355,7 +352,6 @@ void ED_nurb_set_spline_type(struct Nurb *nu, int type){}
 
 void EM_selectmode_set(struct EditMesh *em){}
 int EM_texFaceCheck(struct EditMesh *em){return 0;}
-struct MTFace *EM_get_active_mtface(struct EditMesh *em, struct EditFace **act_efa, struct MCol **mcol, int sloopy){return (struct MTFace *)NULL;}
 void make_editMesh(struct Scene *scene, struct Object *ob){}
 void load_editMesh(struct Scene *scene, struct Object *ob){}