From 0a026033ae46c83a84fcca54112190e1aa80d51f Mon Sep 17 00:00:00 2001 From: Campbell Barton Date: Fri, 1 Jul 2016 19:07:11 +1000 Subject: BMesh: make toolflags optional Saves 8 bytes per vert/edge/face. Gives overall ~20-25% memory saving for dyntopo sculpting and modifiers that use BMesh. --- source/blender/bmesh/operators/bmo_beautify.c | 6 +- source/blender/bmesh/operators/bmo_bridge.c | 12 ++-- source/blender/bmesh/operators/bmo_connect.c | 28 ++++---- .../blender/bmesh/operators/bmo_connect_concave.c | 8 +-- .../bmesh/operators/bmo_connect_nonplanar.c | 6 +- source/blender/bmesh/operators/bmo_connect_pair.c | 29 +++++--- source/blender/bmesh/operators/bmo_create.c | 29 +++++--- source/blender/bmesh/operators/bmo_dissolve.c | 78 ++++++++++----------- source/blender/bmesh/operators/bmo_dupe.c | 52 +++++++------- source/blender/bmesh/operators/bmo_edgenet.c | 14 ++-- source/blender/bmesh/operators/bmo_extrude.c | 81 +++++++++++----------- source/blender/bmesh/operators/bmo_fill_edgeloop.c | 16 ++--- source/blender/bmesh/operators/bmo_fill_grid.c | 4 +- source/blender/bmesh/operators/bmo_hull.c | 79 +++++++++++---------- source/blender/bmesh/operators/bmo_inset.c | 4 +- .../blender/bmesh/operators/bmo_join_triangles.c | 12 ++-- source/blender/bmesh/operators/bmo_normals.c | 20 +++--- .../blender/bmesh/operators/bmo_offset_edgeloops.c | 10 +-- source/blender/bmesh/operators/bmo_planar_faces.c | 14 ++-- source/blender/bmesh/operators/bmo_poke.c | 4 +- source/blender/bmesh/operators/bmo_primitive.c | 80 ++++++++++----------- source/blender/bmesh/operators/bmo_removedoubles.c | 52 +++++++------- source/blender/bmesh/operators/bmo_similar.c | 68 +++++++++--------- source/blender/bmesh/operators/bmo_subdivide.c | 60 ++++++++-------- .../bmesh/operators/bmo_subdivide_edgering.c | 58 ++++++++-------- source/blender/bmesh/operators/bmo_triangulate.c | 16 ++--- source/blender/bmesh/operators/bmo_utils.c | 80 +++++++++++---------- 27 files changed, 483 insertions(+), 437 deletions(-) (limited to 'source/blender/bmesh/operators') diff --git a/source/blender/bmesh/operators/bmo_beautify.c b/source/blender/bmesh/operators/bmo_beautify.c index 4a292c33472..c68d92ea5e0 100644 --- a/source/blender/bmesh/operators/bmo_beautify.c +++ b/source/blender/bmesh/operators/bmo_beautify.c @@ -52,7 +52,7 @@ void bmo_beautify_fill_exec(BMesh *bm, BMOperator *op) int edge_array_len = 0; BMO_ITER (f, &siter, op->slots_in, "faces", BM_FACE) { if (f->len == 3) { - BMO_elem_flag_enable(bm, f, FACE_MARK); + BMO_face_flag_enable(bm, f, FACE_MARK); } } @@ -68,8 +68,8 @@ void bmo_beautify_fill_exec(BMesh *bm, BMOperator *op) /* edge is manifold and can be rotated */ if (BM_edge_rotate_check(e) && /* faces are tagged */ - BMO_elem_flag_test(bm, e->l->f, FACE_MARK) && - BMO_elem_flag_test(bm, e->l->radial_next->f, FACE_MARK)) + BMO_face_flag_test(bm, e->l->f, FACE_MARK) && + BMO_face_flag_test(bm, e->l->radial_next->f, FACE_MARK)) { edge_array[edge_array_len] = e; edge_array_len++; diff --git a/source/blender/bmesh/operators/bmo_bridge.c b/source/blender/bmesh/operators/bmo_bridge.c index a0149a41921..6ef0fd6b084 100644 --- a/source/blender/bmesh/operators/bmo_bridge.c +++ b/source/blender/bmesh/operators/bmo_bridge.c @@ -131,13 +131,13 @@ static void bm_face_edges_tag_out(BMesh *bm, BMFace *f) BMLoop *l_iter, *l_first; l_iter = l_first = BM_FACE_FIRST_LOOP(f); do { - BMO_elem_flag_enable(bm, l_iter->e, EDGE_OUT); + BMO_edge_flag_enable(bm, l_iter->e, EDGE_OUT); } while ((l_iter = l_iter->next) != l_first); } static bool bm_edge_test_cb(BMEdge *e, void *bm_v) { - return BMO_elem_flag_test((BMesh *)bm_v, e, EDGE_MARK); + return BMO_edge_flag_test((BMesh *)bm_v, e, EDGE_MARK); } static void bridge_loop_pair( @@ -425,7 +425,7 @@ static void bridge_loop_pair( if (f_example && (f_example != f)) { BM_elem_attrs_copy(bm, bm, f_example, f); } - BMO_elem_flag_enable(bm, f, FACE_OUT); + BMO_face_flag_enable(bm, f, FACE_OUT); BM_elem_flag_enable(f, BM_ELEM_TAG); /* tag all edges of the face, untag the loop edges after */ @@ -486,7 +486,7 @@ static void bridge_loop_pair( BMOIter siter; BMFace *f; BMO_ITER (f, &siter, op_sub.slots_in, "faces", BM_FACE) { - BMO_elem_flag_enable(bm, f, FACE_OUT); + BMO_face_flag_enable(bm, f, FACE_OUT); bm_face_edges_tag_out(bm, f); } } @@ -498,7 +498,7 @@ static void bridge_loop_pair( BMOIter siter; BMFace *f; BMO_ITER (f, &siter, op_sub.slots_out, "geom.out", BM_FACE) { - BMO_elem_flag_enable(bm, f, FACE_OUT); + BMO_face_flag_enable(bm, f, FACE_OUT); bm_face_edges_tag_out(bm, f); } } @@ -520,7 +520,7 @@ static void bridge_loop_pair( if (el_next) { if (el->data != el_next->data) { BMEdge *e = BM_edge_exists(el->data, el_next->data); - BMO_elem_flag_disable(bm, e, EDGE_OUT); + BMO_edge_flag_disable(bm, e, EDGE_OUT); } } } diff --git a/source/blender/bmesh/operators/bmo_connect.c b/source/blender/bmesh/operators/bmo_connect.c index 0213329118c..5c9cd8dc3fa 100644 --- a/source/blender/bmesh/operators/bmo_connect.c +++ b/source/blender/bmesh/operators/bmo_connect.c @@ -62,10 +62,10 @@ static int bm_face_connect_verts(BMesh *bm, BMFace *f, const bool check_degenera l_iter = l_first = BM_FACE_FIRST_LOOP(f); do { - if (BMO_elem_flag_test(bm, l_iter->v, VERT_INPUT) && + if (BMO_vert_flag_test(bm, l_iter->v, VERT_INPUT) && /* ensure this vertex isnt part of a contiguous group */ - ((BMO_elem_flag_test(bm, l_iter->prev->v, VERT_INPUT) == 0) || - (BMO_elem_flag_test(bm, l_iter->next->v, VERT_INPUT) == 0))) + ((BMO_vert_flag_test(bm, l_iter->prev->v, VERT_INPUT) == 0) || + (BMO_vert_flag_test(bm, l_iter->next->v, VERT_INPUT) == 0))) { if (!l_tag_prev) { l_tag_prev = l_tag_first = l_iter; @@ -75,7 +75,7 @@ static int bm_face_connect_verts(BMesh *bm, BMFace *f, const bool check_degenera if (!BM_loop_is_adjacent(l_tag_prev, l_iter)) { BMEdge *e; e = BM_edge_exists(l_tag_prev->v, l_iter->v); - if (e == NULL || !BMO_elem_flag_test(bm, e, EDGE_OUT)) { + if (e == NULL || !BMO_edge_flag_test(bm, e, EDGE_OUT)) { BMLoop **l_pair = STACK_PUSH_RET(loops_split); l_pair[0] = l_tag_prev; l_pair[1] = l_iter; @@ -138,8 +138,8 @@ static int bm_face_connect_verts(BMesh *bm, BMFace *f, const bool check_degenera if (!l_new || !f_new) { return -1; } - // BMO_elem_flag_enable(bm, f_new, FACE_NEW); - BMO_elem_flag_enable(bm, l_new->e, EDGE_OUT); + // BMO_face_flag_enable(bm, f_new, FACE_NEW); + BMO_edge_flag_enable(bm, l_new->e, EDGE_OUT); } return 1; @@ -164,12 +164,12 @@ void bmo_connect_verts_exec(BMesh *bm, BMOperator *op) BMIter iter; BMLoop *l_iter; - BMO_elem_flag_enable(bm, v, VERT_INPUT); + BMO_vert_flag_enable(bm, v, VERT_INPUT); BM_ITER_ELEM (l_iter, &iter, v, BM_LOOPS_OF_VERT) { f = l_iter->f; - if (!BMO_elem_flag_test(bm, f, FACE_EXCLUDE)) { - if (!BMO_elem_flag_test(bm, f, FACE_TAG)) { - BMO_elem_flag_enable(bm, f, FACE_TAG); + if (!BMO_face_flag_test(bm, f, FACE_EXCLUDE)) { + if (!BMO_face_flag_test(bm, f, FACE_TAG)) { + BMO_face_flag_enable(bm, f, FACE_TAG); if (f->len > 3) { BLI_LINKSTACK_PUSH(faces, f); } @@ -179,11 +179,11 @@ void bmo_connect_verts_exec(BMesh *bm, BMOperator *op) /* flag edges even if these are not newly created * this way cut-pairs that include co-linear edges will get * predictable output. */ - if (BMO_elem_flag_test(bm, l_iter->prev->v, VERT_INPUT)) { - BMO_elem_flag_enable(bm, l_iter->prev->e, EDGE_OUT_ADJ); + if (BMO_vert_flag_test(bm, l_iter->prev->v, VERT_INPUT)) { + BMO_edge_flag_enable(bm, l_iter->prev->e, EDGE_OUT_ADJ); } - if (BMO_elem_flag_test(bm, l_iter->next->v, VERT_INPUT)) { - BMO_elem_flag_enable(bm, l_iter->e, EDGE_OUT_ADJ); + if (BMO_vert_flag_test(bm, l_iter->next->v, VERT_INPUT)) { + BMO_edge_flag_enable(bm, l_iter->e, EDGE_OUT_ADJ); } } } diff --git a/source/blender/bmesh/operators/bmo_connect_concave.c b/source/blender/bmesh/operators/bmo_connect_concave.c index 8b9c60ada52..9bb67ed9341 100644 --- a/source/blender/bmesh/operators/bmo_connect_concave.c +++ b/source/blender/bmesh/operators/bmo_connect_concave.c @@ -107,10 +107,10 @@ static bool bm_face_split_by_concave( int i; for (i = 0; i < faces_array_tot; i++) { BMFace *f = faces_array[i]; - BMO_elem_flag_enable(bm, f, FACE_OUT); + BMO_face_flag_enable(bm, f, FACE_OUT); } } - BMO_elem_flag_enable(bm, f_base, FACE_OUT); + BMO_face_flag_enable(bm, f_base, FACE_OUT); if (edges_array_tot) { int i; @@ -120,7 +120,7 @@ static bool bm_face_split_by_concave( for (i = 0; i < edges_array_tot; i++) { BMLoop *l_pair[2]; BMEdge *e = edges_array[i]; - BMO_elem_flag_enable(bm, e, EDGE_OUT); + BMO_edge_flag_enable(bm, e, EDGE_OUT); if (BM_edge_is_contiguous(e) && BM_edge_loop_pair(e, &l_pair[0], &l_pair[1])) @@ -153,7 +153,7 @@ static bool bm_face_split_by_concave( BMFace *f_new, *f_pair[2] = {l_pair[0]->f, l_pair[1]->f}; f_new = BM_faces_join(bm, f_pair, 2, true); if (f_new) { - BMO_elem_flag_enable(bm, f_new, FACE_OUT); + BMO_face_flag_enable(bm, f_new, FACE_OUT); } } } diff --git a/source/blender/bmesh/operators/bmo_connect_nonplanar.c b/source/blender/bmesh/operators/bmo_connect_nonplanar.c index c80fb95c44a..9b3e1d38feb 100644 --- a/source/blender/bmesh/operators/bmo_connect_nonplanar.c +++ b/source/blender/bmesh/operators/bmo_connect_nonplanar.c @@ -136,9 +136,9 @@ static bool bm_face_split_by_angle(BMesh *bm, BMFace *f, BMFace *r_f_pair[2], co r_f_pair[0] = f; r_f_pair[1] = f_new; - BMO_elem_flag_enable(bm, f, FACE_OUT); - BMO_elem_flag_enable(bm, f_new, FACE_OUT); - BMO_elem_flag_enable(bm, l_new->e, EDGE_OUT); + BMO_face_flag_enable(bm, f, FACE_OUT); + BMO_face_flag_enable(bm, f_new, FACE_OUT); + BMO_edge_flag_enable(bm, l_new->e, EDGE_OUT); return true; } } diff --git a/source/blender/bmesh/operators/bmo_connect_pair.c b/source/blender/bmesh/operators/bmo_connect_pair.c index 3b860778e1c..3eb6fe0cb97 100644 --- a/source/blender/bmesh/operators/bmo_connect_pair.c +++ b/source/blender/bmesh/operators/bmo_connect_pair.c @@ -67,18 +67,29 @@ #define ELE_TOUCHED 4 #define FACE_WALK_TEST(f) (CHECK_TYPE_INLINE(f, BMFace *), \ - BMO_elem_flag_test(pc->bm_bmoflag, f, FACE_EXCLUDE) == 0) + BMO_face_flag_test(pc->bm_bmoflag, f, FACE_EXCLUDE) == 0) #define VERT_WALK_TEST(v) (CHECK_TYPE_INLINE(v, BMVert *), \ - BMO_elem_flag_test(pc->bm_bmoflag, v, VERT_EXCLUDE) == 0) + BMO_vert_flag_test(pc->bm_bmoflag, v, VERT_EXCLUDE) == 0) +#if 0 #define ELE_TOUCH_TEST(e) \ (CHECK_TYPE_ANY(e, BMVert *, BMEdge *, BMElem *, BMElemF *), \ BMO_elem_flag_test(pc->bm_bmoflag, (BMElemF *)e, ELE_TOUCHED)) +#endif #define ELE_TOUCH_MARK(e) \ { CHECK_TYPE_ANY(e, BMVert *, BMEdge *, BMElem *, BMElemF *); \ BMO_elem_flag_enable(pc->bm_bmoflag, (BMElemF *)e, ELE_TOUCHED); } ((void)0) +#define ELE_TOUCH_TEST_VERT(v) BMO_vert_flag_test(pc->bm_bmoflag, v, ELE_TOUCHED) +// #define ELE_TOUCH_MARK_VERT(v) BMO_vert_flag_enable(pc->bm_bmoflag, (BMElemF *)e, ELE_TOUCHED) + +// #define ELE_TOUCH_TEST_EDGE(v) BMO_edge_flag_test(pc->bm_bmoflag, v, ELE_TOUCHED) +// #define ELE_TOUCH_MARK_EDGE(v) BMO_edge_flag_enable(pc->bm_bmoflag, (BMElemF *)e, ELE_TOUCHED) + +// #define ELE_TOUCH_TEST_FACE(v) BMO_face_flag_test(pc->bm_bmoflag, v, ELE_TOUCHED) +// #define ELE_TOUCH_MARK_FACE(v) BMO_face_flag_enable(pc->bm_bmoflag, (BMElemF *)e, ELE_TOUCHED) + // #define DEBUG_PRINT typedef struct PathContext { @@ -352,7 +363,7 @@ static PathLinkState *state_step__face_edges( BMElem *ele_next_from = (BMElem *)l_iter->f; if (FACE_WALK_TEST((BMFace *)ele_next_from) && - (ELE_TOUCH_TEST(ele_next) == false)) + (ELE_TOUCH_TEST_VERT((BMVert *)ele_next) == false)) { min_dist_dir_update(mddir, dist_dir); mddir->dist_min[index] = dist_test; @@ -397,7 +408,7 @@ static PathLinkState *state_step__face_verts( BMElem *ele_next_from = (BMElem *)l_iter->f; if (FACE_WALK_TEST((BMFace *)ele_next_from) && - (ELE_TOUCH_TEST(ele_next) == false)) + (ELE_TOUCH_TEST_VERT((BMVert *)ele_next) == false)) { min_dist_dir_update(mddir, dist_dir); mddir->dist_min[index] = dist_test; @@ -480,7 +491,7 @@ static bool state_step(PathContext *pc, PathLinkState *state) if (state_isect_co_exact(pc, v_other->co)) { BMElem *ele_next = (BMElem *)v_other; BMElem *ele_next_from = (BMElem *)e; - if (ELE_TOUCH_TEST(ele_next) == false) { + if (ELE_TOUCH_TEST_VERT((BMVert *)ele_next) == false) { state = state_link_add_test(pc, state, &state_orig, ele_next, ele_next_from); } } @@ -703,11 +714,11 @@ void bmo_connect_vert_pair_exec(BMesh *bm, BMOperator *op) BMVert *v_new; float e_fac = state_calc_co_pair_fac(&pc, e->v1->co, e->v2->co); v_new = BM_edge_split(bm, e, e->v1, NULL, e_fac); - BMO_elem_flag_enable(bm, v_new, VERT_OUT); + BMO_vert_flag_enable(bm, v_new, VERT_OUT); } else if (link->ele->head.htype == BM_VERT) { BMVert *v = (BMVert *)link->ele; - BMO_elem_flag_enable(bm, v, VERT_OUT); + BMO_vert_flag_enable(bm, v, VERT_OUT); } else { BLI_assert(0); @@ -715,8 +726,8 @@ void bmo_connect_vert_pair_exec(BMesh *bm, BMOperator *op) } while ((link = link->next)); } - BMO_elem_flag_enable(bm, pc.v_a, VERT_OUT); - BMO_elem_flag_enable(bm, pc.v_b, VERT_OUT); + BMO_vert_flag_enable(bm, pc.v_a, VERT_OUT); + BMO_vert_flag_enable(bm, pc.v_b, VERT_OUT); BLI_mempool_destroy(pc.link_pool); diff --git a/source/blender/bmesh/operators/bmo_create.c b/source/blender/bmesh/operators/bmo_create.c index a1e20dab63e..7b8cb36ab59 100644 --- a/source/blender/bmesh/operators/bmo_create.c +++ b/source/blender/bmesh/operators/bmo_create.c @@ -52,12 +52,19 @@ void bmo_contextual_create_exec(BMesh *bm, BMOperator *op) /* count number of each element type we were passe */ BMO_ITER (h, &oiter, op->slots_in, "geom", BM_VERT | BM_EDGE | BM_FACE) { switch (h->htype) { - case BM_VERT: totv++; break; - case BM_EDGE: tote++; break; - case BM_FACE: totf++; break; + case BM_VERT: + BMO_vert_flag_enable(bm, (BMVert *)h, ELE_NEW); + totv++; + break; + case BM_EDGE: + BMO_edge_flag_enable(bm, (BMEdge *)h, ELE_NEW); + tote++; + break; + case BM_FACE: + BMO_face_flag_enable(bm, (BMFace *)h, ELE_NEW); + totf++; + break; } - - BMO_elem_flag_enable(bm, (BMElemF *)h, ELE_NEW); } /* --- Support Edge Creation --- @@ -71,7 +78,7 @@ void bmo_contextual_create_exec(BMesh *bm, BMOperator *op) /* create edge */ e = BM_edge_create(bm, verts[0], verts[1], NULL, BM_CREATE_NO_DOUBLE); - BMO_elem_flag_enable(bm, e, ELE_OUT); + BMO_edge_flag_enable(bm, e, ELE_OUT); tote += 1; BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "edges.out", BM_EDGE, ELE_OUT); return; @@ -131,10 +138,10 @@ void bmo_contextual_create_exec(BMesh *bm, BMOperator *op) BMEdge *e; e = BM_edge_create(bm, v_free, v_a, NULL, BM_CREATE_NO_DOUBLE); - BMO_elem_flag_enable(bm, e, ELE_NEW); + BMO_edge_flag_enable(bm, e, ELE_NEW); e = BM_edge_create(bm, v_free, v_b, NULL, BM_CREATE_NO_DOUBLE); - BMO_elem_flag_enable(bm, e, ELE_NEW); + BMO_edge_flag_enable(bm, e, ELE_NEW); tote += 2; } } @@ -236,7 +243,7 @@ void bmo_contextual_create_exec(BMesh *bm, BMOperator *op) for (ese = bm->selected.first; ese; ese = ese->next) { if (ese->htype == BM_VERT) { - if (BMO_elem_flag_test(bm, (BMElemF *)ese->ele, ELE_NEW)) { + if (BMO_vert_flag_test(bm, (BMVert *)ese->ele, ELE_NEW)) { tot_ese_v++; } else { @@ -256,7 +263,7 @@ void bmo_contextual_create_exec(BMesh *bm, BMOperator *op) BMVert *v = (BMVert *)ese->ele; if (v_prev) { BMEdge *e = BM_edge_create(bm, v, v_prev, NULL, BM_CREATE_NO_DOUBLE); - BMO_elem_flag_enable(bm, e, ELE_OUT); + BMO_edge_flag_enable(bm, e, ELE_OUT); } v_prev = v; } @@ -286,7 +293,7 @@ void bmo_contextual_create_exec(BMesh *bm, BMOperator *op) f = BM_face_create_ngon_vcloud(bm, vert_arr, totv, NULL, BM_CREATE_NO_DOUBLE); if (f) { - BMO_elem_flag_enable(bm, f, ELE_OUT); + BMO_face_flag_enable(bm, f, ELE_OUT); f->mat_nr = mat_nr; if (use_smooth) { BM_elem_flag_enable(f, BM_ELEM_SMOOTH); diff --git a/source/blender/bmesh/operators/bmo_dissolve.c b/source/blender/bmesh/operators/bmo_dissolve.c index 86062ff0b66..05efb14a699 100644 --- a/source/blender/bmesh/operators/bmo_dissolve.c +++ b/source/blender/bmesh/operators/bmo_dissolve.c @@ -74,10 +74,10 @@ static bool UNUSED_FUNCTION(check_hole_in_region) (BMesh *bm, BMFace *f) for (f2 = BMW_begin(®walker, f); f2; f2 = BMW_step(®walker)) { BM_ITER_ELEM (l2, &liter2, f2, BM_LOOPS_OF_FACE) { l3 = l2->radial_next; - if (BMO_elem_flag_test(bm, l3->f, FACE_MARK) != - BMO_elem_flag_test(bm, l2->f, FACE_MARK)) + if (BMO_face_flag_test(bm, l3->f, FACE_MARK) != + BMO_face_flag_test(bm, l2->f, FACE_MARK)) { - if (!BMO_elem_flag_test(bm, l2->e, EDGE_MARK)) { + if (!BMO_edge_flag_test(bm, l2->e, EDGE_MARK)) { return false; } } @@ -99,14 +99,14 @@ static void bm_face_split(BMesh *bm, const short oflag, bool use_edge_delete) } BM_ITER_MESH (v, &iter, bm, BM_VERTS_OF_MESH) { - if (BMO_elem_flag_test(bm, v, oflag)) { + if (BMO_vert_flag_test(bm, v, oflag)) { if (BM_vert_is_edge_pair(v) == false) { BMIter liter; BMLoop *l; BM_ITER_ELEM (l, &liter, v, BM_LOOPS_OF_VERT) { if (l->f->len > 3) { - if (BMO_elem_flag_test(bm, l->next->v, oflag) == 0 && - BMO_elem_flag_test(bm, l->prev->v, oflag) == 0) + if (BMO_vert_flag_test(bm, l->next->v, oflag) == 0 && + BMO_vert_flag_test(bm, l->prev->v, oflag) == 0) { BM_face_split(bm, l->f, l->next, l->prev, NULL, NULL, true); } @@ -153,7 +153,7 @@ void bmo_dissolve_faces_exec(BMesh *bm, BMOperator *op) BMVert *v; BM_ITER_MESH (v, &viter, bm, BM_VERTS_OF_MESH) { - BMO_elem_flag_set(bm, v, VERT_MARK, !BM_vert_is_edge_pair(v)); + BMO_vert_flag_set(bm, v, VERT_MARK, !BM_vert_is_edge_pair(v)); } } @@ -162,7 +162,7 @@ void bmo_dissolve_faces_exec(BMesh *bm, BMOperator *op) /* collect region */ BMO_ITER (f, &oiter, op->slots_in, "faces", BM_FACE) { BMFace *f_iter; - if (!BMO_elem_flag_test(bm, f, FACE_TAG)) { + if (!BMO_face_flag_test(bm, f, FACE_TAG)) { continue; } @@ -181,8 +181,8 @@ void bmo_dissolve_faces_exec(BMesh *bm, BMOperator *op) for (i = 0; i < BLI_array_count(faces); i++) { f_iter = faces[i]; - BMO_elem_flag_disable(bm, f_iter, FACE_TAG); - BMO_elem_flag_enable(bm, f_iter, FACE_ORIG); + BMO_face_flag_disable(bm, f_iter, FACE_TAG); + BMO_face_flag_enable(bm, f_iter, FACE_ORIG); } if (BMO_error_occurred(bm)) { @@ -229,8 +229,8 @@ void bmo_dissolve_faces_exec(BMesh *bm, BMOperator *op) /* if making the new face failed (e.g. overlapping test) * unmark the original faces for deletion */ - BMO_elem_flag_disable(bm, f_new, FACE_ORIG); - BMO_elem_flag_enable(bm, f_new, FACE_NEW); + BMO_face_flag_disable(bm, f_new, FACE_ORIG); + BMO_face_flag_enable(bm, f_new, FACE_NEW); } /* Typically no faces need to be deleted */ @@ -243,7 +243,7 @@ void bmo_dissolve_faces_exec(BMesh *bm, BMOperator *op) BMVert *v, *v_next; BM_ITER_MESH_MUTABLE (v, v_next, &viter, bm, BM_VERTS_OF_MESH) { - if (BMO_elem_flag_test(bm, v, VERT_MARK)) { + if (BMO_vert_flag_test(bm, v, VERT_MARK)) { if (BM_vert_is_edge_pair(v)) { BM_vert_collapse_edge(bm, v->e, v, true, true); } @@ -285,14 +285,14 @@ void bmo_dissolve_edges_exec(BMesh *bm, BMOperator *op) BMIter itersub; int untag_count = 0; BM_ITER_ELEM (e, &itersub, v, BM_EDGES_OF_VERT) { - if (!BMO_elem_flag_test(bm, e, EDGE_TAG)) { + if (!BMO_edge_flag_test(bm, e, EDGE_TAG)) { untag_count++; } } /* check that we have 2 edges remaining after dissolve */ if (untag_count <= 2) { - BMO_elem_flag_enable(bm, v, VERT_TAG); + BMO_vert_flag_enable(bm, v, VERT_TAG); } } @@ -301,7 +301,7 @@ void bmo_dissolve_edges_exec(BMesh *bm, BMOperator *op) if (use_verts) { BM_ITER_MESH (v, &iter, bm, BM_VERTS_OF_MESH) { - BMO_elem_flag_set(bm, v, VERT_MARK, !BM_vert_is_edge_pair(v)); + BMO_vert_flag_set(bm, v, VERT_MARK, !BM_vert_is_edge_pair(v)); } } @@ -314,8 +314,8 @@ void bmo_dissolve_edges_exec(BMesh *bm, BMOperator *op) BMLoop *l_first, *l_iter; l_iter = l_first = BM_FACE_FIRST_LOOP(f_pair[j]); do { - BMO_elem_flag_enable(bm, l_iter->v, VERT_ISGC); - BMO_elem_flag_enable(bm, l_iter->e, EDGE_ISGC); + BMO_vert_flag_enable(bm, l_iter->v, VERT_ISGC); + BMO_edge_flag_enable(bm, l_iter->e, EDGE_ISGC); } while ((l_iter = l_iter->next) != l_first); } } @@ -341,12 +341,12 @@ void bmo_dissolve_edges_exec(BMesh *bm, BMOperator *op) /* Cleanup geometry (#BM_faces_join_pair, but it removes geometry we're looping on) * so do this in a separate pass instead. */ BM_ITER_MESH_MUTABLE (e, e_next, &iter, bm, BM_EDGES_OF_MESH) { - if ((e->l == NULL) && BMO_elem_flag_test(bm, e, EDGE_ISGC)) { + if ((e->l == NULL) && BMO_edge_flag_test(bm, e, EDGE_ISGC)) { BM_edge_kill(bm, e); } } BM_ITER_MESH_MUTABLE (v, v_next, &iter, bm, BM_VERTS_OF_MESH) { - if ((v->e == NULL) && BMO_elem_flag_test(bm, v, VERT_ISGC)) { + if ((v->e == NULL) && BMO_vert_flag_test(bm, v, VERT_ISGC)) { BM_vert_kill(bm, v); } } @@ -355,7 +355,7 @@ void bmo_dissolve_edges_exec(BMesh *bm, BMOperator *op) if (use_verts) { BM_ITER_MESH_MUTABLE (v, v_next, &iter, bm, BM_VERTS_OF_MESH) { - if (BMO_elem_flag_test(bm, v, VERT_MARK)) { + if (BMO_vert_flag_test(bm, v, VERT_MARK)) { if (BM_vert_is_edge_pair(v)) { BM_vert_collapse_edge(bm, v->e, v, true, true); } @@ -376,7 +376,7 @@ void bmo_dissolve_verts_exec(BMesh *bm, BMOperator *op) const bool use_boundary_tear = BMO_slot_bool_get(op->slots_in, "use_boundary_tear"); BMO_ITER (v, &oiter, op->slots_in, "verts", BM_VERT) { - BMO_elem_flag_enable(bm, v, VERT_MARK | VERT_ISGC); + BMO_vert_flag_enable(bm, v, VERT_MARK | VERT_ISGC); } if (use_face_split) { @@ -388,7 +388,7 @@ void bmo_dissolve_verts_exec(BMesh *bm, BMOperator *op) if (!BM_vert_is_edge_pair(v)) { BM_ITER_ELEM (e, &iter, v, BM_EDGES_OF_VERT) { if (BM_edge_is_boundary(e)) { - BMO_elem_flag_enable(bm, v, VERT_MARK_TEAR); + BMO_vert_flag_enable(bm, v, VERT_MARK_TEAR); break; } } @@ -406,8 +406,8 @@ void bmo_dissolve_verts_exec(BMesh *bm, BMOperator *op) BMLoop *l_iter; l_iter = l_first; do { - BMO_elem_flag_enable(bm, l_iter->v, VERT_ISGC); - BMO_elem_flag_enable(bm, l_iter->e, EDGE_ISGC); + BMO_vert_flag_enable(bm, l_iter->v, VERT_ISGC); + BMO_edge_flag_enable(bm, l_iter->e, EDGE_ISGC); } while ((l_iter = l_iter->next) != l_first); e_first = l_first->e; @@ -428,14 +428,14 @@ void bmo_dissolve_verts_exec(BMesh *bm, BMOperator *op) BMO_ITER (v, &oiter, op->slots_in, "verts", BM_VERT) { /* tag here so we avoid feedback loop (checking topology as we edit) */ if (BM_vert_is_edge_pair(v)) { - BMO_elem_flag_enable(bm, v, VERT_MARK_PAIR); + BMO_vert_flag_enable(bm, v, VERT_MARK_PAIR); } } BMO_ITER (v, &oiter, op->slots_in, "verts", BM_VERT) { BMIter itersub; - if (!BMO_elem_flag_test(bm, v, VERT_MARK_PAIR)) { + if (!BMO_vert_flag_test(bm, v, VERT_MARK_PAIR)) { BM_ITER_ELEM (e, &itersub, v, BM_EDGES_OF_VERT) { BMFace *fa, *fb; if (BM_edge_face_pair(e, &fa, &fb)) { @@ -456,7 +456,7 @@ void bmo_dissolve_verts_exec(BMesh *bm, BMOperator *op) /* Cleanup geometry (#BM_faces_join_pair, but it removes geometry we're looping on) * so do this in a separate pass instead. */ BM_ITER_MESH_MUTABLE (e, e_next, &iter, bm, BM_EDGES_OF_MESH) { - if ((e->l == NULL) && BMO_elem_flag_test(bm, e, EDGE_ISGC)) { + if ((e->l == NULL) && BMO_edge_flag_test(bm, e, EDGE_ISGC)) { BM_edge_kill(bm, e); } } @@ -469,7 +469,7 @@ void bmo_dissolve_verts_exec(BMesh *bm, BMOperator *op) } BM_ITER_MESH_MUTABLE (v, v_next, &iter, bm, BM_VERTS_OF_MESH) { - if ((v->e == NULL) && BMO_elem_flag_test(bm, v, VERT_ISGC)) { + if ((v->e == NULL) && BMO_vert_flag_test(bm, v, VERT_ISGC)) { BM_vert_kill(bm, v); } } @@ -518,9 +518,9 @@ void bmo_dissolve_degenerate_exec(BMesh *bm, BMOperator *op) /* collapse zero length edges, this accounts for zero area faces too */ found = false; BM_ITER_MESH (e, &eiter, bm, BM_EDGES_OF_MESH) { - if (BMO_elem_flag_test(bm, e, EDGE_MARK)) { + if (BMO_edge_flag_test(bm, e, EDGE_MARK)) { if (BM_edge_calc_length_squared(e) < dist_sq) { - BMO_elem_flag_enable(bm, e, EDGE_COLLAPSE); + BMO_edge_flag_enable(bm, e, EDGE_COLLAPSE); found = true; } } @@ -543,7 +543,7 @@ void bmo_dissolve_degenerate_exec(BMesh *bm, BMOperator *op) /* clip degenerate ears from the face */ found = false; BM_ITER_MESH (e, &eiter, bm, BM_EDGES_OF_MESH) { - if (e->l && BMO_elem_flag_test(bm, e, EDGE_MARK)) { + if (e->l && BMO_edge_flag_test(bm, e, EDGE_MARK)) { BMLoop *l_iter, *l_first; l_iter = l_first = e->l; do { @@ -553,11 +553,11 @@ void bmo_dissolve_degenerate_exec(BMesh *bm, BMOperator *op) ((void)BM_elem_flag_enable(l_iter, BM_ELEM_TAG), /* check we're marked to tested (radial edge already tested) */ - BMO_elem_flag_test(bm, l_iter->prev->e, EDGE_MARK) && + BMO_edge_flag_test(bm, l_iter->prev->e, EDGE_MARK) && /* check edges are not already going to be collapsed */ - !BMO_elem_flag_test(bm, l_iter->e, EDGE_COLLAPSE) && - !BMO_elem_flag_test(bm, l_iter->prev->e, EDGE_COLLAPSE))) + !BMO_edge_flag_test(bm, l_iter->e, EDGE_COLLAPSE) && + !BMO_edge_flag_test(bm, l_iter->prev->e, EDGE_COLLAPSE))) { /* test if the faces loop (ear) is degenerate */ float dir_prev[3], len_prev; @@ -577,14 +577,14 @@ void bmo_dissolve_degenerate_exec(BMesh *bm, BMOperator *op) /* both edges the same length */ if (l_iter->f->len == 3) { /* ideally this would have been discovered with short edge test above */ - BMO_elem_flag_enable(bm, l_iter->next->e, EDGE_COLLAPSE); + BMO_edge_flag_enable(bm, l_iter->next->e, EDGE_COLLAPSE); found = true; } else { /* add a joining edge and tag for removal */ BMLoop *l_split; if (BM_face_split(bm, l_iter->f, l_iter->prev, l_iter->next, &l_split, NULL, true)) { - BMO_elem_flag_enable(bm, l_split->e, EDGE_COLLAPSE); + BMO_edge_flag_enable(bm, l_split->e, EDGE_COLLAPSE); found = true; reset = true; } @@ -599,7 +599,7 @@ void bmo_dissolve_degenerate_exec(BMesh *bm, BMOperator *op) BLI_assert(v_new == l_iter->next->v); (void)v_new; if (BM_face_split(bm, l_iter->f, l_iter->prev, l_iter->next, &l_split, NULL, true)) { - BMO_elem_flag_enable(bm, l_split->e, EDGE_COLLAPSE); + BMO_edge_flag_enable(bm, l_split->e, EDGE_COLLAPSE); found = true; } reset = true; @@ -613,7 +613,7 @@ void bmo_dissolve_degenerate_exec(BMesh *bm, BMOperator *op) BLI_assert(v_new == l_iter->prev->v); (void)v_new; if (BM_face_split(bm, l_iter->f, l_iter->prev, l_iter->next, &l_split, NULL, true)) { - BMO_elem_flag_enable(bm, l_split->e, EDGE_COLLAPSE); + BMO_edge_flag_enable(bm, l_split->e, EDGE_COLLAPSE); found = true; } reset = true; diff --git a/source/blender/bmesh/operators/bmo_dupe.c b/source/blender/bmesh/operators/bmo_dupe.c index fd430de80f9..56639a097b6 100644 --- a/source/blender/bmesh/operators/bmo_dupe.c +++ b/source/blender/bmesh/operators/bmo_dupe.c @@ -63,7 +63,7 @@ static BMVert *bmo_vert_copy( BM_elem_attrs_copy(bm_src, bm_dst, v_src, v_dst); /* Mark the vert for output */ - BMO_elem_flag_enable(bm_dst, v_dst, DUPE_NEW); + BMO_vert_flag_enable(bm_dst, v_dst, DUPE_NEW); return v_dst; } @@ -94,7 +94,7 @@ static BMEdge *bmo_edge_copy( BMLoop *l_iter_src, *l_first_src; l_iter_src = l_first_src = e_src->l; do { - if (BMO_elem_flag_test(bm_src, l_iter_src->f, DUPE_INPUT)) { + if (BMO_face_flag_test(bm_src, l_iter_src->f, DUPE_INPUT)) { rlen++; } } while ((l_iter_src = l_iter_src->radial_next) != l_first_src); @@ -123,7 +123,7 @@ static BMEdge *bmo_edge_copy( BM_elem_attrs_copy(bm_src, bm_dst, e_src, e_dst); /* Mark the edge for output */ - BMO_elem_flag_enable(bm_dst, e_dst, DUPE_NEW); + BMO_edge_flag_enable(bm_dst, e_dst, DUPE_NEW); return e_dst; } @@ -175,7 +175,7 @@ static BMFace *bmo_face_copy( (l_iter_src = l_iter_src->next) != l_first_src); /* Mark the face for output */ - BMO_elem_flag_enable(bm_dst, f_dst, DUPE_NEW); + BMO_face_flag_enable(bm_dst, f_dst, DUPE_NEW); return f_dst; } @@ -209,8 +209,8 @@ static void bmo_mesh_copy(BMOperator *op, BMesh *bm_dst, BMesh *bm_src) /* duplicate flagged vertices */ BM_ITER_MESH (v, &viter, bm_src, BM_VERTS_OF_MESH) { - if (BMO_elem_flag_test(bm_src, v, DUPE_INPUT) && - !BMO_elem_flag_test(bm_src, v, DUPE_DONE)) + if (BMO_vert_flag_test(bm_src, v, DUPE_INPUT) && + BMO_vert_flag_test(bm_src, v, DUPE_DONE) == false) { BMIter iter; bool isolated = true; @@ -218,7 +218,7 @@ static void bmo_mesh_copy(BMOperator *op, BMesh *bm_dst, BMesh *bm_src) v2 = bmo_vert_copy(op, slot_vert_map_out, bm_dst, bm_src, v, vhash); BM_ITER_ELEM (f, &iter, v, BM_FACES_OF_VERT) { - if (BMO_elem_flag_test(bm_src, f, DUPE_INPUT)) { + if (BMO_face_flag_test(bm_src, f, DUPE_INPUT)) { isolated = false; break; } @@ -226,7 +226,7 @@ static void bmo_mesh_copy(BMOperator *op, BMesh *bm_dst, BMesh *bm_src) if (isolated) { BM_ITER_ELEM (e, &iter, v, BM_EDGES_OF_VERT) { - if (BMO_elem_flag_test(bm_src, e, DUPE_INPUT)) { + if (BMO_edge_flag_test(bm_src, e, DUPE_INPUT)) { isolated = false; break; } @@ -237,53 +237,53 @@ static void bmo_mesh_copy(BMOperator *op, BMesh *bm_dst, BMesh *bm_src) BMO_slot_map_elem_insert(op, slot_isovert_map_out, v, v2); } - BMO_elem_flag_enable(bm_src, v, DUPE_DONE); + BMO_vert_flag_enable(bm_src, v, DUPE_DONE); } } /* now we dupe all the edges */ BM_ITER_MESH (e, &eiter, bm_src, BM_EDGES_OF_MESH) { - if (BMO_elem_flag_test(bm_src, e, DUPE_INPUT) && - !BMO_elem_flag_test(bm_src, e, DUPE_DONE)) + if (BMO_edge_flag_test(bm_src, e, DUPE_INPUT) && + BMO_edge_flag_test(bm_src, e, DUPE_DONE) == false) { /* make sure that verts are copied */ - if (!BMO_elem_flag_test(bm_src, e->v1, DUPE_DONE)) { + if (!BMO_vert_flag_test(bm_src, e->v1, DUPE_DONE)) { bmo_vert_copy(op, slot_vert_map_out, bm_dst, bm_src, e->v1, vhash); - BMO_elem_flag_enable(bm_src, e->v1, DUPE_DONE); + BMO_vert_flag_enable(bm_src, e->v1, DUPE_DONE); } - if (!BMO_elem_flag_test(bm_src, e->v2, DUPE_DONE)) { + if (!BMO_vert_flag_test(bm_src, e->v2, DUPE_DONE)) { bmo_vert_copy(op, slot_vert_map_out, bm_dst, bm_src, e->v2, vhash); - BMO_elem_flag_enable(bm_src, e->v2, DUPE_DONE); + BMO_vert_flag_enable(bm_src, e->v2, DUPE_DONE); } /* now copy the actual edge */ bmo_edge_copy(op, slot_edge_map_out, slot_boundary_map_out, bm_dst, bm_src, e, vhash, ehash); - BMO_elem_flag_enable(bm_src, e, DUPE_DONE); + BMO_edge_flag_enable(bm_src, e, DUPE_DONE); } } /* first we dupe all flagged faces and their elements from source */ BM_ITER_MESH (f, &fiter, bm_src, BM_FACES_OF_MESH) { - if (BMO_elem_flag_test(bm_src, f, DUPE_INPUT)) { + if (BMO_face_flag_test(bm_src, f, DUPE_INPUT)) { /* vertex pass */ BM_ITER_ELEM (v, &viter, f, BM_VERTS_OF_FACE) { - if (!BMO_elem_flag_test(bm_src, v, DUPE_DONE)) { + if (!BMO_vert_flag_test(bm_src, v, DUPE_DONE)) { bmo_vert_copy(op, slot_vert_map_out, bm_dst, bm_src, v, vhash); - BMO_elem_flag_enable(bm_src, v, DUPE_DONE); + BMO_vert_flag_enable(bm_src, v, DUPE_DONE); } } /* edge pass */ BM_ITER_ELEM (e, &eiter, f, BM_EDGES_OF_FACE) { - if (!BMO_elem_flag_test(bm_src, e, DUPE_DONE)) { + if (!BMO_edge_flag_test(bm_src, e, DUPE_DONE)) { bmo_edge_copy(op, slot_edge_map_out, slot_boundary_map_out, bm_dst, bm_src, e, vhash, ehash); - BMO_elem_flag_enable(bm_src, e, DUPE_DONE); + BMO_edge_flag_enable(bm_src, e, DUPE_DONE); } } bmo_face_copy(op, slot_face_map_out, bm_dst, bm_src, f, vhash, ehash); - BMO_elem_flag_enable(bm_src, f, DUPE_DONE); + BMO_face_flag_enable(bm_src, f, DUPE_DONE); } } @@ -408,26 +408,26 @@ void bmo_split_exec(BMesh *bm, BMOperator *op) BM_ITER_MESH (e, &iter, bm, BM_EDGES_OF_MESH) { bool found = false; BM_ITER_ELEM (f, &iter2, e, BM_FACES_OF_EDGE) { - if (!BMO_elem_flag_test(bm, f, SPLIT_INPUT)) { + if (!BMO_face_flag_test(bm, f, SPLIT_INPUT)) { found = true; break; } } if (found == false) { - BMO_elem_flag_enable(bm, e, SPLIT_INPUT); + BMO_edge_flag_enable(bm, e, SPLIT_INPUT); } } BM_ITER_MESH (v, &iter, bm, BM_VERTS_OF_MESH) { bool found = false; BM_ITER_ELEM (e, &iter2, v, BM_EDGES_OF_VERT) { - if (!BMO_elem_flag_test(bm, e, SPLIT_INPUT)) { + if (!BMO_edge_flag_test(bm, e, SPLIT_INPUT)) { found = true; break; } } if (found == false) { - BMO_elem_flag_enable(bm, v, SPLIT_INPUT); + BMO_vert_flag_enable(bm, v, SPLIT_INPUT); } } } diff --git a/source/blender/bmesh/operators/bmo_edgenet.c b/source/blender/bmesh/operators/bmo_edgenet.c index f348014cead..64b092da5c8 100644 --- a/source/blender/bmesh/operators/bmo_edgenet.c +++ b/source/blender/bmesh/operators/bmo_edgenet.c @@ -94,8 +94,8 @@ static BMEdge *edge_next(BMesh *bm, BMEdge *e) for (i = 0; i < 2; i++) { BM_ITER_ELEM (e2, &iter, i ? e->v2 : e->v1, BM_EDGES_OF_VERT) { - if ((BMO_elem_flag_test(bm, e2, EDGE_MARK)) && - (!BMO_elem_flag_test(bm, e2, EDGE_VIS)) && + if ((BMO_edge_flag_test(bm, e2, EDGE_MARK)) && + (BMO_edge_flag_test(bm, e2, EDGE_VIS) == false) && (e2 != e)) { return e2; @@ -144,7 +144,7 @@ void bmo_edgenet_prepare_exec(BMesh *bm, BMOperator *op) count = 0; while (1) { BMO_ITER (e, &siter, op->slots_in, "edges", BM_EDGE) { - if (!BMO_elem_flag_test(bm, e, EDGE_VIS)) { + if (!BMO_edge_flag_test(bm, e, EDGE_VIS)) { if (BMO_iter_elem_count_flag(bm, BM_EDGES_OF_VERT, e->v1, EDGE_MARK, true) == 1 || BMO_iter_elem_count_flag(bm, BM_EDGES_OF_VERT, e->v2, EDGE_MARK, true) == 1) { @@ -169,7 +169,7 @@ void bmo_edgenet_prepare_exec(BMesh *bm, BMOperator *op) i = 0; while (e) { - BMO_elem_flag_enable(bm, e, EDGE_VIS); + BMO_edge_flag_enable(bm, e, EDGE_VIS); BLI_array_grow_one(edges); edges[i] = e; @@ -258,9 +258,9 @@ void bmo_edgenet_prepare_exec(BMesh *bm, BMOperator *op) } e = BM_edge_create(bm, v1, v3, NULL, BM_CREATE_NO_DOUBLE); - BMO_elem_flag_enable(bm, e, ELE_NEW); + BMO_edge_flag_enable(bm, e, ELE_NEW); e = BM_edge_create(bm, v2, v4, NULL, BM_CREATE_NO_DOUBLE); - BMO_elem_flag_enable(bm, e, ELE_NEW); + BMO_edge_flag_enable(bm, e, ELE_NEW); } else if (edges1) { BMVert *v1, *v2; @@ -270,7 +270,7 @@ void bmo_edgenet_prepare_exec(BMesh *bm, BMOperator *op) i = BLI_array_count(edges1) - 1; v2 = BM_vert_in_edge(edges1[i - 1], edges1[i]->v1) ? edges1[i]->v2 : edges1[i]->v1; e = BM_edge_create(bm, v1, v2, NULL, BM_CREATE_NO_DOUBLE); - BMO_elem_flag_enable(bm, e, ELE_NEW); + BMO_edge_flag_enable(bm, e, ELE_NEW); } } diff --git a/source/blender/bmesh/operators/bmo_extrude.c b/source/blender/bmesh/operators/bmo_extrude.c index 5a3bef6ba81..f2a8e05d763 100644 --- a/source/blender/bmesh/operators/bmo_extrude.c +++ b/source/blender/bmesh/operators/bmo_extrude.c @@ -70,10 +70,10 @@ void bmo_extrude_discrete_faces_exec(BMesh *bm, BMOperator *op) BMLoop *l_org, *l_org_first; BMLoop *l_new; - BMO_elem_flag_enable(bm, f_org, EXT_DEL); + BMO_face_flag_enable(bm, f_org, EXT_DEL); f_new = BM_face_copy(bm, bm, f_org, true, true); - BMO_elem_flag_enable(bm, f_new, EXT_KEEP); + BMO_face_flag_enable(bm, f_new, EXT_KEEP); if (select_history_map) { BMEditSelection *ese; @@ -188,9 +188,9 @@ void bmo_extrude_edge_only_exec(BMesh *bm, BMOperator *op) BMEdge *e, *e_new; BMO_ITER (e, &siter, op->slots_in, "edges", BM_EDGE) { - BMO_elem_flag_enable(bm, e, EXT_INPUT); - BMO_elem_flag_enable(bm, e->v1, EXT_INPUT); - BMO_elem_flag_enable(bm, e->v2, EXT_INPUT); + BMO_edge_flag_enable(bm, e, EXT_INPUT); + BMO_vert_flag_enable(bm, e->v1, EXT_INPUT); + BMO_vert_flag_enable(bm, e->v2, EXT_INPUT); } BMO_op_initf( @@ -228,13 +228,14 @@ void bmo_extrude_edge_only_exec(BMesh *bm, BMOperator *op) f = BM_face_create_verts(bm, f_verts, 4, NULL, BM_CREATE_NOP, true); bm_extrude_copy_face_loop_attributes(bm, f); - if (BMO_elem_flag_test(bm, e, EXT_INPUT)) + if (BMO_edge_flag_test(bm, e, EXT_INPUT)) { e = e_new; + } - BMO_elem_flag_enable(bm, f, EXT_KEEP); - BMO_elem_flag_enable(bm, e, EXT_KEEP); - BMO_elem_flag_enable(bm, e->v1, EXT_KEEP); - BMO_elem_flag_enable(bm, e->v2, EXT_KEEP); + BMO_face_flag_enable(bm, f, EXT_KEEP); + BMO_edge_flag_enable(bm, e, EXT_KEEP); + BMO_vert_flag_enable(bm, e->v1, EXT_KEEP); + BMO_vert_flag_enable(bm, e->v2, EXT_KEEP); } @@ -258,7 +259,7 @@ void bmo_extrude_vert_indiv_exec(BMesh *bm, BMOperator *op) for (v = BMO_iter_new(&siter, op->slots_in, "verts", BM_VERT); v; v = BMO_iter_step(&siter)) { dupev = BM_vert_create(bm, v->co, v, BM_CREATE_NOP); - BMO_elem_flag_enable(bm, dupev, EXT_KEEP); + BMO_vert_flag_enable(bm, dupev, EXT_KEEP); if (has_vskin) bm_extrude_disable_skin_root(bm, v); @@ -279,7 +280,7 @@ void bmo_extrude_vert_indiv_exec(BMesh *bm, BMOperator *op) } e = BM_edge_create(bm, v, dupev, NULL, BM_CREATE_NOP); - BMO_elem_flag_enable(bm, e, EXT_KEEP); + BMO_edge_flag_enable(bm, e, EXT_KEEP); } if (select_history_map) { @@ -350,7 +351,7 @@ void bmo_extrude_face_region_exec(BMesh *bm, BMOperator *op) int edge_face_tot; - if (!BMO_elem_flag_test(bm, e, EXT_INPUT)) { + if (!BMO_edge_flag_test(bm, e, EXT_INPUT)) { continue; } @@ -358,7 +359,7 @@ void bmo_extrude_face_region_exec(BMesh *bm, BMOperator *op) edge_face_tot = 0; /* edge/face count */ BM_ITER_ELEM (f, &fiter, e, BM_FACES_OF_EDGE) { - if (!BMO_elem_flag_test(bm, f, EXT_INPUT)) { + if (!BMO_face_flag_test(bm, f, EXT_INPUT)) { found = true; delorig = true; break; @@ -369,7 +370,7 @@ void bmo_extrude_face_region_exec(BMesh *bm, BMOperator *op) if ((edge_face_tot > 1) && (found == false)) { /* edge has a face user, that face isn't extrude input */ - BMO_elem_flag_enable(bm, e, EXT_DEL); + BMO_edge_flag_enable(bm, e, EXT_DEL); } } } @@ -380,7 +381,9 @@ void bmo_extrude_face_region_exec(BMesh *bm, BMOperator *op) found = false; BM_ITER_ELEM (e, &viter, v, BM_EDGES_OF_VERT) { - if (!BMO_elem_flag_test(bm, e, EXT_INPUT) || !BMO_elem_flag_test(bm, e, EXT_DEL)) { + if (!BMO_edge_flag_test(bm, e, EXT_INPUT) || + !BMO_edge_flag_test(bm, e, EXT_DEL)) + { found = true; break; } @@ -389,7 +392,7 @@ void bmo_extrude_face_region_exec(BMesh *bm, BMOperator *op) /* avoid an extra loop */ if (found == true) { BM_ITER_ELEM (f, &viter, v, BM_FACES_OF_VERT) { - if (!BMO_elem_flag_test(bm, f, EXT_INPUT)) { + if (!BMO_face_flag_test(bm, f, EXT_INPUT)) { found = true; break; } @@ -397,14 +400,14 @@ void bmo_extrude_face_region_exec(BMesh *bm, BMOperator *op) } if (found == false) { - BMO_elem_flag_enable(bm, v, EXT_DEL); + BMO_vert_flag_enable(bm, v, EXT_DEL); } } } BM_ITER_MESH (f, &iter, bm, BM_FACES_OF_MESH) { - if (BMO_elem_flag_test(bm, f, EXT_INPUT)) { - BMO_elem_flag_enable(bm, f, EXT_DEL); + if (BMO_face_flag_test(bm, f, EXT_INPUT)) { + BMO_face_flag_enable(bm, f, EXT_DEL); } } @@ -426,7 +429,7 @@ void bmo_extrude_face_region_exec(BMesh *bm, BMOperator *op) } slot_facemap_out = BMO_slot_get(dupeop.slots_out, "face_map.out"); - if (bm->act_face && BMO_elem_flag_test(bm, bm->act_face, EXT_INPUT)) { + if (bm->act_face && BMO_face_flag_test(bm, bm->act_face, EXT_INPUT)) { bm->act_face = BMO_slot_map_elem_get(slot_facemap_out, bm->act_face); } @@ -437,7 +440,7 @@ void bmo_extrude_face_region_exec(BMesh *bm, BMOperator *op) /* if not delorig, reverse loops of original face */ if (!delorig) { BM_ITER_MESH (f, &iter, bm, BM_FACES_OF_MESH) { - if (BMO_elem_flag_test(bm, f, EXT_INPUT)) { + if (BMO_face_flag_test(bm, f, EXT_INPUT)) { BM_face_normal_flip(bm, f); } } @@ -583,7 +586,7 @@ static void calc_solidify_normals(BMesh *bm) BM_mesh_elem_index_ensure(bm, BM_EDGE); BM_ITER_MESH (f, &fiter, bm, BM_FACES_OF_MESH) { - if (!BMO_elem_flag_test(bm, f, FACE_MARK)) { + if (!BMO_face_flag_test(bm, f, FACE_MARK)) { continue; } @@ -591,15 +594,15 @@ static void calc_solidify_normals(BMesh *bm) /* And mark all edges and vertices on the * marked faces */ - BMO_elem_flag_enable(bm, e, EDGE_MARK); - BMO_elem_flag_enable(bm, e->v1, VERT_MARK); - BMO_elem_flag_enable(bm, e->v2, VERT_MARK); + BMO_edge_flag_enable(bm, e, EDGE_MARK); + BMO_vert_flag_enable(bm, e->v1, VERT_MARK); + BMO_vert_flag_enable(bm, e->v2, VERT_MARK); edge_face_count[BM_elem_index_get(e)]++; } } BM_ITER_MESH (e, &eiter, bm, BM_EDGES_OF_MESH) { - if (!BMO_elem_flag_test(bm, e, EDGE_MARK)) { + if (!BMO_edge_flag_test(bm, e, EDGE_MARK)) { continue; } @@ -608,9 +611,9 @@ static void calc_solidify_normals(BMesh *bm) if (i == 0 || i > 2) { /* Edge & vertices are non-manifold even when considering * only marked faces */ - BMO_elem_flag_enable(bm, e, EDGE_NONMAN); - BMO_elem_flag_enable(bm, e->v1, VERT_NONMAN); - BMO_elem_flag_enable(bm, e->v2, VERT_NONMAN); + BMO_edge_flag_enable(bm, e, EDGE_NONMAN); + BMO_vert_flag_enable(bm, e->v1, VERT_NONMAN); + BMO_vert_flag_enable(bm, e->v2, VERT_NONMAN); } } MEM_freeN(edge_face_count); @@ -618,11 +621,11 @@ static void calc_solidify_normals(BMesh *bm) BM_ITER_MESH (v, &viter, bm, BM_VERTS_OF_MESH) { if (!BM_vert_is_manifold(v)) { - BMO_elem_flag_enable(bm, v, VERT_NONMAN); + BMO_vert_flag_enable(bm, v, VERT_NONMAN); continue; } - if (BMO_elem_flag_test(bm, v, VERT_MARK)) { + if (BMO_vert_flag_test(bm, v, VERT_MARK)) { zero_v3(v->no); } } @@ -631,20 +634,20 @@ static void calc_solidify_normals(BMesh *bm) /* If the edge is not part of a the solidify region * its normal should not be considered */ - if (!BMO_elem_flag_test(bm, e, EDGE_MARK)) { + if (!BMO_edge_flag_test(bm, e, EDGE_MARK)) { continue; } /* If the edge joins more than two marked faces high * quality normal computation won't work */ - if (BMO_elem_flag_test(bm, e, EDGE_NONMAN)) { + if (BMO_edge_flag_test(bm, e, EDGE_NONMAN)) { continue; } f1 = f2 = NULL; BM_ITER_ELEM (f, &fiter, e, BM_FACES_OF_EDGE) { - if (BMO_elem_flag_test(bm, f, FACE_MARK)) { + if (BMO_face_flag_test(bm, f, FACE_MARK)) { if (f1 == NULL) { f1 = f; } @@ -689,11 +692,11 @@ static void calc_solidify_normals(BMesh *bm) /* normalize accumulated vertex normal */ BM_ITER_MESH (v, &viter, bm, BM_VERTS_OF_MESH) { - if (!BMO_elem_flag_test(bm, v, VERT_MARK)) { + if (!BMO_vert_flag_test(bm, v, VERT_MARK)) { continue; } - if (BMO_elem_flag_test(bm, v, VERT_NONMAN)) { + if (BMO_vert_flag_test(bm, v, VERT_NONMAN)) { /* use standard normals for vertices connected to non-manifold edges */ BM_vert_normal_update(v); } @@ -701,7 +704,7 @@ static void calc_solidify_normals(BMesh *bm) /* exceptional case, totally flat. use the normal * of any marked face around the vertex */ BM_ITER_ELEM (f, &fiter, v, BM_FACES_OF_VERT) { - if (BMO_elem_flag_test(bm, f, FACE_MARK)) { + if (BMO_face_flag_test(bm, f, FACE_MARK)) { break; } } @@ -726,7 +729,7 @@ static void solidify_add_thickness(BMesh *bm, const float dist) BM_mesh_elem_index_ensure(bm, BM_VERT); BM_ITER_MESH (f, &iter, bm, BM_FACES_OF_MESH) { - if (BMO_elem_flag_test(bm, f, FACE_MARK)) { + if (BMO_face_flag_test(bm, f, FACE_MARK)) { /* array for passing verts to angle_poly_v3 */ float *face_angles = BLI_buffer_reinit_data(&face_angles_buf, float, f->len); diff --git a/source/blender/bmesh/operators/bmo_fill_edgeloop.c b/source/blender/bmesh/operators/bmo_fill_edgeloop.c index 0fbaf5ff11a..c68130bc11d 100644 --- a/source/blender/bmesh/operators/bmo_fill_edgeloop.c +++ b/source/blender/bmesh/operators/bmo_fill_edgeloop.c @@ -59,14 +59,14 @@ void bmo_edgeloop_fill_exec(BMesh *bm, BMOperator *op) i = 0; BMO_ITER (e, &oiter, op->slots_in, "edges", BM_EDGE) { BMIter viter; - BMO_elem_flag_enable(bm, e, EDGE_MARK); + BMO_edge_flag_enable(bm, e, EDGE_MARK); BM_ITER_ELEM (v, &viter, e, BM_VERTS_OF_EDGE) { - if (BMO_elem_flag_test(bm, v, VERT_USED) == false) { + if (BMO_vert_flag_test(bm, v, VERT_USED) == false) { if (i == tote) { goto cleanup; } - BMO_elem_flag_enable(bm, v, VERT_USED); + BMO_vert_flag_enable(bm, v, VERT_USED); verts[i++] = v; } } @@ -103,21 +103,21 @@ void bmo_edgeloop_fill_exec(BMesh *bm, BMOperator *op) while (totv_used < totv) { for (i = 0; i < totv; i++) { v = verts[i]; - if (BMO_elem_flag_test(bm, v, VERT_USED)) { + if (BMO_vert_flag_test(bm, v, VERT_USED)) { break; } } /* this should never fail, as long as (totv_used < totv) * we should have marked verts available */ - BLI_assert(BMO_elem_flag_test(bm, v, VERT_USED)); + BLI_assert(BMO_vert_flag_test(bm, v, VERT_USED)); /* watch it, 'i' is used for final face length */ i = 0; do { /* we know that there are 2 edges per vertex so no need to check */ BM_ITER_ELEM (e, &eiter, v, BM_EDGES_OF_VERT) { - if (BMO_elem_flag_test(bm, e, EDGE_MARK)) { + if (BMO_edge_flag_test(bm, e, EDGE_MARK)) { if (e != e_prev) { e_next = e; break; @@ -127,7 +127,7 @@ void bmo_edgeloop_fill_exec(BMesh *bm, BMOperator *op) /* fill in the array */ f_verts[i] = v; - BMO_elem_flag_disable(bm, v, VERT_USED); + BMO_vert_flag_disable(bm, v, VERT_USED); totv_used++; /* step over the edges */ @@ -141,7 +141,7 @@ void bmo_edgeloop_fill_exec(BMesh *bm, BMOperator *op) /* don't use calc_edges option because we already have the edges */ f = BM_face_create_ngon_verts(bm, f_verts, i, NULL, BM_CREATE_NOP, true, false); - BMO_elem_flag_enable(bm, f, ELE_OUT); + BMO_face_flag_enable(bm, f, ELE_OUT); f->mat_nr = mat_nr; if (use_smooth) { BM_elem_flag_enable(f, BM_ELEM_SMOOTH); diff --git a/source/blender/bmesh/operators/bmo_fill_grid.c b/source/blender/bmesh/operators/bmo_fill_grid.c index 77556591728..04ae915b707 100644 --- a/source/blender/bmesh/operators/bmo_fill_grid.c +++ b/source/blender/bmesh/operators/bmo_fill_grid.c @@ -466,7 +466,7 @@ static void bm_grid_fill_array( /* end interp */ - BMO_elem_flag_enable(bm, f, FACE_OUT); + BMO_face_flag_enable(bm, f, FACE_OUT); f->mat_nr = mat_nr; if (use_smooth) { BM_elem_flag_enable(f, BM_ELEM_SMOOTH); @@ -585,7 +585,7 @@ static void bm_edgeloop_flag_set(struct BMEdgeLoopStore *estore, char hflag, boo static bool bm_edge_test_cb(BMEdge *e, void *bm_v) { - return BMO_elem_flag_test_bool((BMesh *)bm_v, e, EDGE_MARK); + return BMO_edge_flag_test_bool((BMesh *)bm_v, e, EDGE_MARK); } static bool bm_edge_test_rail_cb(BMEdge *e, void *UNUSED(bm_v)) diff --git a/source/blender/bmesh/operators/bmo_hull.c b/source/blender/bmesh/operators/bmo_hull.c index 2dfad5a1f47..9c41e4f2115 100644 --- a/source/blender/bmesh/operators/bmo_hull.c +++ b/source/blender/bmesh/operators/bmo_hull.c @@ -81,7 +81,7 @@ static void hull_add_triangle( /* Mark triangles vertices as not interior */ for (i = 0; i < 3; i++) - BMO_elem_flag_disable(bm, t->v[i], HULL_FLAG_INTERIOR_ELE); + BMO_vert_flag_disable(bm, t->v[i], HULL_FLAG_INTERIOR_ELE); BLI_gset_insert(hull_triangles, t); normal_tri_v3(t->no, v1->co, v2->co, v3->co); @@ -93,8 +93,8 @@ static BMFace *hull_find_example_face(BMesh *bm, BMEdge *e) BMFace *f; BM_ITER_ELEM (f, &iter, e, BM_FACES_OF_EDGE) { - if (BMO_elem_flag_test(bm, f, HULL_FLAG_INPUT) || - !BMO_elem_flag_test(bm, f, HULL_FLAG_OUTPUT_GEOM)) + if (BMO_face_flag_test(bm, f, HULL_FLAG_INPUT) || + BMO_face_flag_test(bm, f, HULL_FLAG_OUTPUT_GEOM) == false) { return f; } @@ -124,9 +124,9 @@ static void hull_output_triangles(BMesh *bm, GSet *hull_triangles) * disabled, but an output face in the hull is the * same as a face in the existing mesh, it should not * be marked as unused or interior. */ - BMO_elem_flag_enable(bm, f, HULL_FLAG_OUTPUT_GEOM); - BMO_elem_flag_disable(bm, f, HULL_FLAG_HOLE); - BMO_elem_flag_disable(bm, f, HULL_FLAG_INTERIOR_ELE); + BMO_face_flag_enable(bm, f, HULL_FLAG_OUTPUT_GEOM); + BMO_face_flag_disable(bm, f, HULL_FLAG_HOLE); + BMO_face_flag_disable(bm, f, HULL_FLAG_INTERIOR_ELE); } else { /* Look for an adjacent face that existed before the hull */ @@ -140,12 +140,12 @@ static void hull_output_triangles(BMesh *bm, GSet *hull_triangles) BM_face_copy_shared(bm, f, NULL, NULL); } /* Mark face for 'geom.out' slot and select */ - BMO_elem_flag_enable(bm, f, HULL_FLAG_OUTPUT_GEOM); + BMO_face_flag_enable(bm, f, HULL_FLAG_OUTPUT_GEOM); BM_face_select_set(bm, f, true); /* Mark edges for 'geom.out' slot */ for (i = 0; i < 3; i++) { - BMO_elem_flag_enable(bm, edges[i], HULL_FLAG_OUTPUT_GEOM); + BMO_edge_flag_enable(bm, edges[i], HULL_FLAG_OUTPUT_GEOM); } } else { @@ -154,17 +154,17 @@ static void hull_output_triangles(BMesh *bm, GSet *hull_triangles) const int next = (i == 2 ? 0 : i + 1); BMEdge *e = BM_edge_exists(t->v[i], t->v[next]); if (e && - BMO_elem_flag_test(bm, e, HULL_FLAG_INPUT) && - !BMO_elem_flag_test(bm, e, HULL_FLAG_HOLE)) + BMO_edge_flag_test(bm, e, HULL_FLAG_INPUT) && + !BMO_edge_flag_test(bm, e, HULL_FLAG_HOLE)) { - BMO_elem_flag_enable(bm, e, HULL_FLAG_OUTPUT_GEOM); + BMO_edge_flag_enable(bm, e, HULL_FLAG_OUTPUT_GEOM); } } } /* Mark verts for 'geom.out' slot */ for (i = 0; i < 3; i++) { - BMO_elem_flag_enable(bm, t->v[i], HULL_FLAG_OUTPUT_GEOM); + BMO_vert_flag_enable(bm, t->v[i], HULL_FLAG_OUTPUT_GEOM); } } } @@ -292,8 +292,8 @@ static void hull_remove_overlapping( BM_vert_in_face(t->v[2], f) && f_on_hull) { t->skip = true; - BMO_elem_flag_disable(bm, f, HULL_FLAG_INTERIOR_ELE); - BMO_elem_flag_enable(bm, f, HULL_FLAG_HOLE); + BMO_face_flag_disable(bm, f, HULL_FLAG_INTERIOR_ELE); + BMO_face_flag_enable(bm, f, HULL_FLAG_HOLE); } } } @@ -310,13 +310,13 @@ static void hull_mark_interior_elements( /* Check for interior edges too */ BMO_ITER (e, &oiter, op->slots_in, "input", BM_EDGE) { if (!hull_final_edges_lookup(final_edges, e->v1, e->v2)) - BMO_elem_flag_enable(bm, e, HULL_FLAG_INTERIOR_ELE); + BMO_edge_flag_enable(bm, e, HULL_FLAG_INTERIOR_ELE); } /* Mark all input faces as interior, some may be unmarked in * hull_remove_overlapping() */ BMO_ITER (f, &oiter, op->slots_in, "input", BM_FACE) { - BMO_elem_flag_enable(bm, f, HULL_FLAG_INTERIOR_ELE); + BMO_face_flag_enable(bm, f, HULL_FLAG_INTERIOR_ELE); } } @@ -333,47 +333,50 @@ static void hull_tag_unused(BMesh *bm, BMOperator *op) * the hull), but that aren't also used by elements outside the * input set */ BMO_ITER (v, &oiter, op->slots_in, "input", BM_VERT) { - if (BMO_elem_flag_test(bm, v, HULL_FLAG_INTERIOR_ELE)) { + if (BMO_vert_flag_test(bm, v, HULL_FLAG_INTERIOR_ELE)) { bool del = true; BM_ITER_ELEM (e, &iter, v, BM_EDGES_OF_VERT) { - if (!BMO_elem_flag_test(bm, e, HULL_FLAG_INPUT)) { + if (!BMO_edge_flag_test(bm, e, HULL_FLAG_INPUT)) { del = false; break; } } BM_ITER_ELEM (f, &iter, v, BM_FACES_OF_VERT) { - if (!BMO_elem_flag_test(bm, f, HULL_FLAG_INPUT)) { + if (!BMO_face_flag_test(bm, f, HULL_FLAG_INPUT)) { del = false; break; } } - if (del) - BMO_elem_flag_enable(bm, v, HULL_FLAG_DEL); + if (del) { + BMO_vert_flag_enable(bm, v, HULL_FLAG_DEL); + } } } BMO_ITER (e, &oiter, op->slots_in, "input", BM_EDGE) { - if (BMO_elem_flag_test(bm, e, HULL_FLAG_INTERIOR_ELE)) { + if (BMO_edge_flag_test(bm, e, HULL_FLAG_INTERIOR_ELE)) { bool del = true; BM_ITER_ELEM (f, &iter, e, BM_FACES_OF_EDGE) { - if (!BMO_elem_flag_test(bm, f, HULL_FLAG_INPUT)) { + if (!BMO_face_flag_test(bm, f, HULL_FLAG_INPUT)) { del = false; break; } } - if (del) - BMO_elem_flag_enable(bm, e, HULL_FLAG_DEL); + if (del) { + BMO_edge_flag_enable(bm, e, HULL_FLAG_DEL); + } } } BMO_ITER (f, &oiter, op->slots_in, "input", BM_FACE) { - if (BMO_elem_flag_test(bm, f, HULL_FLAG_INTERIOR_ELE)) - BMO_elem_flag_enable(bm, f, HULL_FLAG_DEL); + if (BMO_face_flag_test(bm, f, HULL_FLAG_INTERIOR_ELE)) { + BMO_face_flag_enable(bm, f, HULL_FLAG_DEL); + } } } @@ -387,10 +390,10 @@ static void hull_tag_holes(BMesh *bm, BMOperator *op) /* Unmark any hole faces if they are isolated or part of a * border */ BMO_ITER (f, &oiter, op->slots_in, "input", BM_FACE) { - if (BMO_elem_flag_test(bm, f, HULL_FLAG_HOLE)) { + if (BMO_face_flag_test(bm, f, HULL_FLAG_HOLE)) { BM_ITER_ELEM (e, &iter, f, BM_EDGES_OF_FACE) { if (BM_edge_is_boundary(e)) { - BMO_elem_flag_disable(bm, f, HULL_FLAG_HOLE); + BMO_face_flag_disable(bm, f, HULL_FLAG_HOLE); break; } } @@ -405,14 +408,14 @@ static void hull_tag_holes(BMesh *bm, BMOperator *op) BM_ITER_ELEM (f, &iter, e, BM_FACES_OF_EDGE) { any_faces = true; - if (!BMO_elem_flag_test(bm, f, HULL_FLAG_HOLE)) { + if (!BMO_face_flag_test(bm, f, HULL_FLAG_HOLE)) { hole = false; break; } } if (hole && any_faces) - BMO_elem_flag_enable(bm, e, HULL_FLAG_HOLE); + BMO_edge_flag_enable(bm, e, HULL_FLAG_HOLE); } } @@ -578,11 +581,17 @@ void bmo_convex_hull_exec(BMesh *bm, BMOperator *op) /* Tag input elements */ BMO_ITER (ele, &oiter, op->slots_in, "input", BM_ALL) { - BMO_elem_flag_enable(bm, ele, HULL_FLAG_INPUT); - + /* Mark all vertices as interior to begin with */ - if (ele->head.htype == BM_VERT) - BMO_elem_flag_enable(bm, ele, HULL_FLAG_INTERIOR_ELE); + if (ele->head.htype == BM_VERT) { + BMO_vert_flag_enable(bm, (BMVert *)ele, HULL_FLAG_INPUT | HULL_FLAG_INTERIOR_ELE); + } + else if (ele->head.htype == BM_EDGE) { + BMO_edge_flag_enable(bm, (BMEdge *)ele, HULL_FLAG_INPUT); + } + else { + BMO_face_flag_enable(bm, (BMFace *)ele, HULL_FLAG_INPUT); + } } hull_pool = BLI_mempool_create(sizeof(HullTriangle), 0, 128, BLI_MEMPOOL_NOP); diff --git a/source/blender/bmesh/operators/bmo_inset.c b/source/blender/bmesh/operators/bmo_inset.c index ef5d90e6acb..c52c608e671 100644 --- a/source/blender/bmesh/operators/bmo_inset.c +++ b/source/blender/bmesh/operators/bmo_inset.c @@ -313,7 +313,7 @@ static void bmo_face_inset_individual( l_iter->next->v, l_iter->v, f, BM_CREATE_NOP); - BMO_elem_flag_enable(bm, f_new_outer, ELE_NEW); + BMO_face_flag_enable(bm, f_new_outer, ELE_NEW); /* copy loop data */ l_other = l_iter->radial_next; @@ -1037,7 +1037,7 @@ void bmo_inset_region_exec(BMesh *bm, BMOperator *op) /* no need to check doubles, we KNOW there won't be any */ /* yes - reverse face is correct in this case */ f = BM_face_create_verts(bm, varr, j, es->l->f, BM_CREATE_NOP, true); - BMO_elem_flag_enable(bm, f, ELE_NEW); + BMO_face_flag_enable(bm, f, ELE_NEW); /* copy for loop data, otherwise UV's and vcols are no good. * tiny speedup here we could be more clever and copy from known adjacent data diff --git a/source/blender/bmesh/operators/bmo_join_triangles.c b/source/blender/bmesh/operators/bmo_join_triangles.c index 3718f14276c..bc620e4a020 100644 --- a/source/blender/bmesh/operators/bmo_join_triangles.c +++ b/source/blender/bmesh/operators/bmo_join_triangles.c @@ -315,7 +315,7 @@ void bmo_join_triangles_exec(BMesh *bm, BMOperator *op) /* flag all edges of all input face */ BMO_ITER (f, &siter, op->slots_in, "faces", BM_FACE) { if (f->len == 3) { - BMO_elem_flag_enable(bm, f, FACE_INPUT); + BMO_face_flag_enable(bm, f, FACE_INPUT); } } @@ -323,11 +323,11 @@ void bmo_join_triangles_exec(BMesh *bm, BMOperator *op) BM_ITER_MESH (e, &iter, bm, BM_EDGES_OF_MESH) { BMFace *f_a, *f_b; if (BM_edge_face_pair(e, &f_a, &f_b) && - (BMO_elem_flag_test(bm, f_a, FACE_INPUT) && - BMO_elem_flag_test(bm, f_b, FACE_INPUT))) + (BMO_face_flag_test(bm, f_a, FACE_INPUT) && + BMO_face_flag_test(bm, f_b, FACE_INPUT))) { if (!bm_edge_is_delimit(e, &delimit_data)) { - BMO_elem_flag_enable(bm, e, EDGE_MARK); + BMO_edge_flag_enable(bm, e, EDGE_MARK); totedge_tag++; } } @@ -345,7 +345,7 @@ void bmo_join_triangles_exec(BMesh *bm, BMOperator *op) const BMVert *verts[4]; float error; - if (!BMO_elem_flag_test(bm, e, EDGE_MARK)) + if (!BMO_edge_flag_test(bm, e, EDGE_MARK)) continue; bm_edge_to_quad_verts(e, verts); @@ -372,7 +372,7 @@ void bmo_join_triangles_exec(BMesh *bm, BMOperator *op) BMFace *f_new; f_new = BM_faces_join_pair(bm, f_a, f_b, e, true); if (f_new) { - BMO_elem_flag_enable(bm, f_new, FACE_OUT); + BMO_face_flag_enable(bm, f_new, FACE_OUT); } } } diff --git a/source/blender/bmesh/operators/bmo_normals.c b/source/blender/bmesh/operators/bmo_normals.c index 6044960265b..f0738303d5c 100644 --- a/source/blender/bmesh/operators/bmo_normals.c +++ b/source/blender/bmesh/operators/bmo_normals.c @@ -111,7 +111,7 @@ static int recalc_face_normals_find_index(BMesh *bm, BMFace **faces, const int f madd_v3_v3fl(cent, f_cent, cent_fac * f_area); cent_area_accum += f_area; - BLI_assert(BMO_elem_flag_test(bm, faces[i], FACE_TEMP) == 0); + BLI_assert(BMO_face_flag_test(bm, faces[i], FACE_TEMP) == 0); BLI_assert(BM_face_is_normal_valid(faces[i])); } @@ -209,7 +209,7 @@ static void bmo_recalc_face_normals_array(BMesh *bm, BMFace **faces, const int f f_start_index = recalc_face_normals_find_index(bm, faces, faces_len, &is_flip); if (is_flip) { - BMO_elem_flag_enable(bm, faces[f_start_index], FACE_FLIP); + BMO_face_flag_enable(bm, faces[f_start_index], FACE_FLIP); } /* now that we've found our starting face, make all connected faces @@ -219,10 +219,10 @@ static void bmo_recalc_face_normals_array(BMesh *bm, BMFace **faces, const int f BLI_LINKSTACK_INIT(fstack); BLI_LINKSTACK_PUSH(fstack, faces[f_start_index]); - BMO_elem_flag_enable(bm, faces[f_start_index], FACE_TEMP); + BMO_face_flag_enable(bm, faces[f_start_index], FACE_TEMP); while ((f = BLI_LINKSTACK_POP(fstack))) { - const bool flip_state = BMO_elem_flag_test_bool(bm, f, FACE_FLIP); + const bool flip_state = BMO_face_flag_test_bool(bm, f, FACE_FLIP); BMLoop *l_iter, *l_first; l_iter = l_first = BM_FACE_FIRST_LOOP(f); @@ -230,9 +230,9 @@ static void bmo_recalc_face_normals_array(BMesh *bm, BMFace **faces, const int f BMLoop *l_other = l_iter->radial_next; if ((l_other != l_iter) && bmo_recalc_normal_loop_filter_cb(l_iter, NULL)) { - if (!BMO_elem_flag_test(bm, l_other->f, FACE_TEMP)) { - BMO_elem_flag_enable(bm, l_other->f, FACE_TEMP); - BMO_elem_flag_set(bm, l_other->f, FACE_FLIP, (l_other->v == l_iter->v) != flip_state); + if (!BMO_face_flag_test(bm, l_other->f, FACE_TEMP)) { + BMO_face_flag_enable(bm, l_other->f, FACE_TEMP); + BMO_face_flag_set(bm, l_other->f, FACE_FLIP, (l_other->v == l_iter->v) != flip_state); BLI_LINKSTACK_PUSH(fstack, l_other->f); } } @@ -243,10 +243,10 @@ static void bmo_recalc_face_normals_array(BMesh *bm, BMFace **faces, const int f /* apply flipping to oflag'd faces */ for (i = 0; i < faces_len; i++) { - if (BMO_elem_flag_test(bm, faces[i], oflag_flip) == oflag_flip) { + if (BMO_face_flag_test(bm, faces[i], oflag_flip) == oflag_flip) { BM_face_normal_flip(bm, faces[i]); } - BMO_elem_flag_disable(bm, faces[i], FACE_TEMP); + BMO_face_flag_disable(bm, faces[i], FACE_TEMP); } } @@ -284,7 +284,7 @@ void bmo_recalc_face_normals_exec(BMesh *bm, BMOperator *op) faces_grp[j] = BM_face_at_index(bm, groups_array[fg_sta + j]); if (is_calc == false) { - is_calc = BMO_elem_flag_test_bool(bm, faces_grp[j], FACE_FLAG); + is_calc = BMO_face_flag_test_bool(bm, faces_grp[j], FACE_FLAG); } } diff --git a/source/blender/bmesh/operators/bmo_offset_edgeloops.c b/source/blender/bmesh/operators/bmo_offset_edgeloops.c index 8f4bc5ef3ad..7a6f779b34f 100644 --- a/source/blender/bmesh/operators/bmo_offset_edgeloops.c +++ b/source/blender/bmesh/operators/bmo_offset_edgeloops.c @@ -178,7 +178,7 @@ void bmo_offset_edgeloops_exec(BMesh *bm, BMOperator *op) #ifdef USE_CAP_OPTION if (v_edges_num_untag == 1) { - BMO_elem_flag_enable(bm, v, ELE_VERT_ENDPOINT); + BMO_vert_flag_enable(bm, v, ELE_VERT_ENDPOINT); } CLAMP_MIN(v_edges_max, v_edges_num); @@ -201,7 +201,7 @@ void bmo_offset_edgeloops_exec(BMesh *bm, BMOperator *op) (BM_elem_index_get(l->prev->v) == -1)) { #ifdef USE_CAP_OPTION - if (use_cap_endpoint || (BMO_elem_flag_test(bm, v, ELE_VERT_ENDPOINT) == 0)) + if (use_cap_endpoint || (BMO_vert_flag_test(bm, v, ELE_VERT_ENDPOINT) == 0)) #endif { BMLoop *l_new; @@ -209,7 +209,7 @@ void bmo_offset_edgeloops_exec(BMesh *bm, BMOperator *op) BLI_assert(f_cmp == l->f); BLI_assert(f_cmp != l_new->f); UNUSED_VARS_NDEBUG(f_cmp); - BMO_elem_flag_enable(bm, l_new->e, ELE_NEW); + BMO_edge_flag_enable(bm, l_new->e, ELE_NEW); } } else if (l->f->len > 4) { @@ -222,7 +222,7 @@ void bmo_offset_edgeloops_exec(BMesh *bm, BMOperator *op) BM_face_split(bm, l->f, l->prev->prev, l->next, &l_new, NULL, true); BLI_assert(f_cmp == l->f); BLI_assert(f_cmp != l_new->f); - BMO_elem_flag_enable(bm, l_new->e, ELE_NEW); + BMO_edge_flag_enable(bm, l_new->e, ELE_NEW); BM_elem_flag_disable(l->f, BM_ELEM_TAG); } else { @@ -230,7 +230,7 @@ void bmo_offset_edgeloops_exec(BMesh *bm, BMOperator *op) BMLoop *l_new; bm_face_split_walk_back(bm, l, &l_new); do { - BMO_elem_flag_enable(bm, l_new->e, ELE_NEW); + BMO_edge_flag_enable(bm, l_new->e, ELE_NEW); l_new = l_new->next; } while (BM_vert_is_edge_pair(l_new->v)); BM_elem_flag_disable(l->f, BM_ELEM_TAG); diff --git a/source/blender/bmesh/operators/bmo_planar_faces.c b/source/blender/bmesh/operators/bmo_planar_faces.c index 2856d3d18a6..a0951455fb4 100644 --- a/source/blender/bmesh/operators/bmo_planar_faces.c +++ b/source/blender/bmesh/operators/bmo_planar_faces.c @@ -71,13 +71,13 @@ void bmo_planar_faces_exec(BMesh *bm, BMOperator *op) l_iter = l_first = BM_FACE_FIRST_LOOP(f); do { - if (!BMO_elem_flag_test(bm, l_iter->v, ELE_VERT_ADJUST)) { - BMO_elem_flag_enable(bm, l_iter->v, ELE_VERT_ADJUST); + if (!BMO_vert_flag_test(bm, l_iter->v, ELE_VERT_ADJUST)) { + BMO_vert_flag_enable(bm, l_iter->v, ELE_VERT_ADJUST); shared_vert_num += 1; } } while ((l_iter = l_iter->next) != l_first); - BMO_elem_flag_enable(bm, f, ELE_FACE_ADJUST); + BMO_face_flag_enable(bm, f, ELE_FACE_ADJUST); } vert_accum_pool = BLI_mempool_create(sizeof(struct VertAccum), 0, 512, BLI_MEMPOOL_NOP); @@ -91,10 +91,10 @@ void bmo_planar_faces_exec(BMesh *bm, BMOperator *op) BMLoop *l_iter, *l_first; float plane[4]; - if (!BMO_elem_flag_test(bm, f, ELE_FACE_ADJUST)) { + if (!BMO_face_flag_test(bm, f, ELE_FACE_ADJUST)) { continue; } - BMO_elem_flag_disable(bm, f, ELE_FACE_ADJUST); + BMO_face_flag_disable(bm, f, ELE_FACE_ADJUST); BLI_assert(f->len != 3); @@ -130,7 +130,7 @@ void bmo_planar_faces_exec(BMesh *bm, BMOperator *op) BMIter iter; if (len_squared_v3v3(v->co, va->co) > eps_sq) { - BMO_elem_flag_enable(bm, v, ELE_VERT_ADJUST); + BMO_vert_flag_enable(bm, v, ELE_VERT_ADJUST); interp_v3_v3v3(v->co, v->co, va->co, fac); changed = true; } @@ -138,7 +138,7 @@ void bmo_planar_faces_exec(BMesh *bm, BMOperator *op) /* tag for re-calculation */ BM_ITER_ELEM (f, &iter, v, BM_FACES_OF_VERT) { if (f->len != 3) { - BMO_elem_flag_enable(bm, f, ELE_FACE_ADJUST); + BMO_face_flag_enable(bm, f, ELE_FACE_ADJUST); } } } diff --git a/source/blender/bmesh/operators/bmo_poke.c b/source/blender/bmesh/operators/bmo_poke.c index 4d86d6e8e5b..32ad25b7b82 100644 --- a/source/blender/bmesh/operators/bmo_poke.c +++ b/source/blender/bmesh/operators/bmo_poke.c @@ -87,7 +87,7 @@ void bmo_poke_exec(BMesh *bm, BMOperator *op) bm_face_calc_center_fn(f, f_center); v_center = BM_vert_create(bm, f_center, NULL, BM_CREATE_NOP); - BMO_elem_flag_enable(bm, v_center, ELE_NEW); + BMO_vert_flag_enable(bm, v_center, ELE_NEW); if (cd_loop_mdisp_offset != -1) { if (center_mode == BMOP_POKE_MEAN) { @@ -128,7 +128,7 @@ void bmo_poke_exec(BMesh *bm, BMOperator *op) BM_elem_attrs_copy(bm, bm, l_iter, l_new); BM_elem_attrs_copy(bm, bm, l_iter->next, l_new->next); - BMO_elem_flag_enable(bm, f_new, ELE_NEW); + BMO_face_flag_enable(bm, f_new, ELE_NEW); if (cd_loop_mdisp_offset != -1) { float f_new_center[3]; diff --git a/source/blender/bmesh/operators/bmo_primitive.c b/source/blender/bmesh/operators/bmo_primitive.c index b120b48447f..d2b9fa9efa3 100644 --- a/source/blender/bmesh/operators/bmo_primitive.c +++ b/source/blender/bmesh/operators/bmo_primitive.c @@ -259,7 +259,7 @@ void bmo_create_grid_exec(BMesh *bm, BMOperator *op) vec[0] = ((x * xtot_inv2) - 1.0f) * dia; mul_v3_m4v3(tvec, mat, vec); varr[i] = BM_vert_create(bm, tvec, NULL, BM_CREATE_NOP); - BMO_elem_flag_enable(bm, varr[i], VERT_MARK); + BMO_vert_flag_enable(bm, varr[i], VERT_MARK); i++; } } @@ -277,7 +277,7 @@ void bmo_create_grid_exec(BMesh *bm, BMOperator *op) f = BM_face_create_verts(bm, vquad, 4, NULL, BM_CREATE_NOP, true); if (calc_uvs) { - BMO_elem_flag_enable(bm, f, FACE_MARK); + BMO_face_flag_enable(bm, f, FACE_MARK); } } } @@ -315,7 +315,7 @@ void BM_mesh_calc_uvs_grid(BMesh *bm, const unsigned int x_segments, const unsig BLI_assert(cd_loop_uv_offset != -1); BM_ITER_MESH (f, &iter, bm, BM_FACES_OF_MESH) { - if (!BMO_elem_flag_test(bm, f, oflag)) + if (!BMO_face_flag_test(bm, f, oflag)) continue; BM_ITER_ELEM_INDEX (l, &liter, f, BM_LOOPS_OF_FACE, loop_index) { @@ -380,11 +380,11 @@ void bmo_create_uvsphere_exec(BMesh *bm, BMOperator *op) vec[1] = dia * sinf(phi); vec[2] = dia * cosf(phi); eve = BM_vert_create(bm, vec, NULL, BM_CREATE_NOP); - BMO_elem_flag_enable(bm, eve, VERT_MARK); + BMO_vert_flag_enable(bm, eve, VERT_MARK); if (a != 0) { e = BM_edge_create(bm, preveve, eve, NULL, BM_CREATE_NOP); - BMO_elem_flag_enable(bm, e, EDGE_ORIG); + BMO_edge_flag_enable(bm, e, EDGE_ORIG); } phi += phid; @@ -442,14 +442,14 @@ void bmo_create_uvsphere_exec(BMesh *bm, BMOperator *op) bool valid = true; BM_ITER_ELEM (l, &liter, f, BM_LOOPS_OF_FACE) { - if (!BMO_elem_flag_test(bm, l->v, VERT_MARK)) { + if (!BMO_vert_flag_test(bm, l->v, VERT_MARK)) { valid = false; break; } } if (valid) { - BMO_elem_flag_enable(bm, f, FACE_MARK); + BMO_face_flag_enable(bm, f, FACE_MARK); } } @@ -458,7 +458,7 @@ void bmo_create_uvsphere_exec(BMesh *bm, BMOperator *op) /* and now do imat */ BM_ITER_MESH (eve, &iter, bm, BM_VERTS_OF_MESH) { - if (BMO_elem_flag_test(bm, eve, VERT_MARK)) { + if (BMO_vert_flag_test(bm, eve, VERT_MARK)) { mul_m4_v3(mat, eve->co); } } @@ -493,7 +493,7 @@ void bmo_create_icosphere_exec(BMesh *bm, BMOperator *op) vec[2] = dia_div * icovert[a][2]; eva[a] = BM_vert_create(bm, vec, NULL, BM_CREATE_NOP); - BMO_elem_flag_enable(bm, eva[a], VERT_MARK); + BMO_vert_flag_enable(bm, eva[a], VERT_MARK); } for (a = 0; a < 20; a++) { @@ -507,10 +507,10 @@ void bmo_create_icosphere_exec(BMesh *bm, BMOperator *op) eftemp = BM_face_create_quad_tri(bm, v1, v2, v3, NULL, NULL, BM_CREATE_NOP); BM_ITER_ELEM (l, &liter, eftemp, BM_LOOPS_OF_FACE) { - BMO_elem_flag_enable(bm, l->e, EDGE_MARK); + BMO_edge_flag_enable(bm, l->e, EDGE_MARK); } - BMO_elem_flag_enable(bm, eftemp, FACE_MARK); + BMO_face_flag_enable(bm, eftemp, FACE_MARK); } if (subdiv > 1) { @@ -540,14 +540,14 @@ void bmo_create_icosphere_exec(BMesh *bm, BMOperator *op) bool valid = true; BM_ITER_ELEM (l, &liter, f, BM_LOOPS_OF_FACE) { - if (!BMO_elem_flag_test(bm, l->v, VERT_MARK)) { + if (!BMO_vert_flag_test(bm, l->v, VERT_MARK)) { valid = false; break; } } if (valid) { - BMO_elem_flag_enable(bm, f, FACE_MARK); + BMO_face_flag_enable(bm, f, FACE_MARK); } } @@ -556,7 +556,7 @@ void bmo_create_icosphere_exec(BMesh *bm, BMOperator *op) /* must transform after because of sphere subdivision */ BM_ITER_MESH (v, &viter, bm, BM_VERTS_OF_MESH) { - if (BMO_elem_flag_test(bm, v, VERT_MARK)) { + if (BMO_vert_flag_test(bm, v, VERT_MARK)) { mul_m4_v3(mat, v->co); } } @@ -626,7 +626,7 @@ void BM_mesh_calc_uvs_sphere(BMesh *bm, const short oflag) BLI_assert(cd_loop_uv_offset != -1); /* caller is responsible for giving us UVs */ BM_ITER_MESH (f, &iter, bm, BM_FACES_OF_MESH) { - if (!BMO_elem_flag_test(bm, f, oflag)) + if (!BMO_face_flag_test(bm, f, oflag)) continue; bm_mesh_calc_uvs_sphere_face(f, mat_rot, cd_loop_uv_offset); @@ -650,7 +650,7 @@ void bmo_create_monkey_exec(BMesh *bm, BMOperator *op) v[1] = monkeyv[i][2] / -128.0; tv[i] = BM_vert_create(bm, v, NULL, BM_CREATE_NOP); - BMO_elem_flag_enable(bm, tv[i], VERT_MARK); + BMO_vert_flag_enable(bm, tv[i], VERT_MARK); if (fabsf(v[0] = -v[0]) < 0.001f) { tv[monkeynv + i] = tv[i]; @@ -661,7 +661,7 @@ void bmo_create_monkey_exec(BMesh *bm, BMOperator *op) tv[monkeynv + i] = eve; } - BMO_elem_flag_enable(bm, tv[monkeynv + i], VERT_MARK); + BMO_vert_flag_enable(bm, tv[monkeynv + i], VERT_MARK); mul_m4_v3(mat, tv[i]->co); } @@ -713,7 +713,7 @@ void bmo_create_circle_exec(BMesh *bm, BMOperator *op) mul_m4_v3(mat, vec); cent1 = BM_vert_create(bm, vec, NULL, BM_CREATE_NOP); - BMO_elem_flag_enable(bm, cent1, VERT_MARK); + BMO_vert_flag_enable(bm, cent1, VERT_MARK); } for (a = 0; a < segs; a++, phi += phid) { @@ -724,7 +724,7 @@ void bmo_create_circle_exec(BMesh *bm, BMOperator *op) mul_m4_v3(mat, vec); v1 = BM_vert_create(bm, vec, NULL, BM_CREATE_NOP); - BMO_elem_flag_enable(bm, v1, VERT_MARK); + BMO_vert_flag_enable(bm, v1, VERT_MARK); if (lastv1) BM_edge_create(bm, v1, lastv1, NULL, BM_CREATE_NOP); @@ -733,7 +733,7 @@ void bmo_create_circle_exec(BMesh *bm, BMOperator *op) BMFace *f; f = BM_face_create_quad_tri(bm, cent1, lastv1, v1, NULL, NULL, BM_CREATE_NOP); - BMO_elem_flag_enable(bm, f, FACE_NEW); + BMO_face_flag_enable(bm, f, FACE_NEW); } if (!firstv1) @@ -751,7 +751,7 @@ void bmo_create_circle_exec(BMesh *bm, BMOperator *op) BMFace *f; f = BM_face_create_quad_tri(bm, cent1, v1, firstv1, NULL, NULL, BM_CREATE_NOP); - BMO_elem_flag_enable(bm, f, FACE_NEW); + BMO_face_flag_enable(bm, f, FACE_NEW); if (calc_uvs) { BM_mesh_calc_uvs_circle(bm, mat, dia, FACE_NEW); @@ -791,7 +791,7 @@ void BM_mesh_calc_uvs_circle(BMesh *bm, float mat[4][4], const float radius, con invert_m4_m4(inv_mat, mat); BM_ITER_MESH (f, &fiter, bm, BM_FACES_OF_MESH) { - if (!BMO_elem_flag_test(bm, f, oflag)) + if (!BMO_face_flag_test(bm, f, oflag)) continue; BM_ITER_ELEM (l, &liter, f, BM_LOOPS_OF_FACE) { @@ -845,8 +845,8 @@ void bmo_create_cone_exec(BMesh *bm, BMOperator *op) cent2 = BM_vert_create(bm, vec, NULL, BM_CREATE_NOP); - BMO_elem_flag_enable(bm, cent1, VERT_MARK); - BMO_elem_flag_enable(bm, cent2, VERT_MARK); + BMO_vert_flag_enable(bm, cent1, VERT_MARK); + BMO_vert_flag_enable(bm, cent2, VERT_MARK); } for (a = 0; a < segs; a++, phi += phid) { @@ -862,27 +862,27 @@ void bmo_create_cone_exec(BMesh *bm, BMOperator *op) mul_m4_v3(mat, vec); v2 = BM_vert_create(bm, vec, NULL, BM_CREATE_NOP); - BMO_elem_flag_enable(bm, v1, VERT_MARK); - BMO_elem_flag_enable(bm, v2, VERT_MARK); + BMO_vert_flag_enable(bm, v1, VERT_MARK); + BMO_vert_flag_enable(bm, v2, VERT_MARK); if (a) { if (cap_ends) { f = BM_face_create_quad_tri(bm, cent1, lastv1, v1, NULL, NULL, BM_CREATE_NOP); if (calc_uvs) { - BMO_elem_flag_enable(bm, f, FACE_MARK); + BMO_face_flag_enable(bm, f, FACE_MARK); } - BMO_elem_flag_enable(bm, f, FACE_NEW); + BMO_face_flag_enable(bm, f, FACE_NEW); f = BM_face_create_quad_tri(bm, cent2, v2, lastv2, NULL, NULL, BM_CREATE_NOP); if (calc_uvs) { - BMO_elem_flag_enable(bm, f, FACE_MARK); + BMO_face_flag_enable(bm, f, FACE_MARK); } - BMO_elem_flag_enable(bm, f, FACE_NEW); + BMO_face_flag_enable(bm, f, FACE_NEW); } f = BM_face_create_quad_tri(bm, lastv1, lastv2, v2, v1, NULL, BM_CREATE_NOP); if (calc_uvs) { - BMO_elem_flag_enable(bm, f, FACE_MARK); + BMO_face_flag_enable(bm, f, FACE_MARK); } } else { @@ -900,20 +900,20 @@ void bmo_create_cone_exec(BMesh *bm, BMOperator *op) if (cap_ends) { f = BM_face_create_quad_tri(bm, cent1, v1, firstv1, NULL, NULL, BM_CREATE_NOP); if (calc_uvs) { - BMO_elem_flag_enable(bm, f, FACE_MARK); + BMO_face_flag_enable(bm, f, FACE_MARK); } - BMO_elem_flag_enable(bm, f, FACE_NEW); + BMO_face_flag_enable(bm, f, FACE_NEW); f = BM_face_create_quad_tri(bm, cent2, firstv2, v2, NULL, NULL, BM_CREATE_NOP); if (calc_uvs) { - BMO_elem_flag_enable(bm, f, FACE_MARK); + BMO_face_flag_enable(bm, f, FACE_MARK); } - BMO_elem_flag_enable(bm, f, FACE_NEW); + BMO_face_flag_enable(bm, f, FACE_NEW); } f = BM_face_create_quad_tri(bm, v1, v2, firstv2, firstv1, NULL, BM_CREATE_NOP); if (calc_uvs) { - BMO_elem_flag_enable(bm, f, FACE_MARK); + BMO_face_flag_enable(bm, f, FACE_MARK); } if (calc_uvs) { @@ -981,7 +981,7 @@ void BM_mesh_calc_uvs_cone( y = 1.0f - uv_height; BM_ITER_MESH (f, &fiter, bm, BM_FACES_OF_MESH) { - if (!BMO_elem_flag_test(bm, f, oflag)) + if (!BMO_face_flag_test(bm, f, oflag)) continue; if (f->len == 4 && radius_top && radius_bottom) { @@ -1063,7 +1063,7 @@ void bmo_create_cube_exec(BMesh *bm, BMOperator *op) float vec[3] = {(float)x * off, (float)y * off, (float)z * off}; mul_m4_v3(mat, vec); verts[i] = BM_vert_create(bm, vec, NULL, BM_CREATE_NOP); - BMO_elem_flag_enable(bm, verts[i], VERT_MARK); + BMO_vert_flag_enable(bm, verts[i], VERT_MARK); i++; } } @@ -1080,7 +1080,7 @@ void bmo_create_cube_exec(BMesh *bm, BMOperator *op) f = BM_face_create_verts(bm, quad, 4, NULL, BM_CREATE_NOP, true); if (calc_uvs) { - BMO_elem_flag_enable(bm, f, FACE_MARK); + BMO_face_flag_enable(bm, f, FACE_MARK); } } @@ -1117,7 +1117,7 @@ void BM_mesh_calc_uvs_cube(BMesh *bm, const short oflag) BLI_assert(cd_loop_uv_offset != -1); /* the caller can ensure that we have UVs */ BM_ITER_MESH (f, &fiter, bm, BM_FACES_OF_MESH) { - if (!BMO_elem_flag_test(bm, f, oflag)) { + if (!BMO_face_flag_test(bm, f, oflag)) { continue; } diff --git a/source/blender/bmesh/operators/bmo_removedoubles.c b/source/blender/bmesh/operators/bmo_removedoubles.c index c58b4814726..6da591b23a0 100644 --- a/source/blender/bmesh/operators/bmo_removedoubles.c +++ b/source/blender/bmesh/operators/bmo_removedoubles.c @@ -98,7 +98,7 @@ static BMFace *remdoubles_createface(BMesh *bm, BMFace *f, BMOpSlot *slot_target { #define LOOP_MAP_VERT_INIT(l_init, v_map, is_del) \ v_map = l_init->v; \ - is_del = BMO_elem_flag_test_bool(bm, v_map, ELE_DEL); \ + is_del = BMO_vert_flag_test_bool(bm, v_map, ELE_DEL); \ if (is_del) { \ v_map = BMO_slot_map_elem_get(slot_targetmap, v_map); \ } ((void)0) @@ -131,12 +131,12 @@ static BMFace *remdoubles_createface(BMesh *bm, BMFace *f, BMOpSlot *slot_target } if (e_new) { - if (UNLIKELY(BMO_elem_flag_test(bm, v_curr, VERT_IN_FACE))) { + if (UNLIKELY(BMO_vert_flag_test(bm, v_curr, VERT_IN_FACE))) { /* we can't make the face, bail out */ STACK_CLEAR(edges); goto finally; } - BMO_elem_flag_enable(bm, v_curr, VERT_IN_FACE); + BMO_vert_flag_enable(bm, v_curr, VERT_IN_FACE); STACK_PUSH(edges, e_new); STACK_PUSH(loops, l_curr); @@ -155,7 +155,7 @@ finally: { unsigned int i; for (i = 0; i < STACK_SIZE(verts); i++) { - BMO_elem_flag_disable(bm, verts[i], VERT_IN_FACE); + BMO_vert_flag_disable(bm, verts[i], VERT_IN_FACE); } } @@ -198,7 +198,7 @@ void bmo_weld_verts_exec(BMesh *bm, BMOperator *op) /* mark merge verts for deletion */ BM_ITER_MESH (v1, &iter, bm, BM_VERTS_OF_MESH) { if ((v2 = BMO_slot_map_elem_get(slot_targetmap, v1))) { - BMO_elem_flag_enable(bm, v1, ELE_DEL); + BMO_vert_flag_enable(bm, v1, ELE_DEL); /* merge the vertex flags, else we get randomly selected/unselected verts */ BM_elem_flag_merge(v1, v2); @@ -212,8 +212,8 @@ void bmo_weld_verts_exec(BMesh *bm, BMOperator *op) } BM_ITER_MESH (e, &iter, bm, BM_EDGES_OF_MESH) { - const bool is_del_v1 = BMO_elem_flag_test_bool(bm, (v1 = e->v1), ELE_DEL); - const bool is_del_v2 = BMO_elem_flag_test_bool(bm, (v2 = e->v2), ELE_DEL); + const bool is_del_v1 = BMO_vert_flag_test_bool(bm, (v1 = e->v1), ELE_DEL); + const bool is_del_v2 = BMO_vert_flag_test_bool(bm, (v2 = e->v2), ELE_DEL); if (is_del_v1 || is_del_v2) { if (is_del_v1) @@ -222,7 +222,7 @@ void bmo_weld_verts_exec(BMesh *bm, BMOperator *op) v2 = BMO_slot_map_elem_get(slot_targetmap, v2); if (v1 == v2) { - BMO_elem_flag_enable(bm, e, EDGE_COL); + BMO_edge_flag_enable(bm, e, EDGE_COL); } else { /* always merge flags, even for edges we already created */ @@ -233,7 +233,7 @@ void bmo_weld_verts_exec(BMesh *bm, BMOperator *op) BM_elem_flag_merge(e_new, e); } - BMO_elem_flag_enable(bm, e, ELE_DEL); + BMO_edge_flag_enable(bm, e, ELE_DEL); } } @@ -244,16 +244,16 @@ void bmo_weld_verts_exec(BMesh *bm, BMOperator *op) int edge_collapse = 0; BM_ITER_ELEM (l, &liter, f, BM_LOOPS_OF_FACE) { - if (BMO_elem_flag_test(bm, l->v, ELE_DEL)) { + if (BMO_vert_flag_test(bm, l->v, ELE_DEL)) { vert_delete = true; } - if (BMO_elem_flag_test(bm, l->e, EDGE_COL)) { + if (BMO_edge_flag_test(bm, l->e, EDGE_COL)) { edge_collapse++; } } if (vert_delete) { - BMO_elem_flag_enable(bm, f, ELE_DEL); + BMO_face_flag_enable(bm, f, ELE_DEL); if (f->len - edge_collapse >= 3) { BMFace *f_new = remdoubles_createface(bm, f, slot_targetmap); @@ -261,8 +261,12 @@ void bmo_weld_verts_exec(BMesh *bm, BMOperator *op) /* do this so we don't need to return a list of created faces */ if (f_new) { bmesh_face_swap_data(f_new, f); - SWAP(BMFlagLayer *, f->oflags, f_new->oflags); - BMO_elem_flag_disable(bm, f, ELE_DEL); + + if (bm->use_toolflags) { + SWAP(BMFlagLayer *, ((BMFace_OFlag *)f)->oflags, ((BMFace_OFlag *)f_new)->oflags); + } + + BMO_face_flag_disable(bm, f, ELE_DEL); BM_face_kill(bm, f_new); } @@ -439,7 +443,7 @@ void bmo_collapse_exec(BMesh *bm, BMOperator *op) float min[3], max[3], center[3]; BMVert *v_tar; - if (!BMO_elem_flag_test(bm, e, EDGE_MARK)) + if (!BMO_edge_flag_test(bm, e, EDGE_MARK)) continue; BLI_assert(BLI_stack_is_empty(edge_stack)); @@ -510,7 +514,7 @@ static void bmo_collapsecon_do_layer(BMesh *bm, const int layer, const short ofl BM_ITER_MESH (f, &iter, bm, BM_FACES_OF_MESH) { BM_ITER_ELEM (l, &liter, f, BM_LOOPS_OF_FACE) { - if (BMO_elem_flag_test(bm, l->e, oflag)) { + if (BMO_edge_flag_test(bm, l->e, oflag)) { /* walk */ BLI_assert(BLI_stack_is_empty(block_stack)); @@ -606,7 +610,7 @@ static void bmesh_find_doubles_common( for (i = 0; i < verts_len; i++) { BMVert *v_check = verts[i]; - if (BMO_elem_flag_test(bm, v_check, VERT_DOUBLE | VERT_TARGET)) { + if (BMO_vert_flag_test(bm, v_check, VERT_DOUBLE | VERT_TARGET)) { continue; } @@ -614,7 +618,7 @@ static void bmesh_find_doubles_common( BMVert *v_other = verts[j]; /* a match has already been found, (we could check which is best, for now don't) */ - if (BMO_elem_flag_test(bm, v_other, VERT_DOUBLE | VERT_TARGET)) { + if (BMO_vert_flag_test(bm, v_other, VERT_DOUBLE | VERT_TARGET)) { continue; } @@ -628,19 +632,19 @@ static void bmesh_find_doubles_common( } if (keepvert) { - if (BMO_elem_flag_test(bm, v_other, VERT_KEEP) == BMO_elem_flag_test(bm, v_check, VERT_KEEP)) + if (BMO_vert_flag_test(bm, v_other, VERT_KEEP) == BMO_vert_flag_test(bm, v_check, VERT_KEEP)) continue; } if (compare_len_squared_v3v3(v_check->co, v_other->co, dist_sq)) { /* If one vert is marked as keep, make sure it will be the target */ - if (BMO_elem_flag_test(bm, v_other, VERT_KEEP)) { + if (BMO_vert_flag_test(bm, v_other, VERT_KEEP)) { SWAP(BMVert *, v_check, v_other); } - BMO_elem_flag_enable(bm, v_other, VERT_DOUBLE); - BMO_elem_flag_enable(bm, v_check, VERT_TARGET); + BMO_vert_flag_enable(bm, v_other, VERT_DOUBLE); + BMO_vert_flag_enable(bm, v_check, VERT_TARGET); BMO_slot_map_elem_insert(optarget, optarget_slot, v_other, v_check); } @@ -683,8 +687,8 @@ void bmo_automerge_exec(BMesh *bm, BMOperator *op) * as VERT_KEEP. */ BMO_slot_buffer_flag_enable(bm, op->slots_in, "verts", BM_VERT, VERT_IN); BM_ITER_MESH (v, &viter, bm, BM_VERTS_OF_MESH) { - if (!BMO_elem_flag_test(bm, v, VERT_IN)) { - BMO_elem_flag_enable(bm, v, VERT_KEEP); + if (!BMO_vert_flag_test(bm, v, VERT_IN)) { + BMO_vert_flag_enable(bm, v, VERT_KEEP); } } diff --git a/source/blender/bmesh/operators/bmo_similar.c b/source/blender/bmesh/operators/bmo_similar.c index 708d57a7a08..454d6d8c6c8 100644 --- a/source/blender/bmesh/operators/bmo_similar.c +++ b/source/blender/bmesh/operators/bmo_similar.c @@ -121,8 +121,8 @@ void bmo_similar_faces_exec(BMesh *bm, BMOperator *op) * and n is the total number of faces */ BMO_ITER (fs, &fs_iter, op->slots_in, "faces", BM_FACE) { - if (!BMO_elem_flag_test(bm, fs, FACE_MARK)) { /* is this really needed ? */ - BMO_elem_flag_enable(bm, fs, FACE_MARK); + if (!BMO_face_flag_test(bm, fs, FACE_MARK)) { /* is this really needed ? */ + BMO_face_flag_enable(bm, fs, FACE_MARK); num_sels++; } } @@ -134,7 +134,7 @@ void bmo_similar_faces_exec(BMesh *bm, BMOperator *op) /* loop through all the faces and fill the faces/indices structure */ BM_ITER_MESH (fm, &fm_iter, bm, BM_FACES_OF_MESH) { f_ext[i].f = fm; - if (BMO_elem_flag_test(bm, fm, FACE_MARK)) { + if (BMO_face_flag_test(bm, fm, FACE_MARK)) { indices[idx] = i; idx++; } @@ -179,21 +179,21 @@ void bmo_similar_faces_exec(BMesh *bm, BMOperator *op) /* now select the rest (if any) */ for (i = 0; i < num_total; i++) { fm = f_ext[i].f; - if (!BMO_elem_flag_test(bm, fm, FACE_MARK) && !BM_elem_flag_test(fm, BM_ELEM_HIDDEN)) { + if (!BMO_face_flag_test(bm, fm, FACE_MARK) && !BM_elem_flag_test(fm, BM_ELEM_HIDDEN)) { bool cont = true; for (idx = 0; idx < num_sels && cont == true; idx++) { fs = f_ext[indices[idx]].f; switch (type) { case SIMFACE_MATERIAL: if (fm->mat_nr == fs->mat_nr) { - BMO_elem_flag_enable(bm, fm, FACE_MARK); + BMO_face_flag_enable(bm, fm, FACE_MARK); cont = false; } break; case SIMFACE_IMAGE: if (f_ext[i].t == f_ext[indices[idx]].t) { - BMO_elem_flag_enable(bm, fm, FACE_MARK); + BMO_face_flag_enable(bm, fm, FACE_MARK); cont = false; } break; @@ -201,7 +201,7 @@ void bmo_similar_faces_exec(BMesh *bm, BMOperator *op) case SIMFACE_NORMAL: angle = angle_normalized_v3v3(fs->no, fm->no); /* if the angle between the normals -> 0 */ if (angle <= thresh_radians) { - BMO_elem_flag_enable(bm, fm, FACE_MARK); + BMO_face_flag_enable(bm, fm, FACE_MARK); cont = false; } break; @@ -218,7 +218,7 @@ void bmo_similar_faces_exec(BMesh *bm, BMOperator *op) if (angle <= thresh_radians) { /* and dot product difference -> 0 */ delta_fl = f_ext[i].d - (f_ext[indices[idx]].d * sign); if (bm_sel_similar_cmp_fl(delta_fl, thresh, compare)) { - BMO_elem_flag_enable(bm, fm, FACE_MARK); + BMO_face_flag_enable(bm, fm, FACE_MARK); cont = false; } } @@ -227,7 +227,7 @@ void bmo_similar_faces_exec(BMesh *bm, BMOperator *op) case SIMFACE_AREA: delta_fl = f_ext[i].area - f_ext[indices[idx]].area; if (bm_sel_similar_cmp_fl(delta_fl, thresh, compare)) { - BMO_elem_flag_enable(bm, fm, FACE_MARK); + BMO_face_flag_enable(bm, fm, FACE_MARK); cont = false; } break; @@ -235,7 +235,7 @@ void bmo_similar_faces_exec(BMesh *bm, BMOperator *op) case SIMFACE_SIDES: delta_i = fm->len - fs->len; if (bm_sel_similar_cmp_i(delta_i, compare)) { - BMO_elem_flag_enable(bm, fm, FACE_MARK); + BMO_face_flag_enable(bm, fm, FACE_MARK); cont = false; } break; @@ -243,14 +243,14 @@ void bmo_similar_faces_exec(BMesh *bm, BMOperator *op) case SIMFACE_PERIMETER: delta_fl = f_ext[i].perim - f_ext[indices[idx]].perim; if (bm_sel_similar_cmp_fl(delta_fl, thresh, compare)) { - BMO_elem_flag_enable(bm, fm, FACE_MARK); + BMO_face_flag_enable(bm, fm, FACE_MARK); cont = false; } break; case SIMFACE_SMOOTH: if (BM_elem_flag_test(fm, BM_ELEM_SMOOTH) == BM_elem_flag_test(fs, BM_ELEM_SMOOTH)) { - BMO_elem_flag_enable(bm, fm, FACE_MARK); + BMO_face_flag_enable(bm, fm, FACE_MARK); cont = false; } break; @@ -263,7 +263,7 @@ void bmo_similar_faces_exec(BMesh *bm, BMOperator *op) ffa2 = CustomData_bmesh_get(&bm->pdata, fm->head.data, CD_FREESTYLE_FACE); if (ffa1 && ffa2 && (ffa1->flag & FREESTYLE_FACE_MARK) == (ffa2->flag & FREESTYLE_FACE_MARK)) { - BMO_elem_flag_enable(bm, fm, FACE_MARK); + BMO_face_flag_enable(bm, fm, FACE_MARK); cont = false; } } @@ -350,7 +350,7 @@ void bmo_similar_edges_exec(BMesh *bm, BMOperator *op) /* iterate through all selected edges and mark them */ BMO_ITER (es, &es_iter, op->slots_in, "edges", BM_EDGE) { - BMO_elem_flag_enable(bm, es, EDGE_MARK); + BMO_edge_flag_enable(bm, es, EDGE_MARK); num_sels++; } @@ -361,7 +361,7 @@ void bmo_similar_edges_exec(BMesh *bm, BMOperator *op) /* loop through all the edges and fill the edges/indices structure */ BM_ITER_MESH (e, &e_iter, bm, BM_EDGES_OF_MESH) { e_ext[i].e = e; - if (BMO_elem_flag_test(bm, e, EDGE_MARK)) { + if (BMO_edge_flag_test(bm, e, EDGE_MARK)) { indices[idx] = i; idx++; } @@ -397,7 +397,9 @@ void bmo_similar_edges_exec(BMesh *bm, BMOperator *op) /* select the edges if any */ for (i = 0; i < num_total; i++) { e = e_ext[i].e; - if (!BMO_elem_flag_test(bm, e, EDGE_MARK) && !BM_elem_flag_test(e, BM_ELEM_HIDDEN)) { + if (!BMO_edge_flag_test(bm, e, EDGE_MARK) && + !BM_elem_flag_test(e, BM_ELEM_HIDDEN)) + { bool cont = true; for (idx = 0; idx < num_sels && cont == true; idx++) { es = e_ext[indices[idx]].e; @@ -405,7 +407,7 @@ void bmo_similar_edges_exec(BMesh *bm, BMOperator *op) case SIMEDGE_LENGTH: delta_fl = e_ext[i].length - e_ext[indices[idx]].length; if (bm_sel_similar_cmp_fl(delta_fl, thresh, compare)) { - BMO_elem_flag_enable(bm, e, EDGE_MARK); + BMO_edge_flag_enable(bm, e, EDGE_MARK); cont = false; } break; @@ -418,7 +420,7 @@ void bmo_similar_edges_exec(BMesh *bm, BMOperator *op) angle = fabsf(angle - (float)M_PI); if (angle / (float)M_PI_2 <= thresh) { - BMO_elem_flag_enable(bm, e, EDGE_MARK); + BMO_edge_flag_enable(bm, e, EDGE_MARK); cont = false; } break; @@ -426,7 +428,7 @@ void bmo_similar_edges_exec(BMesh *bm, BMOperator *op) case SIMEDGE_FACE: delta_i = e_ext[i].faces - e_ext[indices[idx]].faces; if (bm_sel_similar_cmp_i(delta_i, compare)) { - BMO_elem_flag_enable(bm, e, EDGE_MARK); + BMO_edge_flag_enable(bm, e, EDGE_MARK); cont = false; } break; @@ -435,7 +437,7 @@ void bmo_similar_edges_exec(BMesh *bm, BMOperator *op) if (e_ext[i].faces == 2) { if (e_ext[indices[idx]].faces == 2) { if (fabsf(e_ext[i].angle - e_ext[indices[idx]].angle) <= thresh) { - BMO_elem_flag_enable(bm, e, EDGE_MARK); + BMO_edge_flag_enable(bm, e, EDGE_MARK); cont = false; } } @@ -454,7 +456,7 @@ void bmo_similar_edges_exec(BMesh *bm, BMOperator *op) delta_fl = *c1 - *c2; if (bm_sel_similar_cmp_fl(delta_fl, thresh, compare)) { - BMO_elem_flag_enable(bm, e, EDGE_MARK); + BMO_edge_flag_enable(bm, e, EDGE_MARK); cont = false; } } @@ -469,7 +471,7 @@ void bmo_similar_edges_exec(BMesh *bm, BMOperator *op) delta_fl = *c1 - *c2; if (bm_sel_similar_cmp_fl(delta_fl, thresh, compare)) { - BMO_elem_flag_enable(bm, e, EDGE_MARK); + BMO_edge_flag_enable(bm, e, EDGE_MARK); cont = false; } } @@ -477,14 +479,14 @@ void bmo_similar_edges_exec(BMesh *bm, BMOperator *op) case SIMEDGE_SEAM: if (BM_elem_flag_test(e, BM_ELEM_SEAM) == BM_elem_flag_test(es, BM_ELEM_SEAM)) { - BMO_elem_flag_enable(bm, e, EDGE_MARK); + BMO_edge_flag_enable(bm, e, EDGE_MARK); cont = false; } break; case SIMEDGE_SHARP: if (BM_elem_flag_test(e, BM_ELEM_SMOOTH) == BM_elem_flag_test(es, BM_ELEM_SMOOTH)) { - BMO_elem_flag_enable(bm, e, EDGE_MARK); + BMO_edge_flag_enable(bm, e, EDGE_MARK); cont = false; } break; @@ -497,7 +499,7 @@ void bmo_similar_edges_exec(BMesh *bm, BMOperator *op) fed2 = CustomData_bmesh_get(&bm->edata, es->head.data, CD_FREESTYLE_EDGE); if (fed1 && fed2 && (fed1->flag & FREESTYLE_EDGE_MARK) == (fed2->flag & FREESTYLE_EDGE_MARK)) { - BMO_elem_flag_enable(bm, e, EDGE_MARK); + BMO_edge_flag_enable(bm, e, EDGE_MARK); cont = false; } } @@ -562,7 +564,7 @@ void bmo_similar_verts_exec(BMesh *bm, BMOperator *op) /* iterate through all selected edges and mark them */ BMO_ITER (vs, &vs_iter, op->slots_in, "verts", BM_VERT) { - BMO_elem_flag_enable(bm, vs, VERT_MARK); + BMO_vert_flag_enable(bm, vs, VERT_MARK); num_sels++; } @@ -573,7 +575,7 @@ void bmo_similar_verts_exec(BMesh *bm, BMOperator *op) /* loop through all the vertices and fill the vertices/indices structure */ BM_ITER_MESH (v, &v_iter, bm, BM_VERTS_OF_MESH) { v_ext[i].v = v; - if (BMO_elem_flag_test(bm, v, VERT_MARK)) { + if (BMO_vert_flag_test(bm, v, VERT_MARK)) { indices[idx] = i; idx++; } @@ -599,7 +601,9 @@ void bmo_similar_verts_exec(BMesh *bm, BMOperator *op) /* select the vertices if any */ for (i = 0; i < num_total; i++) { v = v_ext[i].v; - if (!BMO_elem_flag_test(bm, v, VERT_MARK) && !BM_elem_flag_test(v, BM_ELEM_HIDDEN)) { + if (!BMO_vert_flag_test(bm, v, VERT_MARK) && + !BM_elem_flag_test(v, BM_ELEM_HIDDEN)) + { bool cont = true; for (idx = 0; idx < num_sels && cont == true; idx++) { vs = v_ext[indices[idx]].v; @@ -607,7 +611,7 @@ void bmo_similar_verts_exec(BMesh *bm, BMOperator *op) case SIMVERT_NORMAL: /* compare the angle between the normals */ if (angle_normalized_v3v3(v->no, vs->no) <= thresh_radians) { - BMO_elem_flag_enable(bm, v, VERT_MARK); + BMO_vert_flag_enable(bm, v, VERT_MARK); cont = false; } break; @@ -615,7 +619,7 @@ void bmo_similar_verts_exec(BMesh *bm, BMOperator *op) /* number of adjacent faces */ delta_i = v_ext[i].num_faces - v_ext[indices[idx]].num_faces; if (bm_sel_similar_cmp_i(delta_i, compare)) { - BMO_elem_flag_enable(bm, v, VERT_MARK); + BMO_vert_flag_enable(bm, v, VERT_MARK); cont = false; } break; @@ -623,7 +627,7 @@ void bmo_similar_verts_exec(BMesh *bm, BMOperator *op) case SIMVERT_VGROUP: if (v_ext[i].dvert != NULL && v_ext[indices[idx]].dvert != NULL) { if (defvert_find_shared(v_ext[i].dvert, v_ext[indices[idx]].dvert) != -1) { - BMO_elem_flag_enable(bm, v, VERT_MARK); + BMO_vert_flag_enable(bm, v, VERT_MARK); cont = false; } } @@ -632,7 +636,7 @@ void bmo_similar_verts_exec(BMesh *bm, BMOperator *op) /* number of adjacent edges */ delta_i = v_ext[i].num_edges - v_ext[indices[idx]].num_edges; if (bm_sel_similar_cmp_i(delta_i, compare)) { - BMO_elem_flag_enable(bm, v, VERT_MARK); + BMO_vert_flag_enable(bm, v, VERT_MARK); cont = false; } break; diff --git a/source/blender/bmesh/operators/bmo_subdivide.c b/source/blender/bmesh/operators/bmo_subdivide.c index 38fa2cfdcc8..8d672b32caa 100644 --- a/source/blender/bmesh/operators/bmo_subdivide.c +++ b/source/blender/bmesh/operators/bmo_subdivide.c @@ -384,7 +384,7 @@ static BMVert *bm_subdivide_edge_addvert( v_new = BM_edge_split(bm, edge, edge->v1, r_edge, factor_edge_split); - BMO_elem_flag_enable(bm, v_new, ELE_INNER); + BMO_vert_flag_enable(bm, v_new, ELE_INNER); /* offset for smooth or sphere or fractal */ alter_co(v_new, e_orig, params, factor_subd, v_a, v_b); @@ -419,7 +419,7 @@ static BMVert *subdivide_edge_num( BMVert *v_new; float factor_edge_split, factor_subd; - if (BMO_elem_flag_test(bm, edge, EDGE_PERCENT) && totpoint == 1) { + if (BMO_edge_flag_test(bm, edge, EDGE_PERCENT) && totpoint == 1) { factor_edge_split = BMO_slot_map_float_get(params->slot_edge_percents, edge); factor_subd = 0.0f; } @@ -449,9 +449,9 @@ static void bm_subdivide_multicut( for (i = 0; i < numcuts; i++) { v = subdivide_edge_num(bm, eed, &e_tmp, i, params->numcuts, params, v_a, v_b, &e_new); - BMO_elem_flag_enable(bm, v, SUBD_SPLIT | ELE_SPLIT); - BMO_elem_flag_enable(bm, eed, SUBD_SPLIT | ELE_SPLIT); - BMO_elem_flag_enable(bm, e_new, SUBD_SPLIT | ELE_SPLIT); + BMO_vert_flag_enable(bm, v, SUBD_SPLIT | ELE_SPLIT); + BMO_edge_flag_enable(bm, eed, SUBD_SPLIT | ELE_SPLIT); + BMO_edge_flag_enable(bm, e_new, SUBD_SPLIT | ELE_SPLIT); BM_CHECK_ELEMENT(v); if (v->e) BM_CHECK_ELEMENT(v->e); @@ -698,8 +698,8 @@ static void quad_4edge_subdivide(BMesh *bm, BMFace *UNUSED(face), BMVert **verts if (!e) continue; - BMO_elem_flag_enable(bm, e, ELE_INNER); - BMO_elem_flag_enable(bm, f_new, ELE_INNER); + BMO_edge_flag_enable(bm, e, ELE_INNER); + BMO_face_flag_enable(bm, f_new, ELE_INNER); v1 = lines[(i + 1) * s] = verts[a]; @@ -711,7 +711,7 @@ static void quad_4edge_subdivide(BMesh *bm, BMFace *UNUSED(face), BMVert **verts BMESH_ASSERT(v != NULL); - BMO_elem_flag_enable(bm, e_new, ELE_INNER); + BMO_edge_flag_enable(bm, e_new, ELE_INNER); lines[(i + 1) * s + a + 1] = v; } } @@ -724,8 +724,8 @@ static void quad_4edge_subdivide(BMesh *bm, BMFace *UNUSED(face), BMVert **verts if (!e) continue; - BMO_elem_flag_enable(bm, e, ELE_INNER); - BMO_elem_flag_enable(bm, f_new, ELE_INNER); + BMO_edge_flag_enable(bm, e, ELE_INNER); + BMO_face_flag_enable(bm, f_new, ELE_INNER); } } @@ -802,8 +802,8 @@ static void tri_3edge_subdivide(BMesh *bm, BMFace *UNUSED(face), BMVert **verts, e = connect_smallest_face(bm, verts[a], verts[b], &f_new); if (!e) goto cleanup; - BMO_elem_flag_enable(bm, e, ELE_INNER); - BMO_elem_flag_enable(bm, f_new, ELE_INNER); + BMO_edge_flag_enable(bm, e, ELE_INNER); + BMO_face_flag_enable(bm, f_new, ELE_INNER); lines[i + 1][0] = verts[a]; lines[i + 1][i + 1] = verts[b]; @@ -817,7 +817,7 @@ static void tri_3edge_subdivide(BMesh *bm, BMFace *UNUSED(face), BMVert **verts, v = subdivide_edge_num(bm, e, &e_tmp, j, i, params, verts[a], verts[b], &e_new); lines[i + 1][j + 1] = v; - BMO_elem_flag_enable(bm, e_new, ELE_INNER); + BMO_edge_flag_enable(bm, e_new, ELE_INNER); } } @@ -837,13 +837,13 @@ static void tri_3edge_subdivide(BMesh *bm, BMFace *UNUSED(face), BMVert **verts, for (j = 0; j < i; j++) { e = connect_smallest_face(bm, lines[i][j], lines[i + 1][j + 1], &f_new); - BMO_elem_flag_enable(bm, e, ELE_INNER); - BMO_elem_flag_enable(bm, f_new, ELE_INNER); + BMO_edge_flag_enable(bm, e, ELE_INNER); + BMO_face_flag_enable(bm, f_new, ELE_INNER); e = connect_smallest_face(bm, lines[i][j + 1], lines[i + 1][j + 1], &f_new); - BMO_elem_flag_enable(bm, e, ELE_INNER); - BMO_elem_flag_enable(bm, f_new, ELE_INNER); + BMO_edge_flag_enable(bm, e, ELE_INNER); + BMO_face_flag_enable(bm, f_new, ELE_INNER); } } @@ -1023,7 +1023,7 @@ void bmo_subdivide_edges_exec(BMesh *bm, BMOperator *op) edges[i] = l_new->e; verts[i] = l_new->v; - if (BMO_elem_flag_test(bm, edges[i], SUBD_SPLIT)) { + if (BMO_edge_flag_test(bm, edges[i], SUBD_SPLIT)) { if (!e1) e1 = edges[i]; else e2 = edges[i]; @@ -1043,13 +1043,13 @@ void bmo_subdivide_edges_exec(BMesh *bm, BMOperator *op) } } - if (BMO_elem_flag_test(bm, face, FACE_CUSTOMFILL)) { + if (BMO_face_flag_test(bm, face, FACE_CUSTOMFILL)) { pat = *BMO_slot_map_data_get(params.slot_custom_patterns, face); for (i = 0; i < pat->len; i++) { matched = 1; for (j = 0; j < pat->len; j++) { a = (j + i) % pat->len; - if ((!!BMO_elem_flag_test(bm, edges[a], SUBD_SPLIT)) != (!!pat->seledges[j])) { + if ((!!BMO_edge_flag_test(bm, edges[a], SUBD_SPLIT)) != (!!pat->seledges[j])) { matched = 0; break; } @@ -1062,7 +1062,7 @@ void bmo_subdivide_edges_exec(BMesh *bm, BMOperator *op) fd->start = verts[i]; fd->face = face; fd->totedgesel = totesel; - BMO_elem_flag_enable(bm, face, SUBD_SPLIT); + BMO_face_flag_enable(bm, face, SUBD_SPLIT); break; } } @@ -1082,7 +1082,7 @@ void bmo_subdivide_edges_exec(BMesh *bm, BMOperator *op) matched = 1; for (b = 0; b < pat->len; b++) { j = (b + a) % pat->len; - if ((!!BMO_elem_flag_test(bm, edges[j], SUBD_SPLIT)) != (!!pat->seledges[b])) { + if ((!!BMO_edge_flag_test(bm, edges[j], SUBD_SPLIT)) != (!!pat->seledges[b])) { matched = 0; break; } @@ -1094,7 +1094,7 @@ void bmo_subdivide_edges_exec(BMesh *bm, BMOperator *op) if (matched) { SubDFaceData *fd; - BMO_elem_flag_enable(bm, face, SUBD_SPLIT); + BMO_face_flag_enable(bm, face, SUBD_SPLIT); fd = BLI_stack_push_r(facedata); fd->pat = pat; @@ -1110,7 +1110,7 @@ void bmo_subdivide_edges_exec(BMesh *bm, BMOperator *op) if (!matched && totesel) { SubDFaceData *fd; - BMO_elem_flag_enable(bm, face, SUBD_SPLIT); + BMO_face_flag_enable(bm, face, SUBD_SPLIT); /* must initialize all members here */ fd = BLI_stack_push_r(facedata); @@ -1162,22 +1162,22 @@ void bmo_subdivide_edges_exec(BMesh *bm, BMOperator *op) /* find the boundary of one of the split edges */ for (a = 1; a < vlen; a++) { - if (!BMO_elem_flag_test(bm, loops[a - 1]->v, ELE_INNER) && - BMO_elem_flag_test(bm, loops[a]->v, ELE_INNER)) + if (!BMO_vert_flag_test(bm, loops[a - 1]->v, ELE_INNER) && + BMO_vert_flag_test(bm, loops[a]->v, ELE_INNER)) { break; } } - if (BMO_elem_flag_test(bm, loops[(a + numcuts + 1) % vlen]->v, ELE_INNER)) { + if (BMO_vert_flag_test(bm, loops[(a + numcuts + 1) % vlen]->v, ELE_INNER)) { b = (a + numcuts + 1) % vlen; } else { /* find the boundary of the other edge. */ for (j = 0; j < vlen; j++) { b = (j + a + numcuts + 1) % vlen; - if (!BMO_elem_flag_test(bm, loops[b == 0 ? vlen - 1 : b - 1]->v, ELE_INNER) && - BMO_elem_flag_test(bm, loops[b]->v, ELE_INNER)) + if (!BMO_vert_flag_test(bm, loops[b == 0 ? vlen - 1 : b - 1]->v, ELE_INNER) && + BMO_vert_flag_test(bm, loops[b]->v, ELE_INNER)) { break; } @@ -1245,7 +1245,7 @@ void bmo_subdivide_edges_exec(BMesh *bm, BMOperator *op) BLI_assert(BM_edge_exists(loops_split[j][0]->v, loops_split[j][1]->v) == NULL); f_new = BM_face_split(bm, face, loops_split[j][0], loops_split[j][1], &l_new, NULL, false); if (f_new) { - BMO_elem_flag_enable(bm, l_new->e, ELE_INNER); + BMO_edge_flag_enable(bm, l_new->e, ELE_INNER); } } } diff --git a/source/blender/bmesh/operators/bmo_subdivide_edgering.c b/source/blender/bmesh/operators/bmo_subdivide_edgering.c index b5a95ad6283..b4a77bf1a38 100644 --- a/source/blender/bmesh/operators/bmo_subdivide_edgering.c +++ b/source/blender/bmesh/operators/bmo_subdivide_edgering.c @@ -128,7 +128,7 @@ static void bmo_edgeloop_vert_tag(BMesh *bm, struct BMEdgeLoopStore *el_store, c { LinkData *node = BM_edgeloop_verts_get(el_store)->first; do { - BMO_elem_flag_set(bm, (BMVert *)node->data, oflag, tag); + BMO_vert_flag_set(bm, (BMVert *)node->data, oflag, tag); } while ((node = node->next)); } @@ -137,7 +137,7 @@ static bool bmo_face_is_vert_tag_all(BMesh *bm, BMFace *f, short oflag) BMLoop *l_iter, *l_first; l_iter = l_first = BM_FACE_FIRST_LOOP(f); do { - if (!BMO_elem_flag_test(bm, l_iter->v, oflag)) { + if (!BMO_vert_flag_test(bm, l_iter->v, oflag)) { return false; } } while ((l_iter = l_iter->next) != l_first); @@ -150,7 +150,7 @@ static bool bm_vert_is_tag_edge_connect(BMesh *bm, BMVert *v) BMEdge *e; BM_ITER_ELEM (e, &eiter, v, BM_EDGES_OF_VERT) { - if (BMO_elem_flag_test(bm, e, EDGE_RING)) { + if (BMO_edge_flag_test(bm, e, EDGE_RING)) { BMVert *v_other = BM_edge_other_vert(e, v); if (BM_elem_flag_test(v_other, BM_ELEM_TAG)) { return true; @@ -243,7 +243,7 @@ static GSet *bm_edgering_pair_calc(BMesh *bm, ListBase *eloops_rim) BMVert *v = ((LinkData *)BM_edgeloop_verts_get(el_store)->first)->data; BM_ITER_ELEM (e, &eiter, (BMVert *)v, BM_EDGES_OF_VERT) { - if (BMO_elem_flag_test(bm, e, EDGE_RING)) { + if (BMO_edge_flag_test(bm, e, EDGE_RING)) { struct BMEdgeLoopStore *el_store_other; BMVert *v_other = BM_edge_other_vert(e, v); GHashPair pair_test; @@ -339,7 +339,7 @@ static void bm_vert_calc_surface_tangent(BMesh *bm, BMVert *v, float r_no[3]) if (UNLIKELY(BM_edge_is_wire(e))) { /* pass - this may confuse things */ } - else if (BMO_elem_flag_test(bm, e, EDGE_RIM)) { + else if (BMO_edge_flag_test(bm, e, EDGE_RIM)) { BMIter liter; BMLoop *l; BM_ITER_ELEM (l, &liter, e, BM_LOOPS_OF_EDGE) { @@ -347,7 +347,7 @@ static void bm_vert_calc_surface_tangent(BMesh *bm, BMVert *v, float r_no[3]) float no[3]; // BM_face_normal_update(l->f); BM_edge_calc_face_tangent(e, l, no); - if (BMO_elem_flag_test(bm, l->f, FACE_SHARED)) { + if (BMO_face_flag_test(bm, l->f, FACE_SHARED)) { add_v3_v3(no_inner, no); found_inner = true; } @@ -356,7 +356,7 @@ static void bm_vert_calc_surface_tangent(BMesh *bm, BMVert *v, float r_no[3]) found_outer = true; /* other side is used too, blend midway */ - if (BMO_elem_flag_test(bm, l->f, FACE_OUT)) { + if (BMO_face_flag_test(bm, l->f, FACE_OUT)) { found_outer_tag = true; } } @@ -400,9 +400,9 @@ static void bm_faces_share_tag_flush(BMesh *bm, BMEdge **e_arr, const unsigned i l_iter = l_first = e->l; do { - if (!BMO_elem_flag_test(bm, l_iter->f, FACE_SHARED)) { + if (!BMO_face_flag_test(bm, l_iter->f, FACE_SHARED)) { if (bmo_face_is_vert_tag_all(bm, l_iter->f, VERT_SHARED)) { - BMO_elem_flag_enable(bm, l_iter->f, FACE_SHARED); + BMO_face_flag_enable(bm, l_iter->f, FACE_SHARED); } } } while ((l_iter = l_iter->radial_next) != l_first); @@ -422,7 +422,7 @@ static void bm_faces_share_tag_clear(BMesh *bm, BMEdge **e_arr_iter, const unsig l_iter = l_first = e->l; do { - BMO_elem_flag_disable(bm, l_iter->f, FACE_SHARED); + BMO_face_flag_disable(bm, l_iter->f, FACE_SHARED); } while ((l_iter = l_iter->radial_next) != l_first); } } @@ -834,8 +834,8 @@ static void bm_face_slice(BMesh *bm, BMLoop *l, const int cuts) if (l_new->f->len < l_new->radial_next->f->len) { l_new = l_new->radial_next; } - BMO_elem_flag_enable(bm, l_new->f, FACE_OUT); - BMO_elem_flag_enable(bm, l_new->radial_next->f, FACE_OUT); + BMO_face_flag_enable(bm, l_new->f, FACE_OUT); + BMO_face_flag_enable(bm, l_new->radial_next->f, FACE_OUT); } } @@ -903,7 +903,7 @@ static void bm_edgering_pair_order( node = lb_a->first; BM_ITER_ELEM (e, &eiter, (BMVert *)node->data, BM_EDGES_OF_VERT) { - if (BMO_elem_flag_test(bm, e, EDGE_RING)) { + if (BMO_edge_flag_test(bm, e, EDGE_RING)) { v_other = BM_edge_other_vert(e, (BMVert *)node->data); if (BM_elem_flag_test(v_other, BM_ELEM_TAG)) { break; @@ -938,7 +938,7 @@ static void bm_edgering_pair_order( /* if we dont share and edge - flip */ BMEdge *e = BM_edge_exists(((LinkData *)lb_a->first)->data, ((LinkData *)lb_b->first)->data); - if (e == NULL || !BMO_elem_flag_test(bm, e, EDGE_RING)) { + if (e == NULL || !BMO_edge_flag_test(bm, e, EDGE_RING)) { BM_edgeloop_flip(bm, el_store_b); } } @@ -983,19 +983,19 @@ static void bm_edgering_pair_subdiv( BMIter eiter; BM_ITER_ELEM (e, &eiter, (BMVert *)node->data, BM_EDGES_OF_VERT) { - if (!BMO_elem_flag_test(bm, e, EDGE_IN_STACK)) { + if (!BMO_edge_flag_test(bm, e, EDGE_IN_STACK)) { BMVert *v_other = BM_edge_other_vert(e, (BMVert *)node->data); if (BM_elem_flag_test(v_other, BM_ELEM_TAG)) { BMIter fiter; - BMO_elem_flag_enable(bm, e, EDGE_IN_STACK); + BMO_edge_flag_enable(bm, e, EDGE_IN_STACK); STACK_PUSH(edges_ring_arr, e); /* add faces to the stack */ BM_ITER_ELEM (f, &fiter, e, BM_FACES_OF_EDGE) { - if (BMO_elem_flag_test(bm, f, FACE_OUT)) { - if (!BMO_elem_flag_test(bm, f, FACE_IN_STACK)) { - BMO_elem_flag_enable(bm, f, FACE_IN_STACK); + if (BMO_face_flag_test(bm, f, FACE_OUT)) { + if (!BMO_face_flag_test(bm, f, FACE_IN_STACK)) { + BMO_face_flag_enable(bm, f, FACE_IN_STACK); STACK_PUSH(faces_ring_arr, f); } } @@ -1009,10 +1009,10 @@ static void bm_edgering_pair_subdiv( /* found opposite edge */ BMVert *v_other; - BMO_elem_flag_disable(bm, e, EDGE_IN_STACK); + BMO_edge_flag_disable(bm, e, EDGE_IN_STACK); /* unrelated to subdiv, but if we _don't_ clear flag, multiple rings fail */ - BMO_elem_flag_disable(bm, e, EDGE_RING); + BMO_edge_flag_disable(bm, e, EDGE_RING); v_other = BM_elem_flag_test(e->v1, BM_ELEM_TAG) ? e->v1 : e->v2; bm_edge_subdiv_as_loop(bm, eloops_ring, e, v_other, cuts); @@ -1021,12 +1021,12 @@ static void bm_edgering_pair_subdiv( while ((f = STACK_POP(faces_ring_arr))) { BMLoop *l_iter, *l_first; - BMO_elem_flag_disable(bm, f, FACE_IN_STACK); + BMO_face_flag_disable(bm, f, FACE_IN_STACK); /* Check each edge of the face */ l_iter = l_first = BM_FACE_FIRST_LOOP(f); do { - if (BMO_elem_flag_test(bm, l_iter->e, EDGE_RIM)) { + if (BMO_edge_flag_test(bm, l_iter->e, EDGE_RIM)) { bm_face_slice(bm, l_iter, cuts); break; } @@ -1064,7 +1064,7 @@ static void bm_edgering_pair_ringsubd( static bool bm_edge_rim_test_cb(BMEdge *e, void *bm_v) { BMesh *bm = bm_v; - return BMO_elem_flag_test_bool(bm, e, EDGE_RIM); + return BMO_edge_flag_test_bool(bm, e, EDGE_RIM); } @@ -1099,25 +1099,25 @@ void bmo_subdivide_edgering_exec(BMesh *bm, BMOperator *op) BMFace *f; BM_ITER_ELEM (f, &fiter, e, BM_FACES_OF_EDGE) { - if (!BMO_elem_flag_test(bm, f, FACE_OUT)) { + if (!BMO_face_flag_test(bm, f, FACE_OUT)) { BMIter liter; BMLoop *l; bool ok = false; /* check at least 2 edges in the face are rings */ BM_ITER_ELEM (l, &liter, f, BM_LOOPS_OF_FACE) { - if (BMO_elem_flag_test(bm, l->e, EDGE_RING) && e != l->e) { + if (BMO_edge_flag_test(bm, l->e, EDGE_RING) && e != l->e) { ok = true; break; } } if (ok) { - BMO_elem_flag_enable(bm, f, FACE_OUT); + BMO_face_flag_enable(bm, f, FACE_OUT); BM_ITER_ELEM (l, &liter, f, BM_LOOPS_OF_FACE) { - if (!BMO_elem_flag_test(bm, l->e, EDGE_RING)) { - BMO_elem_flag_enable(bm, l->e, EDGE_RIM); + if (!BMO_edge_flag_test(bm, l->e, EDGE_RING)) { + BMO_edge_flag_enable(bm, l->e, EDGE_RIM); } } } diff --git a/source/blender/bmesh/operators/bmo_triangulate.c b/source/blender/bmesh/operators/bmo_triangulate.c index 974446f09c0..8938d086c1a 100644 --- a/source/blender/bmesh/operators/bmo_triangulate.c +++ b/source/blender/bmesh/operators/bmo_triangulate.c @@ -91,7 +91,7 @@ void bmo_triangle_fill_exec(BMesh *bm, BMOperator *op) BMVert **e_verts = &e->v1; unsigned int i; - BMO_elem_flag_enable(bm, e, EDGE_MARK); + BMO_edge_flag_enable(bm, e, EDGE_MARK); calc_winding = (calc_winding || BM_edge_is_boundary(e)); @@ -132,7 +132,7 @@ void bmo_triangle_fill_exec(BMesh *bm, BMOperator *op) add_v3_v3(normal, v->no); BM_ITER_ELEM (e, &eiter, v, BM_EDGES_OF_VERT) { - if (BMO_elem_flag_test(bm, e, EDGE_MARK)) { + if (BMO_edge_flag_test(bm, e, EDGE_MARK)) { if (e_index == 2) { e_index = 0; break; @@ -203,7 +203,7 @@ void bmo_triangle_fill_exec(BMesh *bm, BMOperator *op) for (i = 0, i_prev = 2; i < 3; i_prev = i++) { e = BM_edge_exists(v_tri[i], v_tri[i_prev]); - if (e && BM_edge_is_boundary(e) && BMO_elem_flag_test(bm, e, EDGE_MARK)) { + if (e && BM_edge_is_boundary(e) && BMO_edge_flag_test(bm, e, EDGE_MARK)) { winding_votes += (e->l->v == v_tri[i]) ? 1 : -1; } } @@ -226,10 +226,10 @@ void bmo_triangle_fill_exec(BMesh *bm, BMOperator *op) sf_tri->v1->tmp.p, sf_tri->v2->tmp.p, sf_tri->v3->tmp.p, NULL, NULL, BM_CREATE_NO_DOUBLE); - BMO_elem_flag_enable(bm, f, ELE_NEW); + BMO_face_flag_enable(bm, f, ELE_NEW); BM_ITER_ELEM (l, &liter, f, BM_LOOPS_OF_FACE) { - if (!BMO_elem_flag_test(bm, l->e, EDGE_MARK)) { - BMO_elem_flag_enable(bm, l->e, ELE_NEW); + if (!BMO_edge_flag_test(bm, l->e, EDGE_MARK)) { + BMO_edge_flag_enable(bm, l->e, ELE_NEW); } } } @@ -250,7 +250,7 @@ void bmo_triangle_fill_exec(BMesh *bm, BMOperator *op) BMIter iter; BM_ITER_MESH_MUTABLE (e, e_next, &iter, bm, BM_EDGES_OF_MESH) { - if (BMO_elem_flag_test(bm, e, ELE_NEW)) { + if (BMO_edge_flag_test(bm, e, ELE_NEW)) { /* in rare cases the edges face will have already been removed from the edge */ if (LIKELY(e->l)) { BMFace *f_new = BM_faces_join_pair( @@ -258,7 +258,7 @@ void bmo_triangle_fill_exec(BMesh *bm, BMOperator *op) e->l->radial_next->f, e, false); /* join faces */ if (f_new) { - BMO_elem_flag_enable(bm, f_new, ELE_NEW); + BMO_face_flag_enable(bm, f_new, ELE_NEW); BM_edge_kill(bm, e); } else { diff --git a/source/blender/bmesh/operators/bmo_utils.c b/source/blender/bmesh/operators/bmo_utils.c index e596032663e..aa1e4bc7523 100644 --- a/source/blender/bmesh/operators/bmo_utils.c +++ b/source/blender/bmesh/operators/bmo_utils.c @@ -48,7 +48,7 @@ void bmo_create_vert_exec(BMesh *bm, BMOperator *op) BMO_slot_vec_get(op->slots_in, "co", vec); - BMO_elem_flag_enable(bm, BM_vert_create(bm, vec, NULL, BM_CREATE_NOP), ELE_NEW); + BMO_vert_flag_enable(bm, BM_vert_create(bm, vec, NULL, BM_CREATE_NOP), ELE_NEW); BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "vert.out", BM_VERT, ELE_NEW); } @@ -74,7 +74,7 @@ void bmo_transform_exec(BMesh *UNUSED(bm), BMOperator *op) void bmo_translate_exec(BMesh *bm, BMOperator *op) { float mat[4][4], vec[3]; - + BMO_slot_vec_get(op->slots_in, "vec", vec); unit_m4(mat); @@ -86,7 +86,7 @@ void bmo_translate_exec(BMesh *bm, BMOperator *op) void bmo_scale_exec(BMesh *bm, BMOperator *op) { float mat[3][3], vec[3]; - + BMO_slot_vec_get(op->slots_in, "vec", vec); unit_m3(mat); @@ -143,18 +143,18 @@ void bmo_rotate_edges_exec(BMesh *bm, BMOperator *op) if (BM_edge_face_pair(e, &fa, &fb)) { /* check we're untouched */ - if (BMO_elem_flag_test(bm, fa, FACE_TAINT) == false && - BMO_elem_flag_test(bm, fb, FACE_TAINT) == false) + if (BMO_face_flag_test(bm, fa, FACE_TAINT) == false && + BMO_face_flag_test(bm, fb, FACE_TAINT) == false) { /* don't touch again (faces will be freed so run before rotating the edge) */ - BMO_elem_flag_enable(bm, fa, FACE_TAINT); - BMO_elem_flag_enable(bm, fb, FACE_TAINT); + BMO_face_flag_enable(bm, fa, FACE_TAINT); + BMO_face_flag_enable(bm, fb, FACE_TAINT); if (!(e2 = BM_edge_rotate(bm, e, use_ccw, check_flag))) { - BMO_elem_flag_disable(bm, fa, FACE_TAINT); - BMO_elem_flag_disable(bm, fb, FACE_TAINT); + BMO_face_flag_disable(bm, fa, FACE_TAINT); + BMO_face_flag_disable(bm, fb, FACE_TAINT); #if 0 BMO_error_raise(bm, op, BMERR_INVALID_SELECTION, "Could not rotate edge"); return; @@ -163,7 +163,7 @@ void bmo_rotate_edges_exec(BMesh *bm, BMOperator *op) continue; } - BMO_elem_flag_enable(bm, e2, EDGE_OUT); + BMO_edge_flag_enable(bm, e2, EDGE_OUT); } } } @@ -184,11 +184,11 @@ static void bmo_face_flag_set_flush(BMesh *bm, BMFace *f, const short oflag, con BMLoop *l_iter; BMLoop *l_first; - BMO_elem_flag_set(bm, f, oflag, value); + BMO_face_flag_set(bm, f, oflag, value); l_iter = l_first = BM_FACE_FIRST_LOOP(f); do { - BMO_elem_flag_set(bm, l_iter->e, oflag, value); - BMO_elem_flag_set(bm, l_iter->v, oflag, value); + BMO_edge_flag_set(bm, l_iter->e, oflag, value); + BMO_vert_flag_set(bm, l_iter->v, oflag, value); } while ((l_iter = l_iter->next) != l_first); } @@ -210,7 +210,9 @@ static void bmo_region_extend_expand( BMEdge *e; BM_ITER_ELEM (e, &eiter, v, BM_EDGES_OF_VERT) { - if (!BMO_elem_flag_test(bm, e, SEL_ORIG) && !BM_elem_flag_test(e, BM_ELEM_HIDDEN)) { + if (!BMO_edge_flag_test(bm, e, SEL_ORIG) && + !BM_elem_flag_test(e, BM_ELEM_HIDDEN)) + { found = true; break; } @@ -223,9 +225,11 @@ static void bmo_region_extend_expand( BMEdge *e; BM_ITER_ELEM (e, &eiter, v, BM_EDGES_OF_VERT) { - if (!BMO_elem_flag_test(bm, e, SEL_FLAG) && !BM_elem_flag_test(e, BM_ELEM_HIDDEN)) { - BMO_elem_flag_enable(bm, e, SEL_FLAG); - BMO_elem_flag_enable(bm, BM_edge_other_vert(e, v), SEL_FLAG); + if (!BMO_edge_flag_test(bm, e, SEL_FLAG) && + !BM_elem_flag_test(e, BM_ELEM_HIDDEN)) + { + BMO_edge_flag_enable(bm, e, SEL_FLAG); + BMO_vert_flag_enable(bm, BM_edge_other_vert(e, v), SEL_FLAG); } } } @@ -234,7 +238,9 @@ static void bmo_region_extend_expand( BMFace *f; BM_ITER_ELEM (f, &fiter, v, BM_FACES_OF_VERT) { - if (!BMO_elem_flag_test(bm, f, SEL_FLAG) && !BM_elem_flag_test(f, BM_ELEM_HIDDEN)) { + if (!BMO_face_flag_test(bm, f, SEL_FLAG) && + !BM_elem_flag_test(f, BM_ELEM_HIDDEN)) + { bmo_face_flag_set_flush(bm, f, SEL_FLAG, true); } } @@ -245,9 +251,11 @@ static void bmo_region_extend_expand( BMEdge *e; BM_ITER_ELEM (e, &eiter, v, BM_EDGES_OF_VERT) { if (BM_edge_is_wire(e)) { - if (!BMO_elem_flag_test(bm, e, SEL_FLAG) && !BM_elem_flag_test(e, BM_ELEM_HIDDEN)) { - BMO_elem_flag_enable(bm, e, SEL_FLAG); - BMO_elem_flag_enable(bm, BM_edge_other_vert(e, v), SEL_FLAG); + if (!BMO_edge_flag_test(bm, e, SEL_FLAG) && + !BM_elem_flag_test(e, BM_ELEM_HIDDEN)) + { + BMO_edge_flag_enable(bm, e, SEL_FLAG); + BMO_vert_flag_enable(bm, BM_edge_other_vert(e, v), SEL_FLAG); } } } @@ -269,10 +277,10 @@ static void bmo_region_extend_expand( BMFace *f_other; BM_ITER_ELEM (f_other, &fiter, l->e, BM_FACES_OF_EDGE) { - if (!BMO_elem_flag_test(bm, f_other, SEL_ORIG | SEL_FLAG) && + if (!BMO_face_flag_test(bm, f_other, SEL_ORIG | SEL_FLAG) && !BM_elem_flag_test(f_other, BM_ELEM_HIDDEN)) { - BMO_elem_flag_enable(bm, f_other, SEL_FLAG); + BMO_face_flag_enable(bm, f_other, SEL_FLAG); } } } @@ -281,10 +289,10 @@ static void bmo_region_extend_expand( BMFace *f_other; BM_ITER_ELEM (f_other, &fiter, l->v, BM_FACES_OF_VERT) { - if (!BMO_elem_flag_test(bm, f_other, SEL_ORIG | SEL_FLAG) && + if (!BMO_face_flag_test(bm, f_other, SEL_ORIG | SEL_FLAG) && !BM_elem_flag_test(f_other, BM_ELEM_HIDDEN)) { - BMO_elem_flag_enable(bm, f_other, SEL_FLAG); + BMO_face_flag_enable(bm, f_other, SEL_FLAG); } } } @@ -310,7 +318,7 @@ static void bmo_region_extend_contract( BMEdge *e; BM_ITER_ELEM (e, &eiter, v, BM_EDGES_OF_VERT) { - if (!BMO_elem_flag_test(bm, e, SEL_ORIG)) { + if (!BMO_edge_flag_test(bm, e, SEL_ORIG)) { found = true; break; } @@ -321,7 +329,7 @@ static void bmo_region_extend_contract( BMFace *f; BM_ITER_ELEM (f, &fiter, v, BM_FACES_OF_VERT) { - if (!BMO_elem_flag_test(bm, f, SEL_ORIG)) { + if (!BMO_face_flag_test(bm, f, SEL_ORIG)) { found = true; break; } @@ -334,7 +342,7 @@ static void bmo_region_extend_contract( BM_ITER_ELEM (e, &eiter, v, BM_EDGES_OF_VERT) { if (BM_edge_is_wire(e)) { - if (!BMO_elem_flag_test(bm, e, SEL_ORIG)) { + if (!BMO_edge_flag_test(bm, e, SEL_ORIG)) { found = true; break; } @@ -347,10 +355,10 @@ static void bmo_region_extend_contract( BMIter eiter; BMEdge *e; - BMO_elem_flag_enable(bm, v, SEL_FLAG); + BMO_vert_flag_enable(bm, v, SEL_FLAG); BM_ITER_ELEM (e, &eiter, v, BM_EDGES_OF_VERT) { - BMO_elem_flag_enable(bm, e, SEL_FLAG); + BMO_edge_flag_enable(bm, e, SEL_FLAG); } } } @@ -369,8 +377,8 @@ static void bmo_region_extend_contract( BMFace *f_other; BM_ITER_ELEM (f_other, &fiter, l->e, BM_FACES_OF_EDGE) { - if (!BMO_elem_flag_test(bm, f_other, SEL_ORIG)) { - BMO_elem_flag_enable(bm, f, SEL_FLAG); + if (!BMO_face_flag_test(bm, f_other, SEL_ORIG)) { + BMO_face_flag_enable(bm, f, SEL_FLAG); break; } } @@ -380,8 +388,8 @@ static void bmo_region_extend_contract( BMFace *f_other; BM_ITER_ELEM (f_other, &fiter, l->v, BM_FACES_OF_VERT) { - if (!BMO_elem_flag_test(bm, f_other, SEL_ORIG)) { - BMO_elem_flag_enable(bm, f, SEL_FLAG); + if (!BMO_face_flag_test(bm, f_other, SEL_ORIG)) { + BMO_face_flag_enable(bm, f, SEL_FLAG); break; } } @@ -420,7 +428,7 @@ void bmo_smooth_vert_exec(BMesh *UNUSED(bm), BMOperator *op) const float fac = BMO_slot_float_get(op->slots_in, "factor"); int i, j, clipx, clipy, clipz; int xaxis, yaxis, zaxis; - + clipx = BMO_slot_bool_get(op->slots_in, "mirror_clip_x"); clipy = BMO_slot_bool_get(op->slots_in, "mirror_clip_y"); clipz = BMO_slot_bool_get(op->slots_in, "mirror_clip_z"); @@ -441,7 +449,7 @@ void bmo_smooth_vert_exec(BMesh *UNUSED(bm), BMOperator *op) add_v3_v3v3(co, co, co2); j += 1; } - + if (!j) { copy_v3_v3(co, v->co); i++; -- cgit v1.2.3