diff options
author | Campbell Barton <ideasman42@gmail.com> | 2019-04-17 07:17:24 +0300 |
---|---|---|
committer | Campbell Barton <ideasman42@gmail.com> | 2019-04-17 07:21:24 +0300 |
commit | e12c08e8d170b7ca40f204a5b0423c23a9fbc2c1 (patch) | |
tree | 8cf3453d12edb177a218ef8009357518ec6cab6a /source/blender/bmesh/operators/bmo_rotate_edges.c | |
parent | b3dabc200a4b0399ec6b81f2ff2730d07b44fcaa (diff) |
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
Diffstat (limited to 'source/blender/bmesh/operators/bmo_rotate_edges.c')
-rw-r--r-- | source/blender/bmesh/operators/bmo_rotate_edges.c | 403 |
1 files changed, 201 insertions, 202 deletions
diff --git a/source/blender/bmesh/operators/bmo_rotate_edges.c b/source/blender/bmesh/operators/bmo_rotate_edges.c index bfc7ba75763..e017806df0d 100644 --- a/source/blender/bmesh/operators/bmo_rotate_edges.c +++ b/source/blender/bmesh/operators/bmo_rotate_edges.c @@ -29,33 +29,33 @@ #include "intern/bmesh_operators_private.h" /* own include */ -#define EDGE_OUT 1 +#define EDGE_OUT 1 #define FACE_MARK 1 /** * Rotate edges where every edge has it's own faces (we can rotate in any order). */ -static void bm_rotate_edges_simple( - BMesh *bm, BMOperator *op, - const short check_flag, const bool use_ccw) +static void bm_rotate_edges_simple(BMesh *bm, + BMOperator *op, + const short check_flag, + const bool use_ccw) { - BMOIter siter; - BMEdge *e; - - BMO_ITER (e, &siter, op->slots_in, "edges", BM_EDGE) { - /** - * this ends up being called twice, could add option to not to call check in - * #BM_edge_rotate to get some extra speed */ - if (BM_edge_rotate_check(e)) { - BMEdge *e_rotate = BM_edge_rotate(bm, e, use_ccw, check_flag); - if (e_rotate != NULL) { - BMO_edge_flag_enable(bm, e_rotate, EDGE_OUT); - } - } - } + BMOIter siter; + BMEdge *e; + + BMO_ITER (e, &siter, op->slots_in, "edges", BM_EDGE) { + /** + * this ends up being called twice, could add option to not to call check in + * #BM_edge_rotate to get some extra speed */ + if (BM_edge_rotate_check(e)) { + BMEdge *e_rotate = BM_edge_rotate(bm, e, use_ccw, check_flag); + if (e_rotate != NULL) { + BMO_edge_flag_enable(bm, e_rotate, EDGE_OUT); + } + } + } } - /** * Edge length is just a way of ordering that's independent of order in the edges argument, * we could use some other method since ideally all edges will be rotated, @@ -63,7 +63,7 @@ static void bm_rotate_edges_simple( */ static float bm_edge_calc_rotate_cost(const BMEdge *e) { - return -BM_edge_calc_length_squared(e); + return -BM_edge_calc_length_squared(e); } /** @@ -71,25 +71,25 @@ static float bm_edge_calc_rotate_cost(const BMEdge *e) */ static float bm_edge_rotate_is_boundary(const BMEdge *e) { - /* Number of adjacent shared faces. */ - int count = 0; - BMLoop *l_radial_iter = e->l; - do { - /* Skip this edge. */ - BMLoop *l_iter = l_radial_iter->next; - do { - BMEdge *e_iter = l_iter->e; - const int e_iter_index = BM_elem_index_get(e_iter); - if ((e_iter_index != -1)) { - if (count == 1) { - return false; - } - count += 1; - break; - } - } while ((l_iter = l_iter->next) != l_radial_iter); - } while ((l_radial_iter = l_radial_iter->radial_next) != e->l); - return true; + /* Number of adjacent shared faces. */ + int count = 0; + BMLoop *l_radial_iter = e->l; + do { + /* Skip this edge. */ + BMLoop *l_iter = l_radial_iter->next; + do { + BMEdge *e_iter = l_iter->e; + const int e_iter_index = BM_elem_index_get(e_iter); + if ((e_iter_index != -1)) { + if (count == 1) { + return false; + } + count += 1; + break; + } + } while ((l_iter = l_iter->next) != l_radial_iter); + } while ((l_radial_iter = l_radial_iter->radial_next) != e->l); + return true; } /** @@ -97,172 +97,171 @@ static float bm_edge_rotate_is_boundary(const BMEdge *e) * edges which could not rotate need to be re-considered after neighbors are rotated. */ static void bm_rotate_edges_shared( - BMesh *bm, BMOperator *op, - short check_flag, const bool use_ccw, const int edges_len) + BMesh *bm, BMOperator *op, short check_flag, const bool use_ccw, const int edges_len) { - Heap *heap = BLI_heap_new_ex(edges_len); - HeapNode **eheap_table = MEM_mallocN(sizeof(*eheap_table) * edges_len, __func__); - int edges_len_rotate = 0; - - { - BMIter iter; - BMEdge *e; - BM_ITER_MESH (e, &iter, bm, BM_EDGES_OF_MESH) { - BM_elem_index_set(e, -1); /* set_dirty! */ - } - bm->elem_index_dirty |= BM_EDGE; - } - - { - BMOIter siter; - BMEdge *e; - uint i; - BMO_ITER_INDEX (e, &siter, op->slots_in, "edges", BM_EDGE, i) { - BM_elem_index_set(e, BM_edge_is_manifold(e) ? i : -1); /* set_dirty! */ - eheap_table[i] = NULL; - } - } - - /* First operate on boundary edges, this is often all that's needed, - * regions that have no boundaries are handles after. */ - enum { - PASS_TYPE_BOUNDARY = 0, - PASS_TYPE_ALL = 1, - PASS_TYPE_DONE = 2, - }; - uint pass_type = PASS_TYPE_BOUNDARY; - - - while ((pass_type != PASS_TYPE_DONE) && (edges_len_rotate != edges_len)) { - BLI_assert(BLI_heap_is_empty(heap)); - { - BMOIter siter; - BMEdge *e; - uint i; - BMO_ITER_INDEX (e, &siter, op->slots_in, "edges", BM_EDGE, i) { - BLI_assert(eheap_table[i] == NULL); - - bool ok = (BM_elem_index_get(e) != -1) && BM_edge_rotate_check(e); - - if (ok) { - if (pass_type == PASS_TYPE_BOUNDARY) { - ok = bm_edge_rotate_is_boundary(e); - } - } - - if (ok) { - float cost = bm_edge_calc_rotate_cost(e); - if (pass_type == PASS_TYPE_BOUNDARY) { - /* Trick to ensure once started, non boundaries are handled before other boundary edges. - * This means the first longest boundary defines the starting point which is rotated - * until all its connected edges are exhausted and the next boundary is popped off the heap. - * - * Without this we may rotate from different starting points and meet in the middle - * with obviously uneven topology. - * - * Move from negative to positive value, inverting so large values are still handled first. - */ - cost = cost != 0.0f ? -1.0f / cost : FLT_MAX; - } - eheap_table[i] = BLI_heap_insert(heap, cost, e); - } - } - } - - if (BLI_heap_is_empty(heap)) { - pass_type += 1; - continue; - } - - const int edges_len_rotate_prev = edges_len_rotate; - while (!BLI_heap_is_empty(heap)) { - BMEdge *e_best = BLI_heap_pop_min(heap); - eheap_table[BM_elem_index_get(e_best)] = NULL; - - /* No problem if this fails, re-evaluate if faces connected to this edge are touched. */ - if (BM_edge_rotate_check(e_best)) { - BMEdge *e_rotate = BM_edge_rotate(bm, e_best, use_ccw, check_flag); - if (e_rotate != NULL) { - BMO_edge_flag_enable(bm, e_rotate, EDGE_OUT); - - /* invalidate so we don't try touch this again. */ - BM_elem_index_set(e_rotate, -1); /* set_dirty! */ - - edges_len_rotate += 1; - - /* Note: we could validate all edges which have not been rotated - * (not just previously degenerate edges). - * However there is no real need - they can be left until they're popped off the queue. */ - - /* We don't know the exact topology after rotating the edge, - * so loop over all faces attached to the new edge, typically this will only be two faces. */ - BMLoop *l_radial_iter = e_rotate->l; - do { - /* Skip this edge. */ - BMLoop *l_iter = l_radial_iter->next; - do { - BMEdge *e_iter = l_iter->e; - const int e_iter_index = BM_elem_index_get(e_iter); - if ((e_iter_index != -1) && (eheap_table[e_iter_index] == NULL)) { - if (BM_edge_rotate_check(e_iter)) { - /* Previously degenerate, now valid. */ - float cost = bm_edge_calc_rotate_cost(e_iter); - eheap_table[e_iter_index] = BLI_heap_insert(heap, cost, e_iter); - } - } - } while ((l_iter = l_iter->next) != l_radial_iter); - } while ((l_radial_iter = l_radial_iter->radial_next) != e_rotate->l); - } - } - } - - /* If no actions were taken, move onto the next pass. */ - if (edges_len_rotate == edges_len_rotate_prev) { - pass_type += 1; - continue; - } - } - - BLI_heap_free(heap, NULL); - MEM_freeN(eheap_table); + Heap *heap = BLI_heap_new_ex(edges_len); + HeapNode **eheap_table = MEM_mallocN(sizeof(*eheap_table) * edges_len, __func__); + int edges_len_rotate = 0; + + { + BMIter iter; + BMEdge *e; + BM_ITER_MESH (e, &iter, bm, BM_EDGES_OF_MESH) { + BM_elem_index_set(e, -1); /* set_dirty! */ + } + bm->elem_index_dirty |= BM_EDGE; + } + + { + BMOIter siter; + BMEdge *e; + uint i; + BMO_ITER_INDEX(e, &siter, op->slots_in, "edges", BM_EDGE, i) + { + BM_elem_index_set(e, BM_edge_is_manifold(e) ? i : -1); /* set_dirty! */ + eheap_table[i] = NULL; + } + } + + /* First operate on boundary edges, this is often all that's needed, + * regions that have no boundaries are handles after. */ + enum { + PASS_TYPE_BOUNDARY = 0, + PASS_TYPE_ALL = 1, + PASS_TYPE_DONE = 2, + }; + uint pass_type = PASS_TYPE_BOUNDARY; + + while ((pass_type != PASS_TYPE_DONE) && (edges_len_rotate != edges_len)) { + BLI_assert(BLI_heap_is_empty(heap)); + { + BMOIter siter; + BMEdge *e; + uint i; + BMO_ITER_INDEX(e, &siter, op->slots_in, "edges", BM_EDGE, i) + { + BLI_assert(eheap_table[i] == NULL); + + bool ok = (BM_elem_index_get(e) != -1) && BM_edge_rotate_check(e); + + if (ok) { + if (pass_type == PASS_TYPE_BOUNDARY) { + ok = bm_edge_rotate_is_boundary(e); + } + } + + if (ok) { + float cost = bm_edge_calc_rotate_cost(e); + if (pass_type == PASS_TYPE_BOUNDARY) { + /* Trick to ensure once started, non boundaries are handled before other boundary edges. + * This means the first longest boundary defines the starting point which is rotated + * until all its connected edges are exhausted and the next boundary is popped off the heap. + * + * Without this we may rotate from different starting points and meet in the middle + * with obviously uneven topology. + * + * Move from negative to positive value, inverting so large values are still handled first. + */ + cost = cost != 0.0f ? -1.0f / cost : FLT_MAX; + } + eheap_table[i] = BLI_heap_insert(heap, cost, e); + } + } + } + + if (BLI_heap_is_empty(heap)) { + pass_type += 1; + continue; + } + + const int edges_len_rotate_prev = edges_len_rotate; + while (!BLI_heap_is_empty(heap)) { + BMEdge *e_best = BLI_heap_pop_min(heap); + eheap_table[BM_elem_index_get(e_best)] = NULL; + + /* No problem if this fails, re-evaluate if faces connected to this edge are touched. */ + if (BM_edge_rotate_check(e_best)) { + BMEdge *e_rotate = BM_edge_rotate(bm, e_best, use_ccw, check_flag); + if (e_rotate != NULL) { + BMO_edge_flag_enable(bm, e_rotate, EDGE_OUT); + + /* invalidate so we don't try touch this again. */ + BM_elem_index_set(e_rotate, -1); /* set_dirty! */ + + edges_len_rotate += 1; + + /* Note: we could validate all edges which have not been rotated + * (not just previously degenerate edges). + * However there is no real need - they can be left until they're popped off the queue. */ + + /* We don't know the exact topology after rotating the edge, + * so loop over all faces attached to the new edge, typically this will only be two faces. */ + BMLoop *l_radial_iter = e_rotate->l; + do { + /* Skip this edge. */ + BMLoop *l_iter = l_radial_iter->next; + do { + BMEdge *e_iter = l_iter->e; + const int e_iter_index = BM_elem_index_get(e_iter); + if ((e_iter_index != -1) && (eheap_table[e_iter_index] == NULL)) { + if (BM_edge_rotate_check(e_iter)) { + /* Previously degenerate, now valid. */ + float cost = bm_edge_calc_rotate_cost(e_iter); + eheap_table[e_iter_index] = BLI_heap_insert(heap, cost, e_iter); + } + } + } while ((l_iter = l_iter->next) != l_radial_iter); + } while ((l_radial_iter = l_radial_iter->radial_next) != e_rotate->l); + } + } + } + + /* If no actions were taken, move onto the next pass. */ + if (edges_len_rotate == edges_len_rotate_prev) { + pass_type += 1; + continue; + } + } + + BLI_heap_free(heap, NULL); + MEM_freeN(eheap_table); } void bmo_rotate_edges_exec(BMesh *bm, BMOperator *op) { - BMOIter siter; - BMEdge *e; - const int edges_len = BMO_slot_buffer_count(op->slots_in, "edges"); - const bool use_ccw = BMO_slot_bool_get(op->slots_in, "use_ccw"); - const bool is_single = (edges_len == 1); - short check_flag = is_single ? - BM_EDGEROT_CHECK_EXISTS : - BM_EDGEROT_CHECK_EXISTS | BM_EDGEROT_CHECK_DEGENERATE; - - bool is_simple = true; - if (is_single == false) { - BMO_ITER (e, &siter, op->slots_in, "edges", BM_EDGE) { - BMFace *f_pair[2]; - if (BM_edge_face_pair(e, &f_pair[0], &f_pair[1])) { - for (uint i = 0; i < ARRAY_SIZE(f_pair); i += 1) { - if (BMO_face_flag_test(bm, f_pair[i], FACE_MARK)) { - is_simple = false; - break; - } - BMO_face_flag_enable(bm, f_pair[i], FACE_MARK); - } - if (is_simple == false) { - break; - } - } - } - } - - if (is_simple) { - bm_rotate_edges_simple(bm, op, check_flag, use_ccw); - } - else { - bm_rotate_edges_shared(bm, op, check_flag, use_ccw, edges_len); - } - - BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "edges.out", BM_EDGE, EDGE_OUT); + BMOIter siter; + BMEdge *e; + const int edges_len = BMO_slot_buffer_count(op->slots_in, "edges"); + const bool use_ccw = BMO_slot_bool_get(op->slots_in, "use_ccw"); + const bool is_single = (edges_len == 1); + short check_flag = is_single ? BM_EDGEROT_CHECK_EXISTS : + BM_EDGEROT_CHECK_EXISTS | BM_EDGEROT_CHECK_DEGENERATE; + + bool is_simple = true; + if (is_single == false) { + BMO_ITER (e, &siter, op->slots_in, "edges", BM_EDGE) { + BMFace *f_pair[2]; + if (BM_edge_face_pair(e, &f_pair[0], &f_pair[1])) { + for (uint i = 0; i < ARRAY_SIZE(f_pair); i += 1) { + if (BMO_face_flag_test(bm, f_pair[i], FACE_MARK)) { + is_simple = false; + break; + } + BMO_face_flag_enable(bm, f_pair[i], FACE_MARK); + } + if (is_simple == false) { + break; + } + } + } + } + + if (is_simple) { + bm_rotate_edges_simple(bm, op, check_flag, use_ccw); + } + else { + bm_rotate_edges_shared(bm, op, check_flag, use_ccw, edges_len); + } + + BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "edges.out", BM_EDGE, EDGE_OUT); } |