diff options
Diffstat (limited to 'source/blender/bmesh')
70 files changed, 1573 insertions, 1379 deletions
diff --git a/source/blender/bmesh/CMakeLists.txt b/source/blender/bmesh/CMakeLists.txt index 0606222bb17..d49686f204a 100644 --- a/source/blender/bmesh/CMakeLists.txt +++ b/source/blender/bmesh/CMakeLists.txt @@ -41,7 +41,6 @@ set(INC_SYS set(SRC operators/bmo_bevel.c operators/bmo_connect.c - operators/bmo_slide.c operators/bmo_create.c operators/bmo_dissolve.c operators/bmo_dupe.c diff --git a/source/blender/bmesh/bmesh.h b/source/blender/bmesh/bmesh.h index 60d38719ddb..f593f78bab7 100644 --- a/source/blender/bmesh/bmesh.h +++ b/source/blender/bmesh/bmesh.h @@ -243,6 +243,7 @@ extern "C" { #include <stdlib.h> #include <stdio.h> +#include <assert.h> #include "bmesh_class.h" diff --git a/source/blender/bmesh/bmesh_class.h b/source/blender/bmesh/bmesh_class.h index e838b130cef..4461a7afdd7 100644 --- a/source/blender/bmesh/bmesh_class.h +++ b/source/blender/bmesh/bmesh_class.h @@ -256,18 +256,17 @@ enum { }; /* defines */ - #define BM_ELEM_CD_GET_VOID_P(ele, offset) \ - ((void)0, (void *)((char *)(ele)->head.data + (offset))) + (assert(offset != -1), (void *)((char *)(ele)->head.data + (offset))) #define BM_ELEM_CD_SET_FLOAT(ele, offset, f) \ - { *((float *)((char *)(ele)->head.data + (offset))) = (f); } (void)0 + { assert(offset != -1); *((float *)((char *)(ele)->head.data + (offset))) = (f); } (void)0 #define BM_ELEM_CD_GET_FLOAT(ele, offset) \ - ((void)0, *((float *)((char *)(ele)->head.data + (offset)))) + (assert(offset != -1), *((float *)((char *)(ele)->head.data + (offset)))) #define BM_ELEM_CD_GET_FLOAT_AS_UCHAR(ele, offset) \ - (unsigned char)(BM_ELEM_CD_GET_FLOAT(ele, offset) * 255.0f) + (assert(offset != -1), (unsigned char)(BM_ELEM_CD_GET_FLOAT(ele, offset) * 255.0f)) /*forward declarations*/ diff --git a/source/blender/bmesh/intern/bmesh_construct.c b/source/blender/bmesh/intern/bmesh_construct.c index 5eeee45e7a9..fa58ccd98bc 100644 --- a/source/blender/bmesh/intern/bmesh_construct.c +++ b/source/blender/bmesh/intern/bmesh_construct.c @@ -53,7 +53,7 @@ static void bm_loop_attrs_copy(BMesh *source_mesh, BMesh *target_mesh, * \brief Make Quad/Triangle * * Creates a new quad or triangle from a list of 3 or 4 vertices. - * If \a nodouble is TRUE, then a check is done to see if a face + * If \a no_double is true, then a check is done to see if a face * with these vertices already exists and returns it instead. * * If a pointer to an example face is provided, it's custom data @@ -65,16 +65,16 @@ static void bm_loop_attrs_copy(BMesh *source_mesh, BMesh *target_mesh, BMFace *BM_face_create_quad_tri(BMesh *bm, BMVert *v1, BMVert *v2, BMVert *v3, BMVert *v4, - const BMFace *example, const int nodouble) + const BMFace *example, const bool no_double) { BMVert *vtar[4] = {v1, v2, v3, v4}; - return BM_face_create_quad_tri_v(bm, vtar, v4 ? 4 : 3, example, nodouble); + return BM_face_create_quad_tri_v(bm, vtar, v4 ? 4 : 3, example, no_double); } -BMFace *BM_face_create_quad_tri_v(BMesh *bm, BMVert **verts, int len, const BMFace *example, const int nodouble) +BMFace *BM_face_create_quad_tri_v(BMesh *bm, BMVert **verts, int len, const BMFace *example, const bool no_double) { BMFace *f = NULL; - int is_overlap = FALSE; + bool is_overlap = false; /* sanity check - debug mode only */ if (len == 3) { @@ -97,7 +97,7 @@ BMFace *BM_face_create_quad_tri_v(BMesh *bm, BMVert **verts, int len, const BMFa } - if (nodouble) { + if (no_double) { /* check if face exists or overlaps */ is_overlap = BM_face_exists(verts, len, &f); } @@ -793,7 +793,7 @@ void BM_elem_attrs_copy(BMesh *source_mesh, BMesh *target_mesh, const void *sour /* First we copy select */ if (BM_elem_flag_test((BMElem *)sheader, BM_ELEM_SELECT)) { - BM_elem_select_set(target_mesh, (BMElem *)target, TRUE); + BM_elem_select_set(target_mesh, (BMElem *)target, true); } /* Now we copy flags */ diff --git a/source/blender/bmesh/intern/bmesh_construct.h b/source/blender/bmesh/intern/bmesh_construct.h index 60c465e5f5a..0f597dbb1d8 100644 --- a/source/blender/bmesh/intern/bmesh_construct.h +++ b/source/blender/bmesh/intern/bmesh_construct.h @@ -29,10 +29,10 @@ BMFace *BM_face_create_quad_tri_v(BMesh *bm, BMVert **verts, int len, - const BMFace *example, const int nodouble); + const BMFace *example, const bool no_double); BMFace *BM_face_create_quad_tri(BMesh *bm, BMVert *v1, BMVert *v2, BMVert *v3, BMVert *v4, - const BMFace *example, const int nodouble); + const BMFace *example, const bool no_double); void BM_face_copy_shared(BMesh *bm, BMFace *f); diff --git a/source/blender/bmesh/intern/bmesh_core.c b/source/blender/bmesh/intern/bmesh_core.c index ea9ab364b84..a2f2a9a0dba 100644 --- a/source/blender/bmesh/intern/bmesh_core.c +++ b/source/blender/bmesh/intern/bmesh_core.c @@ -109,7 +109,7 @@ BMVert *BM_vert_create(BMesh *bm, const float co[3], const BMVert *example, cons * \brief Main function for creating a new edge. * * \note Duplicate edges are supported by the API however users should _never_ see them. - * so unless you need a unique edge or know the edge won't exist, you should call with \a nodouble = TRUE + * so unless you need a unique edge or know the edge won't exist, you should call with \a no_double = true */ BMEdge *BM_edge_create(BMesh *bm, BMVert *v1, BMVert *v2, const BMEdge *example, const eBMCreateFlag create_flag) { @@ -209,7 +209,8 @@ static BMLoop *bm_face_boundary_add(BMesh *bm, BMFace *f, BMVert *startv, BMEdge return l; } -BMFace *BM_face_copy(BMesh *bm, BMFace *f, const short copyverts, const short copyedges) +BMFace *BM_face_copy(BMesh *bm, BMFace *f, + const bool copy_verts, const bool copy_edges) { BMVert **verts = BLI_array_alloca(verts, f->len); BMEdge **edges = BLI_array_alloca(edges, f->len); @@ -222,7 +223,7 @@ BMFace *BM_face_copy(BMesh *bm, BMFace *f, const short copyverts, const short co l_iter = l_first = BM_FACE_FIRST_LOOP(f); i = 0; do { - if (copyverts) { + if (copy_verts) { verts[i] = BM_vert_create(bm, l_iter->v->co, l_iter->v, 0); } else { @@ -234,7 +235,7 @@ BMFace *BM_face_copy(BMesh *bm, BMFace *f, const short copyverts, const short co l_iter = l_first = BM_FACE_FIRST_LOOP(f); i = 0; do { - if (copyedges) { + if (copy_edges) { BMVert *v1, *v2; if (l_iter->e->v1 == verts[i]) { @@ -734,7 +735,7 @@ static int UNUSED_FUNCTION(bm_loop_length)(BMLoop *l) * * \return Success */ -static int bm_loop_reverse_loop(BMesh *bm, BMFace *f +static bool bm_loop_reverse_loop(BMesh *bm, BMFace *f #ifdef USE_BMESH_HOLES , BMLoopList *lst #endif @@ -748,7 +749,7 @@ static int bm_loop_reverse_loop(BMesh *bm, BMFace *f #endif const int len = f->len; - const int do_disps = CustomData_has_layer(&bm->ldata, CD_MDISPS); + const bool do_disps = CustomData_has_layer(&bm->ldata, CD_MDISPS); BMLoop *l_iter, *oldprev, *oldnext; BMEdge **edar = BLI_array_alloca(edar, len); int i, j, edok; @@ -816,13 +817,13 @@ static int bm_loop_reverse_loop(BMesh *bm, BMFace *f BM_CHECK_ELEMENT(f); - return 1; + return true; } /** * \brief Flip the faces direction */ -int bmesh_loop_reverse(BMesh *bm, BMFace *f) +bool bmesh_loop_reverse(BMesh *bm, BMFace *f) { #ifdef USE_BMESH_HOLES return bm_loop_reverse_loop(bm, f, f->loops.first); @@ -893,26 +894,26 @@ static int UNUSED_FUNCTION(count_flagged_disk)(BMVert *v, int flag) return i; } -static int disk_is_flagged(BMVert *v, int flag) +static bool disk_is_flagged(BMVert *v, int flag) { BMEdge *e = v->e; if (!e) - return FALSE; + return false; do { BMLoop *l = e->l; if (!l) { - return FALSE; + return false; } if (bmesh_radial_length(l) == 1) - return FALSE; + return false; do { if (!BM_ELEM_API_FLAG_TEST(l->f, flag)) - return FALSE; + return false; l = l->radial_next; } while (l != e->l); @@ -920,7 +921,7 @@ static int disk_is_flagged(BMVert *v, int flag) e = bmesh_disk_edge_next(e, v); } while (e != v->e); - return TRUE; + return true; } /* Mid-level Topology Manipulation Functions */ @@ -939,7 +940,7 @@ static int disk_is_flagged(BMVert *v, int flag) * \note this is a generic, flexible join faces function, * almost everything uses this, including #BM_faces_join_pair */ -BMFace *BM_faces_join(BMesh *bm, BMFace **faces, int totface, const short do_del) +BMFace *BM_faces_join(BMesh *bm, BMFace **faces, int totface, const bool do_del) { BMFace *f, *newf; #ifdef USE_BMESH_HOLES @@ -1198,7 +1199,7 @@ BMFace *bmesh_sfme(BMesh *bm, BMFace *f, BMVert *v1, BMVert *v2, ListBase *holes, #endif BMEdge *example, - const short nodouble + const bool no_double ) { #ifdef USE_BMESH_HOLES @@ -1225,7 +1226,7 @@ BMFace *bmesh_sfme(BMesh *bm, BMFace *f, BMVert *v1, BMVert *v2, } /* allocate new edge between v1 and v2 */ - e = BM_edge_create(bm, v1, v2, example, nodouble ? BM_CREATE_NO_DOUBLE : 0); + e = BM_edge_create(bm, v1, v2, example, no_double ? BM_CREATE_NO_DOUBLE : 0); f2 = bm_face_create__sfme(bm, f); f1loop = bm_loop_create(bm, v2, e, f, v2loop, 0); @@ -1351,9 +1352,10 @@ BMVert *bmesh_semv(BMesh *bm, BMVert *tv, BMEdge *e, BMEdge **r_e) BMLoop *nextl; BMEdge *ne; BMVert *nv, *ov; - int i, edok, valence1 = 0, valence2 = 0; + int i, valence1 = 0, valence2 = 0; + bool edok; - BLI_assert(bmesh_vert_in_edge(e, tv) != FALSE); + BLI_assert(bmesh_vert_in_edge(e, tv) != false); ov = bmesh_edge_other_vert_get(e, tv); @@ -1384,11 +1386,11 @@ BMVert *bmesh_semv(BMesh *bm, BMVert *tv, BMEdge *e, BMEdge **r_e) /* verify disk cycles */ edok = bmesh_disk_validate(valence1, ov->e, ov); - BMESH_ASSERT(edok != FALSE); + BMESH_ASSERT(edok != false); edok = bmesh_disk_validate(valence2, tv->e, tv); - BMESH_ASSERT(edok != FALSE); + BMESH_ASSERT(edok != false); edok = bmesh_disk_validate(2, nv->e, nv); - BMESH_ASSERT(edok != FALSE); + BMESH_ASSERT(edok != false); /* Split the radial cycle if present */ nextl = e->l; @@ -1454,9 +1456,9 @@ BMVert *bmesh_semv(BMesh *bm, BMVert *tv, BMEdge *e, BMEdge **r_e) /* verify length of radial cycle */ edok = bmesh_radial_validate(radlen, e->l); - BMESH_ASSERT(edok != FALSE); + BMESH_ASSERT(edok != false); edok = bmesh_radial_validate(radlen, ne->l); - BMESH_ASSERT(edok != FALSE); + BMESH_ASSERT(edok != false); /* verify loop->v and loop->next->v pointers for e */ for (i = 0, l = e->l; i < radlen; i++, l = l->radial_next) { @@ -1465,7 +1467,7 @@ BMVert *bmesh_semv(BMesh *bm, BMVert *tv, BMEdge *e, BMEdge **r_e) BMESH_ASSERT(!(l->prev->e != ne && l->next->e != ne)); edok = bmesh_verts_in_edge(l->v, l->next->v, e); - BMESH_ASSERT(edok != FALSE); + BMESH_ASSERT(edok != false); BMESH_ASSERT(l->v != l->next->v); BMESH_ASSERT(l->e != l->next->e); @@ -1481,7 +1483,7 @@ BMVert *bmesh_semv(BMesh *bm, BMVert *tv, BMEdge *e, BMEdge **r_e) // BMESH_ASSERT(l->radial_next == l); BMESH_ASSERT(!(l->prev->e != e && l->next->e != e)); edok = bmesh_verts_in_edge(l->v, l->next->v, ne); - BMESH_ASSERT(edok != FALSE); + BMESH_ASSERT(edok != false); BMESH_ASSERT(l->v != l->next->v); BMESH_ASSERT(l->e != l->next->e); @@ -1533,12 +1535,13 @@ BMVert *bmesh_semv(BMesh *bm, BMVert *tv, BMEdge *e, BMEdge **r_e) * faces with just 2 edges. It is up to the caller to decide what to do with * these faces. */ -BMEdge *bmesh_jekv(BMesh *bm, BMEdge *ke, BMVert *kv, const short check_edge_double) +BMEdge *bmesh_jekv(BMesh *bm, BMEdge *ke, BMVert *kv, const bool check_edge_double) { BMEdge *oe; BMVert *ov, *tv; BMLoop *killoop, *l; - int len, radlen = 0, halt = 0, i, valence1, valence2, edok; + int len, radlen = 0, i, valence1, valence2; + bool edok, halt = false; if (bmesh_vert_in_edge(ke, kv) == 0) { return NULL; @@ -1617,7 +1620,7 @@ BMEdge *bmesh_jekv(BMesh *bm, BMEdge *ke, BMVert *kv, const short check_edge_dou /* Validate radial cycle of oe */ edok = bmesh_radial_validate(radlen, oe->l); - BMESH_ASSERT(edok != FALSE); + BMESH_ASSERT(edok != false); } /* deallocate edge */ @@ -1628,17 +1631,17 @@ BMEdge *bmesh_jekv(BMesh *bm, BMEdge *ke, BMVert *kv, const short check_edge_dou /* Validate disk cycle lengths of ov, tv are unchanged */ edok = bmesh_disk_validate(valence1, ov->e, ov); - BMESH_ASSERT(edok != FALSE); + BMESH_ASSERT(edok != false); edok = bmesh_disk_validate(valence2, tv->e, tv); - BMESH_ASSERT(edok != FALSE); + BMESH_ASSERT(edok != false); /* Validate loop cycle of all faces attached to 'oe' */ for (i = 0, l = oe->l; i < radlen; i++, l = l->radial_next) { BMESH_ASSERT(l->e == oe); edok = bmesh_verts_in_edge(l->v, l->next->v, oe); - BMESH_ASSERT(edok != FALSE); + BMESH_ASSERT(edok != false); edok = bmesh_loop_validate(l->f); - BMESH_ASSERT(edok != FALSE); + BMESH_ASSERT(edok != false); BM_CHECK_ELEMENT(l); BM_CHECK_ELEMENT(l->v); @@ -1806,7 +1809,7 @@ BMFace *bmesh_jfke(BMesh *bm, BMFace *f1, BMFace *f2, BMEdge *e) /* validate the new loop cycle */ edok = bmesh_loop_validate(f1); - BMESH_ASSERT(edok != FALSE); + BMESH_ASSERT(edok != false); return f1; } @@ -1822,7 +1825,7 @@ BMFace *bmesh_jfke(BMesh *bm, BMFace *f1, BMFace *f2, BMEdge *e) * where \a v and \a vtarget are connected by an edge * (assert checks for this case). */ -int BM_vert_splice(BMesh *bm, BMVert *v, BMVert *v_target) +bool BM_vert_splice(BMesh *bm, BMVert *v, BMVert *v_target) { void *loops_stack[BM_DEFAULT_ITER_STACK_SIZE]; BMLoop **loops; @@ -1832,7 +1835,7 @@ int BM_vert_splice(BMesh *bm, BMVert *v, BMVert *v_target) /* verts already spliced */ if (v == v_target) { - return FALSE; + return false; } /* we can't modify the vert while iterating so first allocate an array of loops */ @@ -1862,7 +1865,7 @@ int BM_vert_splice(BMesh *bm, BMVert *v, BMVert *v_target) /* v is unused now, and can be killed */ BM_vert_kill(bm, v); - return TRUE; + return true; } /** @@ -1876,7 +1879,7 @@ int BM_vert_splice(BMesh *bm, BMVert *v, BMVert *v_target) * * \return Success */ -int bmesh_vert_separate(BMesh *bm, BMVert *v, BMVert ***r_vout, int *r_vout_len) +bool bmesh_vert_separate(BMesh *bm, BMVert *v, BMVert ***r_vout, int *r_vout_len) { BMEdge **stack = NULL; BLI_array_staticdeclare(stack, BM_DEFAULT_ITER_STACK_SIZE); @@ -1993,13 +1996,13 @@ int bmesh_vert_separate(BMesh *bm, BMVert *v, BMVert ***r_vout, int *r_vout_len) MEM_freeN(verts); } - return TRUE; + return true; } /** * High level function which wraps both #bmesh_vert_separate and #bmesh_edge_separate */ -int BM_vert_separate(BMesh *bm, BMVert *v, BMVert ***r_vout, int *r_vout_len, +bool BM_vert_separate(BMesh *bm, BMVert *v, BMVert ***r_vout, int *r_vout_len, BMEdge **e_in, int e_in_len) { int i; @@ -2023,7 +2026,7 @@ int BM_vert_separate(BMesh *bm, BMVert *v, BMVert ***r_vout, int *r_vout_len, * * \note Edges must already have the same vertices. */ -int BM_edge_splice(BMesh *bm, BMEdge *e, BMEdge *e_target) +bool BM_edge_splice(BMesh *bm, BMEdge *e, BMEdge *e_target) { BMLoop *l; @@ -2034,7 +2037,7 @@ int BM_edge_splice(BMesh *bm, BMEdge *e, BMEdge *e_target) * so assert on release builds */ BLI_assert(0); - return FALSE; + return false; } while (e->l) { @@ -2053,7 +2056,7 @@ int BM_edge_splice(BMesh *bm, BMEdge *e, BMEdge *e_target) /* removes from disks too */ BM_edge_kill(bm, e); - return TRUE; + return true; } /** @@ -2067,7 +2070,7 @@ int BM_edge_splice(BMesh *bm, BMEdge *e, BMEdge *e_target) * \note Does nothing if \a l_sep is already the only loop in the * edge radial. */ -int bmesh_edge_separate(BMesh *bm, BMEdge *e, BMLoop *l_sep) +bool bmesh_edge_separate(BMesh *bm, BMEdge *e, BMLoop *l_sep) { BMEdge *ne; int radlen; @@ -2078,7 +2081,7 @@ int bmesh_edge_separate(BMesh *bm, BMEdge *e, BMLoop *l_sep) radlen = bmesh_radial_length(e->l); if (radlen < 2) { /* no cut required */ - return TRUE; + return true; } if (l_sep == e->l) { @@ -2096,7 +2099,7 @@ int bmesh_edge_separate(BMesh *bm, BMEdge *e, BMLoop *l_sep) BM_CHECK_ELEMENT(ne); BM_CHECK_ELEMENT(e); - return TRUE; + return true; } /** diff --git a/source/blender/bmesh/intern/bmesh_core.h b/source/blender/bmesh/intern/bmesh_core.h index 5fd4a6ec7df..d8cfc973394 100644 --- a/source/blender/bmesh/intern/bmesh_core.h +++ b/source/blender/bmesh/intern/bmesh_core.h @@ -27,7 +27,8 @@ * \ingroup bmesh */ -BMFace *BM_face_copy(BMesh *bm, BMFace *f, const short copyverts, const short copyedges); +BMFace *BM_face_copy(BMesh *bm, BMFace *f, + const bool copy_verts, const bool copy_edges); typedef enum eBMCreateFlag { /* faces and edges only */ @@ -49,16 +50,16 @@ void BM_face_kill(BMesh *bm, BMFace *f); void BM_edge_kill(BMesh *bm, BMEdge *e); void BM_vert_kill(BMesh *bm, BMVert *v); -int bmesh_edge_separate(BMesh *bm, BMEdge *e, BMLoop *l_sep); -int BM_edge_splice(BMesh *bm, BMEdge *e, BMEdge *e_target); -int BM_vert_splice(BMesh *bm, BMVert *v, BMVert *v_target); +bool bmesh_edge_separate(BMesh *bm, BMEdge *e, BMLoop *l_sep); +bool BM_edge_splice(BMesh *bm, BMEdge *e, BMEdge *e_target); +bool BM_vert_splice(BMesh *bm, BMVert *v, BMVert *v_target); -int bmesh_vert_separate(BMesh *bm, BMVert *v, BMVert ***r_vout, int *r_vout_len); +bool bmesh_vert_separate(BMesh *bm, BMVert *v, BMVert ***r_vout, int *r_vout_len); -int bmesh_loop_reverse(BMesh *bm, BMFace *f); +bool bmesh_loop_reverse(BMesh *bm, BMFace *f); -BMFace *BM_faces_join(BMesh *bm, BMFace **faces, int totface, const short do_del); -int BM_vert_separate(BMesh *bm, BMVert *v, BMVert ***r_vout, int *r_vout_len, +BMFace *BM_faces_join(BMesh *bm, BMFace **faces, int totface, const bool do_del); +bool BM_vert_separate(BMesh *bm, BMVert *v, BMVert ***r_vout, int *r_vout_len, BMEdge **e_in, int e_in_len); /* EULER API - For modifying structure */ @@ -68,11 +69,11 @@ BMFace *bmesh_sfme(BMesh *bm, BMFace *f, BMVert *v1, ListBase *holes, #endif BMEdge *example, - const short nodouble + const bool no_double ); BMVert *bmesh_semv(BMesh *bm, BMVert *tv, BMEdge *e, BMEdge **r_e); -BMEdge *bmesh_jekv(BMesh *bm, BMEdge *ke, BMVert *kv, const short check_edge_splice); +BMEdge *bmesh_jekv(BMesh *bm, BMEdge *ke, BMVert *kv, const bool check_edge_splice); BMFace *bmesh_jfke(BMesh *bm, BMFace *f1, BMFace *f2, BMEdge *e); BMVert *bmesh_urmv(BMesh *bm, BMFace *sf, BMVert *sv); BMVert *bmesh_urmv_loop(BMesh *bm, BMLoop *sl); diff --git a/source/blender/bmesh/intern/bmesh_error.h b/source/blender/bmesh/intern/bmesh_error.h index 2ef146c7b38..0f23f87c143 100644 --- a/source/blender/bmesh/intern/bmesh_error.h +++ b/source/blender/bmesh/intern/bmesh_error.h @@ -35,11 +35,11 @@ void BMO_error_raise(BMesh *bm, BMOperator *owner, int errcode, const char *msg) /* gets the topmost error from the stack. * returns error code or 0 if no error.*/ -int BMO_error_get(BMesh *bm, const char **msg, BMOperator **op); -int BMO_error_occurred(BMesh *bm); +int BMO_error_get(BMesh *bm, const char **msg, BMOperator **op); +bool BMO_error_occurred(BMesh *bm); /* same as geterror, only pops the error off the stack as well */ -int BMO_error_pop(BMesh *bm, const char **msg, BMOperator **op); +int BMO_error_pop(BMesh *bm, const char **msg, BMOperator **op); void BMO_error_clear(BMesh *bm); /* this is meant for handling errors, like self-intersection test failures. diff --git a/source/blender/bmesh/intern/bmesh_inline.h b/source/blender/bmesh/intern/bmesh_inline.h index 04b214f725a..102e9d47ffd 100644 --- a/source/blender/bmesh/intern/bmesh_inline.h +++ b/source/blender/bmesh/intern/bmesh_inline.h @@ -44,7 +44,7 @@ BLI_INLINE char _bm_elem_flag_test(const BMHeader *head, const char hflag) return head->hflag & hflag; } -BLI_INLINE short _bm_elem_flag_test_bool(const BMHeader *head, const char hflag) +BLI_INLINE bool _bm_elem_flag_test_bool(const BMHeader *head, const char hflag) { return (head->hflag & hflag) != 0; } diff --git a/source/blender/bmesh/intern/bmesh_interp.c b/source/blender/bmesh/intern/bmesh_interp.c index 1afaf851e2a..44b8baace4c 100644 --- a/source/blender/bmesh/intern/bmesh_interp.c +++ b/source/blender/bmesh/intern/bmesh_interp.c @@ -599,7 +599,7 @@ void BM_loop_interp_multires(BMesh *bm, BMLoop *target, BMFace *source) * if do_vertex is true, target's vert data will also get interpolated. */ void BM_loop_interp_from_face(BMesh *bm, BMLoop *target, BMFace *source, - int do_vertex, int do_multires) + const bool do_vertex, const bool do_multires) { BMLoop *l_iter; BMLoop *l_first; diff --git a/source/blender/bmesh/intern/bmesh_interp.h b/source/blender/bmesh/intern/bmesh_interp.h index 8be963f5798..3563ed1f40e 100644 --- a/source/blender/bmesh/intern/bmesh_interp.h +++ b/source/blender/bmesh/intern/bmesh_interp.h @@ -44,7 +44,7 @@ void BM_elem_float_data_set(CustomData *cd, void *element, int type, const floa void BM_face_interp_from_face(BMesh *bm, BMFace *target, BMFace *source); void BM_loop_interp_from_face(BMesh *bm, BMLoop *target, BMFace *source, - int do_vertex, int do_multires); + const bool do_vertex, const bool do_multires); void BM_face_multires_bounds_smooth(BMesh *bm, BMFace *f); diff --git a/source/blender/bmesh/intern/bmesh_iterators.c b/source/blender/bmesh/intern/bmesh_iterators.c index c3f33eb95e1..44b76df7432 100644 --- a/source/blender/bmesh/intern/bmesh_iterators.c +++ b/source/blender/bmesh/intern/bmesh_iterators.c @@ -164,14 +164,12 @@ void *BM_iter_as_arrayN(BMesh *bm, const char itype, void *data, int *r_len, * * Counts how many flagged / unflagged items are found in this element. */ -int BM_iter_elem_count_flag(const char itype, void *data, const char hflag, const short value) +int BM_iter_elem_count_flag(const char itype, void *data, const char hflag, const bool value) { BMIter iter; BMElem *ele; int count = 0; - BLI_assert(ELEM(value, TRUE, FALSE)); - for (ele = BM_iter_new(&iter, NULL, itype, data); ele; ele = BM_iter_step(&iter)) { if (BM_elem_flag_test_bool(ele, hflag) == value) { count++; @@ -186,14 +184,12 @@ int BM_iter_elem_count_flag(const char itype, void *data, const char hflag, cons * * Counts how many flagged / unflagged items are found in this mesh. */ -int BM_iter_mesh_count_flag(const char itype, BMesh *bm, const char hflag, const short value) +int BM_iter_mesh_count_flag(const char itype, BMesh *bm, const char hflag, const bool value) { BMIter iter; BMElem *ele; int count = 0; - BLI_assert(ELEM(value, TRUE, FALSE)); - for (ele = BM_iter_new(&iter, bm, itype, NULL); ele; ele = BM_iter_step(&iter)) { if (BM_elem_flag_test_bool(ele, hflag) == value) { count++; diff --git a/source/blender/bmesh/intern/bmesh_iterators.h b/source/blender/bmesh/intern/bmesh_iterators.h index 7291bca6356..3b795a253bd 100644 --- a/source/blender/bmesh/intern/bmesh_iterators.h +++ b/source/blender/bmesh/intern/bmesh_iterators.h @@ -131,8 +131,8 @@ void *BM_iter_as_arrayN(BMesh *bm, const char itype, void *data, int *r_len, __attribute__((warn_unused_result)) #endif ; -int BM_iter_elem_count_flag(const char itype, void *data, const char hflag, const short value); -int BM_iter_mesh_count_flag(const char itype, BMesh *bm, const char hflag, const short value); +int BM_iter_elem_count_flag(const char itype, void *data, const char hflag, const bool value); +int BM_iter_mesh_count_flag(const char itype, BMesh *bm, const char hflag, const bool value); /* private for bmesh_iterators_inline.c */ void bmiter__vert_of_mesh_begin(struct BMIter *iter); diff --git a/source/blender/bmesh/intern/bmesh_iterators_inline.h b/source/blender/bmesh/intern/bmesh_iterators_inline.h index 96816521493..d9784ac9b2a 100644 --- a/source/blender/bmesh/intern/bmesh_iterators_inline.h +++ b/source/blender/bmesh/intern/bmesh_iterators_inline.h @@ -50,7 +50,7 @@ BLI_INLINE void *BM_iter_step(BMIter *iter) * it with the appropriate function pointers based * upon its type. */ -BLI_INLINE int BM_iter_init(BMIter *iter, BMesh *bm, const char itype, void *data) +BLI_INLINE bool BM_iter_init(BMIter *iter, BMesh *bm, const char itype, void *data) { /* int argtype; */ iter->itype = itype; @@ -77,91 +77,61 @@ BLI_INLINE int BM_iter_init(BMIter *iter, BMesh *bm, const char itype, void *dat iter->step = bmiter__face_of_mesh_step; break; case BM_EDGES_OF_VERT: - if (UNLIKELY(!data)) { - return FALSE; - } - + BLI_assert(data != NULL); iter->begin = bmiter__edge_of_vert_begin; iter->step = bmiter__edge_of_vert_step; iter->vdata = data; break; case BM_FACES_OF_VERT: - if (UNLIKELY(!data)) { - return FALSE; - } - + BLI_assert(data != NULL); iter->begin = bmiter__face_of_vert_begin; iter->step = bmiter__face_of_vert_step; iter->vdata = data; break; case BM_LOOPS_OF_VERT: - if (UNLIKELY(!data)) { - return FALSE; - } - + BLI_assert(data != NULL); iter->begin = bmiter__loop_of_vert_begin; iter->step = bmiter__loop_of_vert_step; iter->vdata = data; break; case BM_VERTS_OF_EDGE: - if (UNLIKELY(!data)) { - return FALSE; - } - + BLI_assert(data != NULL); iter->begin = bmiter__vert_of_edge_begin; iter->step = bmiter__vert_of_edge_step; iter->edata = data; break; case BM_FACES_OF_EDGE: - if (UNLIKELY(!data)) { - return FALSE; - } - + BLI_assert(data != NULL); iter->begin = bmiter__face_of_edge_begin; iter->step = bmiter__face_of_edge_step; iter->edata = data; break; case BM_VERTS_OF_FACE: - if (UNLIKELY(!data)) { - return FALSE; - } - + BLI_assert(data != NULL); iter->begin = bmiter__vert_of_face_begin; iter->step = bmiter__vert_of_face_step; iter->pdata = data; break; case BM_EDGES_OF_FACE: - if (UNLIKELY(!data)) { - return FALSE; - } - + BLI_assert(data != NULL); iter->begin = bmiter__edge_of_face_begin; iter->step = bmiter__edge_of_face_step; iter->pdata = data; break; case BM_LOOPS_OF_FACE: - if (UNLIKELY(!data)) { - return FALSE; - } - + BLI_assert(data != NULL); iter->begin = bmiter__loop_of_face_begin; iter->step = bmiter__loop_of_face_step; iter->pdata = data; break; case BM_LOOPS_OF_LOOP: - if (UNLIKELY(!data)) { - return FALSE; - } - + BLI_assert(data != NULL); iter->begin = bmiter__loops_of_loop_begin; iter->step = bmiter__loops_of_loop_step; iter->ldata = data; break; case BM_LOOPS_OF_EDGE: - if (UNLIKELY(!data)) { - return FALSE; - } - + BLI_assert(data != NULL); iter->begin = bmiter__loops_of_edge_begin; iter->step = bmiter__loops_of_edge_step; iter->edata = data; @@ -169,13 +139,13 @@ BLI_INLINE int BM_iter_init(BMIter *iter, BMesh *bm, const char itype, void *dat default: /* should never happen */ BLI_assert(0); - return FALSE; + return false; break; } iter->begin(iter); - return TRUE; + return true; } /** diff --git a/source/blender/bmesh/intern/bmesh_log.c b/source/blender/bmesh/intern/bmesh_log.c index a2510129df6..68f8f38fb26 100644 --- a/source/blender/bmesh/intern/bmesh_log.c +++ b/source/blender/bmesh/intern/bmesh_log.c @@ -215,7 +215,8 @@ static BMLogFace *bm_log_face_alloc(BMLog *log, BMFace *f) BLI_assert(f->len == 3); - BM_iter_as_array(NULL, BM_VERTS_OF_FACE, f, (void **)v, 3); + // BM_iter_as_array(NULL, BM_VERTS_OF_FACE, f, (void **)v, 3); + BM_face_as_array_vert_tri(f, v); lf->v_ids[0] = bm_log_vert_id_get(log, v[0]); lf->v_ids[1] = bm_log_vert_id_get(log, v[1]); @@ -276,11 +277,11 @@ static void bm_log_faces_restore(BMesh *bm, BMLog *log, GHash *faces) void *key = BLI_ghashIterator_getKey(&gh_iter); BMLogFace *lf = BLI_ghashIterator_getValue(&gh_iter); BMVert *v[3] = {bm_log_vert_from_id(log, lf->v_ids[0]), - bm_log_vert_from_id(log, lf->v_ids[1]), - bm_log_vert_from_id(log, lf->v_ids[2])}; + bm_log_vert_from_id(log, lf->v_ids[1]), + bm_log_vert_from_id(log, lf->v_ids[2])}; BMFace *f; - f = BM_face_create_quad_tri_v(bm, v, 3, NULL, FALSE); + f = BM_face_create_quad_tri_v(bm, v, 3, NULL, false); bm_log_face_id_set(log, f, GET_INT_FROM_POINTER(key)); } } @@ -805,8 +806,11 @@ void BM_log_vert_removed(BMesh *bm, BMLog *log, BMVert *v) unsigned int v_id = bm_log_vert_id_get(log, v); void *key = SET_INT_IN_POINTER(v_id); - if (BLI_ghash_lookup(entry->added_verts, key)) { - BLI_ghash_remove(entry->added_verts, key, NULL, NULL); + /* if it has a key, it shouldn't be NULL */ + BLI_assert(!!BLI_ghash_lookup(entry->added_verts, key) == + !!BLI_ghash_haskey(entry->added_verts, key)); + + if (BLI_ghash_remove(entry->added_verts, key, NULL, NULL)) { range_tree_uint_release(log->unused_ids, v_id); } else { @@ -843,8 +847,11 @@ void BM_log_face_removed(BMLog *log, BMFace *f) unsigned int f_id = bm_log_face_id_get(log, f); void *key = SET_INT_IN_POINTER(f_id); - if (BLI_ghash_lookup(entry->added_faces, key)) { - BLI_ghash_remove(entry->added_faces, key, NULL, NULL); + /* if it has a key, it shouldn't be NULL */ + BLI_assert(!!BLI_ghash_lookup(entry->added_faces, key) == + !!BLI_ghash_haskey(entry->added_faces, key)); + + if (BLI_ghash_remove(entry->added_faces, key, NULL, NULL)) { range_tree_uint_release(log->unused_ids, f_id); } else { diff --git a/source/blender/bmesh/intern/bmesh_marking.c b/source/blender/bmesh/intern/bmesh_marking.c index 669be315cc6..4e29756104a 100644 --- a/source/blender/bmesh/intern/bmesh_marking.c +++ b/source/blender/bmesh/intern/bmesh_marking.c @@ -107,18 +107,18 @@ void BM_mesh_select_mode_flush_ex(BMesh *bm, const short selectmode) #pragma omp section { BM_ITER_MESH (f, &fiter, bm, BM_FACES_OF_MESH) { - int ok = TRUE; + bool ok = true; if (!BM_elem_flag_test(f, BM_ELEM_HIDDEN)) { l_iter = l_first = BM_FACE_FIRST_LOOP(f); do { if (!BM_elem_flag_test(l_iter->v, BM_ELEM_SELECT)) { - ok = FALSE; + ok = false; break; } } while ((l_iter = l_iter->next) != l_first); } else { - ok = FALSE; + ok = false; } BM_elem_flag_set(f, BM_ELEM_SELECT, ok); @@ -129,18 +129,18 @@ void BM_mesh_select_mode_flush_ex(BMesh *bm, const short selectmode) } else if (selectmode & SCE_SELECT_EDGE) { BM_ITER_MESH (f, &fiter, bm, BM_FACES_OF_MESH) { - int ok = TRUE; + bool ok = true; if (!BM_elem_flag_test(f, BM_ELEM_HIDDEN)) { l_iter = l_first = BM_FACE_FIRST_LOOP(f); do { if (!BM_elem_flag_test(l_iter->e, BM_ELEM_SELECT)) { - ok = FALSE; + ok = false; break; } } while ((l_iter = l_iter->next) != l_first); } else { - ok = FALSE; + ok = false; } BM_elem_flag_set(f, BM_ELEM_SELECT, ok); @@ -171,7 +171,7 @@ void BM_mesh_deselect_flush(BMesh *bm) BMIter eiter; BMIter fiter; - int ok; + bool ok; /* we can use 2 sections here because the second loop isnt checking edge selection */ #pragma omp parallel sections if (bm->totedge + bm->totface >= BM_OMP_LIMIT) @@ -191,21 +191,21 @@ void BM_mesh_deselect_flush(BMesh *bm) #pragma omp section { BM_ITER_MESH (f, &fiter, bm, BM_FACES_OF_MESH) { - ok = TRUE; + ok = true; if (!BM_elem_flag_test(f, BM_ELEM_HIDDEN)) { l_iter = l_first = BM_FACE_FIRST_LOOP(f); do { if (!BM_elem_flag_test(l_iter->v, BM_ELEM_SELECT)) { - ok = FALSE; + ok = false; break; } } while ((l_iter = l_iter->next) != l_first); } else { - ok = FALSE; + ok = false; } - if (ok == FALSE) { + if (ok == false) { BM_elem_flag_disable(f, BM_ELEM_SELECT); } } @@ -233,7 +233,7 @@ void BM_mesh_select_flush(BMesh *bm) BMIter eiter; BMIter fiter; - int ok; + bool ok; /* we can use 2 sections here because the second loop isnt checking edge selection */ #pragma omp parallel sections if (bm->totedge + bm->totface >= BM_OMP_LIMIT) @@ -253,18 +253,18 @@ void BM_mesh_select_flush(BMesh *bm) #pragma omp section { BM_ITER_MESH (f, &fiter, bm, BM_FACES_OF_MESH) { - ok = TRUE; + ok = true; if (!BM_elem_flag_test(f, BM_ELEM_HIDDEN)) { l_iter = l_first = BM_FACE_FIRST_LOOP(f); do { if (!BM_elem_flag_test(l_iter->v, BM_ELEM_SELECT)) { - ok = FALSE; + ok = false; break; } } while ((l_iter = l_iter->next) != l_first); } else { - ok = FALSE; + ok = false; } if (ok) { @@ -283,7 +283,7 @@ void BM_mesh_select_flush(BMesh *bm) * Changes selection state of a single vertex * in a mesh */ -void BM_vert_select_set(BMesh *bm, BMVert *v, int select) +void BM_vert_select_set(BMesh *bm, BMVert *v, const bool select) { BLI_assert(v->head.htype == BM_VERT); @@ -310,7 +310,7 @@ void BM_vert_select_set(BMesh *bm, BMVert *v, int select) * * Changes selection state of a single edge in a mesh. */ -void BM_edge_select_set(BMesh *bm, BMEdge *e, int select) +void BM_edge_select_set(BMesh *bm, BMEdge *e, const bool select) { BLI_assert(e->head.htype == BM_EDGE); @@ -322,8 +322,8 @@ void BM_edge_select_set(BMesh *bm, BMEdge *e, int select) if (!BM_elem_flag_test(e, BM_ELEM_SELECT)) bm->totedgesel += 1; BM_elem_flag_enable(e, BM_ELEM_SELECT); - BM_vert_select_set(bm, e->v1, TRUE); - BM_vert_select_set(bm, e->v2, TRUE); + BM_vert_select_set(bm, e->v1, true); + BM_vert_select_set(bm, e->v2, true); } else { if (BM_elem_flag_test(e, BM_ELEM_SELECT)) bm->totedgesel -= 1; @@ -354,13 +354,13 @@ void BM_edge_select_set(BMesh *bm, BMEdge *e, int select) } if (deselect) { - BM_vert_select_set(bm, verts[i], FALSE); + BM_vert_select_set(bm, verts[i], false); } } } else { - BM_vert_select_set(bm, e->v1, FALSE); - BM_vert_select_set(bm, e->v2, FALSE); + BM_vert_select_set(bm, e->v1, false); + BM_vert_select_set(bm, e->v2, false); } } @@ -372,7 +372,7 @@ void BM_edge_select_set(BMesh *bm, BMEdge *e, int select) * Changes selection state of a single * face in a mesh. */ -void BM_face_select_set(BMesh *bm, BMFace *f, int select) +void BM_face_select_set(BMesh *bm, BMFace *f, const bool select) { BMLoop *l_iter; BMLoop *l_first; @@ -391,8 +391,8 @@ void BM_face_select_set(BMesh *bm, BMFace *f, int select) BM_elem_flag_enable(f, BM_ELEM_SELECT); l_iter = l_first = BM_FACE_FIRST_LOOP(f); do { - BM_vert_select_set(bm, l_iter->v, TRUE); - BM_edge_select_set(bm, l_iter->e, TRUE); + BM_vert_select_set(bm, l_iter->v, true); + BM_edge_select_set(bm, l_iter->e, true); } while ((l_iter = l_iter->next) != l_first); } else { @@ -412,7 +412,7 @@ void BM_face_select_set(BMesh *bm, BMFace *f, int select) } if (!f2) { - BM_edge_select_set(bm, l->e, FALSE); + BM_edge_select_set(bm, l->e, false); } } @@ -426,7 +426,7 @@ void BM_face_select_set(BMesh *bm, BMFace *f, int select) } if (!e) { - BM_vert_select_set(bm, l->v, FALSE); + BM_vert_select_set(bm, l->v, false); } } } @@ -467,7 +467,7 @@ void BM_mesh_select_mode_set(BMesh *bm, int selectmode) BM_ITER_MESH (ele, &iter, bm, BM_EDGES_OF_MESH) { if (BM_elem_flag_test(ele, BM_ELEM_SELECT)) { - BM_edge_select_set(bm, (BMEdge *)ele, TRUE); + BM_edge_select_set(bm, (BMEdge *)ele, true); } } BM_mesh_select_mode_flush(bm); @@ -481,7 +481,7 @@ void BM_mesh_select_mode_set(BMesh *bm, int selectmode) #endif BM_ITER_MESH (ele, &iter, bm, BM_FACES_OF_MESH) { if (BM_elem_flag_test(ele, BM_ELEM_SELECT)) { - BM_face_select_set(bm, (BMFace *)ele, TRUE); + BM_face_select_set(bm, (BMFace *)ele, true); } } BM_mesh_select_mode_flush(bm); @@ -492,14 +492,12 @@ void BM_mesh_select_mode_set(BMesh *bm, int selectmode) * counts number of elements with flag enabled/disabled */ static int bm_mesh_flag_count(BMesh *bm, const char htype, const char hflag, - const short respecthide, const short test_for_enabled) + const short respecthide, const bool test_for_enabled) { BMElem *ele; BMIter iter; int tot = 0; - BLI_assert(ELEM(test_for_enabled, TRUE, FALSE)); - if (htype & BM_VERT) { for (ele = BM_iter_new(&iter, bm, BM_VERTS_OF_MESH, NULL); ele; ele = BM_iter_step(&iter)) { if (respecthide && BM_elem_flag_test(ele, BM_ELEM_HIDDEN)) continue; @@ -522,21 +520,21 @@ static int bm_mesh_flag_count(BMesh *bm, const char htype, const char hflag, return tot; } -int BM_mesh_elem_hflag_count_enabled(BMesh *bm, const char htype, const char hflag, int respecthide) +int BM_mesh_elem_hflag_count_enabled(BMesh *bm, const char htype, const char hflag, const bool respecthide) { - return bm_mesh_flag_count(bm, htype, hflag, respecthide, TRUE); + return bm_mesh_flag_count(bm, htype, hflag, respecthide, true); } -int BM_mesh_elem_hflag_count_disabled(BMesh *bm, const char htype, const char hflag, int respecthide) +int BM_mesh_elem_hflag_count_disabled(BMesh *bm, const char htype, const char hflag, const bool respecthide) { - return bm_mesh_flag_count(bm, htype, hflag, respecthide, FALSE); + return bm_mesh_flag_count(bm, htype, hflag, respecthide, false); } /** * \note use BM_elem_flag_test(ele, BM_ELEM_SELECT) to test selection * \note by design, this will not touch the editselection history stuff */ -void BM_elem_select_set(BMesh *bm, BMElem *ele, int select) +void BM_elem_select_set(BMesh *bm, BMElem *ele, const bool select) { switch (ele->head.htype) { case BM_VERT: @@ -560,12 +558,12 @@ void BM_active_face_set(BMesh *bm, BMFace *efa) bm->act_face = efa; } -BMFace *BM_active_face_get(BMesh *bm, int sloppy, int selected) +BMFace *BM_active_face_get(BMesh *bm, const bool is_sloppy, const bool is_selected) { - if (bm->act_face && (!selected || BM_elem_flag_test(bm->act_face, BM_ELEM_SELECT))) { + if (bm->act_face && (!is_selected || BM_elem_flag_test(bm->act_face, BM_ELEM_SELECT))) { return bm->act_face; } - else if (sloppy) { + else if (is_sloppy) { BMIter iter; BMFace *f = NULL; BMEditSelection *ese; @@ -579,7 +577,7 @@ BMFace *BM_active_face_get(BMesh *bm, int sloppy, int selected) if (BM_elem_flag_test(f, BM_ELEM_HIDDEN)) { f = NULL; } - else if (selected && !BM_elem_flag_test(f, BM_ELEM_SELECT)) { + else if (is_selected && !BM_elem_flag_test(f, BM_ELEM_SELECT)) { f = NULL; } else { @@ -712,12 +710,13 @@ void BM_editselection_plane(BMEditSelection *ese, float r_plane[3]) cross_v3_v3v3(r_plane, efa->no, vec); } else { - BMVert *verts[4] = {NULL}; - - BM_iter_as_array(NULL, BM_VERTS_OF_FACE, efa, (void **)verts, 4); - if (efa->len == 4) { + BMVert *verts[4] = {NULL}; float vecA[3], vecB[3]; + + // BM_iter_as_array(NULL, BM_VERTS_OF_FACE, efa, (void **)verts, 4); + BM_face_as_array_vert_quad(efa, verts); + sub_v3_v3v3(vecA, verts[3]->co, verts[2]->co); sub_v3_v3v3(vecB, verts[0]->co, verts[1]->co); add_v3_v3v3(r_plane, vecA, vecB); @@ -743,20 +742,20 @@ void BM_editselection_plane(BMEditSelection *ese, float r_plane[3]) /* --- macro wrapped funcs --- */ -int _bm_select_history_check(BMesh *bm, const BMHeader *ele) +bool _bm_select_history_check(BMesh *bm, const BMHeader *ele) { return (BLI_findptr(&bm->selected, ele, offsetof(BMEditSelection, ele)) != NULL); } -int _bm_select_history_remove(BMesh *bm, BMHeader *ele) +bool _bm_select_history_remove(BMesh *bm, BMHeader *ele) { BMEditSelection *ese = BLI_findptr(&bm->selected, ele, offsetof(BMEditSelection, ele)); if (ese) { BLI_freelinkN(&bm->selected, ese); - return TRUE; + return true; } else { - return FALSE; + return false; } } @@ -800,10 +799,10 @@ void BM_select_history_validate(BMesh *bm) } /* utility function */ -int BM_select_history_active_get(BMesh *bm, BMEditSelection *ese) +bool BM_select_history_active_get(BMesh *bm, BMEditSelection *ese) { BMEditSelection *ese_last = bm->selected.last; - BMFace *efa = BM_active_face_get(bm, FALSE, FALSE); + BMFace *efa = BM_active_face_get(bm, false, false); ese->next = ese->prev = NULL; @@ -828,14 +827,14 @@ int BM_select_history_active_get(BMesh *bm, BMEditSelection *ese) } else { ese->ele = NULL; - return FALSE; + return false; } - return TRUE; + return true; } void BM_mesh_elem_hflag_disable_test(BMesh *bm, const char htype, const char hflag, - int respecthide, const char hflag_test) + const bool respecthide, const char hflag_test) { const char iter_types[3] = {BM_VERTS_OF_MESH, BM_EDGES_OF_MESH, @@ -851,7 +850,7 @@ void BM_mesh_elem_hflag_disable_test(BMesh *bm, const char htype, const char hfl if ((htype == (BM_VERT | BM_EDGE | BM_FACE)) && (hflag == BM_ELEM_SELECT) && - (respecthide == FALSE) && + (respecthide == false) && (hflag_test == 0)) { /* fast path for deselect all, avoid topology loops @@ -887,7 +886,7 @@ void BM_mesh_elem_hflag_disable_test(BMesh *bm, const char htype, const char hfl } if (hflag & BM_ELEM_SELECT) { - BM_elem_select_set(bm, ele, FALSE); + BM_elem_select_set(bm, ele, false); } BM_elem_flag_disable(ele, hflag); } @@ -897,7 +896,7 @@ void BM_mesh_elem_hflag_disable_test(BMesh *bm, const char htype, const char hfl } void BM_mesh_elem_hflag_enable_test(BMesh *bm, const char htype, const char hflag, - int respecthide, const char hflag_test) + const bool respecthide, const char hflag_test) { const char iter_types[3] = {BM_VERTS_OF_MESH, BM_EDGES_OF_MESH, @@ -935,7 +934,7 @@ void BM_mesh_elem_hflag_enable_test(BMesh *bm, const char htype, const char hfla } if (hflag & BM_ELEM_SELECT) { - BM_elem_select_set(bm, ele, TRUE); + BM_elem_select_set(bm, ele, true); } BM_elem_flag_enable(ele, hflag_nosel); } @@ -944,14 +943,14 @@ void BM_mesh_elem_hflag_enable_test(BMesh *bm, const char htype, const char hfla } void BM_mesh_elem_hflag_disable_all(BMesh *bm, const char htype, const char hflag, - int respecthide) + const bool respecthide) { /* call with 0 hflag_test */ BM_mesh_elem_hflag_disable_test(bm, htype, hflag, respecthide, 0); } void BM_mesh_elem_hflag_enable_all(BMesh *bm, const char htype, const char hflag, - int respecthide) + const bool respecthide) { /* call with 0 hflag_test */ BM_mesh_elem_hflag_enable_test(bm, htype, hflag, respecthide, 0); @@ -963,7 +962,7 @@ static void vert_flush_hide_set(BMVert *v) { BMIter iter; BMEdge *e; - int hide = TRUE; + bool hide = true; BM_ITER_ELEM (e, &iter, v, BM_EDGES_OF_VERT) { hide = hide && BM_elem_flag_test(e, BM_ELEM_HIDDEN); @@ -976,7 +975,7 @@ static void edge_flush_hide(BMEdge *e) { BMIter iter; BMFace *f; - int hide = TRUE; + bool hide = true; BM_ITER_ELEM (f, &iter, e, BM_FACES_OF_EDGE) { hide = hide && BM_elem_flag_test(f, BM_ELEM_HIDDEN); @@ -985,13 +984,15 @@ static void edge_flush_hide(BMEdge *e) BM_elem_flag_set(e, BM_ELEM_HIDDEN, hide); } -void BM_vert_hide_set(BMVert *v, int hide) +void BM_vert_hide_set(BMVert *v, const bool hide) { /* vert hiding: vert + surrounding edges and faces */ BMIter iter, fiter; BMEdge *e; BMFace *f; + BLI_assert(v->head.htype == BM_VERT); + BM_elem_flag_set(v, BM_ELEM_HIDDEN, hide); BM_ITER_ELEM (e, &iter, v, BM_EDGES_OF_VERT) { @@ -1003,12 +1004,14 @@ void BM_vert_hide_set(BMVert *v, int hide) } } -void BM_edge_hide_set(BMEdge *e, int hide) +void BM_edge_hide_set(BMEdge *e, const bool hide) { BMIter iter; BMFace *f; /* BMVert *v; */ + BLI_assert(e->head.htype == BM_EDGE); + /* edge hiding: faces around the edge */ BM_ITER_ELEM (f, &iter, e, BM_FACES_OF_EDGE) { BM_elem_flag_set(f, BM_ELEM_HIDDEN, hide); @@ -1021,11 +1024,13 @@ void BM_edge_hide_set(BMEdge *e, int hide) vert_flush_hide_set(e->v2); } -void BM_face_hide_set(BMFace *f, int hide) +void BM_face_hide_set(BMFace *f, const bool hide) { BMIter iter; BMLoop *l; + BLI_assert(f->head.htype == BM_FACE); + BM_elem_flag_set(f, BM_ELEM_HIDDEN, hide); BM_ITER_ELEM (l, &iter, f, BM_LOOPS_OF_FACE) { @@ -1037,21 +1042,21 @@ void BM_face_hide_set(BMFace *f, int hide) } } -void _bm_elem_hide_set(BMesh *bm, BMHeader *head, int hide) +void _bm_elem_hide_set(BMesh *bm, BMHeader *head, const bool hide) { /* Follow convention of always deselecting before * hiding an element */ switch (head->htype) { case BM_VERT: - if (hide) BM_vert_select_set(bm, (BMVert *)head, FALSE); + if (hide) BM_vert_select_set(bm, (BMVert *)head, false); BM_vert_hide_set((BMVert *)head, hide); break; case BM_EDGE: - if (hide) BM_edge_select_set(bm, (BMEdge *)head, FALSE); + if (hide) BM_edge_select_set(bm, (BMEdge *)head, false); BM_edge_hide_set((BMEdge *)head, hide); break; case BM_FACE: - if (hide) BM_face_select_set(bm, (BMFace *)head, FALSE); + if (hide) BM_face_select_set(bm, (BMFace *)head, false); BM_face_hide_set((BMFace *)head, hide); break; default: diff --git a/source/blender/bmesh/intern/bmesh_marking.h b/source/blender/bmesh/intern/bmesh_marking.h index 8d4397794d5..a3d2d4a6985 100644 --- a/source/blender/bmesh/intern/bmesh_marking.h +++ b/source/blender/bmesh/intern/bmesh_marking.h @@ -35,29 +35,29 @@ typedef struct BMEditSelection { /* geometry hiding code */ #define BM_elem_hide_set(bm, ele, hide) _bm_elem_hide_set(bm, &(ele)->head, hide) -void _bm_elem_hide_set(BMesh *bm, BMHeader *ele, int hide); -void BM_vert_hide_set(BMVert *v, int hide); -void BM_edge_hide_set(BMEdge *e, int hide); -void BM_face_hide_set(BMFace *f, int hide); +void _bm_elem_hide_set(BMesh *bm, BMHeader *ele, const bool hide); +void BM_vert_hide_set(BMVert *v, const bool hide); +void BM_edge_hide_set(BMEdge *e, const bool hide); +void BM_face_hide_set(BMFace *f, const bool hide); /* Selection code */ -void BM_elem_select_set(BMesh *bm, BMElem *ele, int select); +void BM_elem_select_set(BMesh *bm, BMElem *ele, const bool select); void BM_mesh_elem_hflag_enable_test(BMesh *bm, const char htype, const char hflag, - int respecthide, const char hflag_test); + const bool respecthide, const char hflag_test); void BM_mesh_elem_hflag_disable_test(BMesh *bm, const char htype, const char hflag, - int respecthide, const char hflag_test); + const bool respecthide, const char hflag_test); void BM_mesh_elem_hflag_enable_all(BMesh *bm, const char htype, const char hflag, - int respecthide); + const bool respecthide); void BM_mesh_elem_hflag_disable_all(BMesh *bm, const char htype, const char hflag, - int respecthide); + const bool respecthide); /* individual element select functions, BM_elem_select_set is a shortcut for these * that automatically detects which one to use*/ -void BM_vert_select_set(BMesh *bm, BMVert *v, int select); -void BM_edge_select_set(BMesh *bm, BMEdge *e, int select); -void BM_face_select_set(BMesh *bm, BMFace *f, int select); +void BM_vert_select_set(BMesh *bm, BMVert *v, const bool select); +void BM_edge_select_set(BMesh *bm, BMEdge *e, const bool select); +void BM_face_select_set(BMesh *bm, BMFace *f, const bool select); void BM_mesh_select_mode_set(BMesh *bm, int selectmode); void BM_mesh_select_mode_flush_ex(BMesh *bm, const short selectmode); @@ -66,12 +66,12 @@ void BM_mesh_select_mode_flush(BMesh *bm); void BM_mesh_deselect_flush(BMesh *bm); void BM_mesh_select_flush(BMesh *bm); -int BM_mesh_elem_hflag_count_enabled(BMesh *bm, const char htype, const char hflag, int respecthide); -int BM_mesh_elem_hflag_count_disabled(BMesh *bm, const char htype, const char hflag, int respecthide); +int BM_mesh_elem_hflag_count_enabled(BMesh *bm, const char htype, const char hflag, const bool respecthide); +int BM_mesh_elem_hflag_count_disabled(BMesh *bm, const char htype, const char hflag, const bool respecthide); /* edit selection stuff */ void BM_active_face_set(BMesh *bm, BMFace *f); -BMFace *BM_active_face_get(BMesh *bm, int sloppy, int selected); +BMFace *BM_active_face_get(BMesh *bm, const bool is_sloppy, const bool is_selected); void BM_editselection_center(BMEditSelection *ese, float r_center[3]); void BM_editselection_normal(BMEditSelection *ese, float r_normal[3]); @@ -82,13 +82,13 @@ void BM_editselection_plane(BMEditSelection *ese, float r_plane[3]); #define BM_select_history_store_notest(bm, ele) _bm_select_history_store_notest(bm, &(ele)->head) #define BM_select_history_store(bm, ele) _bm_select_history_store(bm, &(ele)->head) -int _bm_select_history_check(BMesh *bm, const BMHeader *ele); -int _bm_select_history_remove(BMesh *bm, BMHeader *ele); +bool _bm_select_history_check(BMesh *bm, const BMHeader *ele); +bool _bm_select_history_remove(BMesh *bm, BMHeader *ele); void _bm_select_history_store_notest(BMesh *bm, BMHeader *ele); void _bm_select_history_store(BMesh *bm, BMHeader *ele); void BM_select_history_validate(BMesh *bm); void BM_select_history_clear(BMesh *em); -int BM_select_history_active_get(BMesh *bm, struct BMEditSelection *ese); +bool BM_select_history_active_get(BMesh *bm, struct BMEditSelection *ese); #endif /* __BMESH_MARKING_H__ */ diff --git a/source/blender/bmesh/intern/bmesh_mesh.c b/source/blender/bmesh/intern/bmesh_mesh.c index 769ede0c2ca..e72ad5dae3c 100644 --- a/source/blender/bmesh/intern/bmesh_mesh.c +++ b/source/blender/bmesh/intern/bmesh_mesh.c @@ -261,7 +261,7 @@ void BM_mesh_free(BMesh *bm) * * Updates the normals of a mesh. */ -void BM_mesh_normals_update(BMesh *bm, const short skip_hidden) +void BM_mesh_normals_update(BMesh *bm, const bool skip_hidden) { BMVert *v; BMFace *f; @@ -362,8 +362,8 @@ static void UNUSED_FUNCTION(bm_mdisps_space_set)(Object *ob, BMesh *bm, int from { /* switch multires data out of tangent space */ if (CustomData_has_layer(&bm->ldata, CD_MDISPS)) { - BMEditMesh *em = BMEdit_Create(bm, FALSE); - DerivedMesh *dm = CDDM_from_editbmesh(em, TRUE, FALSE); + BMEditMesh *em = BMEdit_Create(bm, false); + DerivedMesh *dm = CDDM_from_editbmesh(em, true, false); MDisps *mdisps; BMFace *f; BMIter iter; @@ -455,7 +455,7 @@ void bmesh_edit_end(BMesh *bm, int UNUSED(flag)) #endif /* compute normals, clear temp flags and flush selections */ - BM_mesh_normals_update(bm, TRUE); + BM_mesh_normals_update(bm, true); BM_mesh_select_mode_flush(bm); } @@ -553,12 +553,12 @@ void BM_mesh_elem_index_validate(BMesh *bm, const char *location, const char *fu BMIter iter; BMElem *ele; int i; - int is_any_error = 0; + bool is_any_error = 0; for (i = 0; i < 3; i++) { - const int is_dirty = (flag_types[i] & bm->elem_index_dirty); + const bool is_dirty = (flag_types[i] & bm->elem_index_dirty); int index = 0; - int is_error = FALSE; + bool is_error = false; int err_val = 0; int err_idx = 0; @@ -567,7 +567,7 @@ void BM_mesh_elem_index_validate(BMesh *bm, const char *location, const char *fu if (BM_elem_index_get(ele) != index) { err_val = BM_elem_index_get(ele); err_idx = index; - is_error = TRUE; + is_error = true; } } @@ -575,13 +575,13 @@ void BM_mesh_elem_index_validate(BMesh *bm, const char *location, const char *fu index++; } - if ((is_error == TRUE) && (is_dirty == FALSE)) { - is_any_error = TRUE; + if ((is_error == true) && (is_dirty == false)) { + is_any_error = true; fprintf(stderr, "Invalid Index: at %s, %s, %s[%d] invalid index %d, '%s', '%s'\n", location, func, type_names[i], err_idx, err_val, msg_a, msg_b); } - else if ((is_error == FALSE) && (is_dirty == TRUE)) { + else if ((is_error == false) && (is_dirty == true)) { #if 0 /* mostly annoying */ diff --git a/source/blender/bmesh/intern/bmesh_mesh.h b/source/blender/bmesh/intern/bmesh_mesh.h index 8baba568fb8..35ce1859c2b 100644 --- a/source/blender/bmesh/intern/bmesh_mesh.h +++ b/source/blender/bmesh/intern/bmesh_mesh.h @@ -37,7 +37,7 @@ void BM_mesh_free(BMesh *bm); void BM_mesh_data_free(BMesh *bm); void BM_mesh_clear(BMesh *bm); -void BM_mesh_normals_update(BMesh *bm, const short skip_hidden); +void BM_mesh_normals_update(BMesh *bm, const bool skip_hidden); void bmesh_edit_begin(BMesh *bm, int type_flag); void bmesh_edit_end(BMesh *bm, int type_flag); diff --git a/source/blender/bmesh/intern/bmesh_mesh_conv.c b/source/blender/bmesh/intern/bmesh_mesh_conv.c index 8198e30bac6..a63b715fd14 100644 --- a/source/blender/bmesh/intern/bmesh_mesh_conv.c +++ b/source/blender/bmesh/intern/bmesh_mesh_conv.c @@ -163,7 +163,7 @@ char BM_mesh_cd_flag_from_bmesh(BMesh *bm) } /* Mesh -> BMesh */ -void BM_mesh_bm_from_me(BMesh *bm, Mesh *me, int set_key, int act_key_nr) +void BM_mesh_bm_from_me(BMesh *bm, Mesh *me, bool set_key, int act_key_nr) { MVert *mvert; BLI_array_declare(verts); @@ -174,7 +174,6 @@ void BM_mesh_bm_from_me(BMesh *bm, Mesh *me, int set_key, int act_key_nr) BMVert *v, **vt = NULL, **verts = NULL; BMEdge *e, **fedges = NULL, **et = NULL; BMFace *f; - BMLoop *l; BLI_array_declare(fedges); float (*keyco)[3] = NULL; int *keyi; @@ -280,7 +279,7 @@ void BM_mesh_bm_from_me(BMesh *bm, Mesh *me, int set_key, int act_key_nr) /* this is necessary for selection counts to work properly */ if (mvert->flag & SELECT) { - BM_vert_select_set(bm, v, TRUE); + BM_vert_select_set(bm, v, true); } normal_short_to_float_v3(v->no, mvert->no); @@ -328,7 +327,7 @@ void BM_mesh_bm_from_me(BMesh *bm, Mesh *me, int set_key, int act_key_nr) /* this is necessary for selection counts to work properly */ if (medge->flag & SELECT) { - BM_edge_select_set(bm, e, TRUE); + BM_edge_select_set(bm, e, true); } /* Copy Custom Data */ @@ -343,7 +342,8 @@ void BM_mesh_bm_from_me(BMesh *bm, Mesh *me, int set_key, int act_key_nr) mpoly = me->mpoly; for (i = 0; i < me->totpoly; i++, mpoly++) { - BMIter iter; + BMLoop *l_iter; + BMLoop *l_first; BLI_array_empty(fedges); BLI_array_empty(verts); @@ -395,17 +395,18 @@ void BM_mesh_bm_from_me(BMesh *bm, Mesh *me, int set_key, int act_key_nr) /* this is necessary for selection counts to work properly */ if (mpoly->flag & ME_FACE_SEL) { - BM_face_select_set(bm, f, TRUE); + BM_face_select_set(bm, f, true); } f->mat_nr = mpoly->mat_nr; if (i == me->act_face) bm->act_face = f; - j = 0; - BM_ITER_ELEM_INDEX (l, &iter, f, BM_LOOPS_OF_FACE, j) { + j = mpoly->loopstart; + l_iter = l_first = BM_FACE_FIRST_LOOP(f); + do { /* Save index of correspsonding MLoop */ - CustomData_to_bmesh_block(&me->ldata, &bm->ldata, mpoly->loopstart + j, &l->head.data, true); - } + CustomData_to_bmesh_block(&me->ldata, &bm->ldata, j++, &l_iter->head.data, true); + } while ((l_iter = l_iter->next) != l_first); /* Copy Custom Data */ CustomData_to_bmesh_block(&me->pdata, &bm->pdata, i, &f->head.data, true); @@ -415,22 +416,20 @@ void BM_mesh_bm_from_me(BMesh *bm, Mesh *me, int set_key, int act_key_nr) if (me->mselect && me->totselect != 0) { - BMVert **vert_array = MEM_callocN(sizeof(BMVert *) * bm->totvert, - "Selection Conversion Vertex Pointer Array"); - BMEdge **edge_array = MEM_callocN(sizeof(BMEdge *) * bm->totedge, - "Selection Conversion Edge Pointer Array"); - BMFace **face_array = MEM_callocN(sizeof(BMFace *) * bm->totface, - "Selection Conversion Face Pointer Array"); - - BMIter iter; - BMVert *vert; - BMEdge *edge; - BMFace *face; + BMVert **vert_array = MEM_mallocN(sizeof(BMVert *) * bm->totvert, "VSelConv"); + BMEdge **edge_array = MEM_mallocN(sizeof(BMEdge *) * bm->totedge, "ESelConv"); + BMFace **face_array = MEM_mallocN(sizeof(BMFace *) * bm->totface, "FSelConv"); MSelect *msel; - BM_ITER_MESH_INDEX (vert, &iter, bm, BM_VERTS_OF_MESH, i) { vert_array[i] = vert; } - BM_ITER_MESH_INDEX (edge, &iter, bm, BM_EDGES_OF_MESH, i) { edge_array[i] = edge; } - BM_ITER_MESH_INDEX (face, &iter, bm, BM_FACES_OF_MESH, i) { face_array[i] = face; } +#pragma omp parallel sections if (bm->totvert + bm->totedge + bm->totface >= BM_OMP_LIMIT) + { +#pragma omp section + { BM_iter_as_array(bm, BM_VERTS_OF_MESH, NULL, (void **)vert_array, bm->totvert); } +#pragma omp section + { BM_iter_as_array(bm, BM_EDGES_OF_MESH, NULL, (void **)edge_array, bm->totedge); } +#pragma omp section + { BM_iter_as_array(bm, BM_FACES_OF_MESH, NULL, (void **)face_array, bm->totface); } + } for (i = 0, msel = me->mselect; i < me->totselect; i++, msel++) { switch (msel->type) { @@ -549,7 +548,7 @@ BLI_INLINE void bmesh_quick_edgedraw_flag(MEdge *med, BMEdge *e) } } -void BM_mesh_bm_to_me(BMesh *bm, Mesh *me, int dotess) +void BM_mesh_bm_to_me(BMesh *bm, Mesh *me, bool do_tessface) { MLoop *mloop; MPoly *mpoly; @@ -620,6 +619,8 @@ void BM_mesh_bm_to_me(BMesh *bm, Mesh *me, int dotess) CustomData_add_layer(&me->ldata, CD_MLOOP, CD_ASSIGN, mloop, me->totloop); CustomData_add_layer(&me->pdata, CD_MPOLY, CD_ASSIGN, mpoly, me->totpoly); + me->cd_flag = BM_mesh_cd_flag_from_bmesh(bm); + /* this is called again, 'dotess' arg is used there */ mesh_update_customdata_pointers(me, 0); @@ -755,11 +756,11 @@ void BM_mesh_bm_to_me(BMesh *bm, Mesh *me, int dotess) if (vertMap) MEM_freeN(vertMap); } - if (dotess) { + if (do_tessface) { BKE_mesh_tessface_calc(me); } - mesh_update_customdata_pointers(me, dotess); + mesh_update_customdata_pointers(me, do_tessface); { BMEditSelection *selected; @@ -823,12 +824,12 @@ void BM_mesh_bm_to_me(BMesh *bm, Mesh *me, int dotess) * bmesh and the mesh are out of sync */ (oldverts != NULL)) /* not used here, but 'oldverts' is used later for applying 'ofs' */ { - int act_is_basis = FALSE; + bool act_is_basis = false; /* find if this key is a basis for any others */ for (currkey = me->key->block.first; currkey; currkey = currkey->next) { if (bm->shapenr - 1 == currkey->relative) { - act_is_basis = TRUE; + act_is_basis = true; break; } } diff --git a/source/blender/bmesh/intern/bmesh_mesh_conv.h b/source/blender/bmesh/intern/bmesh_mesh_conv.h index 55ac39c6745..7fe4b8fe58b 100644 --- a/source/blender/bmesh/intern/bmesh_mesh_conv.h +++ b/source/blender/bmesh/intern/bmesh_mesh_conv.h @@ -38,7 +38,7 @@ void BM_mesh_cd_flag_ensure(BMesh *bm, struct Mesh *mesh, const char cd_flag); void BM_mesh_cd_flag_apply(BMesh *bm, const char cd_flag); char BM_mesh_cd_flag_from_bmesh(BMesh *bm); -void BM_mesh_bm_from_me(BMesh *bm, struct Mesh *me, int set_key, int act_key_nr); -void BM_mesh_bm_to_me(BMesh *bm, struct Mesh *me, int dotess); +void BM_mesh_bm_from_me(BMesh *bm, struct Mesh *me, bool set_key, int act_key_nr); +void BM_mesh_bm_to_me(BMesh *bm, struct Mesh *me, bool do_tessface); #endif /* __BMESH_MESH_CONV_H__ */ diff --git a/source/blender/bmesh/intern/bmesh_mesh_validate.c b/source/blender/bmesh/intern/bmesh_mesh_validate.c index 8ab5f10361f..e6eee16e49c 100644 --- a/source/blender/bmesh/intern/bmesh_mesh_validate.c +++ b/source/blender/bmesh/intern/bmesh_mesh_validate.c @@ -49,9 +49,9 @@ /** * Check of this BMesh is valid, this function can be slow since its intended to help with debugging. * - * \return TRUE when the mesh is valid. + * \return true when the mesh is valid. */ -int BM_mesh_validate(BMesh *bm) +bool BM_mesh_validate(BMesh *bm) { int errtot; @@ -106,11 +106,11 @@ int BM_mesh_validate(BMesh *bm) if (l_iter->e != e) { ERRMSG("edge %d: has invalid loop, loop is of face %d", i, BM_elem_index_get(l_iter->f)); } - else if (BM_vert_in_edge(e, l_iter->v) == FALSE) { + else if (BM_vert_in_edge(e, l_iter->v) == false) { ERRMSG("edge %d: has invalid loop with vert not in edge, loop is of face %d", i, BM_elem_index_get(l_iter->f)); } - else if (BM_vert_in_edge(e, l_iter->next->v) == FALSE) { + else if (BM_vert_in_edge(e, l_iter->next->v) == false) { ERRMSG("edge %d: has invalid loop with next vert not in edge, loop is of face %d", i, BM_elem_index_get(l_iter->f)); } @@ -181,7 +181,7 @@ int BM_mesh_validate(BMesh *bm) ERRMSG("Finished - errors %d", errtot); - return TRUE; + return true; } diff --git a/source/blender/bmesh/intern/bmesh_mesh_validate.h b/source/blender/bmesh/intern/bmesh_mesh_validate.h index 6839dc74d25..f89141387d8 100644 --- a/source/blender/bmesh/intern/bmesh_mesh_validate.h +++ b/source/blender/bmesh/intern/bmesh_mesh_validate.h @@ -30,6 +30,6 @@ * \ingroup bmesh */ -int BM_mesh_validate(BMesh *bm); +bool BM_mesh_validate(BMesh *bm); #endif /* __BMESH_MESH_VALIDATE_H__ */ diff --git a/source/blender/bmesh/intern/bmesh_mods.c b/source/blender/bmesh/intern/bmesh_mods.c index 9a99d5b96d1..d98598cac89 100644 --- a/source/blender/bmesh/intern/bmesh_mods.c +++ b/source/blender/bmesh/intern/bmesh_mods.c @@ -64,36 +64,36 @@ * \note dissolves vert, in more situations then BM_disk_dissolve * (e.g. if the vert is part of a wire edge, etc). */ -int BM_vert_dissolve(BMesh *bm, BMVert *v) +bool BM_vert_dissolve(BMesh *bm, BMVert *v) { const int len = BM_vert_edge_count(v); if (len == 1) { BM_vert_kill(bm, v); /* will kill edges too */ - return TRUE; + return true; } else if (!BM_vert_is_manifold(v)) { if (!v->e) { BM_vert_kill(bm, v); - return TRUE; + return true; } else if (!v->e->l) { if (len == 2) { - return (BM_vert_collapse_edge(bm, v->e, v, TRUE) != NULL); + return (BM_vert_collapse_edge(bm, v->e, v, true) != NULL); } else { /* used to kill the vertex here, but it may be connected to faces. * so better do nothing */ - return FALSE; + return false; } } else { - return FALSE; + return false; } } else if (len == 2 && BM_vert_face_count(v) == 1) { /* boundary vertex on a face */ - return (BM_vert_collapse_edge(bm, v->e, v, TRUE) != NULL); + return (BM_vert_collapse_edge(bm, v->e, v, true) != NULL); } else { return BM_disk_dissolve(bm, v); @@ -103,14 +103,14 @@ int BM_vert_dissolve(BMesh *bm, BMVert *v) /** * dissolves all faces around a vert, and removes it. */ -int BM_disk_dissolve(BMesh *bm, BMVert *v) +bool BM_disk_dissolve(BMesh *bm, BMVert *v) { BMFace *f, *f2; BMEdge *e, *keepedge = NULL, *baseedge = NULL; int len = 0; if (!BM_vert_is_manifold(v)) { - return FALSE; + return false; } if (v->e) { @@ -135,62 +135,62 @@ int BM_disk_dissolve(BMesh *bm, BMVert *v) * increasing valence to four. this may be hackish. . */ BMLoop *loop = e->l; if (loop->v == v) loop = loop->next; - if (!BM_face_split(bm, loop->f, v, loop->v, NULL, NULL, FALSE)) - return FALSE; + if (!BM_face_split(bm, loop->f, v, loop->v, NULL, NULL, false)) + return false; if (!BM_disk_dissolve(bm, v)) { - return FALSE; + return false; } #else - if (UNLIKELY(!BM_faces_join_pair(bm, e->l->f, e->l->radial_next->f, e, TRUE))) { - return FALSE; + if (UNLIKELY(!BM_faces_join_pair(bm, e->l->f, e->l->radial_next->f, e, true))) { + return false; } - else if (UNLIKELY(!BM_vert_collapse_faces(bm, v->e, v, 1.0, FALSE, TRUE))) { - return FALSE; + else if (UNLIKELY(!BM_vert_collapse_faces(bm, v->e, v, 1.0, false, true))) { + return false; } #endif - return TRUE; + return true; } else if (keepedge == NULL && len == 2) { /* collapse the vertex */ - e = BM_vert_collapse_faces(bm, v->e, v, 1.0, TRUE, TRUE); + e = BM_vert_collapse_faces(bm, v->e, v, 1.0, true, true); if (!e) { - return FALSE; + return false; } /* handle two-valence */ f = e->l->f; f2 = e->l->radial_next->f; - if (f != f2 && !BM_faces_join_pair(bm, f, f2, e, TRUE)) { - return FALSE; + if (f != f2 && !BM_faces_join_pair(bm, f, f2, e, true)) { + return false; } - return TRUE; + return true; } if (keepedge) { - int done = FALSE; + bool done = false; while (!done) { - done = TRUE; + done = true; e = v->e; do { f = NULL; len = bmesh_radial_length(e->l); if (len == 2 && (e != baseedge) && (e != keepedge)) { - f = BM_faces_join_pair(bm, e->l->f, e->l->radial_next->f, e, TRUE); + f = BM_faces_join_pair(bm, e->l->f, e->l->radial_next->f, e, true); /* return if couldn't join faces in manifold * conditions */ /* !disabled for testing why bad things happen */ if (!f) { - return FALSE; + return false; } } if (f) { - done = FALSE; + done = false; break; } e = bmesh_disk_edge_next(e, v); @@ -199,10 +199,10 @@ int BM_disk_dissolve(BMesh *bm, BMVert *v) /* collapse the vertex */ /* note, the baseedge can be a boundary of manifold, use this as join_faces arg */ - e = BM_vert_collapse_faces(bm, baseedge, v, 1.0, !BM_edge_is_boundary(baseedge), TRUE); + e = BM_vert_collapse_faces(bm, baseedge, v, 1.0, !BM_edge_is_boundary(baseedge), true); if (!e) { - return FALSE; + return false; } /* get remaining two faces */ @@ -211,13 +211,13 @@ int BM_disk_dissolve(BMesh *bm, BMVert *v) if (f != f2) { /* join two remaining faces */ - if (!BM_faces_join_pair(bm, f, f2, e, TRUE)) { - return FALSE; + if (!BM_faces_join_pair(bm, f, f2, e, true)) { + return false; } } } - return TRUE; + return true; } /** @@ -235,7 +235,7 @@ int BM_disk_dissolve(BMesh *bm, BMVert *v) * * \return pointer to the combined face */ -BMFace *BM_faces_join_pair(BMesh *bm, BMFace *f1, BMFace *f2, BMEdge *e, const short do_del) +BMFace *BM_faces_join_pair(BMesh *bm, BMFace *f1, BMFace *f2, BMEdge *e, const bool do_del) { BMLoop *l1, *l2; BMEdge *jed = NULL; @@ -302,7 +302,7 @@ BMEdge *BM_verts_connect(BMesh *bm, BMVert *v1, BMVert *v2, BMFace **r_f) if (v_iter == v2) { BMLoop *nl; - f_iter = BM_face_split(bm, f_iter, v1, v2, &nl, NULL, FALSE); + f_iter = BM_face_split(bm, f_iter, v1, v2, &nl, NULL, false); if (r_f) { *r_f = f_iter; @@ -336,22 +336,22 @@ BMEdge *BM_verts_connect(BMesh *bm, BMVert *v1, BMVert *v2, BMFace **r_f) * other side). NULL if the split fails. */ BMFace *BM_face_split(BMesh *bm, BMFace *f, BMVert *v1, BMVert *v2, BMLoop **r_l, - BMEdge *example, const short nodouble) + BMEdge *example, const bool no_double) { - const int has_mdisp = CustomData_has_layer(&bm->ldata, CD_MDISPS); + const bool has_mdisp = CustomData_has_layer(&bm->ldata, CD_MDISPS); BMFace *nf, *of; BLI_assert(v1 != v2); /* do we have a multires layer? */ if (has_mdisp) { - of = BM_face_copy(bm, f, FALSE, FALSE); + of = BM_face_copy(bm, f, false, false); } #ifdef USE_BMESH_HOLES - nf = bmesh_sfme(bm, f, v1, v2, r_l, NULL, example, nodouble); + nf = bmesh_sfme(bm, f, v1, v2, r_l, NULL, example, no_double); #else - nf = bmesh_sfme(bm, f, v1, v2, r_l, example, nodouble); + nf = bmesh_sfme(bm, f, v1, v2, r_l, example, no_double); #endif if (nf) { @@ -414,15 +414,15 @@ BMFace *BM_face_split_n(BMesh *bm, BMFace *f, BMVert *v1, BMVert *v2, float cos[ BLI_assert(v1 != v2); - of = BM_face_copy(bm, f, TRUE, TRUE); + of = BM_face_copy(bm, f, true, true); if (!r_l) r_l = &l_dummy; #ifdef USE_BMESH_HOLES - nf = bmesh_sfme(bm, f, v1, v2, r_l, NULL, example, FALSE); + nf = bmesh_sfme(bm, f, v1, v2, r_l, NULL, example, false); #else - nf = bmesh_sfme(bm, f, v1, v2, r_l, example, FALSE); + nf = bmesh_sfme(bm, f, v1, v2, r_l, example, false); #endif /* bmesh_sfme returns in r_l a Loop for nf going from v1 to v2. * The radial_next is for f and goes from v2 to v1 */ @@ -445,7 +445,7 @@ BMFace *BM_face_split_n(BMesh *bm, BMFace *f, BMVert *v1, BMVert *v2, float cos[ do { if (l_iter->v == newv) { /* this interpolates both loop and vertex data */ - BM_loop_interp_from_face(bm, l_iter, of, TRUE, TRUE); + BM_loop_interp_from_face(bm, l_iter, of, true, true); } } while ((l_iter = l_iter->radial_next) != e_iter->l); } @@ -482,7 +482,7 @@ BMFace *BM_face_split_n(BMesh *bm, BMFace *f, BMVert *v1, BMVert *v2, float cos[ * \returns The New Edge */ BMEdge *BM_vert_collapse_faces(BMesh *bm, BMEdge *ke, BMVert *kv, float fac, - const short join_faces, const short kill_degenerate_faces) + const bool join_faces, const bool kill_degenerate_faces) { BMEdge *ne = NULL; BMVert *tv = bmesh_edge_other_vert_get(ke, kv); @@ -534,10 +534,10 @@ BMEdge *BM_vert_collapse_faces(BMesh *bm, BMEdge *ke, BMVert *kv, float fac, } if (BLI_array_count(faces) >= 2) { - BMFace *f2 = BM_faces_join(bm, faces, BLI_array_count(faces), TRUE); + BMFace *f2 = BM_faces_join(bm, faces, BLI_array_count(faces), true); if (f2) { BMLoop *nl = NULL; - if (BM_face_split(bm, f2, tv, tv2, &nl, NULL, FALSE)) { + if (BM_face_split(bm, f2, tv, tv2, &nl, NULL, false)) { ne = nl->e; } } @@ -549,7 +549,7 @@ BMEdge *BM_vert_collapse_faces(BMesh *bm, BMEdge *ke, BMVert *kv, float fac, /* single face or no faces */ /* same as BM_vert_collapse_edge() however we already * have vars to perform this operation so don't call. */ - ne = bmesh_jekv(bm, ke, kv, TRUE); + ne = bmesh_jekv(bm, ke, kv, true); /* ne = BM_edge_exists(tv, tv2); */ /* same as return above */ if (ne && kill_degenerate_faces) { @@ -589,7 +589,7 @@ BMEdge *BM_vert_collapse_faces(BMesh *bm, BMEdge *ke, BMVert *kv, float fac, * \return The New Edge */ BMEdge *BM_vert_collapse_edge(BMesh *bm, BMEdge *ke, BMVert *kv, - const short kill_degenerate_faces) + const bool kill_degenerate_faces) { /* nice example implementation but we want loops to have their customdata * accounted for */ @@ -618,7 +618,7 @@ BMEdge *BM_vert_collapse_edge(BMesh *bm, BMEdge *ke, BMVert *kv, #else /* with these args faces are never joined, same as above * but account for loop customdata */ - return BM_vert_collapse_faces(bm, ke, kv, 1.0f, FALSE, kill_degenerate_faces); + return BM_vert_collapse_faces(bm, ke, kv, 1.0f, false, kill_degenerate_faces); #endif } @@ -641,7 +641,7 @@ BMVert *BM_edge_split(BMesh *bm, BMEdge *e, BMVert *v, BMEdge **r_e, float perce BMFace **oldfaces = NULL; BMEdge *e_dummy; BLI_array_staticdeclare(oldfaces, 32); - const int do_mdisp = (e->l && CustomData_has_layer(&bm->ldata, CD_MDISPS)); + const bool do_mdisp = (e->l && CustomData_has_layer(&bm->ldata, CD_MDISPS)); /* we need this for handling multi-res */ if (!r_e) { @@ -662,7 +662,7 @@ BMVert *BM_edge_split(BMesh *bm, BMEdge *e, BMVert *v, BMEdge **r_e, float perce /* flag existing faces so we can differentiate oldfaces from new faces */ for (i = 0; i < BLI_array_count(oldfaces); i++) { BM_ELEM_API_FLAG_ENABLE(oldfaces[i], _FLAG_OVERLAP); - oldfaces[i] = BM_face_copy(bm, oldfaces[i], TRUE, TRUE); + oldfaces[i] = BM_face_copy(bm, oldfaces[i], true, true); BM_ELEM_API_FLAG_DISABLE(oldfaces[i], _FLAG_OVERLAP); } } @@ -761,16 +761,18 @@ BMVert *BM_edge_split_n(BMesh *bm, BMEdge *e, int numcuts) return nv; } +#if 0 /** * Checks if a face is valid in the data structure */ -int BM_face_validate(BMFace *face, FILE *err) +bool BM_face_validate(BMFace *face, FILE *err) { BMIter iter; BLI_array_declare(verts); BMVert **verts = NULL; BMLoop *l; - int ret = 1, i, j; + int i, j; + bool ret = true; if (face->len == 2) { fprintf(err, "warning: found two-edged face. face ptr: %p\n", face); @@ -784,7 +786,7 @@ int BM_face_validate(BMFace *face, FILE *err) fprintf(err, "Found bmesh edge with identical verts!\n"); fprintf(err, " edge ptr: %p, vert: %p\n", l->e, l->e->v1); fflush(err); - ret = 0; + ret = false; } } @@ -798,7 +800,7 @@ int BM_face_validate(BMFace *face, FILE *err) fprintf(err, "Found duplicate verts in bmesh face!\n"); fprintf(err, " face ptr: %p, vert: %p\n", face, verts[i]); fflush(err); - ret = 0; + ret = false; } } } @@ -806,7 +808,7 @@ int BM_face_validate(BMFace *face, FILE *err) BLI_array_free(verts); return ret; } - +#endif /** * Calculate the 2 loops which _would_ make up the newly rotated Edge @@ -822,14 +824,14 @@ int BM_face_validate(BMFace *face, FILE *err) * * \note #BM_edge_rotate_check must have already run. */ -void BM_edge_calc_rotate(BMEdge *e, int ccw, +void BM_edge_calc_rotate(BMEdge *e, const bool ccw, BMLoop **r_l1, BMLoop **r_l2) { BMVert *v1, *v2; BMFace *fa, *fb; /* this should have already run */ - BLI_assert(BM_edge_rotate_check(e) == TRUE); + BLI_assert(BM_edge_rotate_check(e) == true); /* we know this will work */ BM_edge_face_pair(e, &fa, &fb); @@ -855,7 +857,7 @@ void BM_edge_calc_rotate(BMEdge *e, int ccw, * Quick check to see if we could rotate the edge, * use this to avoid calling exceptions on common cases. */ -int BM_edge_rotate_check(BMEdge *e) +bool BM_edge_rotate_check(BMEdge *e) { BMFace *fa, *fb; if (BM_edge_face_pair(e, &fa, &fb)) { @@ -868,7 +870,7 @@ int BM_edge_rotate_check(BMEdge *e) * (ie - the next edge doesn't share the same faces). * since we can't rotate usefully in this case. */ if (la->v == lb->v) { - return FALSE; + return false; } /* mirror of the check above but in the opposite direction */ @@ -876,13 +878,13 @@ int BM_edge_rotate_check(BMEdge *e) lb = BM_face_other_vert_loop(fb, e->v1, e->v2); if (la->v == lb->v) { - return FALSE; + return false; } - return TRUE; + return true; } else { - return FALSE; + return false; } } @@ -897,7 +899,7 @@ int BM_edge_rotate_check(BMEdge *e) * \param l1,l2 are the loops of the proposed verts to rotate too and should * be the result of calling #BM_edge_calc_rotate */ -int BM_edge_rotate_check_degenerate(BMEdge *e, BMLoop *l1, BMLoop *l2) +bool BM_edge_rotate_check_degenerate(BMEdge *e, BMLoop *l1, BMLoop *l2) { /* note: for these vars 'old' just means initial edge state. */ @@ -924,7 +926,7 @@ int BM_edge_rotate_check_degenerate(BMEdge *e, BMLoop *l1, BMLoop *l2) BMVert *v1_alt, *v2_alt; /* this should have already run */ - BLI_assert(BM_edge_rotate_check(e) == TRUE); + BLI_assert(BM_edge_rotate_check(e) == true); BM_edge_ordered_verts(e, &v1_old, &v2_old); @@ -965,12 +967,12 @@ int BM_edge_rotate_check_degenerate(BMEdge *e, BMLoop *l1, BMLoop *l2) cross_v3_v3v3(cross_old, ed_dir_old, ed_dir_v1_old); cross_v3_v3v3(cross_new, ed_dir_new, ed_dir_v1_new); if (dot_v3v3(cross_old, cross_new) < 0.0f) { /* does this flip? */ - return FALSE; + return false; } cross_v3_v3v3(cross_old, ed_dir_old, ed_dir_v2_old); cross_v3_v3v3(cross_new, ed_dir_new, ed_dir_v2_new); if (dot_v3v3(cross_old, cross_new) < 0.0f) { /* does this flip? */ - return FALSE; + return false; } negate_v3_v3(ed_dir_new_flip, ed_dir_new); @@ -979,14 +981,14 @@ int BM_edge_rotate_check_degenerate(BMEdge *e, BMLoop *l1, BMLoop *l2) if ((dot_v3v3(ed_dir_new, ed_dir_v1_new) > 0.999f) || (dot_v3v3(ed_dir_new_flip, ed_dir_v2_new) > 0.999f)) { - return FALSE; + return false; } - return TRUE; + return true; } -int BM_edge_rotate_check_beauty(BMEdge *e, - BMLoop *l1, BMLoop *l2) +bool BM_edge_rotate_check_beauty(BMEdge *e, + BMLoop *l1, BMLoop *l2) { /* Stupid check for now: * Could compare angles of surrounding edges @@ -1009,7 +1011,7 @@ int BM_edge_rotate_check_beauty(BMEdge *e, * * \see header definition for \a check_flag enum. */ -BMEdge *BM_edge_rotate(BMesh *bm, BMEdge *e, const short ccw, const short check_flag) +BMEdge *BM_edge_rotate(BMesh *bm, BMEdge *e, const bool ccw, const short check_flag) { BMVert *v1, *v2; BMLoop *l1, *l2; @@ -1066,7 +1068,7 @@ BMEdge *BM_edge_rotate(BMesh *bm, BMEdge *e, const short ccw, const short check_ f_hflag_prev_2 = l2->f->head.hflag; /* don't delete the edge, manually remove the egde after so we can copy its attributes */ - f = BM_faces_join_pair(bm, l1->f, l2->f, NULL, TRUE); + f = BM_faces_join_pair(bm, l1->f, l2->f, NULL, true); if (f == NULL) { return NULL; @@ -1075,7 +1077,7 @@ BMEdge *BM_edge_rotate(BMesh *bm, BMEdge *e, const short ccw, const short check_ /* note, this assumes joining the faces _didnt_ also remove the verts. * the #BM_edge_rotate_check will ensure this, but its possibly corrupt state or future edits * break this */ - if (!BM_face_split(bm, f, v1, v2, NULL, NULL, TRUE)) { + if (!BM_face_split(bm, f, v1, v2, NULL, NULL, true)) { return NULL; } else { diff --git a/source/blender/bmesh/intern/bmesh_mods.h b/source/blender/bmesh/intern/bmesh_mods.h index 790f0cb6267..358268cb589 100644 --- a/source/blender/bmesh/intern/bmesh_mods.h +++ b/source/blender/bmesh/intern/bmesh_mods.h @@ -29,18 +29,18 @@ #include <stdio.h> -int BM_vert_dissolve(BMesh *bm, BMVert *v); +bool BM_vert_dissolve(BMesh *bm, BMVert *v); -int BM_disk_dissolve(BMesh *bm, BMVert *v); +bool BM_disk_dissolve(BMesh *bm, BMVert *v); -BMFace *BM_faces_join_pair(BMesh *bm, BMFace *f1, BMFace *f2, BMEdge *e, const short do_del); +BMFace *BM_faces_join_pair(BMesh *bm, BMFace *f1, BMFace *f2, BMEdge *e, const bool do_del); BMEdge *BM_verts_connect(BMesh *bm, BMVert *v1, BMVert *v2, BMFace **r_f); BMFace *BM_face_split(BMesh *bm, BMFace *f, BMVert *v1, BMVert *v2, BMLoop **r_l, - BMEdge *example, const short nodouble); + BMEdge *example, const bool no_double); BMFace *BM_face_split_n(BMesh *bm, BMFace *f, BMVert *v1, BMVert *v2, @@ -48,25 +48,25 @@ BMFace *BM_face_split_n(BMesh *bm, BMFace *f, BMLoop **r_l, BMEdge *example); BMEdge *BM_vert_collapse_faces(BMesh *bm, BMEdge *ke, BMVert *kv, float fac, - const short join_faces, const short kill_degenerate_faces); + const bool join_faces, const bool kill_degenerate_faces); BMEdge *BM_vert_collapse_edge(BMesh *bm, BMEdge *ke, BMVert *kv, - const short kill_degenerate_faces); + const bool kill_degenerate_faces); BMVert *BM_edge_split(BMesh *bm, BMEdge *e, BMVert *v, BMEdge **r_e, float percent); BMVert *BM_edge_split_n(BMesh *bm, BMEdge *e, int numcuts); -int BM_face_validate(BMFace *face, FILE *err); +bool BM_face_validate(BMFace *face, FILE *err); -void BM_edge_calc_rotate(BMEdge *e, int ccw, +void BM_edge_calc_rotate(BMEdge *e, const bool ccw, BMLoop **r_l1, BMLoop **r_l2); -int BM_edge_rotate_check(BMEdge *e); -int BM_edge_rotate_check_degenerate(BMEdge *e, +bool BM_edge_rotate_check(BMEdge *e); +bool BM_edge_rotate_check_degenerate(BMEdge *e, BMLoop *l1, BMLoop *l2); -int BM_edge_rotate_check_beauty(BMEdge *e, +bool BM_edge_rotate_check_beauty(BMEdge *e, BMLoop *l1, BMLoop *l2); -BMEdge *BM_edge_rotate(BMesh *bm, BMEdge *e, const short ccw, const short check_flag); +BMEdge *BM_edge_rotate(BMesh *bm, BMEdge *e, const bool ccw, const short check_flag); /* flags for BM_edge_rotate */ enum { diff --git a/source/blender/bmesh/intern/bmesh_opdefines.c b/source/blender/bmesh/intern/bmesh_opdefines.c index 8461ec6fe08..4147da82363 100644 --- a/source/blender/bmesh/intern/bmesh_opdefines.c +++ b/source/blender/bmesh/intern/bmesh_opdefines.c @@ -1536,27 +1536,6 @@ static BMOpDefine bmo_wireframe_def = { 0 }; -/* - * Vertex Slide. - * - * Translates verts along an edge - */ -static BMOpDefine bmo_slide_vert_def = { - "slide_vert", - /* slots_in */ - {{"vert", BMO_OP_SLOT_ELEMENT_BUF, {BM_VERT | BMO_OP_SLOT_SUBTYPE_ELEM_IS_SINGLE}}, - {"edges", BMO_OP_SLOT_ELEMENT_BUF, {BM_EDGE}}, - {"factor", BMO_OP_SLOT_FLT}, - {{'\0'}}, - }, - /* slots_out */ - {{"verts.out", BMO_OP_SLOT_ELEMENT_BUF, {BM_VERT}}, - {{'\0'}}, - }, - bmo_slide_vert_exec, - BMO_OP_FLAG_UNTAN_MULTIRES -}; - #ifdef WITH_BULLET /* * Convex Hull @@ -1676,7 +1655,6 @@ const BMOpDefine *bmo_opdefines[] = { &bmo_similar_edges_def, &bmo_similar_faces_def, &bmo_similar_verts_def, - &bmo_slide_vert_def, &bmo_smooth_vert_def, &bmo_smooth_laplacian_vert_def, &bmo_solidify_def, diff --git a/source/blender/bmesh/intern/bmesh_operator_api.h b/source/blender/bmesh/intern/bmesh_operator_api.h index b8fbfbee37f..fd6571d136e 100644 --- a/source/blender/bmesh/intern/bmesh_operator_api.h +++ b/source/blender/bmesh/intern/bmesh_operator_api.h @@ -244,19 +244,19 @@ void BMO_push(BMesh *bm, BMOperator *op); void BMO_pop(BMesh *bm); /*executes an operator*/ -int BMO_op_callf(BMesh *bm, const int flag, const char *fmt, ...); +bool BMO_op_callf(BMesh *bm, const int flag, const char *fmt, ...); /* initializes, but doesn't execute an operator. this is so you can * gain access to the outputs of the operator. note that you have * to execute/finish (BMO_op_exec and BMO_op_finish) yourself. */ -int BMO_op_initf(BMesh *bm, BMOperator *op, const int flag, const char *fmt, ...); +bool BMO_op_initf(BMesh *bm, BMOperator *op, const int flag, const char *fmt, ...); /* va_list version, used to implement the above two functions, * plus EDBM_op_callf in editmesh_utils.c. */ -int BMO_op_vinitf(BMesh *bm, BMOperator *op, const int flag, const char *fmt, va_list vlist); +bool BMO_op_vinitf(BMesh *bm, BMOperator *op, const int flag, const char *fmt, va_list vlist); /* test whether a named slot exists */ -int BMO_slot_exists(BMOpSlot slot_args[BMO_OP_MAX_SLOTS], const char *identifier); +bool BMO_slot_exists(BMOpSlot slot_args[BMO_OP_MAX_SLOTS], const char *identifier); /* get a pointer to a slot. this may be removed layer on from the public API. */ BMOpSlot *BMO_slot_get(BMOpSlot slot_args[BMO_OP_MAX_SLOTS], const char *identifier); @@ -301,8 +301,8 @@ void BMO_slot_float_set(BMOpSlot slot_args[BMO_OP_MAX_SLOTS], const char *slot_ float BMO_slot_float_get(BMOpSlot slot_args[BMO_OP_MAX_SLOTS], const char *slot_name); void BMO_slot_int_set(BMOpSlot slot_args[BMO_OP_MAX_SLOTS], const char *slot_name, const int i); int BMO_slot_int_get(BMOpSlot slot_args[BMO_OP_MAX_SLOTS], const char *slot_name); -void BMO_slot_bool_set(BMOpSlot slot_args[BMO_OP_MAX_SLOTS], const char *slot_name, const int i); -int BMO_slot_bool_get(BMOpSlot slot_args[BMO_OP_MAX_SLOTS], const char *slot_name); +void BMO_slot_bool_set(BMOpSlot slot_args[BMO_OP_MAX_SLOTS], const char *slot_name, const bool i); +bool BMO_slot_bool_get(BMOpSlot slot_args[BMO_OP_MAX_SLOTS], const char *slot_name); void *BMO_slot_as_arrayN(BMOpSlot slot_args[BMO_OP_MAX_SLOTS], const char *slot_name, int *len); @@ -360,11 +360,11 @@ void BMO_slot_buffer_flag_disable(BMesh *bm, /* tool-flags all elements inside an element slot array with flag flag. */ void BMO_slot_buffer_hflag_enable(BMesh *bm, BMOpSlot slot_args[BMO_OP_MAX_SLOTS], const char *slot_name, - const char htype, const char hflag, const char do_flush); + const char htype, const char hflag, const bool do_flush); /* clears tool-flag flag from all elements inside a slot array. */ void BMO_slot_buffer_hflag_disable(BMesh *bm, BMOpSlot slot_args[BMO_OP_MAX_SLOTS], const char *slot_name, - const char htype, const char hflag, const char do_flush); + const char htype, const char hflag, const bool do_flush); /* puts every element of type 'type' (which is a bitmask) with header * flag 'flag', into a slot. note: ignores hidden elements diff --git a/source/blender/bmesh/intern/bmesh_operator_api_inline.h b/source/blender/bmesh/intern/bmesh_operator_api_inline.h index ad116011421..053d70349e8 100644 --- a/source/blender/bmesh/intern/bmesh_operator_api_inline.h +++ b/source/blender/bmesh/intern/bmesh_operator_api_inline.h @@ -80,7 +80,7 @@ BLI_INLINE void BMO_slot_map_bool_insert(BMOperator *op, BMOpSlot *slot, void *element, const int val) { BLI_assert(slot->slot_subtype.map == BMO_OP_SLOT_SUBTYPE_MAP_BOOL); - BLI_assert(val == FALSE || val == TRUE); + BLI_assert(val == false || val == true); BMO_slot_map_insert(op, slot, element, &val, sizeof(int)); } @@ -173,16 +173,16 @@ BLI_INLINE int BMO_slot_map_int_get(BMOpSlot *slot, const void *element) return 0; } -BLI_INLINE int BMO_slot_map_bool_get(BMOpSlot *slot, const void *element) +BLI_INLINE bool BMO_slot_map_bool_get(BMOpSlot *slot, const void *element) { int *val; BLI_assert(slot->slot_subtype.map == BMO_OP_SLOT_SUBTYPE_MAP_BOOL); val = (int *) BMO_slot_map_data_get(slot, element); - BLI_assert(val == NULL || *val == FALSE || *val == TRUE); - if (val) return *val; + BLI_assert(val == NULL || *val == false || *val == true); + if (val) return (bool)*val; - return 0; + return false; } BLI_INLINE void *BMO_slot_map_ptr_get(BMOpSlot *slot, const void *element) diff --git a/source/blender/bmesh/intern/bmesh_operators.c b/source/blender/bmesh/intern/bmesh_operators.c index fbf51b7dfdf..3308a014d25 100644 --- a/source/blender/bmesh/intern/bmesh_operators.c +++ b/source/blender/bmesh/intern/bmesh_operators.c @@ -238,7 +238,7 @@ void BMO_op_finish(BMesh *bm, BMOperator *op) * * \return Success if the slot if found. */ -int BMO_slot_exists(BMOpSlot slot_args[BMO_OP_MAX_SLOTS], const char *identifier) +bool BMO_slot_exists(BMOpSlot slot_args[BMO_OP_MAX_SLOTS], const char *identifier) { int slot_code = bmo_name_to_slotcode(slot_args, identifier); return (slot_code >= 0); @@ -390,7 +390,7 @@ void BMO_slot_int_set(BMOpSlot slot_args[BMO_OP_MAX_SLOTS], const char *slot_nam slot->data.i = i; } -void BMO_slot_bool_set(BMOpSlot slot_args[BMO_OP_MAX_SLOTS], const char *slot_name, const int i) +void BMO_slot_bool_set(BMOpSlot slot_args[BMO_OP_MAX_SLOTS], const char *slot_name, const bool i) { BMOpSlot *slot = BMO_slot_get(slot_args, slot_name); BLI_assert(slot->slot_type == BMO_OP_SLOT_BOOL); @@ -495,7 +495,7 @@ int BMO_slot_int_get(BMOpSlot slot_args[BMO_OP_MAX_SLOTS], const char *slot_name return slot->data.i; } -int BMO_slot_bool_get(BMOpSlot slot_args[BMO_OP_MAX_SLOTS], const char *slot_name) +bool BMO_slot_bool_get(BMOpSlot slot_args[BMO_OP_MAX_SLOTS], const char *slot_name) { BMOpSlot *slot = BMO_slot_get(slot_args, slot_name); BLI_assert(slot->slot_type == BMO_OP_SLOT_BOOL); @@ -549,7 +549,7 @@ void BMO_slot_vec_get(BMOpSlot slot_args[BMO_OP_MAX_SLOTS], const char *slot_nam */ static int bmo_mesh_flag_count(BMesh *bm, const char htype, const short oflag, - const short test_for_enabled) + const bool test_for_enabled) { const char iter_types[3] = {BM_VERTS_OF_MESH, BM_EDGES_OF_MESH, @@ -562,7 +562,7 @@ static int bmo_mesh_flag_count(BMesh *bm, const char htype, const short oflag, BMElemF *ele_f; int i; - BLI_assert(ELEM(TRUE, FALSE, test_for_enabled)); + BLI_assert(ELEM(true, false, test_for_enabled)); for (i = 0; i < 3; i++) { if (htype & flag_types[i]) { @@ -579,12 +579,12 @@ static int bmo_mesh_flag_count(BMesh *bm, const char htype, const short oflag, int BMO_mesh_enabled_flag_count(BMesh *bm, const char htype, const short oflag) { - return bmo_mesh_flag_count(bm, htype, oflag, TRUE); + return bmo_mesh_flag_count(bm, htype, oflag, true); } int BMO_mesh_disabled_flag_count(BMesh *bm, const char htype, const short oflag) { - return bmo_mesh_flag_count(bm, htype, oflag, FALSE); + return bmo_mesh_flag_count(bm, htype, oflag, false); } void BMO_mesh_flag_disable_all(BMesh *bm, BMOperator *UNUSED(op), const char htype, const short oflag) @@ -795,14 +795,12 @@ void BMO_slot_buffer_from_all(BMesh *bm, BMOperator *op, BMOpSlot slot_args[BMO_ */ static void bmo_slot_buffer_from_hflag(BMesh *bm, BMOperator *op, BMOpSlot slot_args[BMO_OP_MAX_SLOTS], const char *slot_name, const char htype, const char hflag, - const short test_for_enabled) + const bool test_for_enabled) { BMOpSlot *output = BMO_slot_get(slot_args, slot_name); int totelement = 0, i = 0; const int respecthide = (op->flag & BMO_FLAG_RESPECT_HIDE) != 0; - BLI_assert(ELEM(test_for_enabled, TRUE, FALSE)); - if (test_for_enabled) totelement = BM_mesh_elem_hflag_count_enabled(bm, htype, hflag, respecthide); else @@ -858,14 +856,14 @@ void BMO_slot_buffer_from_enabled_hflag(BMesh *bm, BMOperator *op, BMOpSlot slot_args[BMO_OP_MAX_SLOTS], const char *slot_name, const char htype, const char hflag) { - bmo_slot_buffer_from_hflag(bm, op, slot_args, slot_name, htype, hflag, TRUE); + bmo_slot_buffer_from_hflag(bm, op, slot_args, slot_name, htype, hflag, true); } void BMO_slot_buffer_from_disabled_hflag(BMesh *bm, BMOperator *op, BMOpSlot slot_args[BMO_OP_MAX_SLOTS], const char *slot_name, const char htype, const char hflag) { - bmo_slot_buffer_from_hflag(bm, op, slot_args, slot_name, htype, hflag, FALSE); + bmo_slot_buffer_from_hflag(bm, op, slot_args, slot_name, htype, hflag, false); } void BMO_slot_buffer_from_single(BMOperator *op, BMOpSlot *slot, BMHeader *ele) @@ -934,13 +932,13 @@ void _bmo_slot_buffer_append(BMOpSlot slot_args_dst[BMO_OP_MAX_SLOTS], const cha static void bmo_slot_buffer_from_flag(BMesh *bm, BMOperator *op, BMOpSlot slot_args[BMO_OP_MAX_SLOTS], const char *slot_name, const char htype, const short oflag, - const short test_for_enabled) + const bool test_for_enabled) { BMOpSlot *slot = BMO_slot_get(slot_args, slot_name); int totelement, i = 0; BLI_assert(op->slots_in == slot_args || op->slots_out == slot_args); - BLI_assert(ELEM(TRUE, FALSE, test_for_enabled)); + BLI_assert(ELEM(true, false, test_for_enabled)); if (test_for_enabled) totelement = BMO_mesh_enabled_flag_count(bm, htype, oflag); @@ -997,14 +995,14 @@ void BMO_slot_buffer_from_enabled_flag(BMesh *bm, BMOperator *op, BMOpSlot slot_args[BMO_OP_MAX_SLOTS], const char *slot_name, const char htype, const short oflag) { - bmo_slot_buffer_from_flag(bm, op, slot_args, slot_name, htype, oflag, TRUE); + bmo_slot_buffer_from_flag(bm, op, slot_args, slot_name, htype, oflag, true); } void BMO_slot_buffer_from_disabled_flag(BMesh *bm, BMOperator *op, BMOpSlot slot_args[BMO_OP_MAX_SLOTS], const char *slot_name, const char htype, const short oflag) { - bmo_slot_buffer_from_flag(bm, op, slot_args, slot_name, htype, oflag, FALSE); + bmo_slot_buffer_from_flag(bm, op, slot_args, slot_name, htype, oflag, false); } /** @@ -1015,13 +1013,13 @@ void BMO_slot_buffer_from_disabled_flag(BMesh *bm, BMOperator *op, */ void BMO_slot_buffer_hflag_enable(BMesh *bm, BMOpSlot slot_args[BMO_OP_MAX_SLOTS], const char *slot_name, - const char htype, const char hflag, const char do_flush) + const char htype, const char hflag, const bool do_flush) { BMOpSlot *slot = BMO_slot_get(slot_args, slot_name); BMElem **data = (BMElem **)slot->data.buf; int i; - const char do_flush_select = (do_flush && (hflag & BM_ELEM_SELECT)); - const char do_flush_hide = (do_flush && (hflag & BM_ELEM_HIDDEN)); + const bool do_flush_select = (do_flush && (hflag & BM_ELEM_SELECT)); + const bool do_flush_hide = (do_flush && (hflag & BM_ELEM_HIDDEN)); BLI_assert(slot->slot_type == BMO_OP_SLOT_ELEMENT_BUF); BLI_assert(((slot->slot_subtype.elem & BM_ALL_NOLOOP) & htype) == htype); @@ -1031,11 +1029,11 @@ void BMO_slot_buffer_hflag_enable(BMesh *bm, continue; if (do_flush_select) { - BM_elem_select_set(bm, *data, TRUE); + BM_elem_select_set(bm, *data, true); } if (do_flush_hide) { - BM_elem_hide_set(bm, *data, FALSE); + BM_elem_hide_set(bm, *data, false); } BM_elem_flag_enable(*data, hflag); @@ -1050,13 +1048,13 @@ void BMO_slot_buffer_hflag_enable(BMesh *bm, */ void BMO_slot_buffer_hflag_disable(BMesh *bm, BMOpSlot slot_args[BMO_OP_MAX_SLOTS], const char *slot_name, - const char htype, const char hflag, const char do_flush) + const char htype, const char hflag, const bool do_flush) { BMOpSlot *slot = BMO_slot_get(slot_args, slot_name); BMElem **data = (BMElem **)slot->data.buf; int i; - const char do_flush_select = (do_flush && (hflag & BM_ELEM_SELECT)); - const char do_flush_hide = (do_flush && (hflag & BM_ELEM_HIDDEN)); + const bool do_flush_select = (do_flush && (hflag & BM_ELEM_SELECT)); + const bool do_flush_hide = (do_flush && (hflag & BM_ELEM_HIDDEN)); BLI_assert(slot->slot_type == BMO_OP_SLOT_ELEMENT_BUF); BLI_assert(((slot->slot_subtype.elem & BM_ALL_NOLOOP) & htype) == htype); @@ -1066,11 +1064,11 @@ void BMO_slot_buffer_hflag_disable(BMesh *bm, continue; if (do_flush_select) { - BM_elem_select_set(bm, *data, FALSE); + BM_elem_select_set(bm, *data, false); } if (do_flush_hide) { - BM_elem_hide_set(bm, *data, FALSE); + BM_elem_hide_set(bm, *data, false); } BM_elem_flag_disable(*data, hflag); @@ -1482,7 +1480,7 @@ void BMO_error_raise(BMesh *bm, BMOperator *owner, int errcode, const char *msg) BLI_addhead(&bm->errorstack, err); } -int BMO_error_occurred(BMesh *bm) +bool BMO_error_occurred(BMesh *bm) { return bm->errorstack.first != NULL; } @@ -1616,7 +1614,7 @@ static int bmo_opname_to_opcode(const char *opname) * Order is not important so `Hfev` is also valid (all unflagged verts, edges and faces). */ -int BMO_op_vinitf(BMesh *bm, BMOperator *op, const int flag, const char *_fmt, va_list vlist) +bool BMO_op_vinitf(BMesh *bm, BMOperator *op, const int flag, const char *_fmt, va_list vlist) { // BMOpDefine *def; char *opname, *ofmt, *fmt; @@ -1653,7 +1651,7 @@ int BMO_op_vinitf(BMesh *bm, BMOperator *op, const int flag, const char *_fmt, v if (i == -1) { MEM_freeN(ofmt); - return FALSE; + return false; } BMO_op_init(bm, op, flag, opname); @@ -1816,7 +1814,7 @@ int BMO_op_vinitf(BMesh *bm, BMOperator *op, const int flag, const char *_fmt, v } MEM_freeN(ofmt); - return TRUE; + return true; error: /* non urgent todo - explain exactly what is failing */ @@ -1841,14 +1839,14 @@ error: MEM_freeN(ofmt); BMO_op_finish(bm, op); - return FALSE; + return false; #undef GOTO_ERROR } -int BMO_op_initf(BMesh *bm, BMOperator *op, const int flag, const char *fmt, ...) +bool BMO_op_initf(BMesh *bm, BMOperator *op, const int flag, const char *fmt, ...) { va_list list; @@ -1856,14 +1854,14 @@ int BMO_op_initf(BMesh *bm, BMOperator *op, const int flag, const char *fmt, ... if (!BMO_op_vinitf(bm, op, flag, fmt, list)) { printf("%s: failed\n", __func__); va_end(list); - return FALSE; + return false; } va_end(list); - return TRUE; + return true; } -int BMO_op_callf(BMesh *bm, const int flag, const char *fmt, ...) +bool BMO_op_callf(BMesh *bm, const int flag, const char *fmt, ...) { va_list list; BMOperator op; @@ -1872,12 +1870,12 @@ int BMO_op_callf(BMesh *bm, const int flag, const char *fmt, ...) if (!BMO_op_vinitf(bm, &op, flag, fmt, list)) { printf("%s: failed, format is:\n \"%s\"\n", __func__, fmt); va_end(list); - return FALSE; + return false; } BMO_op_exec(bm, &op); BMO_op_finish(bm, &op); va_end(list); - return TRUE; + return true; } diff --git a/source/blender/bmesh/intern/bmesh_operators_private.h b/source/blender/bmesh/intern/bmesh_operators_private.h index 9175af1c822..ea9ad2ed151 100644 --- a/source/blender/bmesh/intern/bmesh_operators_private.h +++ b/source/blender/bmesh/intern/bmesh_operators_private.h @@ -89,7 +89,6 @@ void bmo_shortest_path_exec(BMesh *bm, BMOperator *op); void bmo_similar_edges_exec(BMesh *bm, BMOperator *op); void bmo_similar_faces_exec(BMesh *bm, BMOperator *op); void bmo_similar_verts_exec(BMesh *bm, BMOperator *op); -void bmo_slide_vert_exec(BMesh *bm, BMOperator *op); void bmo_smooth_vert_exec(BMesh *bm, BMOperator *op); void bmo_smooth_laplacian_vert_exec(BMesh *bm, BMOperator *op); void bmo_solidify_face_region_exec(BMesh *bm, BMOperator *op); diff --git a/source/blender/bmesh/intern/bmesh_polygon.c b/source/blender/bmesh/intern/bmesh_polygon.c index 4545c9bb564..5c3d164c768 100644 --- a/source/blender/bmesh/intern/bmesh_polygon.c +++ b/source/blender/bmesh/intern/bmesh_polygon.c @@ -50,7 +50,7 @@ * Used for tessellator */ -static short testedgesidef(const float v1[2], const float v2[2], const float v3[2]) +static bool testedgesidef(const float v1[2], const float v2[2], const float v3[2]) { /* is v3 to the right of v1 - v2 ? With exception: v3 == v1 || v3 == v2 */ double inp; @@ -59,13 +59,13 @@ static short testedgesidef(const float v1[2], const float v2[2], const float v3[ inp = (v2[0] - v1[0]) * (v1[1] - v3[1]) + (v1[1] - v2[1]) * (v1[0] - v3[0]); if (inp < 0.0) { - return FALSE; + return false; } else if (inp == 0) { - if (v1[0] == v3[0] && v1[1] == v3[1]) return FALSE; - if (v2[0] == v3[0] && v2[1] == v3[1]) return FALSE; + if (v1[0] == v3[0] && v1[1] == v3[1]) return false; + if (v2[0] == v3[0] && v2[1] == v3[1]) return false; } - return TRUE; + return true; } /** @@ -319,7 +319,7 @@ void poly_rotate_plane(const float normal[3], float (*verts)[3], const int nvert if (angle < FLT_EPSILON) return; - if (len_v3(axis) < FLT_EPSILON) { + if (len_squared_v3(axis) < FLT_EPSILON) { axis[0] = 0.0f; axis[1] = 1.0f; axis[2] = 0.0f; @@ -498,7 +498,7 @@ void BM_face_normal_flip(BMesh *bm, BMFace *f) /* detects if two line segments cross each other (intersects). * note, there could be more winding cases then there needs to be. */ -static int line_crosses_v2f(const float v1[2], const float v2[2], const float v3[2], const float v4[2]) +static bool line_crosses_v2f(const float v1[2], const float v2[2], const float v3[2], const float v4[2]) { #define GETMIN2_AXIS(a, b, ma, mb, axis) \ @@ -526,7 +526,7 @@ static int line_crosses_v2f(const float v1[2], const float v2[2], const float v3 w5 = !testedgesidef(v3, v1, v4); if (w1 == w2 && w2 == w3 && w3 == w4 && w4 == w5) { - return TRUE; + return true; } GETMIN2(v1, v2, mv1, mv2); @@ -549,7 +549,7 @@ static int line_crosses_v2f(const float v1[2], const float v2[2], const float v3 return (mv4[1] >= mv1[1] && mv3[1] <= mv2[1]); } - return FALSE; + return false; #undef GETMIN2_AXIS #undef GETMIN2 @@ -567,7 +567,7 @@ static int line_crosses_v2f(const float v1[2], const float v2[2], const float v3 * instead of projecting co directly into f's orientation space, * so there might be accuracy issues. */ -int BM_face_point_inside_test(BMFace *f, const float co[3]) +bool BM_face_point_inside_test(BMFace *f, const float co[3]) { int ax, ay; float co2[2], cent[2] = {0.0f, 0.0f}, out[2] = {FLT_MAX * 0.5f, FLT_MAX * 0.5f}; @@ -614,7 +614,7 @@ int BM_face_point_inside_test(BMFace *f, const float co[3]) return crosses % 2 != 0; } -static int bm_face_goodline(float const (*projectverts)[3], BMFace *f, int v1i, int v2i, int v3i) +static bool bm_face_goodline(float const (*projectverts)[3], BMFace *f, int v1i, int v2i, int v3i) { BMLoop *l_iter; BMLoop *l_first; @@ -627,7 +627,7 @@ static int bm_face_goodline(float const (*projectverts)[3], BMFace *f, int v1i, /* v3 must be on the left side of [v1, v2] line, else we know [v1, v3] is outside of f! */ if (testedgesidef(v1, v2, v3)) { - return FALSE; + return false; } l_iter = l_first = BM_FACE_FIRST_LOOP(f); @@ -649,10 +649,10 @@ static int bm_face_goodline(float const (*projectverts)[3], BMFace *f, int v1i, else printf("%d in (%d, %d, %d)\n", v1i, i, v3i, v2i); #endif - return FALSE; + return false; } } while ((l_iter = l_iter->next) != l_first); - return TRUE; + return true; } /** @@ -665,7 +665,7 @@ static int bm_face_goodline(float const (*projectverts)[3], BMFace *f, int v1i, * \param abscoss Must be allocated by caller, and at least f->len length * (allow to avoid allocating a new one for each tri!). */ -static BMLoop *find_ear(BMFace *f, float (*verts)[3], const int use_beauty, float *abscoss) +static BMLoop *find_ear(BMFace *f, float (*verts)[3], const bool use_beauty, float *abscoss) { BMLoop *bestear = NULL; @@ -726,7 +726,8 @@ static BMLoop *find_ear(BMFace *f, float (*verts)[3], const int use_beauty, floa /* float angle, bestangle = 180.0f; */ float cos, tcos, bestcos = 1.0f; float *tcoss; - int isear, i = 0, j, len; + bool is_ear; + int i = 0, j, len; /* Compute cos of all corners! */ l_iter = l_first = BM_FACE_FIRST_LOOP(f); @@ -745,7 +746,7 @@ static BMLoop *find_ear(BMFace *f, float (*verts)[3], const int use_beauty, floa l_iter = l_first; tcoss = abscoss; do { - isear = TRUE; + is_ear = true; v1 = l_iter->prev->v; v2 = l_iter->v; @@ -753,7 +754,7 @@ static BMLoop *find_ear(BMFace *f, float (*verts)[3], const int use_beauty, floa /* We may have already internal edges... */ if (BM_edge_exists(v1, v3)) { - isear = FALSE; + is_ear = false; } else if (!bm_face_goodline((float const (*)[3])verts, f, BM_elem_index_get(v1), BM_elem_index_get(v2), BM_elem_index_get(v3))) @@ -762,10 +763,10 @@ static BMLoop *find_ear(BMFace *f, float (*verts)[3], const int use_beauty, floa printf("(%d, %d, %d) would not be a valid tri!\n", BM_elem_index_get(v1), BM_elem_index_get(v2), BM_elem_index_get(v3)); #endif - isear = FALSE; + is_ear = false; } - if (isear) { + if (is_ear) { #if 0 /* Old, already commented code */ /* if this code comes back, it needs to be converted to radians */ angle = angle_v3v3v3(verts[v1->head.eflag2], verts[v2->head.eflag2], verts[v3->head.eflag2]); @@ -845,9 +846,10 @@ static BMLoop *find_ear(BMFace *f, float (*verts)[3], const int use_beauty, floa * \note newedgeflag sets a flag layer flag, obviously not the header flag. */ void BM_face_triangulate(BMesh *bm, BMFace *f, float (*projectverts)[3], const short newedge_oflag, - const short newface_oflag, BMFace **newfaces, const short use_beauty) + const short newface_oflag, BMFace **newfaces, const bool use_beauty) { - int i, done, nvert, nf_i = 0; + int i, nvert, nf_i = 0; + bool done; BMLoop *newl; BMLoop *l_iter; BMLoop *l_first; @@ -877,14 +879,20 @@ void BM_face_triangulate(BMesh *bm, BMFace *f, float (*projectverts)[3], const s projectverts[i][2] = 0.0f; } - done = FALSE; + done = false; while (!done && f->len > 3) { - done = TRUE; + done = true; l_iter = find_ear(f, projectverts, use_beauty, abscoss); - if (l_iter) { - done = FALSE; + + /* force triangulation - if we can't find an ear the face is degenerate */ + if (l_iter == NULL) { + l_iter = BM_FACE_FIRST_LOOP(f); + } + + { + done = false; /* printf("Subdividing face...\n");*/ - f = BM_face_split(bm, l_iter->f, l_iter->prev->v, l_iter->next->v, &newl, NULL, TRUE); + f = BM_face_split(bm, l_iter->f, l_iter->prev->v, l_iter->next->v, &newl, NULL, true); if (UNLIKELY(!f)) { fprintf(stderr, "%s: triangulator failed to split face! (bmesh internal error)\n", __func__); @@ -912,13 +920,15 @@ void BM_face_triangulate(BMesh *bm, BMFace *f, float (*projectverts)[3], const s } } + BLI_assert(f->len == 3); + #if 0 /* XXX find_ear should now always return a corner, so no more need for this piece of code... */ if (f->len > 3) { l_iter = BM_FACE_FIRST_LOOP(f); while (l_iter->f->len > 3) { nextloop = l_iter->next->next; f = BM_face_split(bm, l_iter->f, l_iter->v, nextloop->v, - &newl, NULL, TRUE); + &newl, NULL, true); if (!f) { printf("triangle fan step of triangulator failed.\n"); @@ -1078,3 +1088,37 @@ void BM_face_legal_splits(BMesh *bm, BMFace *f, BMLoop *(*loops)[2], int len) } } } + + +/** + * Small utility functions for fast access + * + * faster alternative to: + * BM_iter_as_array(bm, BM_VERTS_OF_FACE, f, (void**)v, 3); + */ +void BM_face_as_array_vert_tri(BMFace *f, BMVert *r_verts[3]) +{ + BMLoop *l = BM_FACE_FIRST_LOOP(f); + + BLI_assert(f->len == 3); + + r_verts[0] = l->v; l = l->next; + r_verts[1] = l->v; l = l->next; + r_verts[2] = l->v; +} + +/** + * faster alternative to: + * BM_iter_as_array(bm, BM_VERTS_OF_FACE, f, (void**)v, 4); + */ +void BM_face_as_array_vert_quad(BMFace *f, BMVert *r_verts[4]) +{ + BMLoop *l = BM_FACE_FIRST_LOOP(f); + + BLI_assert(f->len == 4); + + r_verts[0] = l->v; l = l->next; + r_verts[1] = l->v; l = l->next; + r_verts[2] = l->v; l = l->next; + r_verts[3] = l->v; +} diff --git a/source/blender/bmesh/intern/bmesh_polygon.h b/source/blender/bmesh/intern/bmesh_polygon.h index e5777d3611b..a0c6ac5eeaa 100644 --- a/source/blender/bmesh/intern/bmesh_polygon.h +++ b/source/blender/bmesh/intern/bmesh_polygon.h @@ -42,12 +42,15 @@ void BM_vert_normal_update(BMVert *v); void BM_vert_normal_update_all(BMVert *v); void BM_face_normal_flip(BMesh *bm, BMFace *f); -int BM_face_point_inside_test(BMFace *f, const float co[3]); +bool BM_face_point_inside_test(BMFace *f, const float co[3]); void BM_face_triangulate(BMesh *bm, BMFace *f, float (*projectverts)[3], const short newedge_oflag, const short newface_oflag, BMFace **newfaces, - const short use_beauty); + const bool use_beauty); void BM_face_legal_splits(BMesh *bm, BMFace *f, BMLoop *(*loops)[2], int len); +void BM_face_as_array_vert_tri(BMFace *f, BMVert *r_verts[3]); +void BM_face_as_array_vert_quad(BMFace *f, BMVert *r_verts[4]); + #endif /* __BMESH_POLYGON_H__ */ diff --git a/source/blender/bmesh/intern/bmesh_queries.c b/source/blender/bmesh/intern/bmesh_queries.c index b5b6c69bd7e..7ed23aaf1f8 100644 --- a/source/blender/bmesh/intern/bmesh_queries.c +++ b/source/blender/bmesh/intern/bmesh_queries.c @@ -43,7 +43,7 @@ * Returns whether or not a given vertex is * is part of a given edge. */ -int BM_vert_in_edge(BMEdge *e, BMVert *v) +bool BM_vert_in_edge(BMEdge *e, BMVert *v) { return bmesh_vert_in_edge(e, v); } @@ -208,9 +208,9 @@ BMLoop *BM_vert_find_first_loop(BMVert *v) } /** - * Returns TRUE if the vertex is used in a given face. + * Returns true if the vertex is used in a given face. */ -int BM_vert_in_face(BMFace *f, BMVert *v) +bool BM_vert_in_face(BMFace *f, BMVert *v) { BMLoop *l_iter, *l_first; @@ -226,19 +226,19 @@ int BM_vert_in_face(BMFace *f, BMVert *v) #endif do { if (l_iter->v == v) { - return TRUE; + return true; } } while ((l_iter = l_iter->next) != l_first); } - return FALSE; + return false; } /** * Compares the number of vertices in an array * that appear in a given face */ -int BM_verts_in_face(BMFace *f, BMVert **varr, int len) +int BM_verts_in_face_count(BMFace *f, BMVert **varr, int len) { BMLoop *l_iter, *l_first; @@ -278,10 +278,64 @@ int BM_verts_in_face(BMFace *f, BMVert **varr, int len) return count; } + +/** + * Return true if all verts are in the face. + */ +bool BM_verts_in_face(BMFace *f, BMVert **varr, int len) +{ + BMLoop *l_iter, *l_first; + +#ifdef USE_BMESH_HOLES + BMLoopList *lst; +#endif + + int i; + bool ok = true; + + /* simple check, we know can't succeed */ + if (f->len < len) { + return false; + } + + for (i = 0; i < len; i++) { + BM_ELEM_API_FLAG_ENABLE(varr[i], _FLAG_OVERLAP); + } + +#ifdef USE_BMESH_HOLES + for (lst = f->loops.first; lst; lst = lst->next) +#endif + { + +#ifdef USE_BMESH_HOLES + l_iter = l_first = lst->first; +#else + l_iter = l_first = f->l_first; +#endif + + do { + if (BM_ELEM_API_FLAG_TEST(l_iter->v, _FLAG_OVERLAP)) { + /* pass */ + } + else { + ok = false; + break; + } + + } while ((l_iter = l_iter->next) != l_first); + } + + for (i = 0; i < len; i++) { + BM_ELEM_API_FLAG_DISABLE(varr[i], _FLAG_OVERLAP); + } + + return ok; +} + /** * Returns whether or not a given edge is is part of a given face. */ -int BM_edge_in_face(BMFace *f, BMEdge *e) +bool BM_edge_in_face(BMFace *f, BMEdge *e) { BMLoop *l_iter; BMLoop *l_first; @@ -290,17 +344,17 @@ int BM_edge_in_face(BMFace *f, BMEdge *e) do { if (l_iter->e == e) { - return TRUE; + return true; } } while ((l_iter = l_iter->next) != l_first); - return FALSE; + return false; } /** * Returns whether or not a given edge is is part of a given loop. */ -int BM_edge_in_loop(BMEdge *e, BMLoop *l) +bool BM_edge_in_loop(BMEdge *e, BMLoop *l) { return (l->e == e || l->prev->e == e); } @@ -309,7 +363,7 @@ int BM_edge_in_loop(BMEdge *e, BMLoop *l) * Returns whether or not two vertices are in * a given edge */ -int BM_verts_in_edge(BMVert *v1, BMVert *v2, BMEdge *e) +bool BM_verts_in_edge(BMVert *v1, BMVert *v2, BMEdge *e) { return bmesh_verts_in_edge(v1, v2, e); } @@ -487,9 +541,9 @@ float BM_edge_calc_length_squared(BMEdge *e) * Utility function, since enough times we have an edge * and want to access 2 connected faces. * - * \return TRUE when only 2 faces are found. + * \return true when only 2 faces are found. */ -int BM_edge_face_pair(BMEdge *e, BMFace **r_fa, BMFace **r_fb) +bool BM_edge_face_pair(BMEdge *e, BMFace **r_fa, BMFace **r_fb) { BMLoop *la, *lb; @@ -500,12 +554,12 @@ int BM_edge_face_pair(BMEdge *e, BMFace **r_fa, BMFace **r_fb) { *r_fa = la->f; *r_fb = lb->f; - return TRUE; + return true; } else { *r_fa = NULL; *r_fb = NULL; - return FALSE; + return false; } } @@ -513,9 +567,9 @@ int BM_edge_face_pair(BMEdge *e, BMFace **r_fa, BMFace **r_fb) * Utility function, since enough times we have an edge * and want to access 2 connected loops. * - * \return TRUE when only 2 faces are found. + * \return true when only 2 faces are found. */ -int BM_edge_loop_pair(BMEdge *e, BMLoop **r_la, BMLoop **r_lb) +bool BM_edge_loop_pair(BMEdge *e, BMLoop **r_la, BMLoop **r_lb) { BMLoop *la, *lb; @@ -526,12 +580,12 @@ int BM_edge_loop_pair(BMEdge *e, BMLoop **r_la, BMLoop **r_lb) { *r_la = la; *r_lb = lb; - return TRUE; + return true; } else { *r_la = NULL; *r_lb = NULL; - return FALSE; + return false; } } @@ -589,7 +643,7 @@ int BM_vert_face_count(BMVert *v) * Tests whether or not the vertex is part of a wire edge. * (ie: has no faces attached to it) */ -int BM_vert_is_wire(BMVert *v) +bool BM_vert_is_wire(BMVert *v) { if (v->e) { BMEdge *e_first, *e_iter; @@ -597,14 +651,14 @@ int BM_vert_is_wire(BMVert *v) e_first = e_iter = v->e; do { if (e_iter->l) { - return FALSE; + return false; } } while ((e_iter = bmesh_disk_edge_next(e_iter, v)) != e_first); - return TRUE; + return true; } else { - return FALSE; + return false; } } @@ -612,9 +666,9 @@ int BM_vert_is_wire(BMVert *v) * Tests whether or not the edge is part of a wire. * (ie: has no faces attached to it) */ -int BM_edge_is_wire(BMEdge *e) +bool BM_edge_is_wire(BMEdge *e) { - return (e->l) ? FALSE : TRUE; + return (e->l == NULL); } /** @@ -624,7 +678,7 @@ int BM_edge_is_wire(BMEdge *e) * 3: Is part of a an edge with more than 2 faces. * 4: Is part of a wire edge. */ -int BM_vert_is_manifold(BMVert *v) +bool BM_vert_is_manifold(BMVert *v) { BMEdge *e, *oe; BMLoop *l; @@ -632,7 +686,7 @@ int BM_vert_is_manifold(BMVert *v) if (v->e == NULL) { /* loose vert */ - return FALSE; + return false; } /* count edges while looking for non-manifold edges */ @@ -643,7 +697,7 @@ int BM_vert_is_manifold(BMVert *v) * edges with 1 face user are OK, otherwise we could * use BM_edge_is_manifold() here */ if (e->l == NULL || bmesh_radial_length(e->l) > 2) { - return FALSE; + return false; } len++; } while ((e = bmesh_disk_edge_next(e, v)) != oe); @@ -677,10 +731,10 @@ int BM_vert_is_manifold(BMVert *v) if (count < len) { /* vert shared by multiple regions */ - return FALSE; + return false; } - return TRUE; + return true; } /** @@ -689,7 +743,7 @@ int BM_vert_is_manifold(BMVert *v) */ #if 1 /* fast path for checking manifold */ -int BM_edge_is_manifold(BMEdge *e) +bool BM_edge_is_manifold(BMEdge *e) { const BMLoop *l = e->l; return (l && (l->radial_next != l) && /* not 0 or 1 face users */ @@ -700,10 +754,10 @@ int BM_edge_is_manifold(BMEdge *e) { int count = BM_edge_face_count(e); if (count == 2) { - return TRUE; + return true; } else { - return FALSE; + return false; } } #endif @@ -714,7 +768,7 @@ int BM_edge_is_manifold(BMEdge *e) */ #if 1 /* fast path for checking boundary */ -int BM_edge_is_boundary(BMEdge *e) +bool BM_edge_is_boundary(BMEdge *e) { const BMLoop *l = e->l; return (l && (l->radial_next == l)); @@ -724,10 +778,10 @@ int BM_edge_is_boundary(BMEdge *e) { int count = BM_edge_face_count(e); if (count == 1) { - return TRUE; + return true; } else { - return FALSE; + return false; } } #endif @@ -757,7 +811,7 @@ int BM_face_share_face_count(BMFace *f1, BMFace *f2) /** * same as #BM_face_share_face_count but returns a bool */ -int BM_face_share_face_check(BMFace *f1, BMFace *f2) +bool BM_face_share_face_check(BMFace *f1, BMFace *f2) { BMIter iter1, iter2; BMEdge *e; @@ -766,11 +820,11 @@ int BM_face_share_face_check(BMFace *f1, BMFace *f2) BM_ITER_ELEM (e, &iter1, f1, BM_EDGES_OF_FACE) { BM_ITER_ELEM (f, &iter2, e, BM_FACES_OF_EDGE) { if (f != f1 && f != f2 && BM_face_share_edge_check(f, f2)) - return TRUE; + return true; } } - return FALSE; + return false; } /** @@ -793,9 +847,9 @@ int BM_face_share_edge_count(BMFace *f1, BMFace *f2) } /** - * Returns TRUE if the faces share an edge + * Returns true if the faces share an edge */ -int BM_face_share_edge_check(BMFace *f1, BMFace *f2) +bool BM_face_share_edge_check(BMFace *f1, BMFace *f2) { BMLoop *l_iter; BMLoop *l_first; @@ -803,17 +857,17 @@ int BM_face_share_edge_check(BMFace *f1, BMFace *f2) l_iter = l_first = BM_FACE_FIRST_LOOP(f1); do { if (bmesh_radial_face_find(l_iter->e, f2)) { - return TRUE; + return true; } } while ((l_iter = l_iter->next) != l_first); - return FALSE; + return false; } /** - * Test if e1 shares any faces with e2 + * Test if e1 shares any faces with e2 */ -int BM_edge_share_face_check(BMEdge *e1, BMEdge *e2) +bool BM_edge_share_face_check(BMEdge *e1, BMEdge *e2) { BMLoop *l; BMFace *f; @@ -823,18 +877,18 @@ int BM_edge_share_face_check(BMEdge *e1, BMEdge *e2) do { f = l->f; if (bmesh_radial_face_find(e2, f)) { - return TRUE; + return true; } l = l->radial_next; } while (l != e1->l); } - return FALSE; + return false; } /** * Test if e1 shares any quad faces with e2 */ -int BM_edge_share_quad_check(BMEdge *e1, BMEdge *e2) +bool BM_edge_share_quad_check(BMEdge *e1, BMEdge *e2) { BMLoop *l; BMFace *f; @@ -845,19 +899,19 @@ int BM_edge_share_quad_check(BMEdge *e1, BMEdge *e2) f = l->f; if (f->len == 4) { if (bmesh_radial_face_find(e2, f)) { - return TRUE; + return true; } } l = l->radial_next; } while (l != e1->l); } - return FALSE; + return false; } /** * Tests to see if e1 shares a vertex with e2 */ -int BM_edge_share_vert_check(BMEdge *e1, BMEdge *e2) +bool BM_edge_share_vert_check(BMEdge *e1, BMEdge *e2) { return (e1->v1 == e2->v1 || e1->v1 == e2->v2 || @@ -1007,7 +1061,7 @@ void BM_loop_calc_face_tangent(BMLoop *l, float r_tangent[3]) normalize_v3(v_prev); normalize_v3(v_next); - if (compare_v3v3(v_prev, v_next, FLT_EPSILON) == FALSE) { + if (compare_v3v3(v_prev, v_next, FLT_EPSILON) == false) { float dir[3]; float nor[3]; /* for this purpose doesn't need to be normalized */ add_v3_v3v3(dir, v_prev, v_next); @@ -1273,67 +1327,94 @@ BMEdge *BM_edge_find_double(BMEdge *e) } /** - * Given a set of vertices \a varr, find out if - * all those vertices overlap an existing face. - * - * \note Making a face here is valid but in some cases you wont want to - * make a face thats part of another. - * - * \returns TRUE for overlap + * Given a set of vertices (varr), find out if + * there is a face with exactly those vertices + * (and only those vertices). * + * \note there used to be a BM_face_exists_overlap function that checked for partial overlap, + * however this is no longer used, simple to add back. */ -int BM_face_exists_overlap(BMVert **varr, int len, BMFace **r_overlapface) +bool BM_face_exists(BMVert **varr, int len, BMFace **r_existface) { + BMVert *v_search = varr[0]; /* we can search any of the verts in the array */ BMIter viter; BMFace *f; - int i, amount; - for (i = 0; i < len; i++) { - BM_ITER_ELEM (f, &viter, varr[i], BM_FACES_OF_VERT) { - amount = BM_verts_in_face(f, varr, len); - if (amount >= len) { - if (r_overlapface) { - *r_overlapface = f; + +#if 0 + BM_ITER_ELEM (f, &viter, v_search, BM_FACES_OF_VERT) { + if (f->len == len) { + if (BM_verts_in_face(f, varr, len)) { + if (r_existface) { + *r_existface = f; } - return TRUE; + return true; } } } - if (r_overlapface) { - *r_overlapface = NULL; + if (r_existface) { + *r_existface = NULL; } + return false; - return FALSE; -} +#else -/** - * Given a set of vertices (varr), find out if - * there is a face with exactly those vertices - * (and only those vertices). - */ -int BM_face_exists(BMVert **varr, int len, BMFace **r_existface) -{ - BMIter viter; - BMFace *f; - int i, amount; + /* faster to do the flagging once, and inline */ + bool is_init = false; + bool is_found = false; + int i; - for (i = 0; i < len; i++) { - BM_ITER_ELEM (f, &viter, varr[i], BM_FACES_OF_VERT) { - amount = BM_verts_in_face(f, varr, len); - if (amount == len && amount == f->len) { + + BM_ITER_ELEM (f, &viter, v_search, BM_FACES_OF_VERT) { + if (f->len == len) { + if (is_init == false) { + is_init = true; + for (i = 0; i < len; i++) { + BLI_assert(!BM_ELEM_API_FLAG_TEST(varr[i], _FLAG_OVERLAP)); + BM_ELEM_API_FLAG_ENABLE(varr[i], _FLAG_OVERLAP); + } + } + + is_found = true; + + { + BMLoop *l_iter; + BMLoop *l_first; + + l_iter = l_first = BM_FACE_FIRST_LOOP(f); + + do { + if (!BM_ELEM_API_FLAG_TEST(l_iter->v, _FLAG_OVERLAP)) { + is_found = false; + break; + } + } while ((l_iter = l_iter->next) != l_first); + } + + if (is_found) { if (r_existface) { *r_existface = f; } - return TRUE; + break; } } } - if (r_existface) { - *r_existface = NULL; + if (is_found == false) { + if (r_existface) { + *r_existface = NULL; + } } - return FALSE; + + if (is_init == true) { + for (i = 0; i < len; i++) { + BM_ELEM_API_FLAG_DISABLE(varr[i], _FLAG_OVERLAP); + } + } + + return is_found; +#endif } @@ -1349,12 +1430,12 @@ int BM_face_exists(BMVert **varr, int len, BMFace **r_existface) * * \a earr and \a varr can be in any order, however they _must_ form a closed loop. */ -int BM_face_exists_multi(BMVert **varr, BMEdge **earr, int len) +bool BM_face_exists_multi(BMVert **varr, BMEdge **earr, int len) { BMFace *f; BMEdge *e; BMVert *v; - int ok; + bool ok; int tot_tag; BMIter fiter; @@ -1394,10 +1475,10 @@ int BM_face_exists_multi(BMVert **varr, BMEdge **earr, int len) for (i = 0; i < len; i++) { BM_ITER_ELEM (f, &fiter, earr[i], BM_FACES_OF_EDGE) { if (!BM_elem_flag_test(f, BM_ELEM_INTERNAL_TAG)) { - ok = TRUE; + ok = true; BM_ITER_ELEM (v, &viter, f, BM_VERTS_OF_FACE) { if (!BM_elem_flag_test(v, BM_ELEM_INTERNAL_TAG)) { - ok = FALSE; + ok = false; break; } } @@ -1416,20 +1497,20 @@ int BM_face_exists_multi(BMVert **varr, BMEdge **earr, int len) if (tot_tag == 0) { /* no faces use only boundary verts, quit early */ - return FALSE; + return false; } /* 2) loop over non-boundary edges that use boundary verts, * check each have 2 tagges faces connected (faces that only use 'varr' verts) */ - ok = TRUE; + ok = true; for (i = 0; i < len; i++) { BM_ITER_ELEM (e, &fiter, varr[i], BM_EDGES_OF_VERT) { if (/* non-boundary edge */ - BM_elem_flag_test(e, BM_ELEM_INTERNAL_TAG) == FALSE && + BM_elem_flag_test(e, BM_ELEM_INTERNAL_TAG) == false && /* ...using boundary verts */ - BM_elem_flag_test(e->v1, BM_ELEM_INTERNAL_TAG) == TRUE && - BM_elem_flag_test(e->v2, BM_ELEM_INTERNAL_TAG) == TRUE) + BM_elem_flag_test(e->v1, BM_ELEM_INTERNAL_TAG) == true && + BM_elem_flag_test(e->v2, BM_ELEM_INTERNAL_TAG) == true) { int tot_face_tag = 0; BM_ITER_ELEM (f, &fiter, e, BM_FACES_OF_EDGE) { @@ -1439,14 +1520,14 @@ int BM_face_exists_multi(BMVert **varr, BMEdge **earr, int len) } if (tot_face_tag != 2) { - ok = FALSE; + ok = false; break; } } } - if (ok == FALSE) { + if (ok == false) { break; } } @@ -1455,25 +1536,25 @@ int BM_face_exists_multi(BMVert **varr, BMEdge **earr, int len) } /* same as 'BM_face_exists_multi' but built vert array from edges */ -int BM_face_exists_multi_edge(BMEdge **earr, int len) +bool BM_face_exists_multi_edge(BMEdge **earr, int len) { BMVert **varr = BLI_array_alloca(varr, len); - int ok; + bool ok; int i, i_next; /* first check if verts have edges, if not we can bail out early */ - ok = TRUE; + ok = true; for (i = len - 1, i_next = 0; i_next < len; (i = i_next++)) { if (!(varr[i] = BM_edge_share_vert(earr[i], earr[i_next]))) { - ok = FALSE; + ok = false; break; } } - if (ok == FALSE) { + if (ok == false) { BMESH_ASSERT(0); - return FALSE; + return false; } ok = BM_face_exists_multi(varr, earr, len); @@ -1482,13 +1563,13 @@ int BM_face_exists_multi_edge(BMEdge **earr, int len) } /* convenience functions for checking flags */ -int BM_edge_is_any_vert_flag_test(BMEdge *e, const char hflag) +bool BM_edge_is_any_vert_flag_test(BMEdge *e, const char hflag) { return (BM_elem_flag_test(e->v1, hflag) || BM_elem_flag_test(e->v2, hflag)); } -int BM_face_is_any_vert_flag_test(BMFace *f, const char hflag) +bool BM_face_is_any_vert_flag_test(BMFace *f, const char hflag) { BMLoop *l_iter; BMLoop *l_first; @@ -1496,13 +1577,13 @@ int BM_face_is_any_vert_flag_test(BMFace *f, const char hflag) l_iter = l_first = BM_FACE_FIRST_LOOP(f); do { if (BM_elem_flag_test(l_iter->v, hflag)) { - return TRUE; + return true; } } while ((l_iter = l_iter->next) != l_first); - return FALSE; + return false; } -int BM_face_is_any_edge_flag_test(BMFace *f, const char hflag) +bool BM_face_is_any_edge_flag_test(BMFace *f, const char hflag) { BMLoop *l_iter; BMLoop *l_first; @@ -1510,8 +1591,8 @@ int BM_face_is_any_edge_flag_test(BMFace *f, const char hflag) l_iter = l_first = BM_FACE_FIRST_LOOP(f); do { if (BM_elem_flag_test(l_iter->e, hflag)) { - return TRUE; + return true; } } while ((l_iter = l_iter->next) != l_first); - return FALSE; + return false; } diff --git a/source/blender/bmesh/intern/bmesh_queries.h b/source/blender/bmesh/intern/bmesh_queries.h index a9d6719c491..9892700162e 100644 --- a/source/blender/bmesh/intern/bmesh_queries.h +++ b/source/blender/bmesh/intern/bmesh_queries.h @@ -27,19 +27,20 @@ * \ingroup bmesh */ -int BM_vert_in_face(BMFace *f, BMVert *v); -int BM_verts_in_face(BMFace *f, BMVert **varr, int len); +bool BM_vert_in_face(BMFace *f, BMVert *v); +int BM_verts_in_face_count(BMFace *f, BMVert **varr, int len); +bool BM_verts_in_face(BMFace *f, BMVert **varr, int len); -int BM_edge_in_face(BMFace *f, BMEdge *e); -int BM_edge_in_loop(BMEdge *e, BMLoop *l); +bool BM_edge_in_face(BMFace *f, BMEdge *e); +bool BM_edge_in_loop(BMEdge *e, BMLoop *l); -int BM_vert_in_edge(BMEdge *e, BMVert *v); -int BM_verts_in_edge(BMVert *v1, BMVert *v2, BMEdge *e); +bool BM_vert_in_edge(BMEdge *e, BMVert *v); +bool BM_verts_in_edge(BMVert *v1, BMVert *v2, BMEdge *e); float BM_edge_calc_length(BMEdge *e); float BM_edge_calc_length_squared(BMEdge *e); -int BM_edge_face_pair(BMEdge *e, BMFace **r_fa, BMFace **r_fb); -int BM_edge_loop_pair(BMEdge *e, BMLoop **r_la, BMLoop **r_lb); +bool BM_edge_face_pair(BMEdge *e, BMFace **r_fa, BMFace **r_fb); +bool BM_edge_loop_pair(BMEdge *e, BMLoop **r_la, BMLoop **r_lb); BMVert *BM_edge_other_vert(BMEdge *e, BMVert *v); BMLoop *BM_edge_other_loop(BMEdge *e, BMLoop *l); BMLoop *BM_face_other_edge_loop(BMFace *f, BMEdge *e, BMVert *v); @@ -54,12 +55,12 @@ int BM_edge_face_count(BMEdge *e); int BM_vert_face_count(BMVert *v); BMEdge *BM_vert_other_disk_edge(BMVert *v, BMEdge *e); -int BM_vert_is_wire(BMVert *v); -int BM_edge_is_wire(BMEdge *e); +bool BM_vert_is_wire(BMVert *v); +bool BM_edge_is_wire(BMEdge *e); -int BM_vert_is_manifold(BMVert *v); -int BM_edge_is_manifold(BMEdge *e); -int BM_edge_is_boundary(BMEdge *e); +bool BM_vert_is_manifold(BMVert *v); +bool BM_edge_is_manifold(BMEdge *e); +bool BM_edge_is_boundary(BMEdge *e); float BM_loop_calc_face_angle(BMLoop *l); void BM_loop_calc_face_normal(BMLoop *l, float r_normal[3]); @@ -79,21 +80,19 @@ BMLoop *BM_face_find_longest_loop(BMFace *f); BMEdge *BM_edge_exists(BMVert *v1, BMVert *v2); BMEdge *BM_edge_find_double(BMEdge *e); -int BM_face_exists_overlap(BMVert **varr, int len, BMFace **r_existface); +bool BM_face_exists(BMVert **varr, int len, BMFace **r_existface); -int BM_face_exists(BMVert **varr, int len, BMFace **r_existface); - -int BM_face_exists_multi(BMVert **varr, BMEdge **earr, int len); -int BM_face_exists_multi_edge(BMEdge **earr, int len); +bool BM_face_exists_multi(BMVert **varr, BMEdge **earr, int len); +bool BM_face_exists_multi_edge(BMEdge **earr, int len); int BM_face_share_face_count(BMFace *f1, BMFace *f2); int BM_face_share_edge_count(BMFace *f1, BMFace *f2); -int BM_face_share_face_check(BMFace *f1, BMFace *f2); -int BM_face_share_edge_check(BMFace *f1, BMFace *f2); -int BM_edge_share_face_check(BMEdge *e1, BMEdge *e2); -int BM_edge_share_quad_check(BMEdge *e1, BMEdge *e2); -int BM_edge_share_vert_check(BMEdge *e1, BMEdge *e2); +bool BM_face_share_face_check(BMFace *f1, BMFace *f2); +bool BM_face_share_edge_check(BMFace *f1, BMFace *f2); +bool BM_edge_share_face_check(BMEdge *e1, BMEdge *e2); +bool BM_edge_share_quad_check(BMEdge *e1, BMEdge *e2); +bool BM_edge_share_vert_check(BMEdge *e1, BMEdge *e2); BMVert *BM_edge_share_vert(BMEdge *e1, BMEdge *e2); BMLoop *BM_face_vert_share_loop(BMFace *f, BMVert *v); @@ -103,8 +102,8 @@ void BM_edge_ordered_verts(BMEdge *edge, BMVert **r_v1, BMVert **r_v2); void BM_edge_ordered_verts_ex(BMEdge *edge, BMVert **r_v1, BMVert **r_v2, BMLoop *edge_loop); -int BM_edge_is_any_vert_flag_test(BMEdge *e, const char hflag); -int BM_face_is_any_vert_flag_test(BMFace *f, const char hflag); -int BM_face_is_any_edge_flag_test(BMFace *f, const char hflag); +bool BM_edge_is_any_vert_flag_test(BMEdge *e, const char hflag); +bool BM_face_is_any_vert_flag_test(BMFace *f, const char hflag); +bool BM_face_is_any_edge_flag_test(BMFace *f, const char hflag); #endif /* __BMESH_QUERIES_H__ */ diff --git a/source/blender/bmesh/intern/bmesh_structure.c b/source/blender/bmesh/intern/bmesh_structure.c index b58e61a3066..2f568a498c5 100644 --- a/source/blender/bmesh/intern/bmesh_structure.c +++ b/source/blender/bmesh/intern/bmesh_structure.c @@ -40,16 +40,16 @@ * MISC utility functions. */ -int bmesh_vert_in_edge(BMEdge *e, BMVert *v) +bool bmesh_vert_in_edge(BMEdge *e, BMVert *v) { - if (e->v1 == v || e->v2 == v) return TRUE; - return FALSE; + if (e->v1 == v || e->v2 == v) return true; + return false; } -int bmesh_verts_in_edge(BMVert *v1, BMVert *v2, BMEdge *e) +bool bmesh_verts_in_edge(BMVert *v1, BMVert *v2, BMEdge *e) { - if (e->v1 == v1 && e->v2 == v2) return TRUE; - else if (e->v1 == v2 && e->v2 == v1) return TRUE; - return FALSE; + if (e->v1 == v1 && e->v2 == v2) return true; + else if (e->v1 == v2 && e->v2 == v1) return true; + return false; } BMVert *bmesh_edge_other_vert_get(BMEdge *e, BMVert *v) @@ -63,19 +63,19 @@ BMVert *bmesh_edge_other_vert_get(BMEdge *e, BMVert *v) return NULL; } -int bmesh_edge_swapverts(BMEdge *e, BMVert *orig, BMVert *newv) +bool bmesh_edge_swapverts(BMEdge *e, BMVert *orig, BMVert *newv) { if (e->v1 == orig) { e->v1 = newv; e->v1_disk_link.next = e->v1_disk_link.prev = NULL; - return TRUE; + return true; } else if (e->v2 == orig) { e->v2 = newv; e->v2_disk_link.next = e->v2_disk_link.prev = NULL; - return TRUE; + return true; } - return FALSE; + return false; } /** @@ -165,7 +165,7 @@ BLI_INLINE BMDiskLink *bmesh_disk_edge_link_from_vert(BMEdge *e, BMVert *v) } } -int bmesh_disk_edge_append(BMEdge *e, BMVert *v) +void bmesh_disk_edge_append(BMEdge *e, BMVert *v) { if (!v->e) { BMDiskLink *dl1 = bmesh_disk_edge_link_from_vert(e, v); @@ -187,8 +187,6 @@ int bmesh_disk_edge_append(BMEdge *e, BMVert *v) if (dl3) dl3->next = e; } - - return TRUE; } void bmesh_disk_edge_remove(BMEdge *e, BMVert *v) @@ -280,23 +278,23 @@ int bmesh_disk_count(BMVert *v) } } -int bmesh_disk_validate(int len, BMEdge *e, BMVert *v) +bool bmesh_disk_validate(int len, BMEdge *e, BMVert *v) { BMEdge *e_iter; if (!BM_vert_in_edge(e, v)) - return FALSE; + return false; if (bmesh_disk_count(v) != len || len == 0) - return FALSE; + return false; e_iter = e; do { if (len != 1 && bmesh_disk_edge_prev(e_iter, v) == e_iter) { - return FALSE; + return false; } } while ((e_iter = bmesh_disk_edge_next(e_iter, v)) != e); - return TRUE; + return true; } /** @@ -362,34 +360,34 @@ BMEdge *bmesh_disk_faceedge_find_next(BMEdge *e, BMVert *v) } /*****radial cycle functions, e.g. loops surrounding edges**** */ -int bmesh_radial_validate(int radlen, BMLoop *l) +bool bmesh_radial_validate(int radlen, BMLoop *l) { BMLoop *l_iter = l; int i = 0; if (bmesh_radial_length(l) != radlen) - return FALSE; + return false; do { if (UNLIKELY(!l_iter)) { BMESH_ASSERT(0); - return FALSE; + return false; } if (l_iter->e != l->e) - return FALSE; + return false; if (l_iter->v != l->e->v1 && l_iter->v != l->e->v2) - return FALSE; + return false; if (UNLIKELY(i > BM_LOOP_RADIAL_MAX)) { BMESH_ASSERT(0); - return FALSE; + return false; } i++; } while ((l_iter = l_iter->radial_next) != l); - return TRUE; + return true; } /** @@ -511,7 +509,7 @@ void bmesh_radial_append(BMEdge *e, BMLoop *l) l->e = e; } -int bmesh_radial_face_find(BMEdge *e, BMFace *f) +bool bmesh_radial_face_find(BMEdge *e, BMFace *f) { BMLoop *l_iter; int i, len; @@ -519,9 +517,9 @@ int bmesh_radial_face_find(BMEdge *e, BMFace *f) len = bmesh_radial_length(e->l); for (i = 0, l_iter = e->l; i < len; i++, l_iter = l_iter->radial_next) { if (l_iter->f == f) - return TRUE; + return true; } - return FALSE; + return false; } /** @@ -545,7 +543,7 @@ int bmesh_radial_facevert_count(BMLoop *l, BMVert *v) } /*****loop cycle functions, e.g. loops surrounding a face**** */ -int bmesh_loop_validate(BMFace *f) +bool bmesh_loop_validate(BMFace *f) { int i; int len = f->len; @@ -554,7 +552,7 @@ int bmesh_loop_validate(BMFace *f) l_first = BM_FACE_FIRST_LOOP(f); if (l_first == NULL) { - return FALSE; + return false; } /* Validate that the face loop cycle is the length specified by f->len */ @@ -562,22 +560,22 @@ int bmesh_loop_validate(BMFace *f) if ((l_iter->f != f) || (l_iter == l_first)) { - return FALSE; + return false; } } if (l_iter != l_first) { - return FALSE; + return false; } /* Validate the loop->prev links also form a cycle of length f->len */ for (i = 1, l_iter = l_first->prev; i < len; i++, l_iter = l_iter->prev) { if (l_iter == l_first) { - return FALSE; + return false; } } if (l_iter != l_first) { - return FALSE; + return false; } - return TRUE; + return true; } diff --git a/source/blender/bmesh/intern/bmesh_structure.h b/source/blender/bmesh/intern/bmesh_structure.h index b19df4660b8..e67f1e4fb49 100644 --- a/source/blender/bmesh/intern/bmesh_structure.h +++ b/source/blender/bmesh/intern/bmesh_structure.h @@ -42,10 +42,10 @@ struct ListBase; /* LOOP CYCLE MANAGEMENT */ -int bmesh_loop_validate(BMFace *f); +bool bmesh_loop_validate(BMFace *f); /* DISK CYCLE MANAGMENT */ -int bmesh_disk_edge_append(BMEdge *e, BMVert *v); +void bmesh_disk_edge_append(BMEdge *e, BMVert *v); void bmesh_disk_edge_remove(BMEdge *e, BMVert *v); BMEdge *bmesh_disk_edge_next(BMEdge *e, BMVert *v); BMEdge *bmesh_disk_edge_prev(BMEdge *e, BMVert *v); @@ -60,19 +60,19 @@ void bmesh_radial_loop_remove(BMLoop *l, BMEdge *e); * bmesh_radial_loop_next(BMLoop *l) / prev. * just use member access l->radial_next, l->radial_prev now */ -int bmesh_radial_face_find(BMEdge *e, BMFace *f); +bool bmesh_radial_face_find(BMEdge *e, BMFace *f); int bmesh_radial_facevert_count(BMLoop *l, BMVert *v); BMLoop *bmesh_radial_faceloop_find_first(BMLoop *l, BMVert *v); BMLoop *bmesh_radial_faceloop_find_next(BMLoop *l, BMVert *v); BMLoop *bmesh_radial_faceloop_find_vert(BMFace *f, BMVert *v); -int bmesh_radial_validate(int radlen, BMLoop *l); +bool bmesh_radial_validate(int radlen, BMLoop *l); /* EDGE UTILITIES */ -int bmesh_vert_in_edge(BMEdge *e, BMVert *v); -int bmesh_verts_in_edge(BMVert *v1, BMVert *v2, BMEdge *e); -int bmesh_edge_swapverts(BMEdge *e, BMVert *orig, BMVert *newv); /*relink edge*/ +bool bmesh_vert_in_edge(BMEdge *e, BMVert *v); +bool bmesh_verts_in_edge(BMVert *v1, BMVert *v2, BMEdge *e); +bool bmesh_edge_swapverts(BMEdge *e, BMVert *orig, BMVert *newv); /* relink edge */ BMVert *bmesh_edge_other_vert_get(BMEdge *e, BMVert *v); BMEdge *bmesh_disk_edge_exists(BMVert *v1, BMVert *v2); -int bmesh_disk_validate(int len, BMEdge *e, BMVert *v); +bool bmesh_disk_validate(int len, BMEdge *e, BMVert *v); #endif /* __BMESH_STRUCTURE_H__ */ diff --git a/source/blender/bmesh/intern/bmesh_walkers.h b/source/blender/bmesh/intern/bmesh_walkers.h index 4f81f38aeb3..8be362b5afa 100644 --- a/source/blender/bmesh/intern/bmesh_walkers.h +++ b/source/blender/bmesh/intern/bmesh_walkers.h @@ -100,10 +100,9 @@ void BMW_reset(BMWalker *walker); * BMFace *f; * * BMW_init(&walker, bm, BMW_ISLAND, SOME_OP_FLAG); - * f = BMW_begin(&walker, some_start_face); - * for (; f; f = BMW_step(&walker)) - * { - * //do something with f + * + * for (f = BMW_begin(&walker, some_start_face); f; f = BMW_step(&walker)) { + * // do something with f * } * BMW_end(&walker); */ diff --git a/source/blender/bmesh/intern/bmesh_walkers_impl.c b/source/blender/bmesh/intern/bmesh_walkers_impl.c index 538a9058ed5..bbe02a49967 100644 --- a/source/blender/bmesh/intern/bmesh_walkers_impl.c +++ b/source/blender/bmesh/intern/bmesh_walkers_impl.c @@ -34,42 +34,42 @@ #include "intern/bmesh_private.h" #include "intern/bmesh_walkers_private.h" -static int bmw_mask_check_vert(BMWalker *walker, BMVert *v) +static bool bmw_mask_check_vert(BMWalker *walker, BMVert *v) { if ((walker->flag & BMW_FLAG_TEST_HIDDEN) && BM_elem_flag_test(v, BM_ELEM_HIDDEN)) { - return FALSE; + return false; } else if (walker->mask_vert && !BMO_elem_flag_test(walker->bm, v, walker->mask_vert)) { - return FALSE; + return false; } else { - return TRUE; + return true; } } -static int bmw_mask_check_edge(BMWalker *walker, BMEdge *e) +static bool bmw_mask_check_edge(BMWalker *walker, BMEdge *e) { if ((walker->flag & BMW_FLAG_TEST_HIDDEN) && BM_elem_flag_test(e, BM_ELEM_HIDDEN)) { - return FALSE; + return false; } else if (walker->mask_edge && !BMO_elem_flag_test(walker->bm, e, walker->mask_edge)) { - return FALSE; + return false; } else { - return TRUE; + return true; } } -static int bmw_mask_check_face(BMWalker *walker, BMFace *f) +static bool bmw_mask_check_face(BMWalker *walker, BMFace *f) { if ((walker->flag & BMW_FLAG_TEST_HIDDEN) && BM_elem_flag_test(f, BM_ELEM_HIDDEN)) { - return FALSE; + return false; } else if (walker->mask_face && !BMO_elem_flag_test(walker->bm, f, walker->mask_face)) { - return FALSE; + return false; } else { - return TRUE; + return true; } } @@ -164,7 +164,7 @@ static void *bmw_ShellWalker_step(BMWalker *walker) { BMEdge *curedge, *next = NULL; BMVert *ov = NULL; - int restrictpass = 1; + bool restrictpass = true; BMwShellWalker shellWalk = *((BMwShellWalker *)BMW_current_state(walker)); if (!BLI_ghash_haskey(walker->visithash, shellWalk.base)) { @@ -447,7 +447,7 @@ static void bmw_LoopWalker_begin(BMWalker *walker, void *data) lwalk->is_single = (vert_edge_count[0] == 2 && vert_edge_count[1] == 2); /* could also check that vertex*/ - if ((lwalk->is_boundary == FALSE) && + if ((lwalk->is_boundary == false) && (vert_edge_count[0] == 3 || vert_edge_count[1] == 3)) { BMIter iter; @@ -548,19 +548,19 @@ static void *bmw_LoopWalker_step(BMWalker *walker) /* typical loopiong over edges in the middle of a mesh */ /* however, why use 2 here at all? I guess for internal ngon loops it can be useful. Antony R. */ - ((vert_edge_tot == 4 || vert_edge_tot == 2) && owalk.is_boundary == FALSE) || + ((vert_edge_tot == 4 || vert_edge_tot == 2) && owalk.is_boundary == false) || /* walk over boundary of faces but stop at corners */ - (owalk.is_boundary == TRUE && owalk.is_single == FALSE && vert_edge_tot > 2) || + (owalk.is_boundary == true && owalk.is_single == false && vert_edge_tot > 2) || /* initial edge was a boundary, so is this edge and vertex is only apart of this face * this lets us walk over the the boundary of an ngon which is handy */ - (owalk.is_boundary == TRUE && owalk.is_single == TRUE && vert_edge_tot == 2 && BM_edge_is_boundary(e))) + (owalk.is_boundary == true && owalk.is_single == true && vert_edge_tot == 2 && BM_edge_is_boundary(e))) { i = 0; stopi = vert_edge_tot / 2; while (1) { - if ((owalk.is_boundary == FALSE) && (i == stopi)) { + if ((owalk.is_boundary == false) && (i == stopi)) { break; } @@ -589,7 +589,7 @@ static void *bmw_LoopWalker_step(BMWalker *walker) bmw_mask_check_edge(walker, l->e) && !BLI_ghash_haskey(walker->visithash, l->e)) { - if (!(owalk.is_boundary == FALSE && i != stopi)) { + if (!(owalk.is_boundary == false && i != stopi)) { lwalk = BMW_state_add(walker); lwalk->cur = l->e; lwalk->lastv = v; @@ -642,47 +642,47 @@ static void *bmw_LoopWalker_step(BMWalker *walker) /* Check whether the face loop should includes the face specified * by the given BMLoop */ -static int bmw_FaceLoopWalker_include_face(BMWalker *walker, BMLoop *l) +static bool bmw_FaceLoopWalker_include_face(BMWalker *walker, BMLoop *l) { /* face must have degree 4 */ if (l->f->len != 4) { - return FALSE; + return false; } if (!bmw_mask_check_face(walker, l->f)) { - return FALSE; + return false; } /* the face must not have been already visite */ if (BLI_ghash_haskey(walker->visithash, l->f) && BLI_ghash_haskey(walker->secvisithash, l->e)) { - return FALSE; + return false; } - return TRUE; + return true; } /* Check whether the face loop can start from the given edge */ -static int bmw_FaceLoopWalker_edge_begins_loop(BMWalker *walker, BMEdge *e) +static bool bmw_FaceLoopWalker_edge_begins_loop(BMWalker *walker, BMEdge *e) { /* There is no face loop starting from a wire edge */ if (BM_edge_is_wire(e)) { - return FALSE; + return false; } /* Don't start a loop from a boundary edge if it cannot * be extended to cover any faces */ if (BM_edge_is_boundary(e)) { if (!bmw_FaceLoopWalker_include_face(walker, e->l)) { - return FALSE; + return false; } } /* Don't start a face loop from non-manifold edges */ if (!BM_edge_is_manifold(e)) { - return FALSE; + return false; } - return TRUE; + return true; } static void bmw_FaceLoopWalker_begin(BMWalker *walker, void *data) @@ -697,7 +697,7 @@ static void bmw_FaceLoopWalker_begin(BMWalker *walker, void *data) lwalk = BMW_state_add(walker); lwalk->l = e->l; - lwalk->nocalc = 0; + lwalk->no_calc = false; BLI_ghash_insert(walker->visithash, lwalk->l->f, NULL); /* rewin */ @@ -708,7 +708,7 @@ static void bmw_FaceLoopWalker_begin(BMWalker *walker, void *data) lwalk = BMW_state_add(walker); *lwalk = owalk; - lwalk->nocalc = 0; + lwalk->no_calc = false; BLI_ghash_free(walker->secvisithash, NULL, NULL); walker->secvisithash = BLI_ghash_ptr_new("bmesh walkers 3"); @@ -740,7 +740,7 @@ static void *bmw_FaceLoopWalker_step(BMWalker *walker) l = l->radial_next; - if (lwalk->nocalc) { + if (lwalk->no_calc) { return f; } @@ -758,11 +758,11 @@ static void *bmw_FaceLoopWalker_step(BMWalker *walker) lwalk->l = l; if (l->f->len != 4) { - lwalk->nocalc = 1; + lwalk->no_calc = true; lwalk->l = origl; } else { - lwalk->nocalc = 0; + lwalk->no_calc = false; } BLI_ghash_insert(walker->secvisithash, l->e, NULL); diff --git a/source/blender/bmesh/intern/bmesh_walkers_private.h b/source/blender/bmesh/intern/bmesh_walkers_private.h index fc563932c3c..09dd4f18d89 100644 --- a/source/blender/bmesh/intern/bmesh_walkers_private.h +++ b/source/blender/bmesh/intern/bmesh_walkers_private.h @@ -62,14 +62,14 @@ typedef struct BMwLoopWalker { BMEdge *cur, *start; BMVert *lastv, *startv; BMFace *f_hub; - short is_boundary; /* boundary looping changes behavior */ - short is_single; /* single means the edge verts are only connected to 1 face */ + bool is_boundary; /* boundary looping changes behavior */ + bool is_single; /* single means the edge verts are only connected to 1 face */ } BMwLoopWalker; typedef struct BMwFaceLoopWalker { BMwGenericWalker header; BMLoop *l; - int nocalc; + bool no_calc; } BMwFaceLoopWalker; typedef struct BMwEdgeringWalker { diff --git a/source/blender/bmesh/operators/bmo_bevel.c b/source/blender/bmesh/operators/bmo_bevel.c index eb8e84da63f..c56af821a93 100644 --- a/source/blender/bmesh/operators/bmo_bevel.c +++ b/source/blender/bmesh/operators/bmo_bevel.c @@ -34,7 +34,7 @@ void bmo_bevel_exec(BMesh *bm, BMOperator *op) { const float offset = BMO_slot_float_get(op->slots_in, "offset"); const int seg = BMO_slot_int_get(op->slots_in, "segments"); - const int vonly = BMO_slot_bool_get(op->slots_in, "vertex_only"); + const bool vonly = BMO_slot_bool_get(op->slots_in, "vertex_only"); if (offset > 0) { BMOIter siter; @@ -43,7 +43,7 @@ void bmo_bevel_exec(BMesh *bm, BMOperator *op) /* first flush 'geom' into flags, this makes it possible to check connected data, * BM_FACE is cleared so we can put newly created faces into a bmesh slot. */ - BM_mesh_elem_hflag_disable_all(bm, BM_VERT | BM_EDGE | BM_FACE, BM_ELEM_TAG, FALSE); + BM_mesh_elem_hflag_disable_all(bm, BM_VERT | BM_EDGE | BM_FACE, BM_ELEM_TAG, false); BMO_ITER (v, &siter, op->slots_in, "geom", BM_VERT) { BM_elem_flag_enable(v, BM_ELEM_TAG); diff --git a/source/blender/bmesh/operators/bmo_connect.c b/source/blender/bmesh/operators/bmo_connect.c index c7cd1e742d8..3a0e18b9ee5 100644 --- a/source/blender/bmesh/operators/bmo_connect.c +++ b/source/blender/bmesh/operators/bmo_connect.c @@ -106,7 +106,7 @@ void bmo_connect_verts_exec(BMesh *bm, BMOperator *op) } for (i = 0; i < BLI_array_count(verts_pair); i++) { - nf = BM_face_split(bm, f, verts_pair[i][0], verts_pair[i][1], &nl, NULL, FALSE); + nf = BM_face_split(bm, f, verts_pair[i][0], verts_pair[i][1], &nl, NULL, false); f = nf; if (!nl || !nf) { @@ -221,7 +221,7 @@ void bmo_bridge_loops_exec(BMesh *bm, BMOperator *op) int c = 0, cl1 = 0, cl2 = 0; /* merge-bridge support */ - const int use_merge = BMO_slot_bool_get(op->slots_in, "use_merge"); + const bool use_merge = BMO_slot_bool_get(op->slots_in, "use_merge"); const float merge_factor = BMO_slot_float_get(op->slots_in, "merge_factor"); BMO_slot_buffer_flag_enable(bm, op->slots_in, "edges", BM_EDGE, EDGE_MARK); @@ -508,7 +508,7 @@ void bmo_bridge_loops_exec(BMesh *bm, BMOperator *op) vv2[i2], vv2[i2next], vv1[i1next], - f_example, TRUE); + f_example, true); if (UNLIKELY((f == NULL) || (f->len != 4))) { fprintf(stderr, "%s: in bridge! (bmesh internal error)\n", __func__); } diff --git a/source/blender/bmesh/operators/bmo_create.c b/source/blender/bmesh/operators/bmo_create.c index 2ea5914ca92..ae07c2cf0bc 100644 --- a/source/blender/bmesh/operators/bmo_create.c +++ b/source/blender/bmesh/operators/bmo_create.c @@ -87,8 +87,8 @@ BLI_INLINE BMDiskLink *rs_edge_link_get(BMEdge *e, BMVert *v, EdgeData *e_data) &(((EdgeData *)e_data)->v2_disk_link); } -static int rotsys_append_edge(BMEdge *e, BMVert *v, - EdgeData *edata, VertData *vdata) +static bool rotsys_append_edge(BMEdge *e, BMVert *v, + EdgeData *edata, VertData *vdata) { EdgeData *ed = &edata[BM_elem_index_get(e)]; VertData *vd = &vdata[BM_elem_index_get(v)]; @@ -116,7 +116,7 @@ static int rotsys_append_edge(BMEdge *e, BMVert *v, } } - return TRUE; + return true; } static void UNUSED_FUNCTION(rotsys_remove_edge)(BMEdge *e, BMVert *v, @@ -613,10 +613,10 @@ static void init_rotsys(BMesh *bm, EdgeData *edata, VertData *vdata) BM_elem_index_set(v2, -1); /* set_dirty! */ //BM_edge_create(bm, cv, v2, NULL, 0); - BM_vert_select_set(bm, v2, TRUE); + BM_vert_select_set(bm, v2, true); if (lastv) { e2 = BM_edge_create(bm, lastv, v2, NULL, 0); - BM_edge_select_set(bm, e2, TRUE); + BM_edge_select_set(bm, e2, true); } lastv = v2; @@ -742,7 +742,7 @@ static EPath *edge_find_shortest_path(BMesh *bm, BMOperator *op, BMEdge *edge, E BMVert *endv; EPathNode *node; int i; - const int use_restrict = BMO_slot_bool_get(op->slots_in, "use_restrict"); + const bool use_restrict = BMO_slot_bool_get(op->slots_in, "use_restrict"); BMOpSlot *slot_restrict = BMO_slot_get(op->slots_in, "restrict"); @@ -899,10 +899,10 @@ void bmo_edgenet_fill_exec(BMesh *bm, BMOperator *op) BMEdge **edges = NULL; PathBase *pathbase; BLI_array_declare(edges); - int use_restrict = BMO_slot_bool_get(op->slots_in, "use_restrict"); - int use_fill_check = BMO_slot_bool_get(op->slots_in, "use_fill_check"); - const short mat_nr = BMO_slot_int_get(op->slots_in, "mat_nr"); - const short use_smooth = BMO_slot_bool_get(op->slots_in, "use_smooth"); + const bool use_restrict = BMO_slot_bool_get(op->slots_in, "use_restrict"); + const bool use_fill_check = BMO_slot_bool_get(op->slots_in, "use_fill_check"); + const short mat_nr = BMO_slot_int_get(op->slots_in, "mat_nr"); + const bool use_smooth = BMO_slot_bool_get(op->slots_in, "use_smooth"); int i, j, group = 0; unsigned int winding[2]; /* accumulte winding directions for each edge which has a face */ BMOpSlot *slot_restrict = BMO_slot_get(op->slots_in, "restrict"); @@ -1047,9 +1047,9 @@ void bmo_edgenet_fill_exec(BMesh *bm, BMOperator *op) v2 = verts[0]; } - if ((use_fill_check == FALSE) || + if ((use_fill_check == false) || /* fairly expensive check - see if there are already faces filling this area */ - (BM_face_exists_multi_edge(edges, i) == FALSE)) + (BM_face_exists_multi_edge(edges, i) == false)) { f = BM_face_create_ngon(bm, v1, v2, edges, i, BM_CREATE_NO_DOUBLE); if (f && !BMO_elem_flag_test(bm, f, ELE_ORIG)) { @@ -1287,7 +1287,7 @@ void bmo_contextual_create_exec(BMesh *bm, BMOperator *op) BMFace *f; int totv = 0, tote = 0, totf = 0, amount; const short mat_nr = BMO_slot_int_get(op->slots_in, "mat_nr"); - const short use_smooth = BMO_slot_bool_get(op->slots_in, "use_smooth"); + const bool use_smooth = BMO_slot_bool_get(op->slots_in, "use_smooth"); /* count number of each element type we were passe */ BMO_ITER (h, &oiter, op->slots_in, "geom", BM_VERT | BM_EDGE | BM_FACE) { @@ -1321,7 +1321,7 @@ void bmo_contextual_create_exec(BMesh *bm, BMOperator *op) if (totf == 0 && totv >= 4 && totv == tote + 2) { /* find a free standing vertex and 2 endpoint verts */ BMVert *v_free = NULL, *v_a = NULL, *v_b = NULL; - int ok = TRUE; + bool ok = true; BMO_ITER (v, &oiter, op->slots_in, "geom", BM_VERT) { @@ -1339,26 +1339,26 @@ void bmo_contextual_create_exec(BMesh *bm, BMOperator *op) if (tot_edges == 0) { /* only accept 1 free vert */ if (v_free == NULL) v_free = v; - else ok = FALSE; /* only ever want one of these */ + else ok = false; /* only ever want one of these */ } else if (tot_edges == 1) { if (v_a == NULL) v_a = v; else if (v_b == NULL) v_b = v; - else ok = FALSE; /* only ever want 2 of these */ + else ok = false; /* only ever want 2 of these */ } else if (tot_edges == 2) { /* do nothing, regular case */ } else { - ok = FALSE; /* if a vertex has 3+ edge users then cancel - this is only simple cases */ + ok = false; /* if a vertex has 3+ edge users then cancel - this is only simple cases */ } - if (ok == FALSE) { + if (ok == false) { break; } } - if (ok == TRUE && v_free && v_a && v_b) { + if (ok == true && v_free && v_a && v_b) { e = BM_edge_create(bm, v_free, v_a, NULL, BM_CREATE_NO_DOUBLE); BMO_elem_flag_enable(bm, e, ELE_NEW); @@ -1377,7 +1377,7 @@ void bmo_contextual_create_exec(BMesh *bm, BMOperator *op) BMO_op_initf(bm, &op2, op->flag, "edgenet_fill edges=%fe use_fill_check=%b mat_nr=%i use_smooth=%b", - ELE_NEW, TRUE, mat_nr, use_smooth); + ELE_NEW, true, mat_nr, use_smooth); BMO_op_exec(bm, &op2); diff --git a/source/blender/bmesh/operators/bmo_dissolve.c b/source/blender/bmesh/operators/bmo_dissolve.c index 7c3bcd60daa..47b2497816f 100644 --- a/source/blender/bmesh/operators/bmo_dissolve.c +++ b/source/blender/bmesh/operators/bmo_dissolve.c @@ -41,7 +41,7 @@ #define VERT_MARK 1 -static int UNUSED_FUNCTION(check_hole_in_region) (BMesh * bm, BMFace * f) +static bool UNUSED_FUNCTION(check_hole_in_region) (BMesh * bm, BMFace * f) { BMWalker regwalker; BMIter liter2; @@ -55,23 +55,21 @@ static int UNUSED_FUNCTION(check_hole_in_region) (BMesh * bm, BMFace * f) BMW_FLAG_NOP, BMW_NIL_LAY); - f2 = BMW_begin(®walker, f); - for ( ; f2; f2 = BMW_step(®walker)) { - l2 = BM_iter_new(&liter2, bm, BM_LOOPS_OF_FACE, f2); - for ( ; l2; l2 = BM_iter_step(&liter2)) { + 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_elem_flag_test(bm, l2->e, EDGE_MARK)) { - return FALSE; + return false; } } } } BMW_end(®walker); - return TRUE; + return true; } void bmo_dissolve_faces_exec(BMesh *bm, BMOperator *op) @@ -85,7 +83,7 @@ void bmo_dissolve_faces_exec(BMesh *bm, BMOperator *op) BMWalker regwalker; int i; - int use_verts = BMO_slot_bool_get(op->slots_in, "use_verts"); + const bool use_verts = BMO_slot_bool_get(op->slots_in, "use_verts"); if (use_verts) { /* tag verts that start out with only 2 edges, @@ -115,8 +113,7 @@ void bmo_dissolve_faces_exec(BMesh *bm, BMOperator *op) BMW_FLAG_NOP, /* no need to check BMW_FLAG_TEST_HIDDEN, faces are already marked by the bmo */ BMW_NIL_LAY); - f2 = BMW_begin(®walker, f); - for ( ; f2; f2 = BMW_step(®walker)) { + for (f2 = BMW_begin(®walker, f); f2; f2 = BMW_step(®walker)) { BLI_array_append(faces, f2); } BMW_end(®walker); @@ -150,7 +147,7 @@ void bmo_dissolve_faces_exec(BMesh *bm, BMOperator *op) while (faces[tot]) tot++; - f = BM_faces_join(bm, faces, tot, TRUE); + f = BM_faces_join(bm, faces, tot, true); if (!f) { BMO_error_raise(bm, op, BMERR_DISSOLVEFACES_FAILED, "Could not create merged face"); @@ -174,7 +171,7 @@ void bmo_dissolve_faces_exec(BMesh *bm, BMOperator *op) BM_ITER_MESH (v, &viter, bm, BM_VERTS_OF_MESH) { if (BMO_elem_flag_test(bm, v, VERT_MARK)) { if (BM_vert_edge_count(v) == 2) { - BM_vert_collapse_edge(bm, v->e, v, TRUE); + BM_vert_collapse_edge(bm, v->e, v, true); } } } @@ -215,7 +212,7 @@ void bmo_dissolve_edgeloop_exec(BMesh *bm, BMOperator *op) /* BMESH_TODO - check on delaying edge removal since we may end up removing more then * one edge, and later reference a removed edge */ - BM_faces_join_pair(bm, fa, fb, e, TRUE); + BM_faces_join_pair(bm, fa, fb, e, true); } } @@ -228,7 +225,7 @@ void bmo_dissolve_edgeloop_exec(BMesh *bm, BMOperator *op) /* clean up extreneous 2-valence vertice */ for (i = 0; i < BLI_array_count(verts); i++) { if (verts[i]->e) { - BM_vert_collapse_edge(bm, verts[i]->e, verts[i], TRUE); + BM_vert_collapse_edge(bm, verts[i]->e, verts[i], true); } } @@ -254,7 +251,7 @@ void bmo_dissolve_edges_exec(BMesh *bm, BMOperator *op) BMIter viter; BMVert *v; - int use_verts = BMO_slot_bool_get(op->slots_in, "use_verts"); + const bool use_verts = BMO_slot_bool_get(op->slots_in, "use_verts"); if (use_verts) { BM_ITER_MESH (v, &viter, bm, BM_VERTS_OF_MESH) { @@ -271,7 +268,7 @@ void bmo_dissolve_edges_exec(BMesh *bm, BMOperator *op) /* BMESH_TODO - check on delaying edge removal since we may end up removing more then * one edge, and later reference a removed edge */ - BM_faces_join_pair(bm, fa, fb, e, TRUE); + BM_faces_join_pair(bm, fa, fb, e, true); } } @@ -279,20 +276,20 @@ void bmo_dissolve_edges_exec(BMesh *bm, BMOperator *op) BM_ITER_MESH (v, &viter, bm, BM_VERTS_OF_MESH) { if (BMO_elem_flag_test(bm, v, VERT_MARK)) { if (BM_vert_edge_count(v) == 2) { - BM_vert_collapse_edge(bm, v->e, v, TRUE); + BM_vert_collapse_edge(bm, v->e, v, true); } } } } } -static int test_extra_verts(BMesh *bm, BMVert *v) +static bool test_extra_verts(BMesh *bm, BMVert *v) { BMIter iter, liter, iter2, iter3; BMFace *f, *f2; BMLoop *l; BMEdge *e; - int found; + bool found; /* test faces around verts for verts that would be wrongly killed * by dissolve faces. */ @@ -305,31 +302,31 @@ static int test_extra_verts(BMesh *bm, BMVert *v) * then dissolve faces won't destroy it. * also if it forms a boundary with one * of the face region */ - found = FALSE; + found = false; e = BM_iter_new(&iter2, bm, BM_EDGES_OF_VERT, l->v); for ( ; e; e = BM_iter_step(&iter2)) { if (BM_edge_is_boundary(e)) { - found = TRUE; + found = true; } f2 = BM_iter_new(&iter3, bm, BM_FACES_OF_EDGE, e); for ( ; f2; f2 = BM_iter_step(&iter3)) { if (!BMO_elem_flag_test(bm, f2, FACE_MARK)) { - found = TRUE; + found = true; break; } } - if (found == TRUE) { + if (found == true) { break; } } - if (found == FALSE) { - return FALSE; + if (found == false) { + return false; } } } } - return TRUE; + return true; } void bmo_dissolve_verts_exec(BMesh *bm, BMOperator *op) { @@ -349,9 +346,9 @@ void bmo_dissolve_verts_exec(BMesh *bm, BMOperator *op) /* previously the faces were joined, but collapsing between 2 edges * gives some advantage/difference in using vertex-dissolve over edge-dissolve */ #if 0 - BM_vert_collapse_faces(bm, v->e, v, 1.0f, TRUE, TRUE); + BM_vert_collapse_faces(bm, v->e, v, 1.0f, true, true); #else - BM_vert_collapse_edge(bm, v->e, v, TRUE); + BM_vert_collapse_edge(bm, v->e, v, true); #endif continue; @@ -483,7 +480,7 @@ void bmo_dissolve_limit_exec(BMesh *bm, BMOperator *op) BMOpSlot *vinput = BMO_slot_get(op->slots_in, "verts"); const float angle_max = (float)M_PI / 2.0f; const float angle_limit = min_ff(angle_max, BMO_slot_float_get(op->slots_in, "angle_limit")); - const int do_dissolve_boundaries = BMO_slot_bool_get(op->slots_in, "use_dissolve_boundaries"); + const bool do_dissolve_boundaries = BMO_slot_bool_get(op->slots_in, "use_dissolve_boundaries"); BM_mesh_decimate_dissolve_ex(bm, angle_limit, do_dissolve_boundaries, (BMVert **)BMO_SLOT_AS_BUFFER(vinput), vinput->len, diff --git a/source/blender/bmesh/operators/bmo_dupe.c b/source/blender/bmesh/operators/bmo_dupe.c index f288901c272..1448129ccde 100644 --- a/source/blender/bmesh/operators/bmo_dupe.c +++ b/source/blender/bmesh/operators/bmo_dupe.c @@ -213,13 +213,13 @@ static void bmo_mesh_copy(BMOperator *op, BMesh *bm_src, BMesh *bm_dst) !BMO_elem_flag_test(bm_src, v, DUPE_DONE)) { BMIter iter; - int isolated = 1; + bool isolated = true; v2 = copy_vertex(bm_src, v, bm_dst, vhash); BM_ITER_ELEM (f, &iter, v, BM_FACES_OF_VERT) { if (BMO_elem_flag_test(bm_src, f, DUPE_INPUT)) { - isolated = 0; + isolated = false; break; } } @@ -227,7 +227,7 @@ static void bmo_mesh_copy(BMOperator *op, BMesh *bm_src, BMesh *bm_dst) if (isolated) { BM_ITER_ELEM (e, &iter, v, BM_EDGES_OF_VERT) { if (BMO_elem_flag_test(bm_src, e, DUPE_INPUT)) { - isolated = 0; + isolated = false; break; } } @@ -386,7 +386,7 @@ void bmo_split_exec(BMesh *bm, BMOperator *op) BMOperator *splitop = op; BMOperator dupeop; BMOperator delop; - const short use_only_faces = BMO_slot_bool_get(op->slots_in, "use_only_faces"); + const bool use_only_faces = BMO_slot_bool_get(op->slots_in, "use_only_faces"); /* initialize our sub-operator */ BMO_op_init(bm, &dupeop, op->flag, "duplicate"); diff --git a/source/blender/bmesh/operators/bmo_edgesplit.c b/source/blender/bmesh/operators/bmo_edgesplit.c index b4b50a60877..378f790ef32 100644 --- a/source/blender/bmesh/operators/bmo_edgesplit.c +++ b/source/blender/bmesh/operators/bmo_edgesplit.c @@ -37,17 +37,17 @@ /* keep this operator fast, its used in a modifier */ void bmo_split_edges_exec(BMesh *bm, BMOperator *op) { - const int use_verts = BMO_slot_bool_get(op->slots_in, "use_verts"); + const bool use_verts = BMO_slot_bool_get(op->slots_in, "use_verts"); - BMO_slot_buffer_hflag_enable(bm, op->slots_in, "edges", BM_EDGE, BM_ELEM_TAG, FALSE); + BMO_slot_buffer_hflag_enable(bm, op->slots_in, "edges", BM_EDGE, BM_ELEM_TAG, false); if (use_verts) { /* this slows down the operation but its ok because the modifier doesn't use */ - BMO_slot_buffer_hflag_enable(bm, op->slots_in, "verts", BM_VERT, BM_ELEM_TAG, FALSE); + BMO_slot_buffer_hflag_enable(bm, op->slots_in, "verts", BM_VERT, BM_ELEM_TAG, false); } /* this is where everything happens */ - BM_mesh_edgesplit(bm, use_verts, TRUE); + BM_mesh_edgesplit(bm, use_verts, true); BMO_slot_buffer_from_enabled_hflag(bm, op, op->slots_out, "edges.out", BM_EDGE, BM_ELEM_INTERNAL_TAG); } diff --git a/source/blender/bmesh/operators/bmo_extrude.c b/source/blender/bmesh/operators/bmo_extrude.c index 2cca3fcb24a..4fde6150f05 100644 --- a/source/blender/bmesh/operators/bmo_extrude.c +++ b/source/blender/bmesh/operators/bmo_extrude.c @@ -112,7 +112,7 @@ void bmo_extrude_discrete_faces_exec(BMesh *bm, BMOperator *op) l3 = l->next; l4 = l2->next; - f3 = BM_face_create_quad_tri(bm, l3->v, l4->v, l2->v, l->v, f, FALSE); + f3 = BM_face_create_quad_tri(bm, l3->v, l4->v, l2->v, l->v, f, false); /* XXX, no error check here, why? - Campbell */ l_tmp = BM_FACE_FIRST_LOOP(f3); @@ -225,7 +225,7 @@ void bmo_extrude_edge_only_exec(BMesh *bm, BMOperator *op) f_verts[3] = e_new->v2; } /* not sure what to do about example face, pass NULL for now */ - f = BM_face_create_quad_tri_v(bm, f_verts, 4, NULL, FALSE); + f = BM_face_create_quad_tri_v(bm, f_verts, 4, NULL, false); bm_extrude_copy_face_loop_attributes(bm, f); if (BMO_elem_flag_test(bm, e, EXT_INPUT)) @@ -248,7 +248,7 @@ void bmo_extrude_vert_indiv_exec(BMesh *bm, BMOperator *op) BMOIter siter; BMVert *v, *dupev; BMEdge *e; - const int has_vskin = CustomData_has_layer(&bm->vdata, CD_MVERT_SKIN); + const bool has_vskin = CustomData_has_layer(&bm->vdata, CD_MVERT_SKIN); 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, 0); @@ -273,7 +273,7 @@ void bmo_extrude_face_region_exec(BMesh *bm, BMOperator *op) BMEdge *e, *e_new; BMVert *v, *v2; BMFace *f; - int found, fwd, delorig = FALSE; + bool found, fwd, delorig = false; BMOpSlot *slot_facemap_out; BMOpSlot *slot_edges_exclude; @@ -293,20 +293,20 @@ void bmo_extrude_face_region_exec(BMesh *bm, BMOperator *op) continue; } - found = FALSE; /* found a face that isn't input? */ + found = false; /* found a face that isn't input? */ 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)) { - found = TRUE; - delorig = TRUE; + found = true; + delorig = true; break; } edge_face_tot++; } - if ((edge_face_tot > 1) && (found == FALSE)) { + 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); } @@ -316,26 +316,26 @@ void bmo_extrude_face_region_exec(BMesh *bm, BMOperator *op) /* calculate verts to delete */ BM_ITER_MESH (v, &iter, bm, BM_VERTS_OF_MESH) { if (v->e) { /* only deal with verts attached to geometry [#33651] */ - found = FALSE; + 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)) { - found = TRUE; + found = true; break; } } /* avoid an extra loop */ - if (found == TRUE) { + if (found == true) { BM_ITER_ELEM (f, &viter, v, BM_FACES_OF_VERT) { if (!BMO_elem_flag_test(bm, f, EXT_INPUT)) { - found = TRUE; + found = true; break; } } } - if (found == FALSE) { + if (found == false) { BMO_elem_flag_enable(bm, v, EXT_DEL); } } @@ -347,7 +347,7 @@ void bmo_extrude_face_region_exec(BMesh *bm, BMOperator *op) } } - if (delorig == TRUE) { + if (delorig == true) { BMO_op_initf(bm, &delop, op->flag, "delete geom=%fvef context=%i", EXT_DEL, DEL_ONLYTAGGED); @@ -435,7 +435,7 @@ void bmo_extrude_face_region_exec(BMesh *bm, BMOperator *op) } /* not sure what to do about example face, pass NULL for now */ - f = BM_face_create_quad_tri_v(bm, f_verts, 4, NULL, FALSE); + f = BM_face_create_quad_tri_v(bm, f_verts, 4, NULL, false); bm_extrude_copy_face_loop_attributes(bm, f); } @@ -665,7 +665,7 @@ void bmo_solidify_face_region_exec(BMesh *bm, BMOperator *op) BMO_op_finish(bm, &reverseop); /* Extrude the region */ - BMO_op_initf(bm, &extrudeop, op->flag, "extrude_face_region use_keep_orig=%b", TRUE); + BMO_op_initf(bm, &extrudeop, op->flag, "extrude_face_region use_keep_orig=%b", true); BMO_slot_copy(op, slots_in, "geom", &extrudeop, slots_in, "geom"); BMO_op_exec(bm, &extrudeop); diff --git a/source/blender/bmesh/operators/bmo_hull.c b/source/blender/bmesh/operators/bmo_hull.c index e2da4f4f89c..5d8689b9da6 100644 --- a/source/blender/bmesh/operators/bmo_hull.c +++ b/source/blender/bmesh/operators/bmo_hull.c @@ -136,12 +136,12 @@ static void hull_output_triangles(BMesh *bm, GHash *hull_triangles) } /* Create new hull face */ - f = BM_face_create_quad_tri_v(bm, t->v, 3, example, TRUE); + f = BM_face_create_quad_tri_v(bm, t->v, 3, example, true); BM_face_copy_shared(bm, f); } /* Mark face for 'geom.out' slot and select */ BMO_elem_flag_enable(bm, f, HULL_FLAG_OUTPUT_GEOM); - BM_face_select_set(bm, f, TRUE); + BM_face_select_set(bm, f, true); /* Mark edges for 'geom.out' slot */ for (i = 0; i < 3; i++) { @@ -200,7 +200,7 @@ static int hull_final_edges_lookup(HullFinalEdges *final_edges, adj = BLI_ghash_lookup(final_edges->edges, v1); if (!adj) - return FALSE; + return false; return !!final_edges_find_link(adj, v2); } @@ -268,17 +268,17 @@ static void hull_remove_overlapping(BMesh *bm, GHash *hull_triangles, HullTriangle *t = BLI_ghashIterator_getKey(&hull_iter); BMIter bm_iter1, bm_iter2; BMFace *f; - int f_on_hull; + bool f_on_hull; BM_ITER_ELEM (f, &bm_iter1, t->v[0], BM_FACES_OF_VERT) { BMEdge *e; /* Check that all the face's edges are on the hull, * otherwise can't reuse it */ - f_on_hull = TRUE; + f_on_hull = true; BM_ITER_ELEM (e, &bm_iter2, f, BM_EDGES_OF_FACE) { if (!hull_final_edges_lookup(final_edges, e->v1, e->v2)) { - f_on_hull = FALSE; + f_on_hull = false; break; } } @@ -288,7 +288,7 @@ static void hull_remove_overlapping(BMesh *bm, GHash *hull_triangles, if (BM_vert_in_face(f, t->v[1]) && BM_vert_in_face(f, t->v[2]) && f_on_hull) { - t->skip = TRUE; + t->skip = true; BMO_elem_flag_disable(bm, f, HULL_FLAG_INTERIOR_ELE); BMO_elem_flag_enable(bm, f, HULL_FLAG_HOLE); } @@ -330,18 +330,18 @@ static void hull_tag_unused(BMesh *bm, BMOperator *op) * input set */ BMO_ITER (v, &oiter, op->slots_in, "input", BM_VERT) { if (BMO_elem_flag_test(bm, v, HULL_FLAG_INTERIOR_ELE)) { - int del = TRUE; + bool del = true; BM_ITER_ELEM (e, &iter, v, BM_EDGES_OF_VERT) { if (!BMO_elem_flag_test(bm, e, HULL_FLAG_INPUT)) { - del = FALSE; + del = false; break; } } BM_ITER_ELEM (f, &iter, v, BM_FACES_OF_VERT) { if (!BMO_elem_flag_test(bm, f, HULL_FLAG_INPUT)) { - del = FALSE; + del = false; break; } } @@ -353,11 +353,11 @@ static void hull_tag_unused(BMesh *bm, BMOperator *op) BMO_ITER (e, &oiter, op->slots_in, "input", BM_EDGE) { if (BMO_elem_flag_test(bm, e, HULL_FLAG_INTERIOR_ELE)) { - int del = TRUE; + bool del = true; BM_ITER_ELEM (f, &iter, e, BM_FACES_OF_EDGE) { if (!BMO_elem_flag_test(bm, f, HULL_FLAG_INPUT)) { - del = FALSE; + del = false; break; } } @@ -396,13 +396,13 @@ static void hull_tag_holes(BMesh *bm, BMOperator *op) /* Mark edges too if all adjacent faces are holes and the edge is * not already isolated */ BMO_ITER (e, &oiter, op->slots_in, "input", BM_EDGE) { - int hole = TRUE; - int any_faces = FALSE; + bool hole = true; + bool any_faces = false; BM_ITER_ELEM (f, &iter, e, BM_FACES_OF_EDGE) { - any_faces = TRUE; + any_faces = true; if (!BMO_elem_flag_test(bm, f, HULL_FLAG_HOLE)) { - hole = FALSE; + hole = false; break; } } diff --git a/source/blender/bmesh/operators/bmo_inset.c b/source/blender/bmesh/operators/bmo_inset.c index cef1181f63b..ef99dae5ac9 100644 --- a/source/blender/bmesh/operators/bmo_inset.c +++ b/source/blender/bmesh/operators/bmo_inset.c @@ -92,13 +92,13 @@ static BMLoop *bm_edge_is_mixed_face_tag(BMLoop *l) void bmo_inset_exec(BMesh *bm, BMOperator *op) { - const int use_outset = BMO_slot_bool_get(op->slots_in, "use_outset"); - const int use_boundary = BMO_slot_bool_get(op->slots_in, "use_boundary") && (use_outset == FALSE); - const int use_even_offset = BMO_slot_bool_get(op->slots_in, "use_even_offset"); - const int use_even_boundry = use_even_offset; /* could make own option */ - const int use_relative_offset = BMO_slot_bool_get(op->slots_in, "use_relative_offset"); - const float thickness = BMO_slot_float_get(op->slots_in, "thickness"); - const float depth = BMO_slot_float_get(op->slots_in, "depth"); + const bool use_outset = BMO_slot_bool_get(op->slots_in, "use_outset"); + const bool use_boundary = BMO_slot_bool_get(op->slots_in, "use_boundary") && (use_outset == false); + const bool use_even_offset = BMO_slot_bool_get(op->slots_in, "use_even_offset"); + const bool use_even_boundry = use_even_offset; /* could make own option */ + const bool use_relative_offset = BMO_slot_bool_get(op->slots_in, "use_relative_offset"); + const float thickness = BMO_slot_float_get(op->slots_in, "thickness"); + const float depth = BMO_slot_float_get(op->slots_in, "depth"); int edge_info_len = 0; @@ -111,13 +111,13 @@ void bmo_inset_exec(BMesh *bm, BMOperator *op) BMFace *f; int i, j, k; - if (use_outset == FALSE) { - BM_mesh_elem_hflag_disable_all(bm, BM_FACE, BM_ELEM_TAG, FALSE); - BMO_slot_buffer_hflag_enable(bm, op->slots_in, "faces", BM_FACE, BM_ELEM_TAG, FALSE); + if (use_outset == false) { + BM_mesh_elem_hflag_disable_all(bm, BM_FACE, BM_ELEM_TAG, false); + BMO_slot_buffer_hflag_enable(bm, op->slots_in, "faces", BM_FACE, BM_ELEM_TAG, false); } else { - BM_mesh_elem_hflag_enable_all(bm, BM_FACE, BM_ELEM_TAG, FALSE); - BMO_slot_buffer_hflag_disable(bm, op->slots_in, "faces", BM_FACE, BM_ELEM_TAG, FALSE); + BM_mesh_elem_hflag_enable_all(bm, BM_FACE, BM_ELEM_TAG, false); + BMO_slot_buffer_hflag_disable(bm, op->slots_in, "faces", BM_FACE, BM_ELEM_TAG, false); } /* first count all inset edges we will split */ @@ -411,11 +411,11 @@ void bmo_inset_exec(BMesh *bm, BMOperator *op) /* this saves expensive/slow glue check for common cases */ if (r_vout_len > 2) { - int ok = TRUE; + bool ok = true; /* last step, NULL this vertex if has a tagged face */ BM_ITER_ELEM (f, &iter, v_split, BM_FACES_OF_VERT) { if (BM_elem_flag_test(f, BM_ELEM_TAG)) { - ok = FALSE; + ok = false; break; } } @@ -471,7 +471,7 @@ void bmo_inset_exec(BMesh *bm, BMOperator *op) #endif /* no need to check doubles, we KNOW there won't be any */ /* yes - reverse face is correct in this case */ - f = BM_face_create_quad_tri_v(bm, varr, j, es->l->f, FALSE); + f = BM_face_create_quad_tri_v(bm, varr, j, es->l->f, false); BMO_elem_flag_enable(bm, f, ELE_NEW); /* copy for loop data, otherwise UV's and vcols are no good. @@ -548,7 +548,7 @@ void bmo_inset_exec(BMesh *bm, BMOperator *op) /* done correcting edge verts normals */ /* untag verts */ - BM_mesh_elem_hflag_disable_all(bm, BM_VERT, BM_ELEM_TAG, FALSE); + BM_mesh_elem_hflag_disable_all(bm, BM_VERT, BM_ELEM_TAG, false); /* tag face verts */ BMO_ITER (f, &oiter, op->slots_in, "faces", BM_FACE) { diff --git a/source/blender/bmesh/operators/bmo_join_triangles.c b/source/blender/bmesh/operators/bmo_join_triangles.c index 45ecdee014e..e052968a6a0 100644 --- a/source/blender/bmesh/operators/bmo_join_triangles.c +++ b/source/blender/bmesh/operators/bmo_join_triangles.c @@ -105,7 +105,7 @@ static float measure_facepair(BMVert *v1, BMVert *v2, #define T2QUV_LIMIT 0.005f #define T2QCOL_LIMIT 3 -static int bm_edge_faces_cmp(BMesh *bm, BMEdge *e, const int do_uv, const int do_tf, const int do_vcol) +static bool bm_edge_faces_cmp(BMesh *bm, BMEdge *e, const bool do_uv, const bool do_tf, const bool do_vcol) { /* first get loops */ BMLoop *l[4]; @@ -138,7 +138,7 @@ static int bm_edge_faces_cmp(BMesh *bm, BMEdge *e, const int do_uv, const int do if (luv[0] && (!compare_v2v2(luv[0]->uv, luv[2]->uv, T2QUV_LIMIT) || !compare_v2v2(luv[1]->uv, luv[3]->uv, T2QUV_LIMIT))) { - return FALSE; + return false; } } @@ -149,7 +149,7 @@ static int bm_edge_faces_cmp(BMesh *bm, BMEdge *e, const int do_uv, const int do }; if (tp[0] && (tp[0]->tpage != tp[1]->tpage)) { - return FALSE; + return false; } } @@ -166,12 +166,12 @@ static int bm_edge_faces_cmp(BMesh *bm, BMEdge *e, const int do_uv, const int do if (!compare_rgb_uchar((unsigned char *)&lcol[0]->r, (unsigned char *)&lcol[2]->r, T2QCOL_LIMIT) || !compare_rgb_uchar((unsigned char *)&lcol[1]->r, (unsigned char *)&lcol[3]->r, T2QCOL_LIMIT)) { - return FALSE; + return false; } } } - return TRUE; + return true; } typedef struct JoinEdge { @@ -197,6 +197,13 @@ static int fplcmp(const void *v1, const void *v2) void bmo_join_triangles_exec(BMesh *bm, BMOperator *op) { + const bool do_sharp = BMO_slot_bool_get(op->slots_in, "cmp_sharp"); + const bool do_uv = BMO_slot_bool_get(op->slots_in, "cmp_uvs"); + const bool do_tf = do_uv; /* texture face, make make its own option eventually */ + const bool do_vcol = BMO_slot_bool_get(op->slots_in, "cmp_vcols"); + const bool do_mat = BMO_slot_bool_get(op->slots_in, "cmp_materials"); + const float limit = BMO_slot_float_get(op->slots_in, "limit"); + BMIter iter, liter; BMOIter siter; BMFace *f; @@ -204,12 +211,6 @@ void bmo_join_triangles_exec(BMesh *bm, BMOperator *op) BMEdge *e; BLI_array_declare(jedges); JoinEdge *jedges = NULL; - int do_sharp = BMO_slot_bool_get(op->slots_in, "cmp_sharp"); - int do_uv = BMO_slot_bool_get(op->slots_in, "cmp_uvs"); - int do_tf = do_uv; /* texture face, make make its own option eventually */ - int do_vcol = BMO_slot_bool_get(op->slots_in, "cmp_vcols"); - int do_mat = BMO_slot_bool_get(op->slots_in, "cmp_materials"); - float limit = BMO_slot_float_get(op->slots_in, "limit"); int i, totedge; /* flag all edges of all input face */ @@ -265,7 +266,7 @@ void bmo_join_triangles_exec(BMesh *bm, BMOperator *op) if (do_mat && f1->mat_nr != f2->mat_nr) continue; - if ((do_uv || do_tf || do_vcol) && (bm_edge_faces_cmp(bm, e, do_uv, do_tf, do_vcol) == FALSE)) + if ((do_uv || do_tf || do_vcol) && (bm_edge_faces_cmp(bm, e, do_uv, do_tf, do_vcol) == false)) continue; measure = measure_facepair(v1, v2, v3, v4, limit); @@ -308,7 +309,7 @@ void bmo_join_triangles_exec(BMesh *bm, BMOperator *op) BM_edge_face_pair(e, &f1, &f2); /* checked above */ - BM_faces_join_pair(bm, f1, f2, e, TRUE); + BM_faces_join_pair(bm, f1, f2, e, true); } BM_ITER_MESH (e, &iter, bm, BM_EDGES_OF_MESH) { @@ -342,7 +343,7 @@ void bmo_join_triangles_exec(BMesh *bm, BMOperator *op) continue; } - BM_faces_join_pair(bm, f1, f2, e, TRUE); + BM_faces_join_pair(bm, f1, f2, e, true); } } diff --git a/source/blender/bmesh/operators/bmo_mesh_conv.c b/source/blender/bmesh/operators/bmo_mesh_conv.c index 4b897a24c8a..0976c4cdfbb 100644 --- a/source/blender/bmesh/operators/bmo_mesh_conv.c +++ b/source/blender/bmesh/operators/bmo_mesh_conv.c @@ -36,6 +36,9 @@ #include "DNA_key_types.h" #include "DNA_modifier_types.h" +#include "BLI_math.h" +#include "BLI_array.h" + #include "BKE_mesh.h" #include "BLI_listbase.h" #include "BKE_global.h" @@ -43,9 +46,6 @@ #include "BKE_main.h" #include "BKE_customdata.h" -#include "BLI_math.h" -#include "BLI_array.h" - #include "bmesh.h" #include "intern/bmesh_private.h" @@ -53,9 +53,9 @@ void bmo_mesh_to_bmesh_exec(BMesh *bm, BMOperator *op) { - Object *ob = BMO_slot_ptr_get(op->slots_in, "object"); - Mesh *me = BMO_slot_ptr_get(op->slots_in, "mesh"); - int set_key = BMO_slot_bool_get(op->slots_in, "use_shapekey"); + Object *ob = BMO_slot_ptr_get(op->slots_in, "object"); + Mesh *me = BMO_slot_ptr_get(op->slots_in, "mesh"); + bool set_key = BMO_slot_bool_get(op->slots_in, "use_shapekey"); BM_mesh_bm_from_me(bm, me, set_key, ob->shapenr); @@ -72,14 +72,14 @@ void bmo_object_load_bmesh_exec(BMesh *bm, BMOperator *op) BMO_op_callf(bm, op->flag, "bmesh_to_mesh mesh=%p object=%p skip_tessface=%b", - me, ob, TRUE); + me, ob, true); } void bmo_bmesh_to_mesh_exec(BMesh *bm, BMOperator *op) { Mesh *me = BMO_slot_ptr_get(op->slots_in, "mesh"); /* Object *ob = BMO_slot_ptr_get(op, "object"); */ - int dotess = !BMO_slot_bool_get(op->slots_in, "skip_tessface"); + const bool dotess = !BMO_slot_bool_get(op->slots_in, "skip_tessface"); BM_mesh_bm_to_me(bm, me, dotess); } diff --git a/source/blender/bmesh/operators/bmo_mirror.c b/source/blender/bmesh/operators/bmo_mirror.c index 61b061dd21f..48b2f76665c 100644 --- a/source/blender/bmesh/operators/bmo_mirror.c +++ b/source/blender/bmesh/operators/bmo_mirror.c @@ -53,8 +53,8 @@ void bmo_mirror_exec(BMesh *bm, BMOperator *op) float dist = BMO_slot_float_get(op->slots_in, "merge_dist"); int i, ototvert /*, ototedge */; int axis = BMO_slot_int_get(op->slots_in, "axis"); - int mirroru = BMO_slot_bool_get(op->slots_in, "mirror_u"); - int mirrorv = BMO_slot_bool_get(op->slots_in, "mirror_v"); + bool mirror_u = BMO_slot_bool_get(op->slots_in, "mirror_u"); + bool mirror_v = BMO_slot_bool_get(op->slots_in, "mirror_v"); BMOpSlot *slot_targetmap; ototvert = bm->totvert; @@ -97,7 +97,7 @@ void bmo_mirror_exec(BMesh *bm, BMOperator *op) v = BM_iter_step(&iter); } - if (mirroru || mirrorv) { + if (mirror_u || mirror_v) { BMFace *f; BMLoop *l; MLoopUV *luv; @@ -109,9 +109,9 @@ void bmo_mirror_exec(BMesh *bm, BMOperator *op) totlayer = CustomData_number_of_layers(&bm->ldata, CD_MLOOPUV); for (i = 0; i < totlayer; i++) { luv = CustomData_bmesh_get_n(&bm->ldata, l->head.data, CD_MLOOPUV, i); - if (mirroru) + if (mirror_u) luv->uv[0] = 1.0f - luv->uv[0]; - if (mirrorv) + if (mirror_v) luv->uv[1] = 1.0f - luv->uv[1]; } } diff --git a/source/blender/bmesh/operators/bmo_primitive.c b/source/blender/bmesh/operators/bmo_primitive.c index c582f710f43..011002718d3 100644 --- a/source/blender/bmesh/operators/bmo_primitive.c +++ b/source/blender/bmesh/operators/bmo_primitive.c @@ -420,7 +420,7 @@ void bmo_create_icosphere_exec(BMesh *bm, BMOperator *op) v2 = eva[icoface[a][1]]; v3 = eva[icoface[a][2]]; - eftemp = BM_face_create_quad_tri(bm, v1, v2, v3, NULL, NULL, FALSE); + eftemp = BM_face_create_quad_tri(bm, v1, v2, v3, NULL, NULL, false); BM_ITER_ELEM (l, &liter, eftemp, BM_LOOPS_OF_FACE) { BMO_elem_flag_enable(bm, l->e, EDGE_MARK); @@ -438,7 +438,7 @@ void bmo_create_icosphere_exec(BMesh *bm, BMOperator *op) "cuts=%i " "use_grid_fill=%b use_sphere=%b", EDGE_MARK, dia, (1 << (subdiv - 1)) - 1, - TRUE, TRUE); + true, true); BMO_op_exec(bm, &bmop); BMO_slot_buffer_flag_enable(bm, bmop.slots_out, "geom.out", BM_VERT, VERT_MARK); @@ -488,14 +488,14 @@ void bmo_create_monkey_exec(BMesh *bm, BMOperator *op) tv[monkeyf[i][1] + i - monkeyo], tv[monkeyf[i][2] + i - monkeyo], (monkeyf[i][3] != monkeyf[i][2]) ? tv[monkeyf[i][3] + i - monkeyo] : NULL, - NULL, FALSE); + NULL, false); BM_face_create_quad_tri(bm, tv[monkeynv + monkeyf[i][2] + i - monkeyo], tv[monkeynv + monkeyf[i][1] + i - monkeyo], tv[monkeynv + monkeyf[i][0] + i - monkeyo], (monkeyf[i][3] != monkeyf[i][2]) ? tv[monkeynv + monkeyf[i][3] + i - monkeyo] : NULL, - NULL, FALSE); + NULL, false); } MEM_freeN(tv); @@ -508,8 +508,8 @@ void bmo_create_circle_exec(BMesh *bm, BMOperator *op) { const float dia = BMO_slot_float_get(op->slots_in, "diameter"); const int segs = BMO_slot_int_get(op->slots_in, "segments"); - const int cap_ends = BMO_slot_bool_get(op->slots_in, "cap_ends"); - const int cap_tris = BMO_slot_bool_get(op->slots_in, "cap_tris"); + const bool cap_ends = BMO_slot_bool_get(op->slots_in, "cap_ends"); + const bool cap_tris = BMO_slot_bool_get(op->slots_in, "cap_tris"); BMVert *v1, *lastv1 = NULL, *cent1, *firstv1 = NULL; float vec[3], mat[4][4], phi, phid; @@ -547,7 +547,7 @@ void bmo_create_circle_exec(BMesh *bm, BMOperator *op) if (a && cap_ends) { BMFace *f; - f = BM_face_create_quad_tri(bm, cent1, lastv1, v1, NULL, NULL, FALSE); + f = BM_face_create_quad_tri(bm, cent1, lastv1, v1, NULL, NULL, false); BMO_elem_flag_enable(bm, f, FACE_NEW); } @@ -565,7 +565,7 @@ void bmo_create_circle_exec(BMesh *bm, BMOperator *op) if (cap_ends) { BMFace *f; - f = BM_face_create_quad_tri(bm, cent1, v1, firstv1, NULL, NULL, FALSE); + f = BM_face_create_quad_tri(bm, cent1, v1, firstv1, NULL, NULL, false); BMO_elem_flag_enable(bm, f, FACE_NEW); } @@ -584,8 +584,8 @@ void bmo_create_cone_exec(BMesh *bm, BMOperator *op) float dia2 = BMO_slot_float_get(op->slots_in, "diameter2"); float depth = BMO_slot_float_get(op->slots_in, "depth"); int segs = BMO_slot_int_get(op->slots_in, "segments"); - int cap_ends = BMO_slot_bool_get(op->slots_in, "cap_ends"); - int cap_tris = BMO_slot_bool_get(op->slots_in, "cap_tris"); + const bool cap_ends = BMO_slot_bool_get(op->slots_in, "cap_ends"); + const bool cap_tris = BMO_slot_bool_get(op->slots_in, "cap_tris"); int a; if (!segs) @@ -634,12 +634,12 @@ void bmo_create_cone_exec(BMesh *bm, BMOperator *op) if (cap_ends) { BMFace *f; - f = BM_face_create_quad_tri(bm, cent1, lastv1, v1, NULL, NULL, FALSE); + f = BM_face_create_quad_tri(bm, cent1, lastv1, v1, NULL, NULL, false); BMO_elem_flag_enable(bm, f, FACE_NEW); - f = BM_face_create_quad_tri(bm, cent2, v2, lastv2, NULL, NULL, FALSE); + f = BM_face_create_quad_tri(bm, cent2, v2, lastv2, NULL, NULL, false); BMO_elem_flag_enable(bm, f, FACE_NEW); } - BM_face_create_quad_tri(bm, lastv1, lastv2, v2, v1, NULL, FALSE); + BM_face_create_quad_tri(bm, lastv1, lastv2, v2, v1, NULL, false); } else { firstv1 = v1; @@ -656,9 +656,9 @@ void bmo_create_cone_exec(BMesh *bm, BMOperator *op) if (cap_ends) { BMFace *f; - f = BM_face_create_quad_tri(bm, cent1, v1, firstv1, NULL, NULL, FALSE); + f = BM_face_create_quad_tri(bm, cent1, v1, firstv1, NULL, NULL, false); BMO_elem_flag_enable(bm, f, FACE_NEW); - f = BM_face_create_quad_tri(bm, cent2, firstv2, v2, NULL, NULL, FALSE); + f = BM_face_create_quad_tri(bm, cent2, firstv2, v2, NULL, NULL, false); BMO_elem_flag_enable(bm, f, FACE_NEW); } @@ -666,7 +666,7 @@ void bmo_create_cone_exec(BMesh *bm, BMOperator *op) BMO_op_callf(bm, op->flag, "dissolve_faces faces=%ff", FACE_NEW); } - BM_face_create_quad_tri(bm, v1, v2, firstv2, firstv1, NULL, FALSE); + BM_face_create_quad_tri(bm, v1, v2, firstv2, firstv1, NULL, false); BMO_op_callf(bm, op->flag, "remove_doubles verts=%fv dist=%f", VERT_MARK, 0.000001); BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "verts.out", BM_VERT, VERT_MARK); @@ -738,14 +738,14 @@ void bmo_create_cube_exec(BMesh *bm, BMOperator *op) BMO_elem_flag_enable(bm, v8, VERT_MARK); /* the four sides */ - BM_face_create_quad_tri(bm, v5, v6, v2, v1, NULL, FALSE); - BM_face_create_quad_tri(bm, v6, v7, v3, v2, NULL, FALSE); - BM_face_create_quad_tri(bm, v7, v8, v4, v3, NULL, FALSE); - BM_face_create_quad_tri(bm, v8, v5, v1, v4, NULL, FALSE); + BM_face_create_quad_tri(bm, v5, v6, v2, v1, NULL, false); + BM_face_create_quad_tri(bm, v6, v7, v3, v2, NULL, false); + BM_face_create_quad_tri(bm, v7, v8, v4, v3, NULL, false); + BM_face_create_quad_tri(bm, v8, v5, v1, v4, NULL, false); /* top/bottom */ - BM_face_create_quad_tri(bm, v1, v2, v3, v4, NULL, FALSE); - BM_face_create_quad_tri(bm, v8, v7, v6, v5, NULL, FALSE); + BM_face_create_quad_tri(bm, v1, v2, v3, v4, NULL, false); + BM_face_create_quad_tri(bm, v8, v7, v6, v5, NULL, false); BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "verts.out", BM_VERT, VERT_MARK); } diff --git a/source/blender/bmesh/operators/bmo_removedoubles.c b/source/blender/bmesh/operators/bmo_removedoubles.c index 87e26f11d4b..7beac676868 100644 --- a/source/blender/bmesh/operators/bmo_removedoubles.c +++ b/source/blender/bmesh/operators/bmo_removedoubles.c @@ -41,7 +41,7 @@ static void remdoubles_splitface(BMFace *f, BMesh *bm, BMOperator *op, BMOpSlot BMIter liter; BMLoop *l; BMVert *v2, *doub; - int split = FALSE; + bool split = false; BM_ITER_ELEM (l, &liter, f, BM_LOOPS_OF_FACE) { v2 = BMO_slot_map_elem_get(slot_targetmap, l->v); @@ -52,14 +52,14 @@ static void remdoubles_splitface(BMFace *f, BMesh *bm, BMOperator *op, BMOpSlot (v2 != l->next->v)) { doub = l->v; - split = TRUE; + split = true; break; } } if (split && doub != v2) { BMLoop *nl; - BMFace *f2 = BM_face_split(bm, f, doub, v2, &nl, NULL, FALSE); + BMFace *f2 = BM_face_split(bm, f, doub, v2, &nl, NULL, false); remdoubles_splitface(f, bm, op, slot_targetmap); remdoubles_splitface(f2, bm, op, slot_targetmap); @@ -87,12 +87,12 @@ int remdoubles_face_overlaps(BMesh *bm, BMVert **varr, amount = BM_verts_in_face(bm, f, varr, len); if (amount >= len) { if (overlapface) *overlapface = f; - return TRUE; + return true; } f = BM_iter_step(&vertfaces); } } - return FALSE; + return false; } #endif @@ -394,11 +394,10 @@ void bmo_collapse_exec(BMesh *bm, BMOperator *op) if (!BMO_elem_flag_test(bm, e, EDGE_MARK)) continue; - e = BMW_begin(&walker, e->v1); BLI_array_empty(edges); INIT_MINMAX(min, max); - for (tot = 0; e; tot++, e = BMW_step(&walker)) { + for (e = BMW_begin(&walker, e->v1), tot = 0; e; e = BMW_step(&walker), tot++) { BLI_array_grow_one(edges); edges[tot] = e; @@ -454,11 +453,9 @@ static void bmo_collapsecon_do_layer(BMesh *bm, BMOperator *op, int layer) if (BMO_elem_flag_test(bm, l->e, EDGE_MARK)) { /* walk */ BLI_array_empty(blocks); - tot = 0; - l2 = BMW_begin(&walker, l); CustomData_data_initminmax(type, &min, &max); - for (tot = 0; l2; tot++, l2 = BMW_step(&walker)) { + for (l2 = BMW_begin(&walker, l), tot = 0; l2; l2 = BMW_step(&walker), tot++) { BLI_array_grow_one(blocks); blocks[tot] = CustomData_bmesh_get_layer_n(&bm->ldata, l2->head.data, layer); CustomData_data_dominmax(type, blocks[tot], &min, &max); diff --git a/source/blender/bmesh/operators/bmo_similar.c b/source/blender/bmesh/operators/bmo_similar.c index a8cc152bd4e..454f9ab2ad3 100644 --- a/source/blender/bmesh/operators/bmo_similar.c +++ b/source/blender/bmesh/operators/bmo_similar.c @@ -185,21 +185,21 @@ void bmo_similar_faces_exec(BMesh *bm, BMOperator *op) 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)) { - int cont = TRUE; - for (idx = 0; idx < num_sels && cont == TRUE; idx++) { + 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); - cont = FALSE; + cont = false; } break; case SIMFACE_IMAGE: if (f_ext[i].t == f_ext[indices[idx]].t) { BMO_elem_flag_enable(bm, fm, FACE_MARK); - cont = FALSE; + cont = false; } break; @@ -207,7 +207,7 @@ void bmo_similar_faces_exec(BMesh *bm, BMOperator *op) 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); - cont = FALSE; + cont = false; } break; @@ -217,7 +217,7 @@ void bmo_similar_faces_exec(BMesh *bm, BMOperator *op) delta_fl = f_ext[i].d - f_ext[indices[idx]].d; if (bm_sel_similar_cmp_fl(delta_fl, thresh, compare)) { BMO_elem_flag_enable(bm, fm, FACE_MARK); - cont = FALSE; + cont = false; } } break; @@ -226,7 +226,7 @@ void bmo_similar_faces_exec(BMesh *bm, BMOperator *op) 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); - cont = FALSE; + cont = false; } break; @@ -234,7 +234,7 @@ void bmo_similar_faces_exec(BMesh *bm, BMOperator *op) delta_i = fm->len - fs->len; if (bm_sel_similar_cmp_i(delta_i, compare)) { BMO_elem_flag_enable(bm, fm, FACE_MARK); - cont = FALSE; + cont = false; } break; @@ -242,7 +242,7 @@ void bmo_similar_faces_exec(BMesh *bm, BMOperator *op) 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); - cont = FALSE; + cont = false; } break; #ifdef WITH_FREESTYLE @@ -381,15 +381,15 @@ void bmo_similar_edges_exec(BMesh *bm, BMOperator *op) 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)) { - int cont = TRUE; - for (idx = 0; idx < num_sels && cont == TRUE; idx++) { + bool cont = true; + for (idx = 0; idx < num_sels && cont == true; idx++) { es = e_ext[indices[idx]].e; switch (type) { 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); - cont = FALSE; + cont = false; } break; @@ -402,7 +402,7 @@ void bmo_similar_edges_exec(BMesh *bm, BMOperator *op) if (angle / (float)(M_PI / 2.0) <= thresh) { BMO_elem_flag_enable(bm, e, EDGE_MARK); - cont = FALSE; + cont = false; } break; @@ -410,7 +410,7 @@ void bmo_similar_edges_exec(BMesh *bm, BMOperator *op) 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); - cont = FALSE; + cont = false; } break; @@ -419,12 +419,12 @@ void bmo_similar_edges_exec(BMesh *bm, BMOperator *op) 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); - cont = FALSE; + cont = false; } } } else { - cont = FALSE; + cont = false; } break; @@ -438,7 +438,7 @@ void bmo_similar_edges_exec(BMesh *bm, BMOperator *op) if (bm_sel_similar_cmp_fl(delta_fl, thresh, compare)) { BMO_elem_flag_enable(bm, e, EDGE_MARK); - cont = FALSE; + cont = false; } } break; @@ -453,7 +453,7 @@ void bmo_similar_edges_exec(BMesh *bm, BMOperator *op) if (bm_sel_similar_cmp_fl(delta_fl, thresh, compare)) { BMO_elem_flag_enable(bm, e, EDGE_MARK); - cont = FALSE; + cont = false; } } break; @@ -461,14 +461,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); - cont = FALSE; + 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); - cont = FALSE; + cont = false; } break; #ifdef WITH_FREESTYLE @@ -578,15 +578,15 @@ void bmo_similar_verts_exec(BMesh *bm, BMOperator *op) 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)) { - int cont = TRUE; - for (idx = 0; idx < num_sels && cont == TRUE; idx++) { + bool cont = true; + for (idx = 0; idx < num_sels && cont == true; idx++) { vs = v_ext[indices[idx]].v; switch (type) { 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); - cont = FALSE; + cont = false; } break; case SIMVERT_FACE: @@ -594,7 +594,7 @@ void bmo_similar_verts_exec(BMesh *bm, BMOperator *op) 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); - cont = FALSE; + cont = false; } break; @@ -602,7 +602,7 @@ void bmo_similar_verts_exec(BMesh *bm, BMOperator *op) 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); - cont = FALSE; + cont = false; } } break; @@ -611,7 +611,7 @@ void bmo_similar_verts_exec(BMesh *bm, BMOperator *op) 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); - cont = FALSE; + cont = false; } break; default: diff --git a/source/blender/bmesh/operators/bmo_slide.c b/source/blender/bmesh/operators/bmo_slide.c deleted file mode 100644 index ea9f9bf9eba..00000000000 --- a/source/blender/bmesh/operators/bmo_slide.c +++ /dev/null @@ -1,113 +0,0 @@ -/* - * ***** BEGIN GPL LICENSE BLOCK ***** - * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the GNU General Public License - * as published by the Free Software Foundation; either version 2 - * of the License, or (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software Foundation, - * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. - * - * Contributor(s): Francisco De La Cruz - * - * ***** END GPL LICENSE BLOCK ***** - */ - -/** \file blender/bmesh/operators/bmo_slide.c - * \ingroup bmesh - */ - -#include "MEM_guardedalloc.h" - -#include "BKE_global.h" - -#include "BLI_math.h" - -#include "bmesh.h" -#include "intern/bmesh_operators_private.h" /* own include */ - -#define EDGE_MARK 1 -#define VERT_MARK 2 - -/* - * Slides a vertex along a connected edge - * - */ -void bmo_slide_vert_exec(BMesh *bm, BMOperator *op) -{ - BMOIter oiter; - BMIter iter; - BMHeader *h; - BMVert *vertex; - BMEdge *edge; - BMEdge *slide_edge; - - /* Selection counts */ - int selected_edges = 0; - - /* Get slide amount */ - const float factor = BMO_slot_float_get(op->slots_in, "factor"); - - /* Get start vertex */ - vertex = BMO_slot_buffer_get_single(BMO_slot_get(op->slots_in, "vert")); - - if (!vertex) { - if (G.debug & G_DEBUG) { - fprintf(stderr, "slide_vert: No vertex selected..."); - } - BMO_error_raise(bm, op, BMERR_INVALID_SELECTION, "Vertex Slide error: invalid selection"); - return; - } - - /* BMESH_TODO - this is odd, it only uses one edge, why take a list at all? */ - /* Count selected edges */ - BMO_ITER (h, &oiter, op->slots_in, "edges", BM_EDGE) { - selected_edges++; - /* Mark all selected edges (cast BMHeader->BMEdge) */ - BMO_elem_flag_enable(bm, (BMElemF *)h, EDGE_MARK); - break; - } - - /* Only allow sliding if an edge is selected */ - if (selected_edges == 0) { - if (G.debug & G_DEBUG) { - fprintf(stderr, "slide_vert: select a single edge\n"); - } - BMO_error_raise(bm, op, BMERR_INVALID_SELECTION, "Vertex Slide error: invalid selection"); - return; - } - - /* Make sure we get the correct edge. */ - slide_edge = NULL; - BM_ITER_ELEM (edge, &iter, vertex, BM_EDGES_OF_VERT) { - if (BMO_elem_flag_test(bm, edge, EDGE_MARK) && BM_vert_in_edge(edge, vertex)) { - slide_edge = edge; - break; - } - } - - /* Found edge */ - if (slide_edge) { - BMVert *other = BM_edge_other_vert(slide_edge, vertex); - - /* mark */ - BMO_elem_flag_enable(bm, vertex, VERT_MARK); - - /* Interpolate */ - interp_v3_v3v3(vertex->co, vertex->co, other->co, factor); - } - - /* Return the new edge. The same previously marked with VERT_MARK */ - BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "verts.out", BM_VERT, VERT_MARK); - return; -} - -#undef EDGE_MARK -#undef VERT_MARK diff --git a/source/blender/bmesh/operators/bmo_smooth_laplacian.c b/source/blender/bmesh/operators/bmo_smooth_laplacian.c index ce584686757..ba755a866de 100644 --- a/source/blender/bmesh/operators/bmo_smooth_laplacian.c +++ b/source/blender/bmesh/operators/bmo_smooth_laplacian.c @@ -180,7 +180,7 @@ static void init_laplacian_matrix(LaplacianSystem *sys) float *v1, *v2, *v3, *v4; float w1, w2, w3, w4; int i, j; - int has_4_vert; + bool has_4_vert; unsigned int idv1, idv2, idv3, idv4, idv[4]; BMEdge *e; BMFace *f; @@ -297,7 +297,7 @@ static void fill_laplacian_matrix(LaplacianSystem *sys) float *v1, *v2, *v3, *v4; float w2, w3, w4; int i, j; - int has_4_vert; + bool has_4_vert; unsigned int idv1, idv2, idv3, idv4, idv[4]; BMEdge *e; @@ -537,7 +537,7 @@ void bmo_smooth_laplacian_vert_exec(BMesh *bm, BMOperator *op) { int i; int m_vertex_id; - int usex, usey, usez, preserve_volume; + bool usex, usey, usez, preserve_volume; float lambda_factor, lambda_border; float w; BMOIter siter; diff --git a/source/blender/bmesh/operators/bmo_subdivide.c b/source/blender/bmesh/operators/bmo_subdivide.c index 7407eb4423a..c7c33aa2775 100644 --- a/source/blender/bmesh/operators/bmo_subdivide.c +++ b/source/blender/bmesh/operators/bmo_subdivide.c @@ -90,7 +90,7 @@ static BMEdge *connect_smallest_face(BMesh *bm, BMVert *v1, BMVert *v2, BMFace * } if (curf) { - face = BM_face_split(bm, curf, v1, v2, &nl, NULL, FALSE); + face = BM_face_split(bm, curf, v1, v2, &nl, NULL, false); if (r_nf) *r_nf = face; return nl ? nl->e : NULL; @@ -715,8 +715,8 @@ void bmo_subdivide_edges_exec(BMesh *bm, BMOperator *op) BMFace *face; BLI_array_declare(verts); float smooth, fractal, along_normal; - int use_sphere, cornertype, use_single_edge, use_grid_fill, use_only_quads; - int skey, seed, i, j, matched, a, b, numcuts, totesel; + bool use_sphere, use_single_edge, use_grid_fill, use_only_quads; + int cornertype, skey, seed, i, j, matched, a, b, numcuts, totesel; BMO_slot_buffer_flag_enable(bm, op->slots_in, "edges", BM_EDGE, SUBD_SPLIT); @@ -912,6 +912,10 @@ void bmo_subdivide_edges_exec(BMesh *bm, BMOperator *op) j = BLI_array_count(facedata) - 1; BMO_elem_flag_enable(bm, face, SUBD_SPLIT); + + /* must initialize all members here */ + facedata[j].start = NULL; + facedata[j].pat = NULL; facedata[j].totedgesel = totesel; facedata[j].face = face; } @@ -983,7 +987,7 @@ void bmo_subdivide_edges_exec(BMesh *bm, BMOperator *op) BLI_array_grow_items(loops_split, numcuts); for (j = 0; j < numcuts; j++) { - int ok = TRUE; + bool ok = true; /* Check for special case: [#32500] * This edge pair could be used by more then one face, @@ -1006,7 +1010,7 @@ void bmo_subdivide_edges_exec(BMesh *bm, BMOperator *op) BLI_assert(other_loop->prev->v != loops[a]->v); BLI_assert(other_loop->next->v != loops[a]->v); - ok = FALSE; + ok = false; break; } } @@ -1014,7 +1018,7 @@ void bmo_subdivide_edges_exec(BMesh *bm, BMOperator *op) } - if (ok == TRUE) { + if (ok == true) { loops_split[j][0] = loops[a]; loops_split[j][1] = loops[b]; } @@ -1036,10 +1040,10 @@ void bmo_subdivide_edges_exec(BMesh *bm, BMOperator *op) for (j = 0; j < BLI_array_count(loops_split); j++) { if (loops_split[j][0]) { - BLI_assert(BM_edge_exists(loops_split[j][0]->v, loops_split[j][1]->v) == FALSE); + BLI_assert(BM_edge_exists(loops_split[j][0]->v, loops_split[j][1]->v) == NULL); /* BMFace *nf = */ /* UNUSED */ - BM_face_split(bm, face, loops_split[j][0]->v, loops_split[j][1]->v, &nl, NULL, FALSE); + BM_face_split(bm, face, loops_split[j][0]->v, loops_split[j][1]->v, &nl, NULL, false); } } @@ -1123,7 +1127,7 @@ void BM_mesh_esubdivide(BMesh *bm, const char edge_hflag, BMElem *ele; for (ele = BMO_iter_new(&iter, op.slots_out, "geom_inner.out", BM_EDGE | BM_VERT); ele; ele = BMO_iter_step(&iter)) { - BM_elem_select_set(bm, ele, TRUE); + BM_elem_select_set(bm, ele, true); } } else if (seltype == SUBDIV_SELECT_LOOPCUT) { @@ -1131,10 +1135,10 @@ void BM_mesh_esubdivide(BMesh *bm, const char edge_hflag, BMElem *ele; /* deselect input */ - BM_mesh_elem_hflag_disable_all(bm, BM_VERT | BM_EDGE | BM_FACE, BM_ELEM_SELECT, FALSE); + BM_mesh_elem_hflag_disable_all(bm, BM_VERT | BM_EDGE | BM_FACE, BM_ELEM_SELECT, false); for (ele = BMO_iter_new(&iter, op.slots_out, "geom_inner.out", BM_EDGE | BM_VERT); ele; ele = BMO_iter_step(&iter)) { - BM_elem_select_set(bm, ele, TRUE); + BM_elem_select_set(bm, ele, true); if (ele->head.htype == BM_VERT) { BMEdge *e; @@ -1145,13 +1149,13 @@ void BM_mesh_esubdivide(BMesh *bm, const char edge_hflag, BM_elem_flag_test(e->v1, BM_ELEM_SELECT) && BM_elem_flag_test(e->v2, BM_ELEM_SELECT)) { - BM_edge_select_set(bm, e, TRUE); + BM_edge_select_set(bm, e, true); } else if (BM_elem_flag_test(e, BM_ELEM_SELECT) && (!BM_elem_flag_test(e->v1, BM_ELEM_SELECT) || !BM_elem_flag_test(e->v2, BM_ELEM_SELECT))) { - BM_edge_select_set(bm, e, FALSE); + BM_edge_select_set(bm, e, false); } } } diff --git a/source/blender/bmesh/operators/bmo_symmetrize.c b/source/blender/bmesh/operators/bmo_symmetrize.c index 172f0d40b27..0bfc81f83cf 100644 --- a/source/blender/bmesh/operators/bmo_symmetrize.c +++ b/source/blender/bmesh/operators/bmo_symmetrize.c @@ -176,7 +176,7 @@ static void symm_split_asymmetric_edges(Symm *symm) plane_co[symm->axis][0], plane_co[symm->axis][1], plane_co[symm->axis][2], - &lambda, TRUE); + &lambda, true); BLI_assert(r); madd_v3_v3v3fl(co, e->v1->co, edge_dir, lambda); @@ -244,7 +244,7 @@ typedef struct { int len; /* True only if none of the polygon's edges were split */ - int already_symmetric; + bool already_symmetric; BMFace *src_face; } SymmPoly; @@ -261,11 +261,11 @@ static void symm_poly_with_splits(const Symm *symm, /* Count vertices and check for edge splits */ out->len = f->len; - out->already_symmetric = TRUE; + out->already_symmetric = true; BM_ITER_ELEM (l, &iter, f, BM_LOOPS_OF_FACE) { if (BLI_ghash_haskey(symm->edge_split_map, l->e)) { out->len++; - out->already_symmetric = FALSE; + out->already_symmetric = false; } } @@ -332,11 +332,11 @@ static BMVert *symm_poly_mirror_dst(const Symm *symm, return NULL; } -static int symm_poly_next_crossing(const Symm *symm, - const SymmPoly *sp, - int start, - int *l1, - int *l2) +static bool symm_poly_next_crossing(const Symm *symm, + const SymmPoly *sp, + int start, + int *l1, + int *l2) { int i; @@ -347,12 +347,12 @@ static int symm_poly_next_crossing(const Symm *symm, if ((symm_poly_co_side(symm, sp, *l1) == SYMM_SIDE_KILL) ^ (symm_poly_co_side(symm, sp, *l2) == SYMM_SIDE_KILL)) { - return TRUE; + return true; } } BLI_assert(!"symm_poly_next_crossing failed"); - return FALSE; + return false; } static BMFace *symm_face_create_v(BMesh *bm, BMFace *example, @@ -378,7 +378,7 @@ static BMFace *symm_face_create_v(BMesh *bm, BMFace *example, f_new = BM_face_create(bm, fv, fe, len, BM_CREATE_NO_DOUBLE); if (example) BM_elem_attrs_copy(bm, bm, example, f_new); - BM_face_select_set(bm, f_new, TRUE); + BM_face_select_set(bm, f_new, true); BMO_elem_flag_enable(bm, f_new, SYMM_OUTPUT_GEOM); return f_new; @@ -465,15 +465,15 @@ static void symm_mirror_polygons(Symm *symm) BMO_ITER (f, &oiter, symm->op->slots_in, "input", BM_FACE) { BMIter iter; BMLoop *l; - int mirror_all = TRUE, ignore_all = TRUE; + bool mirror_all = true, ignore_all = true; /* Check if entire polygon can be mirrored or ignored */ BM_ITER_ELEM (l, &iter, f, BM_LOOPS_OF_FACE) { const SymmSide side = symm_co_side(symm, l->v->co); if (side == SYMM_SIDE_KILL) - mirror_all = FALSE; + mirror_all = false; else if (side == SYMM_SIDE_KEEP) - ignore_all = FALSE; + ignore_all = false; } if (mirror_all) { diff --git a/source/blender/bmesh/operators/bmo_triangulate.c b/source/blender/bmesh/operators/bmo_triangulate.c index 663ee463a2c..744f706681d 100644 --- a/source/blender/bmesh/operators/bmo_triangulate.c +++ b/source/blender/bmesh/operators/bmo_triangulate.c @@ -52,7 +52,7 @@ void bmo_triangulate_exec(BMesh *bm, BMOperator *op) float (*projectverts)[3] = NULL; BLI_array_declare(projectverts); int i; - const int use_beauty = BMO_slot_bool_get(op->slots_in, "use_beauty"); + const bool use_beauty = BMO_slot_bool_get(op->slots_in, "use_beauty"); BMOpSlot *slot_facemap_out = BMO_slot_get(op->slots_out, "face_map.out"); for (face = BMO_iter_new(&siter, op->slots_in, "faces", BM_FACE); face; face = BMO_iter_step(&siter)) { @@ -138,7 +138,7 @@ void bmo_beautify_fill_exec(BMesh *bm, BMOperator *op) fac2 = opp1 / (len2 + len3 + len6) + opp2 / (len4 + len1 + len6); if (fac1 > fac2) { - e = BM_edge_rotate(bm, e, FALSE, BM_EDGEROT_CHECK_EXISTS); + e = BM_edge_rotate(bm, e, false, BM_EDGEROT_CHECK_EXISTS); if (e) { BMO_elem_flag_enable(bm, e, ELE_NEW); @@ -195,7 +195,7 @@ void bmo_triangle_fill_exec(BMesh *bm, BMOperator *op) for (sf_tri = sf_ctx.fillfacebase.first; sf_tri; sf_tri = sf_tri->next) { BMFace *f = BM_face_create_quad_tri(bm, sf_tri->v1->tmp.p, sf_tri->v2->tmp.p, sf_tri->v3->tmp.p, NULL, - NULL, TRUE); + NULL, true); BMLoop *l; BMIter liter; diff --git a/source/blender/bmesh/operators/bmo_unsubdivide.c b/source/blender/bmesh/operators/bmo_unsubdivide.c index fae7db3d175..784e695efb0 100644 --- a/source/blender/bmesh/operators/bmo_unsubdivide.c +++ b/source/blender/bmesh/operators/bmo_unsubdivide.c @@ -55,5 +55,5 @@ void bmo_unsubdivide_exec(BMesh *bm, BMOperator *op) } /* do all the real work here */ - BM_mesh_decimate_unsubdivide_ex(bm, iterations, TRUE); + BM_mesh_decimate_unsubdivide_ex(bm, iterations, true); } diff --git a/source/blender/bmesh/operators/bmo_utils.c b/source/blender/bmesh/operators/bmo_utils.c index 64dbf0cc0e7..6398d9d04b1 100644 --- a/source/blender/bmesh/operators/bmo_utils.c +++ b/source/blender/bmesh/operators/bmo_utils.c @@ -122,8 +122,8 @@ void bmo_rotate_edges_exec(BMesh *bm, BMOperator *op) { BMOIter siter; BMEdge *e, *e2; - const int use_ccw = BMO_slot_bool_get(op->slots_in, "use_ccw"); - const int is_single = BMO_slot_buffer_count(op->slots_in, "edges") == 1; + const bool use_ccw = BMO_slot_bool_get(op->slots_in, "use_ccw"); + const bool is_single = BMO_slot_buffer_count(op->slots_in, "edges") == 1; short check_flag = is_single ? BM_EDGEROT_CHECK_EXISTS : BM_EDGEROT_CHECK_EXISTS | BM_EDGEROT_CHECK_DEGENERATE; @@ -140,8 +140,8 @@ 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_elem_flag_test(bm, fa, FACE_TAINT) == false && + BMO_elem_flag_test(bm, fb, FACE_TAINT) == false) { if (!(e2 = BM_edge_rotate(bm, e, use_ccw, check_flag))) { @@ -172,14 +172,14 @@ void bmo_rotate_edges_exec(BMesh *bm, BMOperator *op) #define SEL_FLAG 1 #define SEL_ORIG 2 -static void bmo_region_extend_extend(BMesh *bm, BMOperator *op, int usefaces) +static void bmo_region_extend_extend(BMesh *bm, BMOperator *op, const bool use_faces) { BMVert *v; BMEdge *e; BMIter eiter; BMOIter siter; - if (!usefaces) { + if (!use_faces) { BMO_ITER (v, &siter, op->slots_in, "geom", BM_VERT) { BM_ITER_ELEM (e, &eiter, v, BM_EDGES_OF_VERT) { if (!BM_elem_flag_test(e, BM_ELEM_HIDDEN)) @@ -216,14 +216,14 @@ static void bmo_region_extend_extend(BMesh *bm, BMOperator *op, int usefaces) } } -static void bmo_region_extend_constrict(BMesh *bm, BMOperator *op, int usefaces) +static void bmo_region_extend_constrict(BMesh *bm, BMOperator *op, const bool use_faces) { BMVert *v; BMEdge *e; BMIter eiter; BMOIter siter; - if (!usefaces) { + if (!use_faces) { BMO_ITER (v, &siter, op->slots_in, "geom", BM_VERT) { BM_ITER_ELEM (e, &eiter, v, BM_EDGES_OF_VERT) { if (!BM_elem_flag_test(e, BM_ELEM_HIDDEN)) @@ -265,8 +265,8 @@ static void bmo_region_extend_constrict(BMesh *bm, BMOperator *op, int usefaces) void bmo_region_extend_exec(BMesh *bm, BMOperator *op) { - int use_faces = BMO_slot_bool_get(op->slots_in, "use_faces"); - int constrict = BMO_slot_bool_get(op->slots_in, "use_constrict"); + const bool use_faces = BMO_slot_bool_get(op->slots_in, "use_faces"); + const bool constrict = BMO_slot_bool_get(op->slots_in, "use_constrict"); BMO_slot_buffer_flag_enable(bm, op->slots_in, "geom", BM_ALL_NOLOOP, SEL_ORIG); @@ -314,7 +314,8 @@ void bmo_recalc_face_normals_exec(BMesh *bm, BMOperator *op) BLI_array_declare(fstack); BMLoop *l, *l2; float maxx, maxx_test, cent[3]; - int i, i_max, flagflip = BMO_slot_bool_get(op->slots_in, "use_flip"); + int i, i_max; + const bool use_flip = BMO_slot_bool_get(op->slots_in, "use_flip"); startf = NULL; maxx = -1.0e10; @@ -349,7 +350,7 @@ void bmo_recalc_face_normals_exec(BMesh *bm, BMOperator *op) BM_face_normal_flip(bm, startf); BMO_elem_flag_toggle(bm, startf, FACE_FLIP); - if (flagflip) + if (use_flip) BM_elem_flag_toggle(startf, BM_ELEM_TAG); } @@ -381,11 +382,11 @@ void bmo_recalc_face_normals_exec(BMesh *bm, BMOperator *op) BM_face_normal_flip(bm, l2->f); BMO_elem_flag_toggle(bm, l2->f, FACE_FLIP); - if (flagflip) + if (use_flip) BM_elem_flag_toggle(l2->f, BM_ELEM_TAG); } else if (BM_elem_flag_test(l2->f, BM_ELEM_TAG) || BM_elem_flag_test(l->f, BM_ELEM_TAG)) { - if (flagflip) { + if (use_flip) { BM_elem_flag_disable(l->f, BM_ELEM_TAG); BM_elem_flag_disable(l2->f, BM_ELEM_TAG); } @@ -436,9 +437,11 @@ void bmo_smooth_vert_exec(BMesh *UNUSED(bm), BMOperator *op) i = 0; BMO_ITER (v, &siter, op->slots_in, "verts", BM_VERT) { BLI_array_grow_one(cos); + co = cos[i]; - - j = 0; + zero_v3(co); + + j = 0; BM_ITER_ELEM (e, &iter, v, BM_EDGES_OF_VERT) { co2 = BM_edge_other_vert(e, v)->co; add_v3_v3v3(co, co, co2); @@ -489,11 +492,11 @@ void bmo_rotate_uvs_exec(BMesh *bm, BMOperator *op) BMFace *fs; /* current face */ BMIter l_iter; /* iteration loop */ - const int use_ccw = BMO_slot_bool_get(op->slots_in, "use_ccw"); + const bool use_ccw = BMO_slot_bool_get(op->slots_in, "use_ccw"); BMO_ITER (fs, &fs_iter, op->slots_in, "faces", BM_FACE) { if (CustomData_has_layer(&(bm->ldata), CD_MLOOPUV)) { - if (use_ccw == FALSE) { /* same loops direction */ + if (use_ccw == false) { /* same loops direction */ BMLoop *lf; /* current face loops */ MLoopUV *f_luv; /* first face loop uv */ float p_uv[2]; /* previous uvs */ @@ -594,11 +597,11 @@ void bmo_rotate_colors_exec(BMesh *bm, BMOperator *op) BMFace *fs; /* current face */ BMIter l_iter; /* iteration loop */ - const int use_ccw = BMO_slot_bool_get(op->slots_in, "use_ccw"); + const bool use_ccw = BMO_slot_bool_get(op->slots_in, "use_ccw"); BMO_ITER (fs, &fs_iter, op->slots_in, "faces", BM_FACE) { if (CustomData_has_layer(&(bm->ldata), CD_MLOOPCOL)) { - if (use_ccw == FALSE) { /* same loops direction */ + if (use_ccw == false) { /* same loops direction */ BMLoop *lf; /* current face loops */ MLoopCol *f_lcol; /* first face loop color */ MLoopCol p_col; /* previous color */ diff --git a/source/blender/bmesh/operators/bmo_wireframe.c b/source/blender/bmesh/operators/bmo_wireframe.c index 7401704310f..0d603faf3c4 100644 --- a/source/blender/bmesh/operators/bmo_wireframe.c +++ b/source/blender/bmesh/operators/bmo_wireframe.c @@ -134,34 +134,34 @@ static void bm_vert_boundary_tangent(BMVert *v, float r_no[3], float r_no_face[3 } /* check if we are the only tagged loop-face around this edge */ -static int bm_loop_is_radial_boundary(BMLoop *l_first) +static bool bm_loop_is_radial_boundary(BMLoop *l_first) { BMLoop *l = l_first->radial_next; if (l == l_first) { - return TRUE; /* a real boundary */ + return true; /* a real boundary */ } else { do { if (BM_elem_flag_test(l->f, BM_ELEM_TAG)) { - return FALSE; + return false; } } while ((l = l->radial_next) != l_first); } - return TRUE; + return true; } extern float BM_vert_calc_mean_tagged_edge_length(BMVert *v); void bmo_wireframe_exec(BMesh *bm, BMOperator *op) { - const int use_boundary = BMO_slot_bool_get(op->slots_in, "use_boundary"); - const int use_even_offset = BMO_slot_bool_get(op->slots_in, "use_even_offset"); - const int use_relative_offset = BMO_slot_bool_get(op->slots_in, "use_relative_offset"); - const int use_crease = (BMO_slot_bool_get(op->slots_in, "use_crease") && - CustomData_has_layer(&bm->edata, CD_CREASE)); - const float depth = BMO_slot_float_get(op->slots_in, "thickness"); - const float inset = depth; + const bool use_boundary = BMO_slot_bool_get(op->slots_in, "use_boundary"); + const bool use_even_offset = BMO_slot_bool_get(op->slots_in, "use_even_offset"); + const bool use_relative_offset = BMO_slot_bool_get(op->slots_in, "use_relative_offset"); + const bool use_crease = (BMO_slot_bool_get(op->slots_in, "use_crease") && + CustomData_has_layer(&bm->edata, CD_CREASE)); + const float depth = BMO_slot_float_get(op->slots_in, "thickness"); + const float inset = depth; const int totvert_orig = bm->totvert; @@ -203,7 +203,7 @@ void bmo_wireframe_exec(BMesh *bm, BMOperator *op) } /* setup tags, all faces and verts will be tagged which will be duplicated */ - BM_mesh_elem_hflag_disable_all(bm, BM_FACE, BM_ELEM_TAG, FALSE); + BM_mesh_elem_hflag_disable_all(bm, BM_FACE, BM_ELEM_TAG, false); BMO_ITER (f_src, &oiter, op->slots_in, "faces", BM_FACE) { verts_loop_tot += f_src->len; @@ -239,13 +239,13 @@ void bmo_wireframe_exec(BMesh *bm, BMOperator *op) } /* conflicts with BM_vert_calc_mean_tagged_edge_length */ - if (use_relative_offset == FALSE) { + if (use_relative_offset == false) { BM_elem_flag_disable(v_src, BM_ELEM_TAG); } } if (use_relative_offset) { - BM_mesh_elem_hflag_disable_all(bm, BM_VERT, BM_ELEM_TAG, FALSE); + BM_mesh_elem_hflag_disable_all(bm, BM_VERT, BM_ELEM_TAG, false); } verts_loop = MEM_mallocN(sizeof(BMVert **) * verts_loop_tot, __func__); @@ -332,7 +332,7 @@ void bmo_wireframe_exec(BMesh *bm, BMOperator *op) BMVert *v_pos1 = verts_pos[i_1]; BMVert *v_pos2 = verts_pos[i_2]; - f_new = BM_face_create_quad_tri(bm, v_l1, v_l2, v_neg2, v_neg1, f_src, FALSE); + f_new = BM_face_create_quad_tri(bm, v_l1, v_l2, v_neg2, v_neg1, f_src, false); BM_elem_flag_enable(f_new, BM_ELEM_TAG); l_new = BM_FACE_FIRST_LOOP(f_new); @@ -341,7 +341,7 @@ void bmo_wireframe_exec(BMesh *bm, BMOperator *op) BM_elem_attrs_copy(bm, bm, l_next, l_new->next); BM_elem_attrs_copy(bm, bm, l_next, l_new->next->next); - f_new = BM_face_create_quad_tri(bm, v_l2, v_l1, v_pos1, v_pos2, f_src, FALSE); + f_new = BM_face_create_quad_tri(bm, v_l2, v_l1, v_pos1, v_pos2, f_src, false); BM_elem_flag_enable(f_new, BM_ELEM_TAG); l_new = BM_FACE_FIRST_LOOP(f_new); @@ -357,7 +357,7 @@ void bmo_wireframe_exec(BMesh *bm, BMOperator *op) BMVert *v_b1 = verts_boundary[i_1]; BMVert *v_b2 = verts_boundary[i_2]; - f_new = BM_face_create_quad_tri(bm, v_b2, v_b1, v_neg1, v_neg2, f_src, FALSE); + f_new = BM_face_create_quad_tri(bm, v_b2, v_b1, v_neg1, v_neg2, f_src, false); BM_elem_flag_enable(f_new, BM_ELEM_TAG); l_new = BM_FACE_FIRST_LOOP(f_new); @@ -366,7 +366,7 @@ void bmo_wireframe_exec(BMesh *bm, BMOperator *op) BM_elem_attrs_copy(bm, bm, l, l_new->next); BM_elem_attrs_copy(bm, bm, l, l_new->next->next); - f_new = BM_face_create_quad_tri(bm, v_b1, v_b2, v_pos2, v_pos1, f_src, FALSE); + f_new = BM_face_create_quad_tri(bm, v_b1, v_b2, v_pos2, v_pos1, f_src, false); BM_elem_flag_enable(f_new, BM_ELEM_TAG); l_new = BM_FACE_FIRST_LOOP(f_new); diff --git a/source/blender/bmesh/tools/BME_bevel.c b/source/blender/bmesh/tools/BME_bevel.c index 5e1d58150fa..47b507603f4 100644 --- a/source/blender/bmesh/tools/BME_bevel.c +++ b/source/blender/bmesh/tools/BME_bevel.c @@ -90,7 +90,7 @@ static BME_TransData *BME_assign_transdata(BME_TransData_Head *td, BMesh *bm, BM float factor, float weight, float maxfactor, float *max) { BME_TransData *vtd; - int is_new = 0; + int is_new = false; if (v == NULL) { return NULL; @@ -100,7 +100,7 @@ static BME_TransData *BME_assign_transdata(BME_TransData_Head *td, BMesh *bm, BM vtd = BLI_memarena_alloc(td->ma, sizeof(*vtd)); BLI_ghash_insert(td->gh, v, vtd); td->len++; - is_new = 1; + is_new = true; } vtd->bm = bm; @@ -151,12 +151,12 @@ static void BME_Bevel_Dissolve_Disk(BMesh *bm, BMVert *v) { BMFace *f; BMEdge *e; - int done; + bool done; if (v->e) { - done = FALSE; + done = false; while (!done) { - done = TRUE; + done = true; e = v->e; /*loop the edge looking for a edge to dissolve*/ do { f = NULL; @@ -164,14 +164,14 @@ static void BME_Bevel_Dissolve_Disk(BMesh *bm, BMVert *v) f = bmesh_jfke(bm, e->l->f, e->l->radial_next->f, e); } if (f) { - done = FALSE; + done = false; break; } e = bmesh_disk_edge_next(e, v); } while (e != v->e); } - BM_vert_collapse_edge(bm, v->e, v, TRUE); - // bmesh_jekv(bm, v->e, v, FALSE); + BM_vert_collapse_edge(bm, v->e, v, true); + // bmesh_jekv(bm, v->e, v, false); } } @@ -539,18 +539,18 @@ static BMLoop *BME_bevel_edge(BMesh *bm, BMLoop *l, float value, int UNUSED(opti se = l->next->e; jf = NULL; if (kl->v == kv) { - BM_face_split(bm, kl->f, kl->prev->v, kl->next->v, &nl, kl->prev->e, TRUE); + BM_face_split(bm, kl->f, kl->prev->v, kl->next->v, &nl, kl->prev->e, true); ke = kl->e; /* BMESH-TODO: jfke doesn't handle customdata */ jf = bmesh_jfke(bm, kl->prev->radial_next->f, kl->f, kl->prev->e); - BM_vert_collapse_edge(bm, ke, kv, FALSE); + BM_vert_collapse_edge(bm, ke, kv, false); } else { - BM_face_split(bm, kl->f, kl->next->next->v, kl->v, &nl, kl->next->e, TRUE); + BM_face_split(bm, kl->f, kl->next->next->v, kl->v, &nl, kl->next->e, true); ke = kl->e; /* BMESH-TODO: jfke doesn't handle customdata */ jf = bmesh_jfke(bm, kl->next->radial_next->f, kl->f, kl->next->e); - BM_vert_collapse_edge(bm, ke, kv, FALSE); + BM_vert_collapse_edge(bm, ke, kv, false); } /* find saved loop pointer */ l = se->l; @@ -585,18 +585,18 @@ static BMLoop *BME_bevel_edge(BMesh *bm, BMLoop *l, float value, int UNUSED(opti se = l->e; jf = NULL; if (kl->v == kv) { - BM_face_split(bm, kl->f, kl->prev->v, kl->next->v, &nl, kl->prev->e, TRUE); + BM_face_split(bm, kl->f, kl->prev->v, kl->next->v, &nl, kl->prev->e, true); ke = kl->e; /* BMESH-TODO: jfke doesn't handle customdata */ jf = bmesh_jfke(bm, kl->prev->radial_next->f, kl->f, kl->prev->e); - BM_vert_collapse_edge(bm, ke, kv, FALSE); + BM_vert_collapse_edge(bm, ke, kv, false); } else { - BM_face_split(bm, kl->f, kl->next->next->v, kl->v, &nl, kl->next->e, TRUE); + BM_face_split(bm, kl->f, kl->next->next->v, kl->v, &nl, kl->next->e, true); ke = kl->e; /* BMESH-TODO: jfke doesn't handle customdata */ jf = bmesh_jfke(bm, kl->next->radial_next->f, kl->f, kl->next->e); - BM_vert_collapse_edge(bm, ke, kv, FALSE); + BM_vert_collapse_edge(bm, ke, kv, false); } /* find saved loop pointer */ l = se->l; @@ -607,7 +607,7 @@ static BMLoop *BME_bevel_edge(BMesh *bm, BMLoop *l, float value, int UNUSED(opti } if (!BMO_elem_flag_test(bm, v1, BME_BEVEL_NONMAN) || !BMO_elem_flag_test(bm, v2, BME_BEVEL_NONMAN)) { - BM_face_split(bm, f, v2, v1, &l, e, TRUE); + BM_face_split(bm, f, v2, v1, &l, e, true); BMO_elem_flag_enable(bm, l->e, BME_BEVEL_BEVEL); l = l->radial_next; } @@ -636,7 +636,7 @@ static BMLoop *BME_bevel_vert(BMesh *bm, BMLoop *l, float value, int UNUSED(opti l = l->next->next; /* "cut off" this corner */ - /* f = */ BM_face_split(bm, l->f, v2, v1, NULL, l->e, TRUE); + /* f = */ BM_face_split(bm, l->f, v2, v1, NULL, l->e, true); return l; } @@ -1069,7 +1069,7 @@ static BMesh *BME_bevel_mesh(BMesh *bm, float value, int UNUSED(res), int option /* get rid of beveled edge */ BM_ITER_MESH (e, &iter, bm, BM_EDGES_OF_MESH) { if (BMO_elem_flag_test(bm, e, BME_BEVEL_BEVEL) && BMO_elem_flag_test(bm, e, BME_BEVEL_ORIG)) { - BM_faces_join_pair(bm, e->l->f, e->l->radial_next->f, e, TRUE); + BM_faces_join_pair(bm, e->l->f, e->l->radial_next->f, e, true); } } @@ -1083,9 +1083,9 @@ static BMesh *BME_bevel_mesh(BMesh *bm, float value, int UNUSED(res), int option if (l->v != v) l = l->next; if (l2->v != v) l2 = l2->next; if (l->f->len > 3) - BM_face_split(bm, l->f, l->next->v, l->prev->v, &l, l->e, TRUE); /* clip this corner off */ + BM_face_split(bm, l->f, l->next->v, l->prev->v, &l, l->e, true); /* clip this corner off */ if (l2->f->len > 3) - BM_face_split(bm, l2->f, l2->next->v, l2->prev->v, &l, l2->e, TRUE); /* clip this corner off */ + BM_face_split(bm, l2->f, l2->next->v, l2->prev->v, &l, l2->e, true); /* clip this corner off */ curedge = bmesh_disk_edge_next(curedge, v); } while (curedge != v->e); BME_Bevel_Dissolve_Disk(bm, v); diff --git a/source/blender/bmesh/tools/bmesh_bevel.c b/source/blender/bmesh/tools/bmesh_bevel.c index a593e40d850..5461e5fe788 100644 --- a/source/blender/bmesh/tools/bmesh_bevel.c +++ b/source/blender/bmesh/tools/bmesh_bevel.c @@ -41,10 +41,8 @@ -/* experemental - Campbell */ -// #define USE_ALTERNATE_ADJ - -#define BEVEL_EPSILON 1e-6 +#define BEVEL_EPSILON_D 1e-6 +#define BEVEL_EPSILON 1e-6f /* for testing */ // #pragma GCC diagnostic error "-Wpadded" @@ -94,7 +92,7 @@ typedef struct VMesh { M_NONE, /* no polygon mesh needed */ M_POLY, /* a simple polygon */ M_ADJ, /* "adjacent edges" mesh pattern */ -// M_CROSS, /* "cross edges" mesh pattern */ + M_ADJ_SUBDIV, /* like M_ADJ, but using subdivision */ M_TRI_FAN, /* a simple polygon - fan filled */ M_QUAD_STRIP, /* a simple polygon - cut into paralelle strips */ } mesh_kind; @@ -124,7 +122,7 @@ typedef struct BevelParams { // #pragma GCC diagnostic ignored "-Wpadded" -//#include "bevdebug.c" +// #include "bevdebug.c" /* Make a new BoundVert of the given kind, insert it at the end of the circular linked * list with entry point bv->boundstart, and return it. */ @@ -323,7 +321,7 @@ static void offset_meet(EdgeHalf *e1, EdgeHalf *e2, BMVert *v, BMFace *f, sub_v3_v3v3(dir1, v->co, BM_edge_other_vert(e1->e, v)->co); sub_v3_v3v3(dir2, BM_edge_other_vert(e2->e, v)->co, v->co); - if (angle_v3v3(dir1, dir2) < 100.0f * (float)BEVEL_EPSILON) { + if (angle_v3v3(dir1, dir2) < 100.0f * BEVEL_EPSILON) { /* special case: e1 and e2 are parallel; put offset point perp to both, from v. * need to find a suitable plane. * if offsets are different, we're out of luck: just use e1->offset */ @@ -409,7 +407,7 @@ static void offset_in_two_planes(EdgeHalf *e1, EdgeHalf *e2, EdgeHalf *emid, madd_v3_v3fl(off2a, norm_perp2, e2->offset); add_v3_v3v3(off2b, off2a, dir2); - if (angle_v3v3(dir1, dir2) < 100.0f * (float)BEVEL_EPSILON) { + if (angle_v3v3(dir1, dir2) < 100.0f * BEVEL_EPSILON) { /* lines are parallel; off1a is a good meet point */ copy_v3_v3(meetco, off1a); } @@ -421,7 +419,7 @@ static void offset_in_two_planes(EdgeHalf *e1, EdgeHalf *e2, EdgeHalf *emid, } else if (iret == 2) { /* lines are not coplanar; meetco and isect2 are nearest to first and second lines */ - if (len_v3v3(meetco, isect2) > 100.0f * (float)BEVEL_EPSILON) { + if (len_v3v3(meetco, isect2) > 100.0f * BEVEL_EPSILON) { /* offset lines don't meet: project average onto emid; this is not ideal (see TODO above) */ mid_v3_v3v3(co, meetco, isect2); closest_to_line_v3(meetco, co, v->co, BM_edge_other_vert(emid->e, v)->co); @@ -470,7 +468,7 @@ static void slide_dist(EdgeHalf *e, BMVert *v, float d, float slideco[3]) sub_v3_v3v3(dir, v->co, BM_edge_other_vert(e->e, v)->co); len = normalize_v3(dir); if (d > len) - d = len - (float)(50.0 * BEVEL_EPSILON); + d = len - (float)(50.0 * BEVEL_EPSILON_D); copy_v3_v3(slideco, v->co); madd_v3_v3fl(slideco, dir, -d); } @@ -501,79 +499,6 @@ static int bev_ccw_test(BMEdge *a, BMEdge *b, BMFace *f) return lb->next == la ? 1 : -1; } -#ifdef USE_ALTERNATE_ADJ - -static void vmesh_cent(VMesh *vm, float r_cent[3]) -{ - BoundVert *v; - zero_v3(r_cent); - - v = vm->boundstart; - do { - add_v3_v3(r_cent, v->nv.co); - } while ((v = v->next) != vm->boundstart); - mul_v3_fl(r_cent, 1.0f / (float)vm->count); -} - -/** - * - * This example shows a tri fan of quads, - * but could be an NGon fan of quads too. - * <pre> - * The whole triangle X - * represents the / \ - * new bevel face. / \ - * / \ - * Split into / \ - * a quad fan. / \ - * / \ - * / \ - * / \ - * co_prev +-. .-+ - * / `-._ _.-' \ - * / co_cent`-+-' \ - * / | \ - * Quad of / | \ - * interest -- / ---> X | \ - * / | \ - * / | \ - * / co_next| \ - * co_orig +-----------------+-----------------+ - * - * For each quad, calcualte UV's based on the following: - * U = k / (vm->seg * 2) - * V = ring / (vm->seg * 2) - * quad = (co_orig, co_prev, co_cent, co_next) - * ... note that co_cent is the same for all quads in the fan. - * </pre> - * - */ - -static void get_point_uv(float uv[2], - /* all these args are int's originally - * but pass as floats to the function */ - const float seg, const float ring, const float k) -{ - uv[0] = (ring / seg) * 2.0f; - uv[1] = (k / seg) * 2.0f; -} - -/* TODO: make this a lot smarter!, - * this is the main reason USE_ALTERNATE_ADJ isn't so good right now :S */ -static float get_point_uv_factor(const float uv[2]) -{ - return sinf(1.0f - max_ff(uv[0], uv[1]) / 2.0f); -} - -static void get_point_on_round_edge(const float uv[2], - float quad[4][3], - float r_co[3]) -{ - interp_bilinear_quad_v3(quad, uv[0], uv[1], r_co); -} - -#else /* USE_ALTERNATE_ADJ */ - /* Fill matrix r_mat so that a point in the sheared parallelogram with corners * va, vmid, vb (and the 4th that is implied by it being a parallelogram) * is transformed to the unit square by multiplication with r_mat. @@ -601,7 +526,7 @@ static int make_unit_square_map(const float va[3], const float vmid[3], const fl sub_v3_v3v3(va_vmid, vmid, va); sub_v3_v3v3(vb_vmid, vmid, vb); - if (fabsf(angle_v3v3(va_vmid, vb_vmid) - (float)M_PI) > 100.f *(float)BEVEL_EPSILON) { + if (fabsf(angle_v3v3(va_vmid, vb_vmid) - (float)M_PI) > 100.0f * BEVEL_EPSILON) { sub_v3_v3v3(vo, va, vb_vmid); cross_v3_v3v3(vddir, vb_vmid, va_vmid); normalize_v3(vddir); @@ -694,8 +619,6 @@ static void snap_to_edge_profile(EdgeHalf *e, const float va[3], const float vb[ } } -#endif /* !USE_ALTERNATE_ADJ */ - /* Make a circular list of BoundVerts for bv, each of which has the coordinates * of a vertex on the the boundary of the beveled vertex bv->v. * Also decide on the mesh pattern that will be used inside the boundary. @@ -811,7 +734,10 @@ static void build_boundary(BevelParams *bp, BevVert *bv) } while ((e = e->next) != efirst); BLI_assert(vm->count >= 2); - if (vm->count == 2 && bv->edgecount == 3) { + if (bp->vertex_only) { + vm->mesh_kind = bp->seg > 1 ? M_ADJ_SUBDIV : M_POLY; + } + else if (vm->count == 2 && bv->edgecount == 3) { vm->mesh_kind = M_NONE; } else if (bv->selcount == 2) { @@ -846,19 +772,6 @@ static void bevel_build_rings(BMesh *bm, BevVert *bv) float co[3], coa[3], cob[3], midco[3]; float va_pipe[3], vb_pipe[3]; -#ifdef USE_ALTERNATE_ADJ - /* ordered as follows (orig, prev, center, next)*/ - float quad_plane[4][3]; - float quad_orig[4][3]; -#endif - - -#ifdef USE_ALTERNATE_ADJ - /* the rest are initialized inline, this remains the same for all */ - vmesh_cent(vm, quad_plane[2]); - copy_v3_v3(quad_orig[2], bv->v->co); -#endif - n = vm->count; ns = vm->seg; ns2 = ns / 2; @@ -875,7 +788,7 @@ static void bevel_build_rings(BMesh *bm, BevVert *bv) float dir1[3], dir2[3]; sub_v3_v3v3(dir1, bv->v->co, BM_edge_other_vert(e1->e, bv->v)->co); sub_v3_v3v3(dir2, BM_edge_other_vert(e2->e, bv->v)->co, bv->v->co); - if (angle_v3v3(dir1, dir2) < 100.0f * (float)BEVEL_EPSILON) { + if (angle_v3v3(dir1, dir2) < 100.0f * BEVEL_EPSILON) { epipe = e1; break; } @@ -918,37 +831,6 @@ static void bevel_build_rings(BMesh *bm, BevVert *bv) copy_v3_v3(nv->co, cob); nv->v = nvnext->v; -#ifdef USE_ALTERNATE_ADJ - /* plane */ - copy_v3_v3(quad_plane[0], v->nv.co); - mid_v3_v3v3(quad_plane[1], v->nv.co, v->prev->nv.co); - /* quad[2] is set */ - mid_v3_v3v3(quad_plane[3], v->nv.co, v->next->nv.co); - - /* orig */ - copy_v3_v3(quad_orig[0], v->nv.co); /* only shared location between 2 quads */ - project_to_edge(v->ebev->prev->e, v->nv.co, v->prev->nv.co, quad_orig[1]); - project_to_edge(v->ebev->e, v->nv.co, v->next->nv.co, quad_orig[3]); - - //bl_debug_draw_quad_add(UNPACK4(quad_plane)); - //bl_debug_draw_quad_add(UNPACK4(quad_orig)); -#endif - -#ifdef USE_ALTERNATE_ADJ - for (k = 1; k < ns; k++) { - float uv[2]; - float fac; - float co_plane[3]; - float co_orig[3]; - - get_point_uv(uv, v->ebev->seg, ring, k); - get_point_on_round_edge(uv, quad_plane, co_plane); - get_point_on_round_edge(uv, quad_orig, co_orig); - fac = get_point_uv_factor(uv); - interp_v3_v3v3(co, co_plane, co_orig, fac); - copy_v3_v3(mesh_vert(vm, i, ring, k)->co, co); - } -#else /* TODO: better calculation of new midarc point? */ project_to_edge(v->ebev->e, coa, cob, midco); @@ -962,7 +844,6 @@ static void bevel_build_rings(BMesh *bm, BevVert *bv) copy_v3_v3(va_pipe, mesh_vert(vm, i, 0, 0)->co); copy_v3_v3(vb_pipe, mesh_vert(vm, i, 0, ns)->co); } -#endif } } while ((v = v->next) != vm->boundstart); } @@ -990,9 +871,7 @@ static void bevel_build_rings(BMesh *bm, BevVert *bv) if (epipe) snap_to_edge_profile(epipe, va_pipe, vb_pipe, co); -#ifndef USE_ALTERNATE_ADJ copy_v3_v3(nv->co, co); -#endif BLI_assert(nv->v == NULL && nvprev->v == NULL); create_mesh_bmvert(bm, vm, i, ring, k, bv->v); copy_mesh_vert(vm, vprev->index, k, ns - ring, i, ring, k); @@ -1041,9 +920,7 @@ static void bevel_build_rings(BMesh *bm, BevVert *bv) mid_v3_v3v3v3(co, nvprev->co, nv->co, nvnext->co); if (epipe) snap_to_edge_profile(epipe, va_pipe, vb_pipe, co); -#ifndef USE_ALTERNATE_ADJ copy_v3_v3(nv->co, co); -#endif create_mesh_bmvert(bm, vm, i, k, ns2, bv->v); copy_mesh_vert(vm, vprev->index, ns2, ns - k, i, k, ns2); copy_mesh_vert(vm, vnext->index, ns2, k, i, k, ns2); @@ -1053,9 +930,7 @@ static void bevel_build_rings(BMesh *bm, BevVert *bv) mid_v3_v3v3(co, nvprev->co, nv->co); if (epipe) snap_to_edge_profile(epipe, va_pipe, vb_pipe, co); -#ifndef USE_ALTERNATE_ADJ copy_v3_v3(nv->co, co); -#endif create_mesh_bmvert(bm, vm, i, k, ns2, bv->v); copy_mesh_vert(vm, vprev->index, ns2, ns - k, i, k, ns2); @@ -1065,9 +940,7 @@ static void bevel_build_rings(BMesh *bm, BevVert *bv) mid_v3_v3v3(co, nv->co, nvnext->co); if (epipe) snap_to_edge_profile(epipe, va_pipe, vb_pipe, co); -#ifndef USE_ALTERNATE_ADJ copy_v3_v3(nv->co, co); -#endif create_mesh_bmvert(bm, vm, i, k, ns2, bv->v); copy_mesh_vert(vm, vnext->index, ns2, k, i, k, ns2); @@ -1220,6 +1093,413 @@ static void bevel_build_rings(BMesh *bm, BevVert *bv) } } +static VMesh *new_adj_subdiv_vmesh(MemArena *mem_arena, int count, int seg, BoundVert *bounds) +{ + VMesh *vm; + + vm = (VMesh *)BLI_memarena_alloc(mem_arena, sizeof(VMesh)); + vm->count = count; + vm->seg = seg; + vm->boundstart = bounds; + vm->mesh = (NewVert *)BLI_memarena_alloc(mem_arena, count * (1 + seg / 2) * (1 + seg) * sizeof(NewVert)); + vm->mesh_kind = M_ADJ_SUBDIV; + return vm; +} + +/* VMesh verts for vertex i have data for (i, 0 <= j <= ns2, 0 <= k <= ns), where ns2 = floor(nseg / 2). + * But these overlap data from previous and next i: there are some forced equivalences. + * Let's call these indices the canonical ones: we will just calculate data for these + * 0 <= j <= ns2, 0 <= k < ns2 (for odd ns2) + * 0 <= j < ns2, 0 <= k <= ns2 (for even ns2) + * also (j=ns2, k=ns2) at i=0 (for even ns2) + * This function returns the canonical one for any i, j, k in [0,n],[0,ns],[0,ns] */ +static NewVert *mesh_vert_canon(VMesh *vm, int i, int j, int k) +{ + int n, ns, ns2, odd; + NewVert *ans; + + n = vm->count; + ns = vm->seg; + ns2 = ns / 2; + odd = ns % 2; + BLI_assert(0 <= i && i <= n && 0 <= j && j <= ns && 0 <= k && k <= ns); + + if (!odd && j == ns2 && k == ns2) + ans = mesh_vert(vm, 0, j, k); + else if (j <= ns2 - 1 + odd && k <= ns2) + ans = mesh_vert(vm, i, j, k); + else if (k <= ns2) + ans = mesh_vert(vm, (i + n - 1) % n, k, ns - j); + else + ans = mesh_vert(vm, (i + 1) % n, ns - k, j); + return ans; +} + +static int is_canon(VMesh *vm, int i, int j, int k) +{ + int ns2 = vm->seg / 2; + if (vm->seg % 2 == 1) + return (j <= ns2 && k <= ns2); + else + return ((j < ns2 && k <= ns2) || (j == ns2 && k == ns2 && i == 0)); +} + +/* Copy the vertex data to all of vm verts from canonical ones */ +static void vmesh_copy_equiv_verts(VMesh *vm) +{ + int n, ns, ns2, i, j, k; + NewVert *v0, *v1; + + n = vm->count; + ns = vm->seg; + ns2 = ns / 2; + for (i = 0; i < n; i++) { + for (j = 0; j <= ns2; j++) { + for (k = 0; k <= ns; k++) { + if (is_canon(vm, i, j, k)) + continue; + v1 = mesh_vert(vm, i, j, k); + v0 = mesh_vert_canon(vm, i, j, k); + copy_v3_v3(v1->co, v0->co); + v1->v = v0->v; + } + } + } +} + +/* Calculate and return in r_cent the centroid of the center poly */ +static void vmesh_center(VMesh *vm, float r_cent[3]) +{ + int n, ns2, i; + + n = vm->count; + ns2 = vm->seg / 2; + if (vm->seg % 2) { + zero_v3(r_cent); + for (i = 0; i < n; i++) { + add_v3_v3(r_cent, mesh_vert(vm, i, ns2, ns2)->co); + } + mul_v3_fl(r_cent, 1.0f / (float) n); + } + else { + copy_v3_v3(r_cent, mesh_vert(vm, 0, ns2, ns2)->co); + } +} + +/* Do one step of quadratic subdivision (Doo-Sabin), with special rules at boundaries. + * For now, this is written assuming vm0->nseg is odd. + * See Hwang-Chuang 2003 paper: "N-sided hole filling and vertex blending using subdivision surfaces" */ +static VMesh *quadratic_subdiv(MemArena *mem_arena, VMesh *vm0) +{ + int n, ns0, ns20, ns1 /*, ns21 */; + int i, j, k, j1, k1; + VMesh *vm1; + float co[3], co1[3], co2[3], co3[3], co4[3]; + float co11[3], co21[3], co31[3], co41[3]; + float denom; + const float wcorner[4] = {0.25f, 0.25f, 0.25f, 0.25f}; + const float wboundary[4] = {0.375f, 0.375f, 0.125f, 0.125f}; /* {3, 3, 1, 1}/8 */ + const float winterior[4] = {0.5625f, 0.1875f, 0.1875f, 0.0625f}; /* {9, 3, 3, 1}/16 */ + + n = vm0->count; + ns0 = vm0->seg; + ns20 = ns0 / 2; + BLI_assert(ns0 % 2 == 1); + + ns1 = 2 * ns0 - 1; + // ns21 = ns1 / 2; /* UNUSED */ + vm1 = new_adj_subdiv_vmesh(mem_arena, n, ns1, vm0->boundstart); + + for (i = 0; i < n; i ++) { + /* For handle vm0 polys with lower left corner at (i,j,k) for + * j in [0, ns20], k in [0, ns20]; then the center ngon. + * but only fill in data for canonical verts of v1. */ + for (j = 0; j <= ns20; j++) { + for (k = 0; k <= ns20; k++) { + if (j == ns20 && k == ns20) + continue; /* center ngon is special */ + copy_v3_v3(co1, mesh_vert_canon(vm0, i, j, k)->co); + copy_v3_v3(co2, mesh_vert_canon(vm0, i, j, k + 1)->co); + copy_v3_v3(co3, mesh_vert_canon(vm0, i, j + 1, k + 1)->co); + copy_v3_v3(co4, mesh_vert_canon(vm0, i, j + 1, k)->co); + if (j == 0 && k == 0) { + /* corner */ + copy_v3_v3(co11, co1); + interp_v3_v3v3(co21, co1, co2, 0.5f); + interp_v3_v3v3v3v3(co31, co1, co2, co3, co4, wcorner); + interp_v3_v3v3(co41, co1, co4, 0.5f); + } + else if (j == 0) { + /* ring 0 boundary */ + interp_v3_v3v3(co11, co1, co2, 0.25f); + interp_v3_v3v3(co21, co1, co2, 0.75f); + interp_v3_v3v3v3v3(co31, co2, co3, co1, co4, wboundary); + interp_v3_v3v3v3v3(co41, co1, co4, co2, co3, wboundary); + } + else if (k == 0) { + /* ring-starts boundary */ + interp_v3_v3v3(co11, co1, co4, 0.25f); + interp_v3_v3v3v3v3(co21, co1, co2, co3, co4, wboundary); + interp_v3_v3v3v3v3(co31, co3, co4, co1, co2, wboundary); + interp_v3_v3v3(co41, co1, co4, 0.75f); + } + else { + /* interior */ + interp_v3_v3v3v3v3(co11, co1, co2, co4, co3, winterior); + interp_v3_v3v3v3v3(co21, co2, co1, co3, co4, winterior); + interp_v3_v3v3v3v3(co31, co3, co2, co4, co1, winterior); + interp_v3_v3v3v3v3(co41, co4, co1, co3, co2, winterior); + } + j1 = 2 * j; + k1 = 2 * k; + if (is_canon(vm1, i, j1, k1)) + copy_v3_v3(mesh_vert(vm1, i, j1, k1)->co, co11); + if (is_canon(vm1, i, j1, k1 + 1)) + copy_v3_v3(mesh_vert(vm1, i, j1, k1 + 1)->co, co21); + if (is_canon(vm1, i, j1 + 1, k1 + 1)) + copy_v3_v3(mesh_vert(vm1, i, j1 + 1, k1 + 1)->co, co31); + if (is_canon(vm1, i, j1 + 1, k1)) + copy_v3_v3(mesh_vert(vm1, i, j1 + 1, k1)->co, co41); + } + } + + /* center ngon */ + denom = 8.0f * (float) n; + zero_v3(co); + for (j = 0; j < n; j++) { + copy_v3_v3(co1, mesh_vert(vm0, j, ns20, ns20)->co); + if (i == j) + madd_v3_v3fl(co, co1, (4.0f * (float) n + 2.0f) / denom); + else if ((i + 1) % n == j || (i + n - 1) % n == j) + madd_v3_v3fl(co, co1, ((float) n + 2.0f) / denom); + else + madd_v3_v3fl(co, co1, 2.0f / denom); + } + copy_v3_v3(mesh_vert(vm1, i, 2 * ns20, 2 * ns20)->co, co); + } + + vmesh_copy_equiv_verts(vm1); + return vm1; +} + +/* After a step of quadratic_subdiv, adjust the ring 1 verts to be on the planes of their respective faces, + * so that the cross-tangents will match on further subdivision. */ +static void fix_vmesh_tangents(VMesh *vm, BevVert *bv) +{ + int i, n; + NewVert *v; + BoundVert *bndv; + float co[3]; + + n = vm->count; + bndv = vm->boundstart; + do { + i = bndv->index; + + /* (i, 1, 1) snap to edge line */ + v = mesh_vert(vm, i, 1, 1); + closest_to_line_v3(co, v->co, bndv->nv.co, bv->v->co); + copy_v3_v3(v->co, co); + copy_v3_v3(mesh_vert(vm, (i + n -1) % n, 1, vm->seg - 1)->co, co); + + /* Also want (i, 1, k) snapped to plane of adjacent face for + * 1 < k < ns - 1, but current initial cage and subdiv rules + * ensure this, so nothing to do */ + } while ((bndv = bndv->next) != vm->boundstart); +} + +/* Fill frac with fractions of way along ring 0 for vertex i, for use with interp_range function */ +static void fill_vmesh_fracs(VMesh *vm, float *frac, int i) +{ + int k, ns; + float total = 0.0f; + + ns = vm->seg; + frac[0] = 0.0f; + for (k = 0; k < ns; k++) { + total += len_v3v3(mesh_vert(vm, i, 0, k)->co, mesh_vert(vm, i, 0, k + 1)->co); + frac[k + 1] = total; + } + if (total > BEVEL_EPSILON) { + for (k = 1; k <= ns; k++) + frac[k] /= total; + } +} + +/* Return i such that frac[i] <= f <= frac[i + 1], where frac[n] == 1.0 + * and put fraction of rest of way between frac[i] and frac[i + 1] into r_rest */ +static int interp_range(const float *frac, int n, const float f, float *r_rest) +{ + int i; + float rest; + + /* could binary search in frac, but expect n to be reasonably small */ + for (i = 0; i < n; i++) { + if (f <= frac[i + 1]) { + rest = f - frac[i]; + if (rest == 0) + *r_rest = 0.0f; + else + *r_rest = rest / (frac[i + 1] - frac[i]); + return i; + } + } + *r_rest = 0.0f; + return n; +} + +/* Interpolate given vmesh to make one with target nseg and evenly spaced border vertices */ +static VMesh *interp_vmesh(MemArena *mem_arena, VMesh *vm0, int nseg) +{ + int n, ns0, nseg2, odd, i, j, k, j0, k0; + float *prev_frac, *frac, f, restj, restk; + float quad[4][3], co[3], center[3]; + VMesh *vm1; + + n = vm0->count; + ns0 = vm0->seg; + nseg2 = nseg / 2; + odd = nseg % 2; + vm1 = new_adj_subdiv_vmesh(mem_arena, n, nseg, vm0->boundstart); + prev_frac = (float *)BLI_memarena_alloc(mem_arena, (ns0 + 1 ) *sizeof(float)); + frac = (float *)BLI_memarena_alloc(mem_arena, (ns0 + 1 ) *sizeof(float)); + + fill_vmesh_fracs(vm0, prev_frac, n - 1); + fill_vmesh_fracs(vm0, frac, 0); + for (i = 0; i < n; i++) { + for (j = 0; j <= nseg2 -1 + odd; j++) { + for (k = 0; k <= nseg2; k++) { + f = (float) k / (float) nseg; + k0 = interp_range(frac, ns0, f, &restk); + f = 1.0f - (float) j / (float) nseg; + j0 = interp_range(prev_frac, ns0, f, &restj); + if (restj < BEVEL_EPSILON) { + j0 = ns0 - j0; + restj = 0.0f; + } + else { + j0 = ns0 - j0 - 1; + restj = 1.0f - restj; + } + /* Use bilinear interpolation within the source quad; could be smarter here */ + if (restj < BEVEL_EPSILON && restk < BEVEL_EPSILON) { + copy_v3_v3(co, mesh_vert_canon(vm0, i, j0, k0)->co); + } + else { + copy_v3_v3(quad[0], mesh_vert_canon(vm0, i, j0, k0)->co); + copy_v3_v3(quad[1], mesh_vert_canon(vm0, i, j0, k0 + 1)->co); + copy_v3_v3(quad[2], mesh_vert_canon(vm0, i, j0 + 1, k0 + 1)->co); + copy_v3_v3(quad[3], mesh_vert_canon(vm0, i, j0 + 1, k0)->co); + interp_bilinear_quad_v3(quad, restk, restj, co); + } + copy_v3_v3(mesh_vert(vm1, i, j, k)->co, co); + } + } + } + if (!odd) { + vmesh_center(vm0, center); + copy_v3_v3(mesh_vert(vm1, 0, nseg2, nseg2)->co, center); + } + vmesh_copy_equiv_verts(vm1); + return vm1; +} + +/* + * Given that the boundary is built and the boundary BMVerts have been made, + * calculate the positions of the interior mesh points for the M_ADJ_SUBDIV pattern, + * then make the BMVerts and the new faces. */ +static void bevel_build_rings_subdiv(BevelParams *bp, BMesh *bm, BevVert *bv) +{ + int n, ns, ns2, odd, i, j, k; + VMesh *vm0, *vm1, *vm; + float coa[3], cob[3], coc[3]; + BoundVert *v; + BMVert *bmv1, *bmv2, *bmv3, *bmv4; + BMFace *f; + MemArena *mem_arena = bp->mem_arena; + const float fullness = 0.5f; + + n = bv->edgecount; + ns = bv->vmesh->seg; + ns2 = ns / 2; + odd = ns % 2; + BLI_assert(n >= 3 && ns > 1); + + /* First construct an initial control mesh, with nseg==3 */ + vm0 = new_adj_subdiv_vmesh(mem_arena, n, 3, bv->vmesh->boundstart); + + for (i = 0; i < n; i++) { + /* Boundaries just divide input polygon edges into 3 even segments */ + copy_v3_v3(coa, mesh_vert(bv->vmesh, i, 0, 0)->co); + copy_v3_v3(cob, mesh_vert(bv->vmesh, (i + 1) % n, 0, 0)->co); + copy_v3_v3(coc, mesh_vert(bv->vmesh, (i + n -1) % n, 0, 0)->co); + copy_v3_v3(mesh_vert(vm0, i, 0, 0)->co, coa); + interp_v3_v3v3(mesh_vert(vm0, i, 0, 1)->co, coa, cob, 1.0f / 3.0f); + interp_v3_v3v3(mesh_vert(vm0, i, 1, 0)->co, coa, coc, 1.0f / 3.0f); + interp_v3_v3v3(mesh_vert(vm0, i, 1, 1)->co, coa, bv->v->co, fullness); + } + vmesh_copy_equiv_verts(vm0); + + vm1 = vm0; + do { + vm1 = quadratic_subdiv(mem_arena, vm1); + fix_vmesh_tangents(vm1, bv); + } while (vm1->seg <= ns); + vm1 = interp_vmesh(mem_arena, vm1, ns); + + /* copy final vmesh into bv->vmesh, make BMVerts and BMFaces */ + vm = bv->vmesh; + for (i = 0; i < n; i ++) { + for (j = 0; j <= ns2; j++) { + for (k = 0; k <= ns; k++) { + if (j == 0 && (k == 0 || k == ns)) + continue; /* boundary corners already made */ + if (!is_canon(vm, i, j, k)) + continue; + copy_v3_v3(mesh_vert(vm, i, j, k)->co, mesh_vert(vm1, i, j, k)->co); + create_mesh_bmvert(bm, vm, i, j, k, bv->v); + } + } + } + vmesh_copy_equiv_verts(vm); + /* make the polygons */ + v = vm->boundstart; + do { + i = v->index; + f = boundvert_rep_face(v); + /* For odd ns, make polys with lower left corner at (i,j,k) for + * j in [0, ns2-1], k in [0, ns2]. And then the center ngon. + * For even ns, + * j in [0, ns2-1], k in [0, ns2-1] */ + for (j = 0; j < ns2; j++) { + for (k = 0; k < ns2 + odd; k++) { + bmv1 = mesh_vert(vm, i, j, k)->v; + bmv2 = mesh_vert(vm, i, j, k + 1)->v; + bmv3 = mesh_vert(vm, i, j + 1, k + 1)->v; + bmv4 = mesh_vert(vm, i, j + 1, k)->v; + BLI_assert(bmv1 && bmv2 && bmv3 && bmv4); + bev_create_quad_tri(bm, bmv1, bmv2, bmv3, bmv4, f); + } + } + } while ((v = v->next) != vm->boundstart); + + /* center ngon */ + if (odd) { + BMVert **vv = NULL; + BLI_array_staticdeclare(vv, BM_DEFAULT_NGON_STACK_SIZE); + + v = vm->boundstart; + do { + i = v->index; + BLI_array_append(vv, mesh_vert(vm, i, ns2, ns2)->v); + } while ((v = v->next) != vm->boundstart); + f = boundvert_rep_face(vm->boundstart); + bev_create_ngon(bm, vv, BLI_array_count(vv), f); + + BLI_array_free(vv); + } +} + static BMFace *bevel_build_poly_ex(BMesh *bm, BevVert *bv) { BMFace *f; @@ -1339,24 +1619,7 @@ static void build_vmesh(BevelParams *bp, BMesh *bm, BevVert *bv) BoundVert *v, *weld1, *weld2; int n, ns, ns2, i, k, weld; float *va, *vb, co[3]; - -#ifdef USE_ALTERNATE_ADJ - /* ordered as follows (orig, prev, center, next)*/ - float quad_plane[4][3]; - float quad_orig_a[4][3]; - float quad_orig_b[4][3]; - const int is_odd = (vm->seg % 2); -#else float midco[3]; -#endif - -#ifdef USE_ALTERNATE_ADJ - /* the rest are initialized inline, this remains the same for all */ - /* NOTE; in this usage we only interpolate on the 'V' so cent and next points are unused (2,3)*/ - vmesh_cent(vm, quad_plane[2]); - copy_v3_v3(quad_orig_a[2], bv->v->co); - copy_v3_v3(quad_orig_b[2], bv->v->co); -#endif n = vm->count; ns = vm->seg; @@ -1389,59 +1652,6 @@ static void build_vmesh(BevelParams *bp, BMesh *bm, BevVert *bv) i = v->index; copy_mesh_vert(vm, i, 0, ns, v->next->index, 0, 0); if (v->ebev) { - -#ifdef USE_ALTERNATE_ADJ - copy_v3_v3(quad_plane[0], v->nv.co); - mid_v3_v3v3(quad_plane[1], v->nv.co, v->prev->nv.co); - /* quad[2] is set */ - mid_v3_v3v3(quad_plane[3], v->nv.co, v->next->nv.co); - - /* orig 'A' */ - copy_v3_v3(quad_orig_a[0], v->nv.co); /* only shared location between 2 quads */ - project_to_edge(v->ebev->prev->e, v->nv.co, v->prev->nv.co, quad_orig_a[1]); - project_to_edge(v->ebev->e, v->nv.co, v->next->nv.co, quad_orig_a[3]); - - /* orig 'B' */ - copy_v3_v3(quad_orig_b[3], v->next->nv.co); /* only shared location between 2 quads */ - project_to_edge(v->ebev->prev->e, v->nv.co, v->prev->nv.co, quad_orig_b[1]); - project_to_edge(v->ebev->e, v->nv.co, v->next->nv.co, quad_orig_b[0]); - - //bl_debug_draw_quad_add(UNPACK4(quad_plane)); - //bl_debug_draw_quad_add(UNPACK4(quad_orig_a)); - //bl_debug_draw_quad_add(UNPACK4(quad_orig_b)); -#endif /* USE_ALTERNATE_ADJ */ - -#ifdef USE_ALTERNATE_ADJ - for (k = 1; k < ns; k++) { - float uv[2]; - float fac; - float co_plane[3]; - float co_orig[3]; - - /* quad_plane */ - get_point_uv(uv, v->ebev->seg, 0, k); - get_point_on_round_edge(uv, quad_plane, co_plane); - - /* quad_orig */ - /* each half has different UV's */ - if (k <= ns2) { - get_point_uv(uv, v->ebev->seg, 0, k); - get_point_on_round_edge(uv, quad_orig_a, co_orig); - } - else { - get_point_uv(uv, v->ebev->seg, 0, (k - ns2) - (is_odd ? 0.5f : 0.0f)); - get_point_on_round_edge(uv, quad_orig_b, co_orig); - uv[1] = 1.0f - uv[1]; /* so we can get the factor */ - } - fac = get_point_uv_factor(uv); - - /* done. interp */ - interp_v3_v3v3(co, co_plane, co_orig, fac); - copy_v3_v3(mesh_vert(vm, i, 0, k)->co, co); - if (!weld) - create_mesh_bmvert(bm, vm, i, 0, k, bv->v); - } -#else /* USE_ALTERNATE_ADJ */ va = mesh_vert(vm, i, 0, 0)->co; vb = mesh_vert(vm, i, 0, ns)->co; project_to_edge(v->ebev->e, va, vb, midco); @@ -1451,7 +1661,6 @@ static void build_vmesh(BevelParams *bp, BMesh *bm, BevVert *bv) if (!weld) create_mesh_bmvert(bm, vm, i, 0, k, bv->v); } -#endif /* !USE_ALTERNATE_ADJ */ } } while ((v = v->next) != vm->boundstart); @@ -1478,6 +1687,9 @@ static void build_vmesh(BevelParams *bp, BMesh *bm, BevVert *bv) case M_ADJ: bevel_build_rings(bm, bv); break; + case M_ADJ_SUBDIV: + bevel_build_rings_subdiv(bp, bm, bv); + break; case M_TRI_FAN: bevel_build_trifan(bm, bv); break; @@ -1687,6 +1899,14 @@ static int bev_rebuild_polygon(BMesh *bm, BevelParams *bp, BMFace *f) BLI_array_append(vv, bmv); } } + else if (bp->vertex_only && vm->mesh_kind == M_ADJ_SUBDIV && vm->seg > 1) { + BLI_assert(v->prev == vend); + i = vend->index; + for (k = vm->seg - 1; k > 0; k--) { + bmv = mesh_vert(vm, i, 0, k)->v; + BLI_array_append(vv, bmv); + } + } v = v->prev; BLI_array_append(vv, v->nv.v); } diff --git a/source/blender/bmesh/tools/bmesh_decimate.h b/source/blender/bmesh/tools/bmesh_decimate.h index 4a557c20ae3..d3eaf1c6670 100644 --- a/source/blender/bmesh/tools/bmesh_decimate.h +++ b/source/blender/bmesh/tools/bmesh_decimate.h @@ -27,15 +27,15 @@ * \ingroup bmesh */ -void BM_mesh_decimate_collapse(BMesh *bm, const float factor, float *vweights, const int do_triangulate); +void BM_mesh_decimate_collapse(BMesh *bm, const float factor, float *vweights, const bool do_triangulate); -void BM_mesh_decimate_unsubdivide_ex(BMesh *bm, const int iterations, const int tag_only); +void BM_mesh_decimate_unsubdivide_ex(BMesh *bm, const int iterations, const bool tag_only); void BM_mesh_decimate_unsubdivide(BMesh *bm, const int iterations); -void BM_mesh_decimate_dissolve_ex(BMesh *bm, const float angle_limit, const int do_dissolve_boundaries, +void BM_mesh_decimate_dissolve_ex(BMesh *bm, const float angle_limit, const bool do_dissolve_boundaries, BMVert **vinput_arr, const int vinput_len, BMEdge **einput_arr, const int einput_len); -void BM_mesh_decimate_dissolve(BMesh *bm, const float angle_limit, const int do_dissolve_boundaries); +void BM_mesh_decimate_dissolve(BMesh *bm, const float angle_limit, const bool do_dissolve_boundaries); /* these weights are accumulated so too high values may reach 'inf' too quickly */ #define BM_MESH_DECIM_WEIGHT_MAX 100000.0f diff --git a/source/blender/bmesh/tools/bmesh_decimate_collapse.c b/source/blender/bmesh/tools/bmesh_decimate_collapse.c index 794afb3e0d2..e94bb9f5417 100644 --- a/source/blender/bmesh/tools/bmesh_decimate_collapse.c +++ b/source/blender/bmesh/tools/bmesh_decimate_collapse.c @@ -134,7 +134,7 @@ static void bm_decim_calc_target_co(BMEdge *e, float optimize_co[3], } } -static int bm_edge_collapse_is_degenerate_flip(BMEdge *e, const float optimize_co[3]) +static bool bm_edge_collapse_is_degenerate_flip(BMEdge *e, const float optimize_co[3]) { BMIter liter; BMLoop *l; @@ -175,13 +175,13 @@ static int bm_edge_collapse_is_degenerate_flip(BMEdge *e, const float optimize_c * (first making it zero area, then flipping again) */ if (dot_v3v3(cross_exist, cross_optim) <= FLT_EPSILON) { //printf("no flip\n"); - return TRUE; + return true; } } } } - return FALSE; + return false; } static void bm_decim_build_edge_cost_single(BMEdge *e, @@ -291,15 +291,15 @@ static void bm_decim_build_edge_cost(BMesh *bm, * collapsing edges so even has some advantage over decimating quads * directly. * - * \return TRUE if any faces were triangulated. + * \return true if any faces were triangulated. */ -static int bm_decim_triangulate_begin(BMesh *bm) +static bool bm_decim_triangulate_begin(BMesh *bm) { BMIter iter; BMFace *f; - // int has_quad; // could optimize this a little - int has_cut = FALSE; + // bool has_quad; // could optimize this a little + bool has_cut = false; BLI_assert((bm->elem_index_dirty & BM_VERT) == 0); @@ -345,7 +345,7 @@ static int bm_decim_triangulate_begin(BMesh *bm) } #ifdef USE_SAFETY_CHECKS - if (BM_edge_exists(l_a->v, l_b->v) == FALSE) + if (BM_edge_exists(l_a->v, l_b->v) == false) #endif { BMFace *f_new; @@ -355,7 +355,7 @@ static int bm_decim_triangulate_begin(BMesh *bm) * - if there is a quad that has a free standing edge joining it along * where we want to split the face, there isnt a good way we can handle this. * currently that edge will get removed when joining the tris back into a quad. */ - f_new = BM_face_split(bm, f, l_a->v, l_b->v, &l_new, NULL, FALSE); + f_new = BM_face_split(bm, f, l_a->v, l_b->v, &l_new, NULL, false); if (f_new) { /* the value of this doesn't matter, only that the 2 loops match and have unique values */ @@ -370,7 +370,7 @@ static int bm_decim_triangulate_begin(BMesh *bm) BM_face_normal_update(f); BM_face_normal_update(f_new); - has_cut = TRUE; + has_cut = true; } } } @@ -410,15 +410,15 @@ static void bm_decim_triangulate_end(BMesh *bm) BM_vert_in_edge(e, l_b->next->v) ? l_b->prev->v : l_b->next->v, }; - BLI_assert(ELEM3(vquad[0], vquad[1], vquad[2], vquad[3]) == FALSE); - BLI_assert(ELEM3(vquad[1], vquad[0], vquad[2], vquad[3]) == FALSE); - BLI_assert(ELEM3(vquad[2], vquad[1], vquad[0], vquad[3]) == FALSE); - BLI_assert(ELEM3(vquad[3], vquad[1], vquad[2], vquad[0]) == FALSE); + BLI_assert(ELEM3(vquad[0], vquad[1], vquad[2], vquad[3]) == false); + BLI_assert(ELEM3(vquad[1], vquad[0], vquad[2], vquad[3]) == false); + BLI_assert(ELEM3(vquad[2], vquad[1], vquad[0], vquad[3]) == false); + BLI_assert(ELEM3(vquad[3], vquad[1], vquad[2], vquad[0]) == false); if (is_quad_convex_v3(vquad[0]->co, vquad[1]->co, vquad[2]->co, vquad[3]->co)) { /* highly unlikely to fail, but prevents possible double-ups */ BMFace *f[2] = {l_a->f, l_b->f}; - BM_faces_join(bm, f, 2, TRUE); + BM_faces_join(bm, f, 2, true); } } } @@ -445,7 +445,7 @@ static void bm_edge_collapse_loop_customdata(BMesh *bm, BMLoop *l, BMVert *v_cle //#define USE_SEAM /* these don't need to be updated, since they will get removed when the edge collapses */ BMLoop *l_clear, *l_other; - const int is_manifold = BM_edge_is_manifold(l->e); + const bool is_manifold = BM_edge_is_manifold(l->e); int side; /* l defines the vert to collapse into */ @@ -467,7 +467,7 @@ static void bm_edge_collapse_loop_customdata(BMesh *bm, BMLoop *l, BMVert *v_cle /* now we have both corners of the face 'l->f' */ for (side = 0; side < 2; side++) { #ifdef USE_SEAM - int is_seam = FALSE; + bool is_seam = false; #endif void *src[2]; BMFace *f_exit = is_manifold ? l->radial_next->f : NULL; @@ -507,7 +507,7 @@ static void bm_edge_collapse_loop_customdata(BMesh *bm, BMLoop *l, BMVert *v_cle #ifdef USE_SEAM /* break out unless we find a match */ - is_seam = TRUE; + is_seam = true; #endif /* ok. we have a loop. now be smart with it! */ @@ -517,13 +517,13 @@ static void bm_edge_collapse_loop_customdata(BMesh *bm, BMLoop *l, BMVert *v_cle const int type = bm->ldata.layers[i].type; void *cd_src[2] = {(char *)src[0] + offset, (char *)src[1] + offset}; - void *cd_iter = (char *)l_iter->head.data + offset;; + void *cd_iter = (char *)l_iter->head.data + offset; /* detect seams */ if (CustomData_data_equals(type, cd_src[0], cd_iter)) { CustomData_bmesh_interp_n(&bm->ldata, cd_src, w, NULL, 2, l_iter->head.data, i); #ifdef USE_SEAM - is_seam = FALSE; + is_seam = false; #endif } } @@ -598,7 +598,7 @@ BLI_INLINE int bm_edge_is_manifold_or_boundary(BMLoop *l) #endif } -static int bm_edge_collapse_is_degenerate_topology(BMEdge *e_first) +static bool bm_edge_collapse_is_degenerate_topology(BMEdge *e_first) { /* simply check that there is no overlap between faces and edges of each vert, * (excluding the 2 faces attached to 'e' and 'e' its self) */ @@ -609,7 +609,7 @@ static int bm_edge_collapse_is_degenerate_topology(BMEdge *e_first) e_iter = e_first; do { if (!bm_edge_is_manifold_or_boundary(e_iter->l)) { - return TRUE; + return true; } bm_edge_tag_disable(e_iter); } while ((e_iter = bmesh_disk_edge_next(e_iter, e_first->v1)) != e_first); @@ -617,7 +617,7 @@ static int bm_edge_collapse_is_degenerate_topology(BMEdge *e_first) e_iter = e_first; do { if (!bm_edge_is_manifold_or_boundary(e_iter->l)) { - return TRUE; + return true; } bm_edge_tag_disable(e_iter); } while ((e_iter = bmesh_disk_edge_next(e_iter, e_first->v2)) != e_first); @@ -673,11 +673,11 @@ static int bm_edge_collapse_is_degenerate_topology(BMEdge *e_first) e_iter = e_first; do { if (bm_edge_tag_test(e_iter)) { - return TRUE; + return true; } } while ((e_iter = bmesh_disk_edge_next(e_iter, e_first->v2)) != e_first); - return FALSE; + return false; } /** @@ -690,13 +690,13 @@ static int bm_edge_collapse_is_degenerate_topology(BMEdge *e_first) * \param e_clear_other let caller know what edges we remove besides \a e_clear * \param customdata_flag merge factor, scales from 0 - 1 ('v_clear' -> 'v_other') */ -static int bm_edge_collapse(BMesh *bm, BMEdge *e_clear, BMVert *v_clear, int r_e_clear_other[2], +static bool bm_edge_collapse(BMesh *bm, BMEdge *e_clear, BMVert *v_clear, int r_e_clear_other[2], #ifdef USE_CUSTOMDATA - const CD_UseFlag customdata_flag, - const float customdata_fac + const CD_UseFlag customdata_flag, + const float customdata_fac #else - const CD_UseFlag UNUSED(customdata_flag), - const float UNUSED(customdata_fac) + const CD_UseFlag UNUSED(customdata_flag), + const float UNUSED(customdata_fac) #endif ) { @@ -708,11 +708,11 @@ static int bm_edge_collapse(BMesh *bm, BMEdge *e_clear, BMVert *v_clear, int r_e if (BM_edge_is_manifold(e_clear)) { BMLoop *l_a, *l_b; BMEdge *e_a_other[2], *e_b_other[2]; - int ok; + bool ok; ok = BM_edge_loop_pair(e_clear, &l_a, &l_b); - BLI_assert(ok == TRUE); + BLI_assert(ok == true); BLI_assert(l_a->f->len == 3); BLI_assert(l_b->f->len == 3); @@ -749,7 +749,7 @@ static int bm_edge_collapse(BMesh *bm, BMEdge *e_clear, BMVert *v_clear, int r_e if (ELEM(e_a_other[0], e_b_other[0], e_b_other[1]) || ELEM(e_a_other[1], e_b_other[0], e_b_other[1])) { - return FALSE; + return false; } r_e_clear_other[0] = BM_elem_index_get(e_a_other[0]); @@ -782,7 +782,7 @@ static int bm_edge_collapse(BMesh *bm, BMEdge *e_clear, BMVert *v_clear, int r_e // BM_mesh_validate(bm); - return TRUE; + return true; } else if (BM_edge_is_boundary(e_clear)) { /* same as above but only one triangle */ @@ -829,10 +829,10 @@ static int bm_edge_collapse(BMesh *bm, BMEdge *e_clear, BMVert *v_clear, int r_e // BM_mesh_validate(bm); - return TRUE; + return true; } else { - return FALSE; + return false; } } @@ -869,7 +869,7 @@ static void bm_decim_edge_collapse(BMesh *bm, BMEdge *e, } /* use for customdata merging */ - if (LIKELY(compare_v3v3(e->v1->co, e->v2->co, FLT_EPSILON) == FALSE)) { + if (LIKELY(compare_v3v3(e->v1->co, e->v2->co, FLT_EPSILON) == false)) { customdata_fac = line_point_factor_v3(optimize_co, e->v1->co, e->v2->co); #if 0 /* simple test for stupid collapse */ @@ -946,7 +946,7 @@ static void bm_decim_edge_collapse(BMesh *bm, BMEdge *e, else e_outer = l->prev->e; - BLI_assert(BM_vert_in_edge(e_outer, l->v) == FALSE); + BLI_assert(BM_vert_in_edge(e_outer, l->v) == false); bm_decim_build_edge_cost_single(e_outer, vquadrics, vweights, eheap, eheap_table); } @@ -972,14 +972,14 @@ static void bm_decim_edge_collapse(BMesh *bm, BMEdge *e, * \param vweights Optional array of vertex aligned weights [0 - 1], * a vertex group is the usual source for this. */ -void BM_mesh_decimate_collapse(BMesh *bm, const float factor, float *vweights, const int do_triangulate) +void BM_mesh_decimate_collapse(BMesh *bm, const float factor, float *vweights, const bool do_triangulate) { Heap *eheap; /* edge heap */ HeapNode **eheap_table; /* edge index aligned table pointing to the eheap */ Quadric *vquadrics; /* vert index aligned quadrics */ int tot_edge_orig; int face_tot_target; - int use_triangulate; + bool use_triangulate; CD_UseFlag customdata_flag = 0; @@ -1015,7 +1015,7 @@ void BM_mesh_decimate_collapse(BMesh *bm, const float factor, float *vweights, c /* iterative edge collapse and maintain the eheap */ while ((bm->totface > face_tot_target) && - (BLI_heap_is_empty(eheap) == FALSE) && + (BLI_heap_is_empty(eheap) == false) && (BLI_heap_node_value(BLI_heap_top(eheap)) != COST_INVALID)) { // const float value = BLI_heap_node_value(BLI_heap_top(eheap)); @@ -1033,7 +1033,7 @@ void BM_mesh_decimate_collapse(BMesh *bm, const float factor, float *vweights, c #ifdef USE_TRIANGULATE - if (do_triangulate == FALSE) { + if (do_triangulate == false) { /* its possible we only had triangles, skip this step in that case */ if (LIKELY(use_triangulate)) { /* temp convert quads to triangles */ diff --git a/source/blender/bmesh/tools/bmesh_decimate_dissolve.c b/source/blender/bmesh/tools/bmesh_decimate_dissolve.c index f67f01e4585..3a724769f2a 100644 --- a/source/blender/bmesh/tools/bmesh_decimate_dissolve.c +++ b/source/blender/bmesh/tools/bmesh_decimate_dissolve.c @@ -69,7 +69,7 @@ static int dissolve_elem_cmp(const void *a1, const void *a2) return 0; } -void BM_mesh_decimate_dissolve_ex(BMesh *bm, const float angle_limit, const int do_dissolve_boundaries, +void BM_mesh_decimate_dissolve_ex(BMesh *bm, const float angle_limit, const bool do_dissolve_boundaries, BMVert **vinput_arr, const int vinput_len, BMEdge **einput_arr, const int einput_len) { @@ -117,7 +117,7 @@ void BM_mesh_decimate_dissolve_ex(BMesh *bm, const float angle_limit, const int BMFace *nf = BM_faces_join_pair(bm, e->l->f, e->l->radial_next->f, e, - FALSE); /* join faces */ + false); /* join faces */ /* there may be some errors, we don't mind, just move on */ if (nf) { @@ -148,7 +148,7 @@ void BM_mesh_decimate_dissolve_ex(BMesh *bm, const float angle_limit, const int for (i = bm->totedge - 1; i != -1; i--) { e_iter = earray[i]; - if (BM_edge_is_wire(e_iter) && (BM_elem_flag_test(e_iter, BM_ELEM_TAG) == FALSE)) { + if (BM_edge_is_wire(e_iter) && (BM_elem_flag_test(e_iter, BM_ELEM_TAG) == false)) { /* edge has become wire */ int vidx_reverse; BMVert *v1 = e_iter->v1; @@ -179,7 +179,7 @@ void BM_mesh_decimate_dissolve_ex(BMesh *bm, const float angle_limit, const int if (LIKELY(v != NULL) && BM_vert_edge_count(v) == 2) { - BM_vert_collapse_edge(bm, v->e, v, TRUE); /* join edges */ + BM_vert_collapse_edge(bm, v->e, v, true); /* join edges */ } } } @@ -210,7 +210,7 @@ void BM_mesh_decimate_dissolve_ex(BMesh *bm, const float angle_limit, const int /* check twice because cumulative effect could dissolve over angle limit */ bm_vert_edge_face_angle(v) < angle_limit) { - BMEdge *ne = BM_vert_collapse_edge(bm, v->e, v, TRUE); /* join edges */ + BMEdge *ne = BM_vert_collapse_edge(bm, v->e, v, true); /* join edges */ if (ne && ne->l) { BM_edge_normals_update(ne); @@ -223,7 +223,7 @@ void BM_mesh_decimate_dissolve_ex(BMesh *bm, const float angle_limit, const int MEM_freeN(weight_elems); } -void BM_mesh_decimate_dissolve(BMesh *bm, const float angle_limit, const int do_dissolve_boundaries) +void BM_mesh_decimate_dissolve(BMesh *bm, const float angle_limit, const bool do_dissolve_boundaries) { int vinput_len; int einput_len; diff --git a/source/blender/bmesh/tools/bmesh_decimate_unsubdivide.c b/source/blender/bmesh/tools/bmesh_decimate_unsubdivide.c index 71c1cedbd5e..9dc4b596568 100644 --- a/source/blender/bmesh/tools/bmesh_decimate_unsubdivide.c +++ b/source/blender/bmesh/tools/bmesh_decimate_unsubdivide.c @@ -36,7 +36,7 @@ #include "intern/bmesh_operators_private.h" /* own include */ -static int bm_vert_dissolve_fan_test(BMVert *v) +static bool bm_vert_dissolve_fan_test(BMVert *v) { /* check if we should walk over these verts */ BMIter iter; @@ -61,21 +61,21 @@ static int bm_vert_dissolve_fan_test(BMVert *v) } if ((tot_edge == 4) && (tot_edge_boundary == 0) && (tot_edge_manifold == 4)) { - return TRUE; + return true; } else if ((tot_edge == 3) && (tot_edge_boundary == 0) && (tot_edge_manifold == 3)) { - return TRUE; + return true; } else if ((tot_edge == 3) && (tot_edge_boundary == 2) && (tot_edge_manifold == 1)) { - return TRUE; + return true; } else if ((tot_edge == 2) && (tot_edge_wire == 2)) { - return TRUE; + return true; } - return FALSE; + return false; } -static int bm_vert_dissolve_fan(BMesh *bm, BMVert *v) +static bool bm_vert_dissolve_fan(BMesh *bm, BMVert *v) { /* collapse under 2 conditions. * - vert connects to 4 manifold edges (and 4 faces). @@ -110,7 +110,7 @@ static int bm_vert_dissolve_fan(BMesh *bm, BMVert *v) if (tot_edge == 2) { /* check for 2 wire verts only */ if (tot_edge_wire == 2) { - return (BM_vert_collapse_edge(bm, v->e, v, TRUE) != NULL); + return (BM_vert_collapse_edge(bm, v->e, v, true) != NULL); } } else if (tot_edge == 4) { @@ -145,7 +145,7 @@ static int bm_vert_dissolve_fan(BMesh *bm, BMVert *v) if (l->f->len > 3) { BMLoop *l_new; BLI_assert(l->prev->v != l->next->v); - BM_face_split(bm, l->f, l->prev->v, l->next->v, &l_new, NULL, TRUE); + BM_face_split(bm, l->f, l->prev->v, l->next->v, &l_new, NULL, true); BM_elem_flag_merge_into(l_new->e, l->e, l->prev->e); } } @@ -153,7 +153,7 @@ static int bm_vert_dissolve_fan(BMesh *bm, BMVert *v) return BM_vert_dissolve(bm, v); } - return FALSE; + return false; } enum { @@ -170,7 +170,7 @@ enum { /** * \param tag_only so we can call this from an operator */ -void BM_mesh_decimate_unsubdivide_ex(BMesh *bm, const int iterations, const int tag_only) +void BM_mesh_decimate_unsubdivide_ex(BMesh *bm, const int iterations, const bool tag_only) { #ifdef USE_WALKER # define ELE_VERT_TAG 1 @@ -191,14 +191,14 @@ void BM_mesh_decimate_unsubdivide_ex(BMesh *bm, const int iterations, const int /* if tag_only is set, we assyme the caller knows what verts to tag * needed for the operator */ - if (tag_only == FALSE) { + if (tag_only == false) { BM_ITER_MESH (v, &iter, bm, BM_VERTS_OF_MESH) { BM_elem_flag_enable(v, BM_ELEM_TAG); } } for (iter_step = 0; iter_step < iterations; iter_step++) { - int iter_done; + bool iter_done; BM_ITER_MESH (v, &iter, bm, BM_VERTS_OF_MESH) { if (BM_elem_flag_test(v, BM_ELEM_TAG) && bm_vert_dissolve_fan_test(v)) { @@ -215,7 +215,7 @@ void BM_mesh_decimate_unsubdivide_ex(BMesh *bm, const int iterations, const int /* main loop, keep tagging until we can't tag any more islands */ - while (TRUE) { + while (true) { #ifdef USE_WALKER BMWalker walker; #else @@ -273,7 +273,7 @@ void BM_mesh_decimate_unsubdivide_ex(BMesh *bm, const int iterations, const int vert_seek_b_tot = 0; vert_seek_b[vert_seek_b_tot++] = v_first; - while (TRUE) { + while (true) { BMEdge *e; if ((offset + depth) % nth) { @@ -318,14 +318,16 @@ void BM_mesh_decimate_unsubdivide_ex(BMesh *bm, const int iterations, const int } /* now we tagged all verts -1 for removal, lets loop over and rebuild faces */ - iter_done = FALSE; + iter_done = false; BM_ITER_MESH (v, &iter, bm, BM_VERTS_OF_MESH) { if (BM_elem_index_get(v) == VERT_INDEX_DO_COLLAPSE) { - iter_done |= bm_vert_dissolve_fan(bm, v); + if (bm_vert_dissolve_fan(bm, v)) { + iter_done = true; + } } } - if (iter_done == FALSE) { + if (iter_done == false) { break; } } @@ -340,5 +342,5 @@ void BM_mesh_decimate_unsubdivide_ex(BMesh *bm, const int iterations, const int void BM_mesh_decimate_unsubdivide(BMesh *bm, const int iterations) { - BM_mesh_decimate_unsubdivide_ex(bm, iterations, FALSE); + BM_mesh_decimate_unsubdivide_ex(bm, iterations, false); } diff --git a/source/blender/bmesh/tools/bmesh_edgesplit.c b/source/blender/bmesh/tools/bmesh_edgesplit.c index b6a8c7985d6..1d3f973dbc0 100644 --- a/source/blender/bmesh/tools/bmesh_edgesplit.c +++ b/source/blender/bmesh/tools/bmesh_edgesplit.c @@ -98,14 +98,14 @@ static void bm_edgesplit_validate_seams(BMesh *bm) MEM_freeN(vtouch); } -void BM_mesh_edgesplit(BMesh *bm, const int use_verts, const int tag_only) +void BM_mesh_edgesplit(BMesh *bm, const bool use_verts, const bool tag_only) { BMIter iter; BMEdge *e; - if (tag_only == FALSE) { - BM_mesh_elem_hflag_enable_all(bm, BM_EDGE | (use_verts ? BM_VERT : 0), BM_ELEM_TAG, FALSE); + if (tag_only == false) { + BM_mesh_elem_hflag_enable_all(bm, BM_EDGE | (use_verts ? BM_VERT : 0), BM_ELEM_TAG, false); } if (use_verts) { @@ -117,8 +117,8 @@ void BM_mesh_edgesplit(BMesh *bm, const int use_verts, const int tag_only) */ BM_ITER_MESH (e, &iter, bm, BM_EDGES_OF_MESH) { if (BM_elem_flag_test(e, BM_ELEM_TAG)) { - if (UNLIKELY(((BM_elem_flag_test(e->v1, BM_ELEM_TAG) == FALSE) && - (BM_elem_flag_test(e->v2, BM_ELEM_TAG) == FALSE)))) + if (UNLIKELY(((BM_elem_flag_test(e->v1, BM_ELEM_TAG) == false) && + (BM_elem_flag_test(e->v2, BM_ELEM_TAG) == false)))) { BM_elem_flag_enable(e->v1, BM_ELEM_TAG); BM_elem_flag_enable(e->v2, BM_ELEM_TAG); @@ -146,10 +146,10 @@ void BM_mesh_edgesplit(BMesh *bm, const int use_verts, const int tag_only) if (use_verts) { BM_ITER_MESH (e, &iter, bm, BM_EDGES_OF_MESH) { - if (BM_elem_flag_test(e->v1, BM_ELEM_TAG) == FALSE) { + if (BM_elem_flag_test(e->v1, BM_ELEM_TAG) == false) { BM_elem_flag_disable(e->v1, BM_ELEM_TAG); } - if (BM_elem_flag_test(e->v2, BM_ELEM_TAG) == FALSE) { + if (BM_elem_flag_test(e->v2, BM_ELEM_TAG) == false) { BM_elem_flag_disable(e->v2, BM_ELEM_TAG); } } diff --git a/source/blender/bmesh/tools/bmesh_edgesplit.h b/source/blender/bmesh/tools/bmesh_edgesplit.h index 687fdac0e00..8c1231dd794 100644 --- a/source/blender/bmesh/tools/bmesh_edgesplit.h +++ b/source/blender/bmesh/tools/bmesh_edgesplit.h @@ -27,6 +27,6 @@ * \ingroup bmesh */ -void BM_mesh_edgesplit(BMesh *bm, const int use_verts, const int tag_only); +void BM_mesh_edgesplit(BMesh *bm, const bool use_verts, const bool tag_only); #endif /* __BMESH_EDGESPLIT_H__ */ |