remove ifdef'd bevel code, current bevel works better then the previous code.
authorCampbell Barton <ideasman42@gmail.com>
Wed, 14 Nov 2012 09:45:15 +0000 (09:45 +0000)
committerCampbell Barton <ideasman42@gmail.com>
Wed, 14 Nov 2012 09:45:15 +0000 (09:45 +0000)
reduce strlen check in texttool_suggest_add()
use 'del list[:]' rather then 'list[:] = []' in python scripts which clear lists.

build_files/cmake/cmake_consistency_check.py
doc/python_api/sphinx_doc_gen.py
release/scripts/modules/bpy/utils.py
release/scripts/modules/bpy_extras/mesh_utils.py
release/scripts/startup/bl_operators/uvcalc_smart_project.py
source/blender/blenkernel/intern/suggestions.c
source/blender/bmesh/operators/bmo_bevel.c

index 072bbb12fb36a49427f3f89e24382befdd3f2b12..83ebf927b3c56c7cd8a831998b3e5801902f0db5 100755 (executable)
@@ -222,8 +222,8 @@ def cmake_get_src(f):
             '''
 
             # reset
-            sources_h[:] = []
-            sources_c[:] = []
+            del sources_h[:]
+            del sources_c[:]
 
     filen.close()
 
index 6f7d4f3582a51b398462f5406a4f6dd1f15cc9b0..410612fabd5991de73965905c214e883159f74f9 100644 (file)
@@ -1251,7 +1251,7 @@ def pyrna2sphinx(basepath):
             bases = list(reversed(struct.get_bases()))
 
             # props
-            lines[:] = []
+            del lines[:]
 
             if _BPY_STRUCT_FAKE:
                 descr_items = [(key, descr) for key, descr in sorted(bpy.types.Struct.__bases__[0].__dict__.items()) if not key.startswith("__")]
@@ -1282,7 +1282,7 @@ def pyrna2sphinx(basepath):
                 fw("\n")
 
             # funcs
-            lines[:] = []
+            del lines[:]
 
             if _BPY_STRUCT_FAKE:
                 for key, descr in descr_items:
@@ -1305,7 +1305,7 @@ def pyrna2sphinx(basepath):
                     fw(line)
                 fw("\n")
 
-            lines[:] = []
+            del lines[:]
 
         if struct.references:
             # use this otherwise it gets in the index for a normal heading.
index 573694ff08e3e1cc4758e0313d05f3fa7ef27048..4ad00eb267e63dd04ca579565935f6f4278620e7 100644 (file)
@@ -216,7 +216,7 @@ def load_scripts(reload_scripts=False, refresh_scripts=False):
         for mod in _global_loaded_modules:
             test_reload(mod)
 
-        _global_loaded_modules[:] = []
+        del _global_loaded_modules[:]
 
     for base_path in script_paths():
         for path_subdir in _script_module_dirs:
index ad3cf8c08ec7076c2cb17583b67bee6956d00598..2042cc1c8a1c44316f201ff0ccc9d0af4a913cf7 100644 (file)
@@ -223,7 +223,7 @@ def edge_loops_from_tessfaces(mesh, tessfaces=None, seams=()):
             else:
                 other_dir = None
 
-            ed_adj[:] = []
+            del ed_adj[:]
 
             flipped = False
 
@@ -235,22 +235,22 @@ def edge_loops_from_tessfaces(mesh, tessfaces=None, seams=()):
                     if other_dir and flipped is False:
                         flipped = True  # only flip the list once
                         context_loop.reverse()
-                        ed_adj[:] = []
+                        del ed_adj[:]
                         context_loop.append(other_dir)  # save 1 look-up
 
                         ed_adj = edges[context_loop[-1]]
                         if len(ed_adj) != 2:
-                            ed_adj[:] = []
+                            del ed_adj[:]
                             break
                     else:
-                        ed_adj[:] = []
+                        del ed_adj[:]
                         break
 
                 i = ed_adj.index(context_loop[-2])
                 context_loop.append(ed_adj[not  i])
 
                 # Dont look at this again
-                ed_adj[:] = []
+                del ed_adj[:]
 
     return edge_loops
 
@@ -436,7 +436,7 @@ def ngon_tessellate(from_data, indices, fix_loops=True):
             if s1[0][1] == s1[-1][1]:  # remove endpoints double
                 s1.pop()
 
-            s2[:] = []  # Empty this segment s2 so we don't use it again.
+            del s2[:]  # Empty this segment s2 so we don't use it again.
             return True
 
         joining_segments = True
index 9fa44cac81279a043fae6039d53fd97e6221b6d4..eb05057de3d848ae7bbba0d962b20dcf368c77ca 100644 (file)
@@ -517,7 +517,7 @@ def mergeUvIslands(islandList):
                                     for uv in f.uv:
                                         uv+= offset
 
-                                sourceIsland[0][:] = [] # Empty
+                                del sourceIsland[0][:]  # Empty
 
 
                                 # Move edge loop into new and offset.
@@ -527,7 +527,7 @@ def mergeUvIslands(islandList):
                                      (e[0]+offset, e[1]+offset, e[2])\
                                 ) for e in sourceIsland[6] ] )
 
-                                sourceIsland[6][:] = [] # Empty
+                                del sourceIsland[6][:]  # Empty
 
                                 # Sort by edge length, reverse so biggest are first.
 
@@ -540,7 +540,7 @@ def mergeUvIslands(islandList):
                                 for p in sourceIsland[7]:
                                     p+= offset
 
-                                sourceIsland[7][:] = []
+                                del sourceIsland[7][:]
 
 
                                 # Decrement the efficiency
index 99e33594a3e8dbc1d27def56ba2cc2861785d845..ff9774f85afc7ff7316a3b584ee512c67e86d935 100644 (file)
@@ -47,6 +47,7 @@ static SuggList suggestions = {NULL, NULL, NULL, NULL, NULL};
 static char *documentation = NULL;
 //static int doc_lines = 0;
 
+/* TODO, replace with  BLI_strncasecmp() */
 static int txttl_cmp(const char *first, const char *second, int len)
 {
        int cmp, i;
@@ -113,19 +114,18 @@ short texttool_text_is_active(Text *text)
 
 void texttool_suggest_add(const char *name, char type)
 {
+       const int len = strlen(name);
+       int cmp;
        SuggItem *newitem, *item;
-       int len, cmp;
 
-       newitem = MEM_mallocN(sizeof(SuggItem) + strlen(name) + 1, "SuggestionItem");
+       newitem = MEM_mallocN(sizeof(SuggItem) + len + 1, "SuggItem");
        if (!newitem) {
                printf("Failed to allocate memory for suggestion.\n");
                return;
        }
 
        newitem->name = (char *) (newitem + 1);
-       len = strlen(name);
-       strncpy(newitem->name, name, len);
-       newitem->name[len] = '\0';
+       memcpy(newitem->name, name, len + 1);
        newitem->type = type;
        newitem->prev = newitem->next = NULL;
 
index db5b769d0785a4c36a8ba2b68332823d9facf45d..374895109766f968f8f4444cff7d37a2dd154d59 100644 (file)
@@ -37,9 +37,6 @@
 
 #include "intern/bmesh_operators_private.h" /* own include */
 
-#define NEW_BEVEL 1
-
-#ifdef NEW_BEVEL
 #define BEVEL_FLAG      1
 #define EDGE_SELECTED   2
 
@@ -1496,858 +1493,4 @@ void bmo_bevel_exec(BMesh *bm, BMOperator *op)
                }
                free_bevel_params(&bp);
        }
-
-}
-
-#else
-#define BEVEL_FLAG  1
-#define BEVEL_DEL   2
-#define FACE_NEW    4
-#define EDGE_OLD    8
-#define FACE_OLD    16
-#define VERT_OLD    32
-#define FACE_SPAN   64
-#define FACE_HOLE   128
-
-typedef struct LoopTag {
-       BMVert *newv;
-} LoopTag;
-
-typedef struct EdgeTag {
-       BMVert *newv1, *newv2;
-} EdgeTag;
-
-static void calc_corner_co(BMLoop *l, const float fac, float r_co[3],
-                           const short do_dist, const short do_even)
-{
-       float no[3], l_vec_prev[3], l_vec_next[3], l_co_prev[3], l_co[3], l_co_next[3], co_ofs[3];
-       int is_concave;
-
-       /* first get the prev/next verts */
-       if (l->f->len > 2) {
-               copy_v3_v3(l_co_prev, l->prev->v->co);
-               copy_v3_v3(l_co, l->v->co);
-               copy_v3_v3(l_co_next, l->next->v->co);
-
-               /* calculate normal */
-               sub_v3_v3v3(l_vec_prev, l_co_prev, l_co);
-               sub_v3_v3v3(l_vec_next, l_co_next, l_co);
-
-               cross_v3_v3v3(no, l_vec_prev, l_vec_next);
-               is_concave = dot_v3v3(no, l->f->no) > 0.0f;
-       }
-       else {
-               BMIter iter;
-               BMLoop *l2;
-               float up[3] = {0.0f, 0.0f, 1.0f};
-
-               copy_v3_v3(l_co_prev, l->prev->v->co);
-               copy_v3_v3(l_co, l->v->co);
-               
-               BM_ITER_ELEM (l2, &iter, l->v, BM_LOOPS_OF_VERT) {
-                       if (l2->f != l->f) {
-                               copy_v3_v3(l_co_next, BM_edge_other_vert(l2->e, l2->next->v)->co);
-                               break;
-                       }
-               }
-               
-               sub_v3_v3v3(l_vec_prev, l_co_prev, l_co);
-               sub_v3_v3v3(l_vec_next, l_co_next, l_co);
-
-               cross_v3_v3v3(no, l_vec_prev, l_vec_next);
-               if (dot_v3v3(no, no) == 0.0f) {
-                       no[0] = no[1] = 0.0f; no[2] = -1.0f;
-               }
-               
-               is_concave = dot_v3v3(no, up) < 0.0f;
-       }
-
-
-       /* now calculate the new location */
-       if (do_dist) { /* treat 'fac' as distance */
-
-               normalize_v3(l_vec_prev);
-               normalize_v3(l_vec_next);
-
-               add_v3_v3v3(co_ofs, l_vec_prev, l_vec_next);
-               if (UNLIKELY(normalize_v3(co_ofs) == 0.0f)) {  /* edges form a straight line */
-                       cross_v3_v3v3(co_ofs, l_vec_prev, l->f->no);
-               }
-
-               if (do_even) {
-                       negate_v3(l_vec_next);
-                       mul_v3_fl(co_ofs, fac * shell_angle_to_dist(0.5f * angle_normalized_v3v3(l_vec_prev, l_vec_next)));
-                       /* negate_v3(l_vec_next); */ /* no need unless we use again */
-               }
-               else {
-                       mul_v3_fl(co_ofs, fac);
-               }
-       }
-       else { /* treat as 'fac' as a factor (0 - 1) */
-
-               /* not strictly necessary, balance vectors
-                * so the longer edge doesn't skew the result,
-                * gives nicer, move even output.
-                *
-                * Use the minimum rather then the middle value so skinny faces don't flip along the short axis */
-               float min_fac = min_ff(normalize_v3(l_vec_prev), normalize_v3(l_vec_next));
-               float angle;
-
-               if (do_even) {
-                       negate_v3(l_vec_next);
-                       angle = angle_normalized_v3v3(l_vec_prev, l_vec_next);
-                       negate_v3(l_vec_next); /* no need unless we use again */
-               }
-               else {
-                       angle = 0.0f;
-               }
-
-               mul_v3_fl(l_vec_prev, min_fac);
-               mul_v3_fl(l_vec_next, min_fac);
-
-               add_v3_v3v3(co_ofs, l_vec_prev, l_vec_next);
-
-               if (UNLIKELY(is_zero_v3(co_ofs))) {
-                       cross_v3_v3v3(co_ofs, l_vec_prev, l->f->no);
-                       normalize_v3(co_ofs);
-                       mul_v3_fl(co_ofs, min_fac);
-               }
-
-               /* done */
-               if (do_even) {
-                       mul_v3_fl(co_ofs, (fac * 0.5f) * shell_angle_to_dist(0.5f * angle));
-               }
-               else {
-                       mul_v3_fl(co_ofs, fac * 0.5f);
-               }
-       }
-
-       /* apply delta vec */
-       if (is_concave)
-               negate_v3(co_ofs);
-
-       add_v3_v3v3(r_co, co_ofs, l->v->co);
-}
-
-
-#define ETAG_SET(e, v, nv)  (                                                 \
-       (v) == (e)->v1 ?                                                          \
-               (etags[BM_elem_index_get((e))].newv1 = (nv)) :                        \
-               (etags[BM_elem_index_get((e))].newv2 = (nv))                          \
-       )
-
-#define ETAG_GET(e, v)  (                                                     \
-       (v) == (e)->v1 ?                                                          \
-               (etags[BM_elem_index_get((e))].newv1) :                               \
-               (etags[BM_elem_index_get((e))].newv2)                                 \
-       )
-
-void bmo_bevel_exec(BMesh *bm, BMOperator *op)
-{
-       BMOIter siter;
-       BMIter iter;
-       BMEdge *e;
-       BMVert *v;
-       BMFace **faces = NULL, *f;
-       LoopTag *tags = NULL, *tag;
-       EdgeTag *etags = NULL;
-       BMVert **verts = NULL;
-       BMEdge **edges = NULL;
-       BLI_array_declare(faces);
-       BLI_array_declare(tags);
-       BLI_array_declare(etags);
-       BLI_array_declare(verts);
-       BLI_array_declare(edges);
-       SmallHash hash;
-       float fac = BMO_slot_float_get(op, "percent");
-       const short do_even = BMO_slot_bool_get(op, "use_even");
-       const short do_dist = BMO_slot_bool_get(op, "use_dist");
-       int i, li, has_elens, HasMDisps = CustomData_has_layer(&bm->ldata, CD_MDISPS);
-       
-       has_elens = CustomData_has_layer(&bm->edata, CD_PROP_FLT) && BMO_slot_bool_get(op, "use_lengths");
-       if (has_elens) {
-               li = BMO_slot_int_get(op, "lengthlayer");
-       }
-       
-       BLI_smallhash_init(&hash);
-       
-       BMO_ITER (e, &siter, bm, op, "geom", BM_EDGE) {
-               BMO_elem_flag_enable(bm, e, BEVEL_FLAG | BEVEL_DEL);
-               BMO_elem_flag_enable(bm, e->v1, BEVEL_FLAG | BEVEL_DEL);
-               BMO_elem_flag_enable(bm, e->v2, BEVEL_FLAG | BEVEL_DEL);
-               
-               if (BM_edge_face_count(e) < 2) {
-                       BMO_elem_flag_disable(bm, e, BEVEL_DEL);
-                       BMO_elem_flag_disable(bm, e->v1, BEVEL_DEL);
-                       BMO_elem_flag_disable(bm, e->v2, BEVEL_DEL);
-               }
-#if 0
-               if (BM_edge_is_wire(e)) {
-                       BMVert *verts[2] = {e->v1, e->v2};
-                       BMEdge *edges[2] = {e, BM_edge_create(bm, e->v1, e->v2, e, 0)};
-                       
-                       BMO_elem_flag_enable(bm, edges[1], BEVEL_FLAG);
-                       BM_face_create(bm, verts, edges, 2, FALSE);
-               }
-#endif
-       }
-       
-       BM_ITER_MESH (v, &iter, bm, BM_VERTS_OF_MESH) {
-               BMO_elem_flag_enable(bm, v, VERT_OLD);
-       }
-
-#if 0
-       /* a bit of cleaner code that, alas, doens't work. */
-       /* build edge tag */
-       BM_ITER_MESH (e, &iter, bm, BM_EDGES_OF_MESH) {
-               if (BMO_elem_flag_test(bm, e->v1, BEVEL_FLAG) || BMO_elem_flag_test(bm, e->v2, BEVEL_FLAG)) {
-                       BMIter liter;
-                       BMLoop *l;
-                       
-                       if (!BMO_elem_flag_test(bm, e, EDGE_OLD)) {
-                               BM_elem_index_set(e, BLI_array_count(etags)); /* set_dirty! */
-                               BLI_array_grow_one(etags);
-                               
-                               BMO_elem_flag_enable(bm, e, EDGE_OLD);
-                       }
-                       
-                       BM_ITER_ELEM (l, &liter, e, BM_LOOPS_OF_EDGE) {
-                               BMLoop *l2;
-                               BMIter liter2;
-                               
-                               if (BMO_elem_flag_test(bm, l->f, BEVEL_FLAG))
-                                       continue;
-
-                               BM_ITER_ELEM (l2, &liter2, l->f, BM_LOOPS_OF_FACE) {
-                                       BM_elem_index_set(l2, BLI_array_count(tags)); /* set_loop */
-                                       BLI_array_grow_one(tags);
-
-                                       if (!BMO_elem_flag_test(bm, l2->e, EDGE_OLD)) {
-                                               BM_elem_index_set(l2->e, BLI_array_count(etags)); /* set_dirty! */
-                                               BLI_array_grow_one(etags);
-                                               
-                                               BMO_elem_flag_enable(bm, l2->e, EDGE_OLD);
-                                       }
-                               }
-
-                               BMO_elem_flag_enable(bm, l->f, BEVEL_FLAG);
-                               BLI_array_append(faces, l->f);
-                       }
-               }
-               else {
-                       BM_elem_index_set(e, -1); /* set_dirty! */
-               }
-       }
-#endif
-       
-       /* create and assign looptag structure */
-       BMO_ITER (e, &siter, bm, op, "geom", BM_EDGE) {
-               BMLoop *l;
-               BMIter liter;
-
-               BMO_elem_flag_enable(bm, e->v1, BEVEL_FLAG | BEVEL_DEL);
-               BMO_elem_flag_enable(bm, e->v2, BEVEL_FLAG | BEVEL_DEL);
-               
-               if (BM_edge_face_count(e) < 2) {
-                       BMO_elem_flag_disable(bm, e, BEVEL_DEL);
-                       BMO_elem_flag_disable(bm, e->v1, BEVEL_DEL);
-                       BMO_elem_flag_disable(bm, e->v2, BEVEL_DEL);
-               }
-               
-               if (!BLI_smallhash_haskey(&hash, (intptr_t)e)) {
-                       BLI_array_grow_one(etags);
-                       BM_elem_index_set(e, BLI_array_count(etags) - 1); /* set_dirty! */
-                       BLI_smallhash_insert(&hash, (intptr_t)e, NULL);
-                       BMO_elem_flag_enable(bm, e, EDGE_OLD);
-               }
-               
-               /* find all faces surrounding e->v1 and, e->v2 */
-               for (i = 0; i < 2; i++) {
-                       BM_ITER_ELEM (l, &liter, i ? e->v2 : e->v1, BM_LOOPS_OF_VERT) {
-                               BMLoop *l2;
-                               BMIter liter2;
-                               
-                               /* see if we've already processed this loop's fac */
-                               if (BLI_smallhash_haskey(&hash, (intptr_t)l->f))
-                                       continue;
-                               
-                               /* create tags for all loops in l-> */
-                               BM_ITER_ELEM (l2, &liter2, l->f, BM_LOOPS_OF_FACE) {
-                                       BLI_array_grow_one(tags);
-                                       BM_elem_index_set(l2, BLI_array_count(tags) - 1); /* set_loop */
-                                       
-                                       if (!BLI_smallhash_haskey(&hash, (intptr_t)l2->e)) {
-                                               BLI_array_grow_one(etags);
-                                               BM_elem_index_set(l2->e, BLI_array_count(etags) - 1); /* set_dirty! */
-                                               BLI_smallhash_insert(&hash, (intptr_t)l2->e, NULL);
-                                               BMO_elem_flag_enable(bm, l2->e, EDGE_OLD);
-                                       }
-                               }
-
-                               BLI_smallhash_insert(&hash, (intptr_t)l->f, NULL);
-                               BMO_elem_flag_enable(bm, l->f, BEVEL_FLAG);
-                               BLI_array_append(faces, l->f);
-                       }
-               }
-       }
-
-       bm->elem_index_dirty |= BM_EDGE;
-       
-       BM_ITER_MESH (v, &iter, bm, BM_VERTS_OF_MESH) {
-               BMIter eiter;
-               
-               if (!BMO_elem_flag_test(bm, v, BEVEL_FLAG))
-                       continue;
-               
-               BM_ITER_ELEM (e, &eiter, v, BM_EDGES_OF_VERT) {
-                       if (!BMO_elem_flag_test(bm, e, BEVEL_FLAG) && !ETAG_GET(e, v)) {
-                               BMVert *v2;
-                               float co[3];
-                               
-                               v2 = BM_edge_other_vert(e, v);
-                               sub_v3_v3v3(co, v2->co, v->co);
-                               if (has_elens) {
-                                       float elen = *(float *)CustomData_bmesh_get_n(&bm->edata, e->head.data, CD_PROP_FLT, li);
-
-                                       normalize_v3(co);
-                                       mul_v3_fl(co, elen);
-                               }
-                               
-                               mul_v3_fl(co, fac);
-                               add_v3_v3(co, v->co);
-                               
-                               v2 = BM_vert_create(bm, co, v);
-                               ETAG_SET(e, v, v2);
-                       }
-               }
-       }
-       
-       for (i = 0; i < BLI_array_count(faces); i++) {
-               BMLoop *l;
-               BMIter liter;
-               
-               BMO_elem_flag_enable(bm, faces[i], FACE_OLD);
-               
-               BM_ITER_ELEM (l, &liter, faces[i], BM_LOOPS_OF_FACE) {
-                       float co[3];
-
-                       if (BMO_elem_flag_test(bm, l->e, BEVEL_FLAG)) {
-                               if (BMO_elem_flag_test(bm, l->prev->e, BEVEL_FLAG)) {
-                                       tag = tags + BM_elem_index_get(l);
-                                       calc_corner_co(l, fac, co, do_dist, do_even);
-                                       tag->newv = BM_vert_create(bm, co, l->v);
-                               }
-                               else {
-                                       tag = tags + BM_elem_index_get(l);
-                                       tag->newv = ETAG_GET(l->prev->e, l->v);
-                                       
-                                       if (!tag->newv) {
-                                               sub_v3_v3v3(co, l->prev->v->co, l->v->co);
-                                               if (has_elens) {
-                                                       float elen = *(float *)CustomData_bmesh_get_n(&bm->edata, l->prev->e->head.data,
-                                                                                                     CD_PROP_FLT, li);
-
-                                                       normalize_v3(co);
-                                                       mul_v3_fl(co, elen);
-                                               }
-
-                                               mul_v3_fl(co, fac);
-                                               add_v3_v3(co, l->v->co);
-
-                                               tag->newv = BM_vert_create(bm, co, l->v);
-                                               
-                                               ETAG_SET(l->prev->e, l->v, tag->newv);
-                                       }
-                               }
-                       }
-                       else if (BMO_elem_flag_test(bm, l->v, BEVEL_FLAG)) {
-                               tag = tags + BM_elem_index_get(l);
-                               tag->newv = ETAG_GET(l->e, l->v);
-
-                               if (!tag->newv) {
-                                       sub_v3_v3v3(co, l->next->v->co, l->v->co);
-                                       if (has_elens) {
-                                               float elen = *(float *)CustomData_bmesh_get_n(&bm->edata, l->e->head.data, CD_PROP_FLT, li);
-
-                                               normalize_v3(co);
-                                               mul_v3_fl(co, elen);
-                                       }
-                                       
-                                       mul_v3_fl(co, fac);
-                                       add_v3_v3(co, l->v->co);
-
-                                       tag = tags + BM_elem_index_get(l);
-                                       tag->newv = BM_vert_create(bm, co, l->v);
-                                       
-                                       ETAG_SET(l->e, l->v, tag->newv);
-                               }
-                       }
-                       else {
-                               tag = tags + BM_elem_index_get(l);
-                               tag->newv = l->v;
-                               BMO_elem_flag_disable(bm, l->v, BEVEL_DEL);
-                       }
-               }
-       }
-       
-       /* create new faces inset from original face */
-       for (i = 0; i < BLI_array_count(faces); i++) {
-               BMLoop *l;
-               BMIter liter;
-               BMFace *f;
-               BMVert *lastv = NULL, *firstv = NULL;
-
-               BMO_elem_flag_enable(bm, faces[i], BEVEL_DEL);
-               
-               BLI_array_empty(verts);
-               BLI_array_empty(edges);
-               
-               BM_ITER_ELEM (l, &liter, faces[i], BM_LOOPS_OF_FACE) {
-                       BMVert *v2;
-                       
-                       tag = tags + BM_elem_index_get(l);
-                       BLI_array_append(verts, tag->newv);
-                       
-                       if (!firstv)
-                               firstv = tag->newv;
-                       
-                       if (lastv) {
-                               e = BM_edge_create(bm, lastv, tag->newv, l->e, TRUE);
-                               BM_elem_attrs_copy(bm, bm, l->prev->e, e);
-                               BLI_array_append(edges, e);
-                       }
-                       lastv = tag->newv;
-                       
-                       v2 = ETAG_GET(l->e, l->next->v);
-                       
-                       tag = &tags[BM_elem_index_get(l->next)];
-                       if (!BMO_elem_flag_test(bm, l->e, BEVEL_FLAG) && v2 && v2 != tag->newv) {
-                               BLI_array_append(verts, v2);
-                               
-                               e = BM_edge_create(bm, lastv, v2, l->e, TRUE);
-                               BM_elem_attrs_copy(bm, bm, l->e, e);
-                               
-                               BLI_array_append(edges, e);
-                               lastv = v2;
-                       }
-               }
-               
-               e = BM_edge_create(bm, firstv, lastv, BM_FACE_FIRST_LOOP(faces[i])->e, TRUE);
-               if (BM_FACE_FIRST_LOOP(faces[i])->prev->e != e) {
-                       BM_elem_attrs_copy(bm, bm, BM_FACE_FIRST_LOOP(faces[i])->prev->e, e);
-               }
-               BLI_array_append(edges, e);
-               
-               f = BM_face_create_ngon(bm, verts[0], verts[1], edges, BLI_array_count(edges), FALSE);
-               if (UNLIKELY(f == NULL)) {
-                       printf("%s: could not make face!\n", __func__);
-                       continue;
-               }
-
-               BMO_elem_flag_enable(bm, f, FACE_NEW);
-       }
-
-       for (i = 0; i < BLI_array_count(faces); i++) {
-               BMLoop *l;
-               BMIter liter;
-               int j;
-               
-               /* create quad spans between split edge */
-               BM_ITER_ELEM (l, &liter, faces[i], BM_LOOPS_OF_FACE) {
-                       BMVert *v1 = NULL, *v2 = NULL, *v3 = NULL, *v4 = NULL;
-                       
-                       if (!BMO_elem_flag_test(bm, l->e, BEVEL_FLAG))
-                               continue;
-                       
-                       v1 = tags[BM_elem_index_get(l)].newv;
-                       v2 = tags[BM_elem_index_get(l->next)].newv;
-                       if (l->radial_next != l) {
-                               v3 = tags[BM_elem_index_get(l->radial_next)].newv;
-                               if (l->radial_next->next->v == l->next->v) {
-                                       v4 = v3;
-                                       v3 = tags[BM_elem_index_get(l->radial_next->next)].newv;
-                               }
-                               else {
-                                       v4 = tags[BM_elem_index_get(l->radial_next->next)].newv;
-                               }
-                       }
-                       else {
-                               /* the loop is on a boundar */
-                               v3 = l->next->v;
-                               v4 = l->v;
-                               
-                               for (j = 0; j < 2; j++) {
-                                       BMIter eiter;
-                                       BMVert *v = j ? v4 : v3;
-
-                                       BM_ITER_ELEM (e, &eiter, v, BM_EDGES_OF_VERT) {
-                                               if (!BM_vert_in_edge(e, v3) || !BM_vert_in_edge(e, v4))
-                                                       continue;
-                                               
-                                               if (!BMO_elem_flag_test(bm, e, BEVEL_FLAG) && BMO_elem_flag_test(bm, e, EDGE_OLD)) {
-                                                       BMVert *vv;
-                                                       
-                                                       vv = ETAG_GET(e, v);
-                                                       if (!vv || BMO_elem_flag_test(bm, vv, BEVEL_FLAG))
-                                                               continue;
-                                                       
-                                                       if (j) {
-                                                               v1 = vv;
-                                                       }
-                                                       else {
-                                                               v2 = vv;
-                                                       }
-                                                       break;
-                                               }
-                                       }
-                               }
-
-                               BMO_elem_flag_disable(bm, v3, BEVEL_DEL);
-                               BMO_elem_flag_disable(bm, v4, BEVEL_DEL);
-                       }
-                       
-                       if (v1 != v2 && v2 != v3 && v3 != v4) {
-                               BMIter liter2;
-                               BMLoop *l2, *l3;
-                               BMEdge *e1, *e2;
-                               float d1, d2, *d3;
-                               
-                               f = BM_face_create_quad_tri(bm, v4, v3, v2, v1, l->f, TRUE);
-
-                               e1 = BM_edge_exists(v4, v3);
-                               e2 = BM_edge_exists(v2, v1);
-                               BM_elem_attrs_copy(bm, bm, l->e, e1);
-                               BM_elem_attrs_copy(bm, bm, l->e, e2);
-                               
-                               /* set edge lengths of cross edges as the average of the cross edges they're based o */
-                               if (has_elens) {
-                                       /* angle happens not to be used. why? - not sure it just isn't - campbell.
-                                        * leave this in in case we need to use it later */
-#if 0
-                                       float ang;
-#endif
-                                       e1 = BM_edge_exists(v1, v4);
-                                       e2 = BM_edge_exists(v2, v3);
-                                       
-                                       if (l->radial_next->v == l->v) {
-                                               l2 = l->radial_next->prev;
-                                               l3 = l->radial_next->next;
-                                       }
-                                       else {
-                                               l2 = l->radial_next->next;
-                                               l3 = l->radial_next->prev;
-                                       }
-                                       
-                                       d3 = CustomData_bmesh_get_n(&bm->edata, e1->head.data, CD_PROP_FLT, li);
-                                       d1 = *(float *)CustomData_bmesh_get_n(&bm->edata, l->prev->e->head.data, CD_PROP_FLT, li);
-                                       d2 = *(float *)CustomData_bmesh_get_n(&bm->edata, l2->e->head.data, CD_PROP_FLT, li);
-#if 0
-                                       ang = angle_v3v3v3(l->prev->v->co, l->v->co, BM_edge_other_vert(l2->e, l->v)->co);
-#endif
-                                       *d3 = (d1 + d2) * 0.5f;
-                                       
-                                       d3 = CustomData_bmesh_get_n(&bm->edata, e2->head.data, CD_PROP_FLT, li);
-                                       d1 = *(float *)CustomData_bmesh_get_n(&bm->edata, l->next->e->head.data, CD_PROP_FLT, li);
-                                       d2 = *(float *)CustomData_bmesh_get_n(&bm->edata, l3->e->head.data, CD_PROP_FLT, li);
-#if 0
-                                       ang = angle_v3v3v3(BM_edge_other_vert(l->next->e, l->next->v)->co, l->next->v->co,
-                                                          BM_edge_other_vert(l3->e, l->next->v)->co);
-#endif
-                                       *d3 = (d1 + d2) * 0.5f;
-                               }
-
-                               if (UNLIKELY(f == NULL)) {
-                                       fprintf(stderr, "%s: face index out of range! (bmesh internal error)\n", __func__);
-                                       continue;
-                               }
-                               
-                               BMO_elem_flag_enable(bm, f, FACE_NEW | FACE_SPAN);
-                               
-                               /* un-tag edges in f for deletio */
-                               BM_ITER_ELEM (l2, &liter2, f, BM_LOOPS_OF_FACE) {
-                                       BMO_elem_flag_disable(bm, l2->e, BEVEL_DEL);
-                               }
-                       }
-                       else {
-                               f = NULL;
-                       }
-               }
-       }
-       
-       /* fill in holes at vertices */
-       BM_ITER_MESH (v, &iter, bm, BM_VERTS_OF_MESH) {
-               BMIter eiter;
-               BMVert *vv, *vstart = NULL, *lastv = NULL;
-               SmallHash tmphash;
-               int rad, insorig = 0, err = 0;
-
-               BLI_smallhash_init(&tmphash);
-
-               if (!BMO_elem_flag_test(bm, v, BEVEL_FLAG))
-                       continue;
-               
-               BLI_array_empty(verts);
-               BLI_array_empty(edges);
-               
-               BM_ITER_ELEM (e, &eiter, v, BM_EDGES_OF_VERT) {
-                       BMIter liter;
-                       BMVert *v1 = NULL, *v2 = NULL;
-                       BMLoop *l;
-                       
-                       if (BM_edge_face_count(e) < 2)
-                               insorig = 1;
-                       
-                       if (BM_elem_index_get(e) == -1)
-                               continue;
-                       
-                       rad = 0;
-                       BM_ITER_ELEM (l, &liter, e, BM_LOOPS_OF_EDGE) {
-                               if (!BMO_elem_flag_test(bm, l->f, FACE_OLD))
-                                       continue;
-                               
-                               rad++;
-                               
-                               tag = tags + BM_elem_index_get((l->v == v) ? l : l->next);
-                               
-                               if (!v1)
-                                       v1 = tag->newv;
-                               else if (!v2)
-                                       v2 = tag->newv;
-                       }
-                       
-                       if (rad < 2)
-                               insorig = 1;
-                       
-                       if (!v1)
-                               v1 = ETAG_GET(e, v);
-                       if (!v2 || v1 == v2)
-                               v2 = ETAG_GET(e, v);
-                       
-                       if (v1) {
-                               if (!BLI_smallhash_haskey(&tmphash, (intptr_t)v1)) {
-                                       BLI_array_append(verts, v1);
-                                       BLI_smallhash_insert(&tmphash, (intptr_t)v1, NULL);
-                               }
-                               
-                               if (v2 && v1 != v2 && !BLI_smallhash_haskey(&tmphash, (intptr_t)v2)) {
-                                       BLI_array_append(verts, v2);
-                                       BLI_smallhash_insert(&tmphash, (intptr_t)v2, NULL);
-                               }
-                       }
-               }
-               
-               if (!BLI_array_count(verts))
-                       continue;
-               
-               if (insorig) {
-                       BLI_array_append(verts, v);
-                       BLI_smallhash_insert(&tmphash, (intptr_t)v, NULL);
-               }
-               
-               /* find edges that exist between vertices in verts.  this is basically
-                * a topological walk of the edges connecting them */
-               vstart = vstart ? vstart : verts[0];
-               vv = vstart;
-               do {
-                       BM_ITER_ELEM (e, &eiter, vv, BM_EDGES_OF_VERT) {
-                               BMVert *vv2 = BM_edge_other_vert(e, vv);
-                               
-                               if (vv2 != lastv && BLI_smallhash_haskey(&tmphash, (intptr_t)vv2)) {
-                                       /* if we've go over the same vert twice, break out of outer loop */
-                                       if (BLI_smallhash_lookup(&tmphash, (intptr_t)vv2) != NULL) {
-                                               e = NULL;
-                                               err = 1;
-                                               break;
-                                       }
-                                       
-                                       /* use self pointer as ta */
-                                       BLI_smallhash_remove(&tmphash, (intptr_t)vv2);
-                                       BLI_smallhash_insert(&tmphash, (intptr_t)vv2, vv2);
-                                       
-                                       lastv = vv;
-                                       BLI_array_append(edges, e);
-                                       vv = vv2;
-                                       break;
-                               }
-                       }
-
-                       if (e == NULL) {
-                               break;
-                       }
-               } while (vv != vstart);
-               
-               if (err) {
-                       continue;
-               }
-
-               /* there may not be a complete loop of edges, so start again and make
-                * final edge afterwards.  in this case, the previous loop worked to
-                * find one of the two edges at the extremes. */
-               if (vv != vstart) {
-                       /* undo previous taggin */
-                       for (i = 0; i < BLI_array_count(verts); i++) {
-                               BLI_smallhash_remove(&tmphash, (intptr_t)verts[i]);
-                               BLI_smallhash_insert(&tmphash, (intptr_t)verts[i], NULL);
-                       }
-
-                       vstart = vv;
-                       lastv = NULL;
-                       BLI_array_empty(edges);
-                       do {
-                               BM_ITER_ELEM (e, &eiter, vv, BM_EDGES_OF_VERT) {
-                                       BMVert *vv2 = BM_edge_other_vert(e, vv);
-                                       
-                                       if (vv2 != lastv && BLI_smallhash_haskey(&tmphash, (intptr_t)vv2)) {
-                                               /* if we've go over the same vert twice, break out of outer loo */
-                                               if (BLI_smallhash_lookup(&tmphash, (intptr_t)vv2) != NULL) {
-                                                       e = NULL;
-                                                       err = 1;
-                                                       break;
-                                               }
-                                               
-                                               /* use self pointer as ta */
-                                               BLI_smallhash_remove(&tmphash, (intptr_t)vv2);
-                                               BLI_smallhash_insert(&tmphash, (intptr_t)vv2, vv2);
-                                               
-                                               lastv = vv;
-                                               BLI_array_append(edges, e);
-                                               vv = vv2;
-                                               break;
-                                       }
-                               }
-                               if (e == NULL)
-                                       break;
-                       } while (vv != vstart);
-                       
-                       if (!err) {
-                               e = BM_edge_create(bm, vv, vstart, NULL, TRUE);
-                               BLI_array_append(edges, e);
-                       }
-               }
-               
-               if (err)
-                       continue;
-               
-               if (BLI_array_count(edges) >= 3) {
-                       BMFace *f;
-                       
-                       if (BM_face_exists(bm, verts, BLI_array_count(verts), &f))
-                               continue;
-                       
-                       f = BM_face_create_ngon(bm, lastv, vstart, edges, BLI_array_count(edges), FALSE);
-                       if (UNLIKELY(f == NULL)) {
-                               fprintf(stderr, "%s: in bevel vert fill! (bmesh internal error)\n", __func__);
-                       }
-                       else {
-                               BMO_elem_flag_enable(bm, f, FACE_NEW | FACE_HOLE);
-                       }
-               }
-               BLI_smallhash_release(&tmphash);
-       }
-       
-       /* copy over customdat */
-       for (i = 0; i < BLI_array_count(faces); i++) {
-               BMLoop *l;
-               BMIter liter;
-               BMFace *f = faces[i];
-               
-               BM_ITER_ELEM (l, &liter, f, BM_LOOPS_OF_FACE) {
-                       BMLoop *l2;
-                       BMIter liter2;
-                       
-                       tag = tags + BM_elem_index_get(l);
-                       if (!tag->newv)
-                               continue;
-                       
-                       BM_ITER_ELEM (l2, &liter2, tag->newv, BM_LOOPS_OF_VERT) {
-                               if (!BMO_elem_flag_test(bm, l2->f, FACE_NEW) || (l2->v != tag->newv && l2->v != l->v))
-                                       continue;
-                               
-                               if (tag->newv != l->v || HasMDisps) {
-                                       BM_elem_attrs_copy(bm, bm, l->f, l2->f);
-                                       BM_loop_interp_from_face(bm, l2, l->f, TRUE, TRUE);
-                               }
-                               else {
-                                       BM_elem_attrs_copy(bm, bm, l->f, l2->f);
-                                       BM_elem_attrs_copy(bm, bm, l, l2);
-                               }
-                               
-                               if (HasMDisps) {
-                                       BMLoop *l3;
-                                       BMIter liter3;
-                                       
-                                       BM_ITER_ELEM (l3, &liter3, l2->f, BM_LOOPS_OF_FACE) {
-                                               BM_loop_interp_multires(bm, l3, l->f);
-                                       }
-                               }
-                       }
-               }
-       }
-       
-       /* handle vertices along boundary edge */
-       BM_ITER_MESH (v, &iter, bm, BM_VERTS_OF_MESH) {
-               if (BMO_elem_flag_test(bm, v, VERT_OLD) &&
-                   BMO_elem_flag_test(bm, v, BEVEL_FLAG) &&
-                   !BMO_elem_flag_test(bm, v, BEVEL_DEL))
-               {
-                       BMLoop *l;
-                       BMLoop *lorig = NULL;
-                       BMIter liter;
-                       
-                       BM_ITER_ELEM (l, &liter, v, BM_LOOPS_OF_VERT) {
-                               // BMIter liter2;
-                               // BMLoop *l2 = l->v == v ? l : l->next, *l3;
-                               
-                               if (BMO_elem_flag_test(bm, l->f, FACE_OLD)) {
-                                       lorig = l;
-                                       break;
-                               }
-                       }
-                       
-                       if (!lorig)
-                               continue;
-                       
-                       BM_ITER_ELEM (l, &liter, v, BM_LOOPS_OF_VERT) {
-                               BMLoop *l2 = l->v == v ? l : l->next;
-                               
-                               BM_elem_attrs_copy(bm, bm, lorig->f, l2->f);
-                               BM_elem_attrs_copy(bm, bm, lorig, l2);
-                       }
-               }
-       }
-#if 0
-       /* clean up any remaining 2-edged face */
-       BM_ITER_MESH (f, &iter, bm, BM_FACES_OF_MESH) {
-               if (f->len == 2) {
-                       BMFace *faces[2] = {f, BM_FACE_FIRST_LOOP(f)->radial_next->f};
-                       
-                       if (faces[0] == faces[1])
-                               BM_face_kill(bm, f);
-                       else
-                               BM_faces_join(bm, faces, 2);
-               }
-       }
-#endif
-
-       BMO_op_callf(bm, op->flag, "delete geom=%fv context=%i", BEVEL_DEL, DEL_VERTS);
-
-       /* clean up any edges that might not get properly delete */
-       BM_ITER_MESH (e, &iter, bm, BM_EDGES_OF_MESH) {
-               if (BMO_elem_flag_test(bm, e, EDGE_OLD) && !e->l)
-                       BMO_elem_flag_enable(bm, e, BEVEL_DEL);
-       }
-
-       BMO_op_callf(bm, op->flag, "delete geom=%fe context=%i", BEVEL_DEL, DEL_EDGES);
-       BMO_op_callf(bm, op->flag, "delete geom=%ff context=%i", BEVEL_DEL, DEL_FACES);
-       
-       BLI_smallhash_release(&hash);
-       BLI_array_free(tags);
-       BLI_array_free(etags);
-       BLI_array_free(verts);
-       BLI_array_free(edges);
-       BLI_array_free(faces);
-       
-       BMO_slot_buffer_from_enabled_flag(bm, op, "face_spans", BM_FACE, FACE_SPAN);
-       BMO_slot_buffer_from_enabled_flag(bm, op, "face_holes", BM_FACE, FACE_HOLE);
 }
-#endif  /* NEW_BEVEL */