From e12c08e8d170b7ca40f204a5b0423c23a9fbc2c1 Mon Sep 17 00:00:00 2001 From: Campbell Barton Date: Wed, 17 Apr 2019 06:17:24 +0200 Subject: ClangFormat: apply to source, most of intern Apply clang format as proposed in T53211. For details on usage and instructions for migrating branches without conflicts, see: https://wiki.blender.org/wiki/Tools/ClangFormat --- source/blender/bmesh/tools/bmesh_path_region.c | 733 ++++++++++++------------- 1 file changed, 364 insertions(+), 369 deletions(-) (limited to 'source/blender/bmesh/tools/bmesh_path_region.c') diff --git a/source/blender/bmesh/tools/bmesh_path_region.c b/source/blender/bmesh/tools/bmesh_path_region.c index 8eb5b50b2a2..9ec3b51f29a 100644 --- a/source/blender/bmesh/tools/bmesh_path_region.c +++ b/source/blender/bmesh/tools/bmesh_path_region.c @@ -29,8 +29,7 @@ #include "BLI_alloca.h" #include "bmesh.h" -#include "bmesh_path_region.h" /* own include */ - +#include "bmesh_path_region.h" /* own include */ /** * Special handling of vertices with 2 edges @@ -45,7 +44,6 @@ */ #define USE_EDGE_CHAIN - #ifdef USE_EDGE_CHAIN /** * Takes a vertex with 2 edge users and assigns the vertices at each end-point, @@ -54,66 +52,62 @@ */ static bool bm_vert_pair_ends(BMVert *v_pivot, BMVert *v_end_pair[2]) { - BMEdge *e = v_pivot->e; - int j = 0; - do { - BMEdge *e_chain = e; - BMVert *v_other = BM_edge_other_vert(e_chain, v_pivot); - while (BM_vert_is_edge_pair_manifold(v_other)) { - BMEdge *e_chain_next = BM_DISK_EDGE_NEXT(e_chain, v_other); - BLI_assert(BM_DISK_EDGE_NEXT(e_chain_next, v_other) == e_chain); - v_other = BM_edge_other_vert(e_chain_next, v_other); - if (v_other == v_pivot) { - return false; - } - e_chain = e_chain_next; - } - v_end_pair[j++] = v_other; - } while ((e = BM_DISK_EDGE_NEXT(e, v_pivot)) != v_pivot->e); - - BLI_assert(j == 2); - return true; + BMEdge *e = v_pivot->e; + int j = 0; + do { + BMEdge *e_chain = e; + BMVert *v_other = BM_edge_other_vert(e_chain, v_pivot); + while (BM_vert_is_edge_pair_manifold(v_other)) { + BMEdge *e_chain_next = BM_DISK_EDGE_NEXT(e_chain, v_other); + BLI_assert(BM_DISK_EDGE_NEXT(e_chain_next, v_other) == e_chain); + v_other = BM_edge_other_vert(e_chain_next, v_other); + if (v_other == v_pivot) { + return false; + } + e_chain = e_chain_next; + } + v_end_pair[j++] = v_other; + } while ((e = BM_DISK_EDGE_NEXT(e, v_pivot)) != v_pivot->e); + + BLI_assert(j == 2); + return true; } -#endif /* USE_EDGE_CHAIN */ - +#endif /* USE_EDGE_CHAIN */ /** \name Vertex in Region Checks * \{ */ -static bool bm_vert_region_test(BMVert *v, int * const depths[2], const int pass) +static bool bm_vert_region_test(BMVert *v, int *const depths[2], const int pass) { - const int index = BM_elem_index_get(v); - return (((depths[0][index] != -1) && (depths[1][index] != -1)) && \ - ((depths[0][index] + depths[1][index]) < pass)); + const int index = BM_elem_index_get(v); + return (((depths[0][index] != -1) && (depths[1][index] != -1)) && + ((depths[0][index] + depths[1][index]) < pass)); } #ifdef USE_EDGE_CHAIN -static bool bm_vert_region_test_chain(BMVert *v, int * const depths[2], const int pass) +static bool bm_vert_region_test_chain(BMVert *v, int *const depths[2], const int pass) { - BMVert *v_end_pair[2]; - if (bm_vert_region_test(v, depths, pass)) { - return true; - } - else if (BM_vert_is_edge_pair_manifold(v) && - bm_vert_pair_ends(v, v_end_pair) && - bm_vert_region_test(v_end_pair[0], depths, pass) && - bm_vert_region_test(v_end_pair[1], depths, pass)) - { - return true; - } - - return false; + BMVert *v_end_pair[2]; + if (bm_vert_region_test(v, depths, pass)) { + return true; + } + else if (BM_vert_is_edge_pair_manifold(v) && bm_vert_pair_ends(v, v_end_pair) && + bm_vert_region_test(v_end_pair[0], depths, pass) && + bm_vert_region_test(v_end_pair[1], depths, pass)) { + return true; + } + + return false; } #else -static bool bm_vert_region_test_chain(BMVert *v, int * const depths[2], const int pass) +static bool bm_vert_region_test_chain(BMVert *v, int *const depths[2], const int pass) { - return bm_vert_region_test(v, depths, pass); + return bm_vert_region_test(v, depths, pass); } #endif /** \} */ - /** * Main logic for calculating region between 2 elements. * @@ -126,358 +120,359 @@ static bool bm_vert_region_test_chain(BMVert *v, int * const depths[2], const in * * \note Only verts without BM_ELEM_TAG will be walked over. */ -static LinkNode *mesh_calc_path_region_elem( - BMesh *bm, - BMElem *ele_src, BMElem *ele_dst, - const char path_htype) +static LinkNode *mesh_calc_path_region_elem(BMesh *bm, + BMElem *ele_src, + BMElem *ele_dst, + const char path_htype) { - int ele_verts_len[2]; - BMVert **ele_verts[2]; - - /* Get vertices from any `ele_src/ele_dst` elements. */ - for (int side = 0; side < 2; side++) { - BMElem *ele = side ? ele_dst : ele_src; - int j = 0; - - if (ele->head.htype == BM_FACE) { - BMFace *f = (BMFace *)ele; - ele_verts[side] = BLI_array_alloca(ele_verts[side], f->len); - - BMLoop *l_first, *l_iter; - l_iter = l_first = BM_FACE_FIRST_LOOP(f); - do { - ele_verts[side][j++] = l_iter->v; - } while ((l_iter = l_iter->next) != l_first); - } - else if (ele->head.htype == BM_EDGE) { - BMEdge *e = (BMEdge *)ele; - ele_verts[side] = BLI_array_alloca(ele_verts[side], 2); - - ele_verts[side][j++] = e->v1; - ele_verts[side][j++] = e->v2; - } - else if (ele->head.htype == BM_VERT) { - BMVert *v = (BMVert *)ele; - ele_verts[side] = BLI_array_alloca(ele_verts[side], 1); - - ele_verts[side][j++] = v; - } - else { - BLI_assert(0); - } - ele_verts_len[side] = j; - } - - int *depths[2] = {NULL}; - int pass = 0; - - BMVert **stack = MEM_mallocN(sizeof(*stack) * bm->totvert, __func__); - BMVert **stack_other = MEM_mallocN(sizeof(*stack_other) * bm->totvert, __func__); - - STACK_DECLARE(stack); - STACK_INIT(stack, bm->totvert); - - STACK_DECLARE(stack_other); - STACK_INIT(stack_other, bm->totvert); - - BM_mesh_elem_index_ensure(bm, BM_VERT); - - /* After exhausting all possible elements, we should have found all elements on the 'side_other'. - * otherwise, exit early. */ - bool found_all = false; - - for (int side = 0; side < 2; side++) { - const int side_other = !side; - - /* initialize depths to -1 (un-touched), fill in with the depth as we walk over the edges. */ - depths[side] = MEM_mallocN(sizeof(*depths[side]) * bm->totvert, __func__); - copy_vn_i(depths[side], bm->totvert, -1); - - /* needed for second side */ - STACK_CLEAR(stack); - STACK_CLEAR(stack_other); - - for (int i = 0; i < ele_verts_len[side]; i++) { - BMVert *v = ele_verts[side][i]; - depths[side][BM_elem_index_get(v)] = 0; - if (v->e && !BM_elem_flag_test(v, BM_ELEM_TAG)) { - STACK_PUSH(stack, v); - } - } + int ele_verts_len[2]; + BMVert **ele_verts[2]; + + /* Get vertices from any `ele_src/ele_dst` elements. */ + for (int side = 0; side < 2; side++) { + BMElem *ele = side ? ele_dst : ele_src; + int j = 0; + + if (ele->head.htype == BM_FACE) { + BMFace *f = (BMFace *)ele; + ele_verts[side] = BLI_array_alloca(ele_verts[side], f->len); + + BMLoop *l_first, *l_iter; + l_iter = l_first = BM_FACE_FIRST_LOOP(f); + do { + ele_verts[side][j++] = l_iter->v; + } while ((l_iter = l_iter->next) != l_first); + } + else if (ele->head.htype == BM_EDGE) { + BMEdge *e = (BMEdge *)ele; + ele_verts[side] = BLI_array_alloca(ele_verts[side], 2); + + ele_verts[side][j++] = e->v1; + ele_verts[side][j++] = e->v2; + } + else if (ele->head.htype == BM_VERT) { + BMVert *v = (BMVert *)ele; + ele_verts[side] = BLI_array_alloca(ele_verts[side], 1); + + ele_verts[side][j++] = v; + } + else { + BLI_assert(0); + } + ele_verts_len[side] = j; + } + + int *depths[2] = {NULL}; + int pass = 0; + + BMVert **stack = MEM_mallocN(sizeof(*stack) * bm->totvert, __func__); + BMVert **stack_other = MEM_mallocN(sizeof(*stack_other) * bm->totvert, __func__); + + STACK_DECLARE(stack); + STACK_INIT(stack, bm->totvert); + + STACK_DECLARE(stack_other); + STACK_INIT(stack_other, bm->totvert); + + BM_mesh_elem_index_ensure(bm, BM_VERT); + + /* After exhausting all possible elements, we should have found all elements on the 'side_other'. + * otherwise, exit early. */ + bool found_all = false; + + for (int side = 0; side < 2; side++) { + const int side_other = !side; + + /* initialize depths to -1 (un-touched), fill in with the depth as we walk over the edges. */ + depths[side] = MEM_mallocN(sizeof(*depths[side]) * bm->totvert, __func__); + copy_vn_i(depths[side], bm->totvert, -1); + + /* needed for second side */ + STACK_CLEAR(stack); + STACK_CLEAR(stack_other); + + for (int i = 0; i < ele_verts_len[side]; i++) { + BMVert *v = ele_verts[side][i]; + depths[side][BM_elem_index_get(v)] = 0; + if (v->e && !BM_elem_flag_test(v, BM_ELEM_TAG)) { + STACK_PUSH(stack, v); + } + } #ifdef USE_EDGE_CHAIN - /* Expand initial state to end-point vertices when they only have 2x edges, - * this prevents odd behavior when source or destination are in the middle of a long chain of edges. */ - if (ELEM(path_htype, BM_VERT, BM_EDGE)) { - for (int i = 0; i < ele_verts_len[side]; i++) { - BMVert *v = ele_verts[side][i]; - BMVert *v_end_pair[2]; - if (BM_vert_is_edge_pair_manifold(v) && bm_vert_pair_ends(v, v_end_pair)) { - for (int j = 0; j < 2; j++) { - const int v_end_index = BM_elem_index_get(v_end_pair[j]); - if (depths[side][v_end_index] == -1) { - depths[side][v_end_index] = 0; - if (!BM_elem_flag_test(v_end_pair[j], BM_ELEM_TAG)) { - STACK_PUSH(stack, v_end_pair[j]); - } - } - } - } - } - } -#endif /* USE_EDGE_CHAIN */ - - /* Keep walking over connected geometry until we find all the vertices in `ele_verts[side_other]`, - * or exit the loop when theres no connection. */ - found_all = false; - for (pass = 1; (STACK_SIZE(stack) != 0); pass++) { - while (STACK_SIZE(stack) != 0) { - BMVert *v_a = STACK_POP(stack); - // const int v_a_index = BM_elem_index_get(v_a); /* only for assert */ - BMEdge *e = v_a->e; - - do { - BMVert *v_b = BM_edge_other_vert(e, v_a); - int v_b_index = BM_elem_index_get(v_b); - if (depths[side][v_b_index] == -1) { + /* Expand initial state to end-point vertices when they only have 2x edges, + * this prevents odd behavior when source or destination are in the middle of a long chain of edges. */ + if (ELEM(path_htype, BM_VERT, BM_EDGE)) { + for (int i = 0; i < ele_verts_len[side]; i++) { + BMVert *v = ele_verts[side][i]; + BMVert *v_end_pair[2]; + if (BM_vert_is_edge_pair_manifold(v) && bm_vert_pair_ends(v, v_end_pair)) { + for (int j = 0; j < 2; j++) { + const int v_end_index = BM_elem_index_get(v_end_pair[j]); + if (depths[side][v_end_index] == -1) { + depths[side][v_end_index] = 0; + if (!BM_elem_flag_test(v_end_pair[j], BM_ELEM_TAG)) { + STACK_PUSH(stack, v_end_pair[j]); + } + } + } + } + } + } +#endif /* USE_EDGE_CHAIN */ + + /* Keep walking over connected geometry until we find all the vertices in `ele_verts[side_other]`, + * or exit the loop when theres no connection. */ + found_all = false; + for (pass = 1; (STACK_SIZE(stack) != 0); pass++) { + while (STACK_SIZE(stack) != 0) { + BMVert *v_a = STACK_POP(stack); + // const int v_a_index = BM_elem_index_get(v_a); /* only for assert */ + BMEdge *e = v_a->e; + + do { + BMVert *v_b = BM_edge_other_vert(e, v_a); + int v_b_index = BM_elem_index_get(v_b); + if (depths[side][v_b_index] == -1) { #ifdef USE_EDGE_CHAIN - /* Walk along the chain, fill in values until we reach a vertex with 3+ edges. */ - { - BMEdge *e_chain = e; - while (BM_vert_is_edge_pair_manifold(v_b) && - ((depths[side][v_b_index] == -1))) - { - depths[side][v_b_index] = pass; - - BMEdge *e_chain_next = BM_DISK_EDGE_NEXT(e_chain, v_b); - BLI_assert(BM_DISK_EDGE_NEXT(e_chain_next, v_b) == e_chain); - v_b = BM_edge_other_vert(e_chain_next, v_b); - v_b_index = BM_elem_index_get(v_b); - e_chain = e_chain_next; - } - } -#endif /* USE_EDGE_CHAIN */ - - /* Add the other vertex to the stack, to be traversed in the next pass. */ - if (depths[side][v_b_index] == -1) { + /* Walk along the chain, fill in values until we reach a vertex with 3+ edges. */ + { + BMEdge *e_chain = e; + while (BM_vert_is_edge_pair_manifold(v_b) && ((depths[side][v_b_index] == -1))) { + depths[side][v_b_index] = pass; + + BMEdge *e_chain_next = BM_DISK_EDGE_NEXT(e_chain, v_b); + BLI_assert(BM_DISK_EDGE_NEXT(e_chain_next, v_b) == e_chain); + v_b = BM_edge_other_vert(e_chain_next, v_b); + v_b_index = BM_elem_index_get(v_b); + e_chain = e_chain_next; + } + } +#endif /* USE_EDGE_CHAIN */ + + /* Add the other vertex to the stack, to be traversed in the next pass. */ + if (depths[side][v_b_index] == -1) { #ifdef USE_EDGE_CHAIN - BLI_assert(!BM_vert_is_edge_pair_manifold(v_b)); + BLI_assert(!BM_vert_is_edge_pair_manifold(v_b)); #endif - BLI_assert(pass == depths[side][BM_elem_index_get(v_a)] + 1); - depths[side][v_b_index] = pass; - if (!BM_elem_flag_test(v_b, BM_ELEM_TAG)) { - STACK_PUSH(stack_other, v_b); - } - } - } - } while ((e = BM_DISK_EDGE_NEXT(e, v_a)) != v_a->e); - } - - /* Stop searching once theres none left. - * Note that this looks in-efficient, however until the target elements reached, - * it will exit immediately. - * After that, it takes as many passes as the element has edges to finish off. */ - found_all = true; - for (int i = 0; i < ele_verts_len[side_other]; i++) { - if (depths[side][BM_elem_index_get(ele_verts[side_other][i])] == -1) { - found_all = false; - break; - } - } - if (found_all == true) { - pass++; - break; - } - - STACK_SWAP(stack, stack_other); - } - - /* if we have nothing left, and didn't find all elements on the other side, - * exit early and don't continue */ - if (found_all == false) { - break; - } - } - - MEM_freeN(stack); - MEM_freeN(stack_other); - - - /* Now we have depths recorded from both sides, - * select elements that use tagged verts. */ - LinkNode *path = NULL; - - if (found_all == false) { - /* fail! (do nothing) */ - } - else if (path_htype == BM_FACE) { - BMIter fiter; - BMFace *f; - - BM_ITER_MESH (f, &fiter, bm, BM_FACES_OF_MESH) { - if (!BM_elem_flag_test(f, BM_ELEM_TAG)) { - /* check all verts in face are tagged */ - BMLoop *l_first, *l_iter; - l_iter = l_first = BM_FACE_FIRST_LOOP(f); - bool ok = true; + BLI_assert(pass == depths[side][BM_elem_index_get(v_a)] + 1); + depths[side][v_b_index] = pass; + if (!BM_elem_flag_test(v_b, BM_ELEM_TAG)) { + STACK_PUSH(stack_other, v_b); + } + } + } + } while ((e = BM_DISK_EDGE_NEXT(e, v_a)) != v_a->e); + } + + /* Stop searching once theres none left. + * Note that this looks in-efficient, however until the target elements reached, + * it will exit immediately. + * After that, it takes as many passes as the element has edges to finish off. */ + found_all = true; + for (int i = 0; i < ele_verts_len[side_other]; i++) { + if (depths[side][BM_elem_index_get(ele_verts[side_other][i])] == -1) { + found_all = false; + break; + } + } + if (found_all == true) { + pass++; + break; + } + + STACK_SWAP(stack, stack_other); + } + + /* if we have nothing left, and didn't find all elements on the other side, + * exit early and don't continue */ + if (found_all == false) { + break; + } + } + + MEM_freeN(stack); + MEM_freeN(stack_other); + + /* Now we have depths recorded from both sides, + * select elements that use tagged verts. */ + LinkNode *path = NULL; + + if (found_all == false) { + /* fail! (do nothing) */ + } + else if (path_htype == BM_FACE) { + BMIter fiter; + BMFace *f; + + BM_ITER_MESH (f, &fiter, bm, BM_FACES_OF_MESH) { + if (!BM_elem_flag_test(f, BM_ELEM_TAG)) { + /* check all verts in face are tagged */ + BMLoop *l_first, *l_iter; + l_iter = l_first = BM_FACE_FIRST_LOOP(f); + bool ok = true; #if 0 - do { - if (!bm_vert_region_test_chain(l_iter->v, depths, pass)) { - ok = false; - break; - } - } while ((l_iter = l_iter->next) != l_first); + do { + if (!bm_vert_region_test_chain(l_iter->v, depths, pass)) { + ok = false; + break; + } + } while ((l_iter = l_iter->next) != l_first); #else - /* Allowing a single failure on a face gives fewer 'gaps'. - * While correct, in practice they're often part of what a user would consider the 'region'. */ - int ok_tests = f->len > 3 ? 1 : 0; /* how many times we may fail */ - do { - if (!bm_vert_region_test_chain(l_iter->v, depths, pass)) { - if (ok_tests == 0) { - ok = false; - break; - } - ok_tests--; - } - } while ((l_iter = l_iter->next) != l_first); + /* Allowing a single failure on a face gives fewer 'gaps'. + * While correct, in practice they're often part of what a user would consider the 'region'. */ + int ok_tests = f->len > 3 ? 1 : 0; /* how many times we may fail */ + do { + if (!bm_vert_region_test_chain(l_iter->v, depths, pass)) { + if (ok_tests == 0) { + ok = false; + break; + } + ok_tests--; + } + } while ((l_iter = l_iter->next) != l_first); #endif - if (ok) { - BLI_linklist_prepend(&path, f); - } - } - } - } - else if (path_htype == BM_EDGE) { - BMIter eiter; - BMEdge *e; - - BM_ITER_MESH (e, &eiter, bm, BM_EDGES_OF_MESH) { - if (!BM_elem_flag_test(e, BM_ELEM_TAG)) { - /* check all verts in edge are tagged */ - bool ok = true; - for (int j = 0; j < 2; j++) { - if (!bm_vert_region_test_chain(*((&e->v1) + j), depths, pass)) { - ok = false; - break; - } - } - - if (ok) { - BLI_linklist_prepend(&path, e); - } - } - } - } - else if (path_htype == BM_VERT) { - BMIter viter; - BMVert *v; - - BM_ITER_MESH (v, &viter, bm, BM_VERTS_OF_MESH) { - if (bm_vert_region_test_chain(v, depths, pass)) { - BLI_linklist_prepend(&path, v); - } - } - } - - - for (int side = 0; side < 2; side++) { - if (depths[side]) { - MEM_freeN(depths[side]); - } - } - - return path; + if (ok) { + BLI_linklist_prepend(&path, f); + } + } + } + } + else if (path_htype == BM_EDGE) { + BMIter eiter; + BMEdge *e; + + BM_ITER_MESH (e, &eiter, bm, BM_EDGES_OF_MESH) { + if (!BM_elem_flag_test(e, BM_ELEM_TAG)) { + /* check all verts in edge are tagged */ + bool ok = true; + for (int j = 0; j < 2; j++) { + if (!bm_vert_region_test_chain(*((&e->v1) + j), depths, pass)) { + ok = false; + break; + } + } + + if (ok) { + BLI_linklist_prepend(&path, e); + } + } + } + } + else if (path_htype == BM_VERT) { + BMIter viter; + BMVert *v; + + BM_ITER_MESH (v, &viter, bm, BM_VERTS_OF_MESH) { + if (bm_vert_region_test_chain(v, depths, pass)) { + BLI_linklist_prepend(&path, v); + } + } + } + + for (int side = 0; side < 2; side++) { + if (depths[side]) { + MEM_freeN(depths[side]); + } + } + + return path; } #undef USE_EDGE_CHAIN - /** \name Main Functions (exposed externally). * \{ */ -LinkNode *BM_mesh_calc_path_region_vert( - BMesh *bm, BMElem *ele_src, BMElem *ele_dst, - bool (*filter_fn)(BMVert *, void *user_data), void *user_data) +LinkNode *BM_mesh_calc_path_region_vert(BMesh *bm, + BMElem *ele_src, + BMElem *ele_dst, + bool (*filter_fn)(BMVert *, void *user_data), + void *user_data) { - LinkNode *path = NULL; - /* BM_ELEM_TAG flag is used to store visited verts */ - BMVert *v; - BMIter viter; - int i; + LinkNode *path = NULL; + /* BM_ELEM_TAG flag is used to store visited verts */ + BMVert *v; + BMIter viter; + int i; - BM_ITER_MESH_INDEX (v, &viter, bm, BM_VERTS_OF_MESH, i) { - BM_elem_flag_set(v, BM_ELEM_TAG, !filter_fn(v, user_data)); - BM_elem_index_set(v, i); /* set_inline */ - } - bm->elem_index_dirty &= ~BM_VERT; + BM_ITER_MESH_INDEX (v, &viter, bm, BM_VERTS_OF_MESH, i) { + BM_elem_flag_set(v, BM_ELEM_TAG, !filter_fn(v, user_data)); + BM_elem_index_set(v, i); /* set_inline */ + } + bm->elem_index_dirty &= ~BM_VERT; - path = mesh_calc_path_region_elem(bm, ele_src, ele_dst, BM_VERT); + path = mesh_calc_path_region_elem(bm, ele_src, ele_dst, BM_VERT); - return path; + return path; } -LinkNode *BM_mesh_calc_path_region_edge( - BMesh *bm, BMElem *ele_src, BMElem *ele_dst, - bool (*filter_fn)(BMEdge *, void *user_data), void *user_data) +LinkNode *BM_mesh_calc_path_region_edge(BMesh *bm, + BMElem *ele_src, + BMElem *ele_dst, + bool (*filter_fn)(BMEdge *, void *user_data), + void *user_data) { - LinkNode *path = NULL; - /* BM_ELEM_TAG flag is used to store visited verts */ - BMEdge *e; - BMIter eiter; - int i; - - /* flush flag to verts */ - BM_mesh_elem_hflag_enable_all(bm, BM_VERT, BM_ELEM_TAG, false); - - BM_ITER_MESH_INDEX (e, &eiter, bm, BM_EDGES_OF_MESH, i) { - bool test; - BM_elem_flag_set(e, BM_ELEM_TAG, test = !filter_fn(e, user_data)); - - /* flush tag to verts */ - if (test == false) { - for (int j = 0; j < 2; j++) { - BM_elem_flag_disable(*((&e->v1) + j), BM_ELEM_TAG); - } - } - } - - path = mesh_calc_path_region_elem(bm, ele_src, ele_dst, BM_EDGE); - - return path; + LinkNode *path = NULL; + /* BM_ELEM_TAG flag is used to store visited verts */ + BMEdge *e; + BMIter eiter; + int i; + + /* flush flag to verts */ + BM_mesh_elem_hflag_enable_all(bm, BM_VERT, BM_ELEM_TAG, false); + + BM_ITER_MESH_INDEX (e, &eiter, bm, BM_EDGES_OF_MESH, i) { + bool test; + BM_elem_flag_set(e, BM_ELEM_TAG, test = !filter_fn(e, user_data)); + + /* flush tag to verts */ + if (test == false) { + for (int j = 0; j < 2; j++) { + BM_elem_flag_disable(*((&e->v1) + j), BM_ELEM_TAG); + } + } + } + + path = mesh_calc_path_region_elem(bm, ele_src, ele_dst, BM_EDGE); + + return path; } -LinkNode *BM_mesh_calc_path_region_face( - BMesh *bm, BMElem *ele_src, BMElem *ele_dst, - bool (*filter_fn)(BMFace *, void *user_data), void *user_data) +LinkNode *BM_mesh_calc_path_region_face(BMesh *bm, + BMElem *ele_src, + BMElem *ele_dst, + bool (*filter_fn)(BMFace *, void *user_data), + void *user_data) { - LinkNode *path = NULL; - /* BM_ELEM_TAG flag is used to store visited verts */ - BMFace *f; - BMIter fiter; - int i; - - /* flush flag to verts */ - BM_mesh_elem_hflag_enable_all(bm, BM_VERT, BM_ELEM_TAG, false); - - BM_ITER_MESH_INDEX (f, &fiter, bm, BM_FACES_OF_MESH, i) { - bool test; - BM_elem_flag_set(f, BM_ELEM_TAG, test = !filter_fn(f, user_data)); - - /* flush tag to verts */ - if (test == false) { - BMLoop *l_first, *l_iter; - l_iter = l_first = BM_FACE_FIRST_LOOP(f); - do { - BM_elem_flag_disable(l_iter->v, BM_ELEM_TAG); - } while ((l_iter = l_iter->next) != l_first); - } - } - - path = mesh_calc_path_region_elem(bm, ele_src, ele_dst, BM_FACE); - - return path; + LinkNode *path = NULL; + /* BM_ELEM_TAG flag is used to store visited verts */ + BMFace *f; + BMIter fiter; + int i; + + /* flush flag to verts */ + BM_mesh_elem_hflag_enable_all(bm, BM_VERT, BM_ELEM_TAG, false); + + BM_ITER_MESH_INDEX (f, &fiter, bm, BM_FACES_OF_MESH, i) { + bool test; + BM_elem_flag_set(f, BM_ELEM_TAG, test = !filter_fn(f, user_data)); + + /* flush tag to verts */ + if (test == false) { + BMLoop *l_first, *l_iter; + l_iter = l_first = BM_FACE_FIRST_LOOP(f); + do { + BM_elem_flag_disable(l_iter->v, BM_ELEM_TAG); + } while ((l_iter = l_iter->next) != l_first); + } + } + + path = mesh_calc_path_region_elem(bm, ele_src, ele_dst, BM_FACE); + + return path; } /** \} */ -- cgit v1.2.3