diff options
Diffstat (limited to 'source/blender/bmesh')
46 files changed, 479 insertions, 399 deletions
diff --git a/source/blender/bmesh/CMakeLists.txt b/source/blender/bmesh/CMakeLists.txt index 0efa5f73ae4..77223ecd1c7 100644 --- a/source/blender/bmesh/CMakeLists.txt +++ b/source/blender/bmesh/CMakeLists.txt @@ -207,6 +207,22 @@ if(WITH_GMP) ) endif() +if(WITH_TBB) + add_definitions(-DWITH_TBB) + if(WIN32) + # TBB includes Windows.h which will define min/max macros + # that will collide with the stl versions. + add_definitions(-DNOMINMAX) + endif() + list(APPEND INC_SYS + ${TBB_INCLUDE_DIRS} + ) + + list(APPEND LIB + ${TBB_LIBRARIES} + ) +endif() + blender_add_lib(bf_bmesh "${SRC}" "${INC}" "${INC_SYS}" "${LIB}") if(MSVC AND NOT MSVC_CLANG) diff --git a/source/blender/bmesh/bmesh.h b/source/blender/bmesh/bmesh.h index 2833105e5a4..3956db0288a 100644 --- a/source/blender/bmesh/bmesh.h +++ b/source/blender/bmesh/bmesh.h @@ -148,7 +148,7 @@ * * These conventions should be used throughout the bmesh module. * - * - `bmesh_kernel_*()` - Low level API, for primitive functions that others are built ontop of. + * - `bmesh_kernel_*()` - Low level API, for primitive functions that others are built on top of. * - `bmesh_***()` - Low level API function. * - `bm_***()` - 'static' functions, not a part of the API at all, * but use prefix since they operate on BMesh data. diff --git a/source/blender/bmesh/intern/bmesh_construct.c b/source/blender/bmesh/intern/bmesh_construct.c index 757d006b04d..cff8eb5a2f7 100644 --- a/source/blender/bmesh/intern/bmesh_construct.c +++ b/source/blender/bmesh/intern/bmesh_construct.c @@ -21,8 +21,6 @@ #include "bmesh.h" #include "intern/bmesh_private.h" -#define SELECT 1 - bool BM_verts_from_edges(BMVert **vert_arr, BMEdge **edge_arr, const int len) { int i, i_prev = len - 1; @@ -507,42 +505,40 @@ void BM_mesh_copy_init_customdata_from_mesh_array(BMesh *bm_dst, allocsize = &bm_mesh_allocsize_default; } - char cd_flag = 0; - for (int i = 0; i < me_src_array_len; i++) { const Mesh *me_src = me_src_array[i]; + CustomData mesh_vdata = CustomData_shallow_copy_remove_non_bmesh_attributes( + &me_src->vdata, CD_MASK_BMESH.vmask); + CustomData mesh_edata = CustomData_shallow_copy_remove_non_bmesh_attributes( + &me_src->edata, CD_MASK_BMESH.emask); + CustomData mesh_pdata = CustomData_shallow_copy_remove_non_bmesh_attributes( + &me_src->pdata, CD_MASK_BMESH.lmask); + CustomData mesh_ldata = CustomData_shallow_copy_remove_non_bmesh_attributes( + &me_src->ldata, CD_MASK_BMESH.pmask); + if (i == 0) { - CustomData_copy_mesh_to_bmesh( - &me_src->vdata, &bm_dst->vdata, CD_MASK_BMESH.vmask, CD_SET_DEFAULT, 0); - CustomData_copy_mesh_to_bmesh( - &me_src->edata, &bm_dst->edata, CD_MASK_BMESH.emask, CD_SET_DEFAULT, 0); - CustomData_copy_mesh_to_bmesh( - &me_src->ldata, &bm_dst->ldata, CD_MASK_BMESH.lmask, CD_SET_DEFAULT, 0); - CustomData_copy_mesh_to_bmesh( - &me_src->pdata, &bm_dst->pdata, CD_MASK_BMESH.pmask, CD_SET_DEFAULT, 0); + CustomData_copy(&mesh_vdata, &bm_dst->vdata, CD_MASK_BMESH.vmask, CD_SET_DEFAULT, 0); + CustomData_copy(&mesh_edata, &bm_dst->edata, CD_MASK_BMESH.emask, CD_SET_DEFAULT, 0); + CustomData_copy(&mesh_pdata, &bm_dst->pdata, CD_MASK_BMESH.pmask, CD_SET_DEFAULT, 0); + CustomData_copy(&mesh_ldata, &bm_dst->ldata, CD_MASK_BMESH.lmask, CD_SET_DEFAULT, 0); } else { - CustomData_merge_mesh_to_bmesh( - &me_src->vdata, &bm_dst->vdata, CD_MASK_BMESH.vmask, CD_SET_DEFAULT, 0); - CustomData_merge_mesh_to_bmesh( - &me_src->edata, &bm_dst->edata, CD_MASK_BMESH.emask, CD_SET_DEFAULT, 0); - CustomData_merge_mesh_to_bmesh( - &me_src->ldata, &bm_dst->ldata, CD_MASK_BMESH.lmask, CD_SET_DEFAULT, 0); - CustomData_merge_mesh_to_bmesh( - &me_src->pdata, &bm_dst->pdata, CD_MASK_BMESH.pmask, CD_SET_DEFAULT, 0); + CustomData_merge(&mesh_vdata, &bm_dst->vdata, CD_MASK_BMESH.vmask, CD_SET_DEFAULT, 0); + CustomData_merge(&mesh_edata, &bm_dst->edata, CD_MASK_BMESH.emask, CD_SET_DEFAULT, 0); + CustomData_merge(&mesh_pdata, &bm_dst->pdata, CD_MASK_BMESH.pmask, CD_SET_DEFAULT, 0); + CustomData_merge(&mesh_ldata, &bm_dst->ldata, CD_MASK_BMESH.lmask, CD_SET_DEFAULT, 0); } - cd_flag |= me_src->cd_flag; + MEM_SAFE_FREE(mesh_vdata.layers); + MEM_SAFE_FREE(mesh_edata.layers); + MEM_SAFE_FREE(mesh_pdata.layers); + MEM_SAFE_FREE(mesh_ldata.layers); } - cd_flag |= BM_mesh_cd_flag_from_bmesh(bm_dst); - CustomData_bmesh_init_pool(&bm_dst->vdata, allocsize->totvert, BM_VERT); CustomData_bmesh_init_pool(&bm_dst->edata, allocsize->totedge, BM_EDGE); CustomData_bmesh_init_pool(&bm_dst->ldata, allocsize->totloop, BM_LOOP); CustomData_bmesh_init_pool(&bm_dst->pdata, allocsize->totface, BM_FACE); - - BM_mesh_cd_flag_apply(bm_dst, cd_flag); } void BM_mesh_copy_init_customdata_from_mesh(BMesh *bm_dst, @@ -720,43 +716,27 @@ BMesh *BM_mesh_copy(BMesh *bm_old) return bm_new; } -char BM_vert_flag_from_mflag(const char mflag) -{ - return ((mflag & SELECT) ? BM_ELEM_SELECT : 0); -} char BM_edge_flag_from_mflag(const short mflag) { - return (((mflag & SELECT) ? BM_ELEM_SELECT : 0) | ((mflag & ME_SEAM) ? BM_ELEM_SEAM : 0) | - ((mflag & ME_EDGEDRAW) ? BM_ELEM_DRAW : 0) | + return (((mflag & ME_SEAM) ? BM_ELEM_SEAM : 0) | ((mflag & ME_EDGEDRAW) ? BM_ELEM_DRAW : 0) | ((mflag & ME_SHARP) == 0 ? BM_ELEM_SMOOTH : 0)); } char BM_face_flag_from_mflag(const char mflag) { - return (((mflag & ME_FACE_SEL) ? BM_ELEM_SELECT : 0) | - ((mflag & ME_SMOOTH) ? BM_ELEM_SMOOTH : 0)); -} - -char BM_vert_flag_to_mflag(BMVert *v) -{ - const char hflag = v->head.hflag; - - return (((hflag & BM_ELEM_SELECT) ? SELECT : 0)); + return ((mflag & ME_SMOOTH) ? BM_ELEM_SMOOTH : 0); } short BM_edge_flag_to_mflag(BMEdge *e) { const char hflag = e->head.hflag; - return (((hflag & BM_ELEM_SELECT) ? SELECT : 0) | ((hflag & BM_ELEM_SEAM) ? ME_SEAM : 0) | - ((hflag & BM_ELEM_DRAW) ? ME_EDGEDRAW : 0) | + return (((hflag & BM_ELEM_SEAM) ? ME_SEAM : 0) | ((hflag & BM_ELEM_DRAW) ? ME_EDGEDRAW : 0) | ((hflag & BM_ELEM_SMOOTH) == 0 ? ME_SHARP : 0) | - (BM_edge_is_wire(e) ? ME_LOOSEEDGE : 0) | /* not typical */ - ME_EDGERENDER); + (BM_edge_is_wire(e) ? ME_LOOSEEDGE : 0)); } char BM_face_flag_to_mflag(BMFace *f) { const char hflag = f->head.hflag; - return (((hflag & BM_ELEM_SELECT) ? ME_FACE_SEL : 0) | - ((hflag & BM_ELEM_SMOOTH) ? ME_SMOOTH : 0)); + return ((hflag & BM_ELEM_SMOOTH) ? ME_SMOOTH : 0); } diff --git a/source/blender/bmesh/intern/bmesh_construct.h b/source/blender/bmesh/intern/bmesh_construct.h index 1851cf58d4e..225e15c90e9 100644 --- a/source/blender/bmesh/intern/bmesh_construct.h +++ b/source/blender/bmesh/intern/bmesh_construct.h @@ -169,8 +169,5 @@ BMesh *BM_mesh_copy(BMesh *bm_old); char BM_face_flag_from_mflag(char mflag); char BM_edge_flag_from_mflag(short mflag); /* ME -> BM */ -char BM_vert_flag_from_mflag(char mflag); char BM_face_flag_to_mflag(BMFace *f); short BM_edge_flag_to_mflag(BMEdge *e); -/* BM -> ME */ -char BM_vert_flag_to_mflag(BMVert *v); diff --git a/source/blender/bmesh/intern/bmesh_core.c b/source/blender/bmesh/intern/bmesh_core.c index 4d84d558cd7..5fbbd087d7e 100644 --- a/source/blender/bmesh/intern/bmesh_core.c +++ b/source/blender/bmesh/intern/bmesh_core.c @@ -95,7 +95,7 @@ BMVert *BM_vert_create(BMesh *bm, /* handles 'v->no' too */ BM_elem_attrs_copy(bm, bm, v_example, v); - /* exception: don't copy the original shapekey index */ + /* Exception: don't copy the original shape-key index. */ keyi = CustomData_bmesh_get(&bm->vdata, v->head.data, CD_SHAPE_KEYINDEX); if (keyi) { *keyi = ORIGINDEX_NONE; diff --git a/source/blender/bmesh/intern/bmesh_log.c b/source/blender/bmesh/intern/bmesh_log.c index 64e6c63e9f0..a8a9390f525 100644 --- a/source/blender/bmesh/intern/bmesh_log.c +++ b/source/blender/bmesh/intern/bmesh_log.c @@ -288,7 +288,8 @@ static void bm_log_verts_restore(BMesh *bm, BMLog *log, GHash *verts) static void bm_log_faces_restore(BMesh *bm, BMLog *log, GHash *faces) { GHashIterator gh_iter; - const int cd_face_sets = CustomData_get_offset(&bm->pdata, CD_SCULPT_FACE_SETS); + const int cd_face_sets = CustomData_get_offset_named( + &bm->pdata, CD_PROP_INT32, ".sculpt_face_set"); GHASH_ITER (gh_iter, faces) { void *key = BLI_ghashIterator_getKey(&gh_iter); @@ -1002,3 +1003,31 @@ void bm_log_print(const BMLog *log, const char *description) } } #endif + +void BM_log_print_entry(BMesh *bm, BMLogEntry *entry) +{ + if (bm) { + printf("BM { totvert=%d totedge=%d totloop=%d totpoly=%d\n", + bm->totvert, + bm->totedge, + bm->totloop, + bm->totface); + + if (!bm->totvert) { + printf("%s: Warning: empty bmesh\n", __func__); + } + } + else { + printf("BM { totvert=unknown totedge=unknown totloop=unknown totpoly=unknown\n"); + } + + printf("v | added: %d, removed: %d, modified: %d\n", + (int)BLI_ghash_len(entry->added_verts), + (int)BLI_ghash_len(entry->deleted_verts), + (int)BLI_ghash_len(entry->modified_verts)); + printf("f | added: %d, removed: %d, modified: %d\n", + (int)BLI_ghash_len(entry->added_faces), + (int)BLI_ghash_len(entry->deleted_faces), + (int)BLI_ghash_len(entry->modified_faces)); + printf("}\n"); +} diff --git a/source/blender/bmesh/intern/bmesh_log.h b/source/blender/bmesh/intern/bmesh_log.h index 5daa5dd9a68..8c9db9c66e7 100644 --- a/source/blender/bmesh/intern/bmesh_log.h +++ b/source/blender/bmesh/intern/bmesh_log.h @@ -22,7 +22,7 @@ BMLog *BM_log_create(BMesh *bm); /** * Allocate and initialize a new #BMLog using existing #BMLogEntries * - * The 'entry' should be the last entry in the BMLog. Its prev pointer + * The 'entry' should be the last entry in the #BMLog. Its `prev` pointer * will be followed back to find the first entry. * * The unused IDs field of the log will be initialized by taking all @@ -206,3 +206,5 @@ void BM_log_original_vert_data(BMLog *log, BMVert *v, const float **r_co, const BMLogEntry *BM_log_current_entry(BMLog *log); /** For internal use only (unit testing) */ struct RangeTreeUInt *BM_log_unused_ids(BMLog *log); + +void BM_log_print_entry(BMesh *bm, BMLogEntry *entry); diff --git a/source/blender/bmesh/intern/bmesh_marking.c b/source/blender/bmesh/intern/bmesh_marking.c index f348cd58085..a1c2815ab2f 100644 --- a/source/blender/bmesh/intern/bmesh_marking.c +++ b/source/blender/bmesh/intern/bmesh_marking.c @@ -1020,7 +1020,7 @@ static BMEditSelection *bm_select_history_create(BMHeader *ele) return ese; } -/* --- macro wrapped funcs --- */ +/* --- Macro wrapped functions. --- */ bool _bm_select_history_check(BMesh *bm, const BMHeader *ele) { @@ -1075,7 +1075,7 @@ void _bm_select_history_store_after(BMesh *bm, BMEditSelection *ese_ref, BMHeade BM_select_history_store_after_notest(bm, ese_ref, (BMElem *)ele); } } -/* --- end macro wrapped funcs --- */ +/* --- End macro wrapped functions --- */ void BM_select_history_clear(BMesh *bm) { diff --git a/source/blender/bmesh/intern/bmesh_mesh.cc b/source/blender/bmesh/intern/bmesh_mesh.cc index 4f42ce4a470..5c8f32b9bfa 100644 --- a/source/blender/bmesh/intern/bmesh_mesh.cc +++ b/source/blender/bmesh/intern/bmesh_mesh.cc @@ -269,7 +269,7 @@ void BM_mesh_free(BMesh *bm) MEM_freeN(bm); } -void bmesh_edit_begin(BMesh *UNUSED(bm), BMOpTypeFlag UNUSED(type_flag)) +void bmesh_edit_begin(BMesh * /*bm*/, BMOpTypeFlag /*type_flag*/) { /* Most operators seem to be using BMO_OPTYPE_FLAG_UNTAN_MULTIRES to change the MDisps to * absolute space during mesh edits. With this enabled, changes to the topology diff --git a/source/blender/bmesh/intern/bmesh_mesh_convert.cc b/source/blender/bmesh/intern/bmesh_mesh_convert.cc index 94440916603..d65cac08db8 100644 --- a/source/blender/bmesh/intern/bmesh_mesh_convert.cc +++ b/source/blender/bmesh/intern/bmesh_mesh_convert.cc @@ -110,57 +110,6 @@ using blender::MutableSpan; using blender::Span; using blender::StringRef; -void BM_mesh_cd_flag_ensure(BMesh *bm, Mesh *mesh, const char cd_flag) -{ - const char cd_flag_all = BM_mesh_cd_flag_from_bmesh(bm) | cd_flag; - BM_mesh_cd_flag_apply(bm, cd_flag_all); - if (mesh) { - mesh->cd_flag = cd_flag_all; - } -} - -void BM_mesh_cd_flag_apply(BMesh *bm, const char cd_flag) -{ - /* CustomData_bmesh_init_pool() must run first */ - BLI_assert(bm->vdata.totlayer == 0 || bm->vdata.pool != nullptr); - BLI_assert(bm->edata.totlayer == 0 || bm->edata.pool != nullptr); - BLI_assert(bm->pdata.totlayer == 0 || bm->pdata.pool != nullptr); - - if (cd_flag & ME_CDFLAG_VERT_CREASE) { - if (!CustomData_has_layer(&bm->vdata, CD_CREASE)) { - BM_data_layer_add(bm, &bm->vdata, CD_CREASE); - } - } - else { - if (CustomData_has_layer(&bm->vdata, CD_CREASE)) { - BM_data_layer_free(bm, &bm->vdata, CD_CREASE); - } - } - - if (cd_flag & ME_CDFLAG_EDGE_CREASE) { - if (!CustomData_has_layer(&bm->edata, CD_CREASE)) { - BM_data_layer_add(bm, &bm->edata, CD_CREASE); - } - } - else { - if (CustomData_has_layer(&bm->edata, CD_CREASE)) { - BM_data_layer_free(bm, &bm->edata, CD_CREASE); - } - } -} - -char BM_mesh_cd_flag_from_bmesh(BMesh *bm) -{ - char cd_flag = 0; - if (CustomData_has_layer(&bm->vdata, CD_CREASE)) { - cd_flag |= ME_CDFLAG_VERT_CREASE; - } - if (CustomData_has_layer(&bm->edata, CD_CREASE)) { - cd_flag |= ME_CDFLAG_EDGE_CREASE; - } - return cd_flag; -} - /* Static function for alloc (duplicate in modifiers_bmesh.c) */ static BMFace *bm_face_create_from_mpoly(BMesh &bm, Span<MLoop> loops, @@ -180,6 +129,10 @@ static BMFace *bm_face_create_from_mpoly(BMesh &bm, void BM_mesh_bm_from_me(BMesh *bm, const Mesh *me, const struct BMeshFromMeshParams *params) { + if (!me) { + /* Sanity check. */ + return; + } const bool is_new = !(bm->totvert || (bm->vdata.totlayer || bm->edata.totlayer || bm->pdata.totlayer || bm->ldata.totlayer)); KeyBlock *actkey; @@ -187,19 +140,35 @@ void BM_mesh_bm_from_me(BMesh *bm, const Mesh *me, const struct BMeshFromMeshPar CustomData_MeshMasks mask = CD_MASK_BMESH; CustomData_MeshMasks_update(&mask, ¶ms->cd_mask_extra); - if (!me || !me->totvert) { - if (me && is_new) { /* No verts? still copy custom-data layout. */ - CustomData_copy_mesh_to_bmesh(&me->vdata, &bm->vdata, mask.vmask, CD_CONSTRUCT, 0); - CustomData_copy_mesh_to_bmesh(&me->edata, &bm->edata, mask.emask, CD_CONSTRUCT, 0); - CustomData_copy_mesh_to_bmesh(&me->ldata, &bm->ldata, mask.lmask, CD_CONSTRUCT, 0); - CustomData_copy_mesh_to_bmesh(&me->pdata, &bm->pdata, mask.pmask, CD_CONSTRUCT, 0); + CustomData mesh_vdata = CustomData_shallow_copy_remove_non_bmesh_attributes(&me->vdata, + mask.vmask); + CustomData mesh_edata = CustomData_shallow_copy_remove_non_bmesh_attributes(&me->edata, + mask.emask); + CustomData mesh_pdata = CustomData_shallow_copy_remove_non_bmesh_attributes(&me->pdata, + mask.pmask); + CustomData mesh_ldata = CustomData_shallow_copy_remove_non_bmesh_attributes(&me->ldata, + mask.lmask); + BLI_SCOPED_DEFER([&]() { + MEM_SAFE_FREE(mesh_vdata.layers); + MEM_SAFE_FREE(mesh_edata.layers); + MEM_SAFE_FREE(mesh_pdata.layers); + MEM_SAFE_FREE(mesh_ldata.layers); + }); + + if (me->totvert == 0) { + if (is_new) { + /* No verts? still copy custom-data layout. */ + CustomData_copy(&mesh_vdata, &bm->vdata, mask.vmask, CD_CONSTRUCT, 0); + CustomData_copy(&mesh_edata, &bm->edata, mask.emask, CD_CONSTRUCT, 0); + CustomData_copy(&mesh_pdata, &bm->pdata, mask.pmask, CD_CONSTRUCT, 0); + CustomData_copy(&mesh_ldata, &bm->ldata, mask.lmask, CD_CONSTRUCT, 0); CustomData_bmesh_init_pool(&bm->vdata, me->totvert, BM_VERT); CustomData_bmesh_init_pool(&bm->edata, me->totedge, BM_EDGE); CustomData_bmesh_init_pool(&bm->ldata, me->totloop, BM_LOOP); CustomData_bmesh_init_pool(&bm->pdata, me->totpoly, BM_FACE); } - return; /* Sanity check. */ + return; } const float(*vert_normals)[3] = nullptr; @@ -208,16 +177,16 @@ void BM_mesh_bm_from_me(BMesh *bm, const Mesh *me, const struct BMeshFromMeshPar } if (is_new) { - CustomData_copy_mesh_to_bmesh(&me->vdata, &bm->vdata, mask.vmask, CD_SET_DEFAULT, 0); - CustomData_copy_mesh_to_bmesh(&me->edata, &bm->edata, mask.emask, CD_SET_DEFAULT, 0); - CustomData_copy_mesh_to_bmesh(&me->ldata, &bm->ldata, mask.lmask, CD_SET_DEFAULT, 0); - CustomData_copy_mesh_to_bmesh(&me->pdata, &bm->pdata, mask.pmask, CD_SET_DEFAULT, 0); + CustomData_copy(&mesh_vdata, &bm->vdata, mask.vmask, CD_SET_DEFAULT, 0); + CustomData_copy(&mesh_edata, &bm->edata, mask.emask, CD_SET_DEFAULT, 0); + CustomData_copy(&mesh_pdata, &bm->pdata, mask.pmask, CD_SET_DEFAULT, 0); + CustomData_copy(&mesh_ldata, &bm->ldata, mask.lmask, CD_SET_DEFAULT, 0); } else { - CustomData_bmesh_merge(&me->vdata, &bm->vdata, mask.vmask, CD_SET_DEFAULT, bm, BM_VERT); - CustomData_bmesh_merge(&me->edata, &bm->edata, mask.emask, CD_SET_DEFAULT, bm, BM_EDGE); - CustomData_bmesh_merge(&me->ldata, &bm->ldata, mask.lmask, CD_SET_DEFAULT, bm, BM_LOOP); - CustomData_bmesh_merge(&me->pdata, &bm->pdata, mask.pmask, CD_SET_DEFAULT, bm, BM_FACE); + CustomData_bmesh_merge(&mesh_vdata, &bm->vdata, mask.vmask, CD_SET_DEFAULT, bm, BM_VERT); + CustomData_bmesh_merge(&mesh_edata, &bm->edata, mask.emask, CD_SET_DEFAULT, bm, BM_EDGE); + CustomData_bmesh_merge(&mesh_pdata, &bm->pdata, mask.pmask, CD_SET_DEFAULT, bm, BM_FACE); + CustomData_bmesh_merge(&mesh_ldata, &bm->ldata, mask.lmask, CD_SET_DEFAULT, bm, BM_LOOP); } /* -------------------------------------------------------------------- */ @@ -310,19 +279,21 @@ void BM_mesh_bm_from_me(BMesh *bm, const Mesh *me, const struct BMeshFromMeshPar CustomData_bmesh_init_pool(&bm->ldata, me->totloop, BM_LOOP); CustomData_bmesh_init_pool(&bm->pdata, me->totpoly, BM_FACE); } - BM_mesh_cd_flag_apply(bm, me->cd_flag | (is_new ? 0 : BM_mesh_cd_flag_from_bmesh(bm))); /* Only copy these values over if the source mesh is flagged to be using them. * Even if `bm` has these layers, they may have been added from another mesh, when `!is_new`. */ - const int cd_edge_crease_offset = (me->cd_flag & ME_CDFLAG_EDGE_CREASE) ? - CustomData_get_offset(&bm->edata, CD_CREASE) : - -1; const int cd_shape_key_offset = tot_shape_keys ? CustomData_get_offset(&bm->vdata, CD_SHAPEKEY) : -1; const int cd_shape_keyindex_offset = is_new && (tot_shape_keys || params->add_key_index) ? CustomData_get_offset(&bm->vdata, CD_SHAPE_KEYINDEX) : -1; + const bool *select_vert = (const bool *)CustomData_get_layer_named( + &me->vdata, CD_PROP_BOOL, ".select_vert"); + const bool *select_edge = (const bool *)CustomData_get_layer_named( + &me->edata, CD_PROP_BOOL, ".select_edge"); + const bool *select_poly = (const bool *)CustomData_get_layer_named( + &me->pdata, CD_PROP_BOOL, ".select_poly"); const bool *hide_vert = (const bool *)CustomData_get_layer_named( &me->vdata, CD_PROP_BOOL, ".hide_vert"); const bool *hide_edge = (const bool *)CustomData_get_layer_named( @@ -339,14 +310,10 @@ void BM_mesh_bm_from_me(BMesh *bm, const Mesh *me, const struct BMeshFromMeshPar bm, keyco ? keyco[i] : mvert[i].co, nullptr, BM_CREATE_SKIP_CD); BM_elem_index_set(v, i); /* set_ok */ - /* Transfer flag. */ - v->head.hflag = BM_vert_flag_from_mflag(mvert[i].flag & ~SELECT); if (hide_vert && hide_vert[i]) { BM_elem_flag_enable(v, BM_ELEM_HIDDEN); } - - /* This is necessary for selection counts to work properly. */ - if (mvert[i].flag & SELECT) { + if (select_vert && select_vert[i]) { BM_vert_select_set(bm, v, true); } @@ -355,7 +322,7 @@ void BM_mesh_bm_from_me(BMesh *bm, const Mesh *me, const struct BMeshFromMeshPar } /* Copy Custom Data */ - CustomData_to_bmesh_block(&me->vdata, &bm->vdata, i, &v->head.data, true); + CustomData_to_bmesh_block(&mesh_vdata, &bm->vdata, i, &v->head.data, true); /* Set shape key original index. */ if (cd_shape_keyindex_offset != -1) { @@ -382,22 +349,16 @@ void BM_mesh_bm_from_me(BMesh *bm, const Mesh *me, const struct BMeshFromMeshPar BM_elem_index_set(e, i); /* set_ok */ /* Transfer flags. */ - e->head.hflag = BM_edge_flag_from_mflag(medge[i].flag & ~SELECT); + e->head.hflag = BM_edge_flag_from_mflag(medge[i].flag); if (hide_edge && hide_edge[i]) { BM_elem_flag_enable(e, BM_ELEM_HIDDEN); } - - /* This is necessary for selection counts to work properly. */ - if (medge[i].flag & SELECT) { + if (select_edge && select_edge[i]) { BM_edge_select_set(bm, e, true); } /* Copy Custom Data */ - CustomData_to_bmesh_block(&me->edata, &bm->edata, i, &e->head.data, true); - - if (cd_edge_crease_offset != -1) { - BM_ELEM_CD_SET_FLOAT(e, cd_edge_crease_offset, (float)medge[i].crease / 255.0f); - } + CustomData_to_bmesh_block(&mesh_edata, &bm->edata, i, &e->head.data, true); } if (is_new) { bm->elem_index_dirty &= ~BM_EDGE; /* Added in order, clear dirty flag. */ @@ -435,13 +396,11 @@ void BM_mesh_bm_from_me(BMesh *bm, const Mesh *me, const struct BMeshFromMeshPar BM_elem_index_set(f, bm->totface - 1); /* set_ok */ /* Transfer flag. */ - f->head.hflag = BM_face_flag_from_mflag(mpoly[i].flag & ~ME_FACE_SEL); + f->head.hflag = BM_face_flag_from_mflag(mpoly[i].flag); if (hide_poly && hide_poly[i]) { BM_elem_flag_enable(f, BM_ELEM_HIDDEN); } - - /* This is necessary for selection counts to work properly. */ - if (mpoly[i].flag & ME_FACE_SEL) { + if (select_poly && select_poly[i]) { BM_face_select_set(bm, f, true); } @@ -458,11 +417,11 @@ void BM_mesh_bm_from_me(BMesh *bm, const Mesh *me, const struct BMeshFromMeshPar BM_elem_index_set(l_iter, totloops++); /* set_ok */ /* Save index of corresponding #MLoop. */ - CustomData_to_bmesh_block(&me->ldata, &bm->ldata, j++, &l_iter->head.data, true); + CustomData_to_bmesh_block(&mesh_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); + CustomData_to_bmesh_block(&mesh_pdata, &bm->pdata, i, &f->head.data, true); if (params->calc_face_normal) { BM_face_normal_update(f); @@ -888,24 +847,31 @@ template<typename T, typename GetFn> static void write_fn_to_attribute(blender::bke::MutableAttributeAccessor attributes, const StringRef attribute_name, const eAttrDomain domain, - const bool do_write, const GetFn &get_fn) { using namespace blender; - if (do_write) { - bke::SpanAttributeWriter<T> attribute = attributes.lookup_or_add_for_write_only_span<T>( - attribute_name, domain); - threading::parallel_for(attribute.span.index_range(), 4096, [&](IndexRange range) { - for (const int i : range) { - attribute.span[i] = get_fn(i); - } - }); - attribute.finish(); - } - else { - /* To avoid overhead, remove the hide attribute if possible. */ - attributes.remove(attribute_name); - } + bke::SpanAttributeWriter<T> attribute = attributes.lookup_or_add_for_write_only_span<T>( + attribute_name, domain); + threading::parallel_for(attribute.span.index_range(), 4096, [&](IndexRange range) { + for (const int i : range) { + attribute.span[i] = get_fn(i); + } + }); + attribute.finish(); +} + +static void assert_bmesh_has_no_mesh_only_attributes(const BMesh &bm) +{ + (void)bm; /* Unused in the release builds. */ + + /* The "hide" attributes are stored as flags on #BMesh. */ + BLI_assert(CustomData_get_layer_named(&bm.vdata, CD_PROP_BOOL, ".hide_vert") == nullptr); + BLI_assert(CustomData_get_layer_named(&bm.edata, CD_PROP_BOOL, ".hide_edge") == nullptr); + BLI_assert(CustomData_get_layer_named(&bm.pdata, CD_PROP_BOOL, ".hide_poly") == nullptr); + /* The "selection" attributes are stored as flags on #BMesh. */ + BLI_assert(CustomData_get_layer_named(&bm.vdata, CD_PROP_BOOL, ".select_vert") == nullptr); + BLI_assert(CustomData_get_layer_named(&bm.edata, CD_PROP_BOOL, ".select_edge") == nullptr); + BLI_assert(CustomData_get_layer_named(&bm.pdata, CD_PROP_BOOL, ".select_poly") == nullptr); } static void convert_bmesh_hide_flags_to_mesh_attributes(BMesh &bm, @@ -916,9 +882,7 @@ static void convert_bmesh_hide_flags_to_mesh_attributes(BMesh &bm, { using namespace blender; /* The "hide" attributes are stored as flags on #BMesh. */ - BLI_assert(CustomData_get_layer_named(&bm.vdata, CD_PROP_BOOL, ".hide_vert") == nullptr); - BLI_assert(CustomData_get_layer_named(&bm.edata, CD_PROP_BOOL, ".hide_edge") == nullptr); - BLI_assert(CustomData_get_layer_named(&bm.pdata, CD_PROP_BOOL, ".hide_poly") == nullptr); + assert_bmesh_has_no_mesh_only_attributes(bm); if (!(need_hide_vert || need_hide_edge || need_hide_poly)) { return; @@ -927,18 +891,52 @@ static void convert_bmesh_hide_flags_to_mesh_attributes(BMesh &bm, bke::MutableAttributeAccessor attributes = mesh.attributes_for_write(); BM_mesh_elem_table_ensure(&bm, BM_VERT | BM_EDGE | BM_FACE); - write_fn_to_attribute<bool>( - attributes, ".hide_vert", ATTR_DOMAIN_POINT, need_hide_vert, [&](const int i) { - return BM_elem_flag_test(BM_vert_at_index(&bm, i), BM_ELEM_HIDDEN); - }); - write_fn_to_attribute<bool>( - attributes, ".hide_edge", ATTR_DOMAIN_EDGE, need_hide_edge, [&](const int i) { - return BM_elem_flag_test(BM_edge_at_index(&bm, i), BM_ELEM_HIDDEN); - }); - write_fn_to_attribute<bool>( - attributes, ".hide_poly", ATTR_DOMAIN_FACE, need_hide_poly, [&](const int i) { - return BM_elem_flag_test(BM_face_at_index(&bm, i), BM_ELEM_HIDDEN); - }); + if (need_hide_vert) { + write_fn_to_attribute<bool>(attributes, ".hide_vert", ATTR_DOMAIN_POINT, [&](const int i) { + return BM_elem_flag_test(BM_vert_at_index(&bm, i), BM_ELEM_HIDDEN); + }); + } + if (need_hide_edge) { + write_fn_to_attribute<bool>(attributes, ".hide_edge", ATTR_DOMAIN_EDGE, [&](const int i) { + return BM_elem_flag_test(BM_edge_at_index(&bm, i), BM_ELEM_HIDDEN); + }); + } + if (need_hide_poly) { + write_fn_to_attribute<bool>(attributes, ".hide_poly", ATTR_DOMAIN_FACE, [&](const int i) { + return BM_elem_flag_test(BM_face_at_index(&bm, i), BM_ELEM_HIDDEN); + }); + } +} + +static void convert_bmesh_selection_flags_to_mesh_attributes(BMesh &bm, + const bool need_select_vert, + const bool need_select_edge, + const bool need_select_poly, + Mesh &mesh) +{ + using namespace blender; + if (!(need_select_vert || need_select_edge || need_select_poly)) { + return; + } + + bke::MutableAttributeAccessor attributes = mesh.attributes_for_write(); + BM_mesh_elem_table_ensure(&bm, BM_VERT | BM_EDGE | BM_FACE); + + if (need_select_vert) { + write_fn_to_attribute<bool>(attributes, ".select_vert", ATTR_DOMAIN_POINT, [&](const int i) { + return BM_elem_flag_test(BM_vert_at_index(&bm, i), BM_ELEM_SELECT); + }); + } + if (need_select_edge) { + write_fn_to_attribute<bool>(attributes, ".select_edge", ATTR_DOMAIN_EDGE, [&](const int i) { + return BM_elem_flag_test(BM_edge_at_index(&bm, i), BM_ELEM_SELECT); + }); + } + if (need_select_poly) { + write_fn_to_attribute<bool>(attributes, ".select_poly", ATTR_DOMAIN_FACE, [&](const int i) { + return BM_elem_flag_test(BM_face_at_index(&bm, i), BM_ELEM_SELECT); + }); + } } void BM_mesh_bm_to_me(Main *bmain, BMesh *bm, Mesh *me, const struct BMeshToMeshParams *params) @@ -949,7 +947,6 @@ void BM_mesh_bm_to_me(Main *bmain, BMesh *bm, Mesh *me, const struct BMeshToMesh BMIter iter; int i, j; - const int cd_edge_crease_offset = CustomData_get_offset(&bm->edata, CD_CREASE); const int cd_shape_keyindex_offset = CustomData_get_offset(&bm->vdata, CD_SHAPE_KEYINDEX); const int ototvert = me->totvert; @@ -974,37 +971,24 @@ void BM_mesh_bm_to_me(Main *bmain, BMesh *bm, Mesh *me, const struct BMeshToMesh { CustomData_MeshMasks mask = CD_MASK_MESH; CustomData_MeshMasks_update(&mask, ¶ms->cd_mask_extra); - CustomData_copy_mesh_to_bmesh(&bm->vdata, &me->vdata, mask.vmask, CD_SET_DEFAULT, me->totvert); - CustomData_copy_mesh_to_bmesh(&bm->edata, &me->edata, mask.emask, CD_SET_DEFAULT, me->totedge); - CustomData_copy_mesh_to_bmesh(&bm->ldata, &me->ldata, mask.lmask, CD_SET_DEFAULT, me->totloop); - CustomData_copy_mesh_to_bmesh(&bm->pdata, &me->pdata, mask.pmask, CD_SET_DEFAULT, me->totpoly); + CustomData_copy(&bm->vdata, &me->vdata, mask.vmask, CD_SET_DEFAULT, me->totvert); + CustomData_copy(&bm->edata, &me->edata, mask.emask, CD_SET_DEFAULT, me->totedge); + CustomData_copy(&bm->ldata, &me->ldata, mask.lmask, CD_SET_DEFAULT, me->totloop); + CustomData_copy(&bm->pdata, &me->pdata, mask.pmask, CD_SET_DEFAULT, me->totpoly); } - MutableSpan<MVert> mvert; - MutableSpan<MEdge> medge; - MutableSpan<MPoly> mpoly; - MutableSpan<MLoop> mloop; - if (me->totvert > 0) { - mvert = {static_cast<MVert *>( - CustomData_add_layer(&me->vdata, CD_MVERT, CD_SET_DEFAULT, nullptr, me->totvert)), - me->totvert}; - } - if (me->totedge > 0) { - medge = {static_cast<MEdge *>( - CustomData_add_layer(&me->edata, CD_MEDGE, CD_SET_DEFAULT, nullptr, me->totedge)), - me->totedge}; - } - if (me->totpoly > 0) { - mpoly = {static_cast<MPoly *>( - CustomData_add_layer(&me->pdata, CD_MPOLY, CD_SET_DEFAULT, nullptr, me->totpoly)), - me->totpoly}; - } - if (me->totloop > 0) { - mloop = {static_cast<MLoop *>( - CustomData_add_layer(&me->ldata, CD_MLOOP, CD_SET_DEFAULT, nullptr, me->totloop)), - me->totloop}; - } + CustomData_add_layer(&me->vdata, CD_MVERT, CD_SET_DEFAULT, nullptr, me->totvert); + CustomData_add_layer(&me->edata, CD_MEDGE, CD_SET_DEFAULT, nullptr, me->totedge); + CustomData_add_layer(&me->ldata, CD_MLOOP, CD_SET_DEFAULT, nullptr, me->totloop); + CustomData_add_layer(&me->pdata, CD_MPOLY, CD_SET_DEFAULT, nullptr, me->totpoly); + MutableSpan<MVert> mvert = me->verts_for_write(); + MutableSpan<MEdge> medge = me->edges_for_write(); + MutableSpan<MPoly> mpoly = me->polys_for_write(); + MutableSpan<MLoop> mloop = me->loops_for_write(); + bool need_select_vert = false; + bool need_select_edge = false; + bool need_select_poly = false; bool need_hide_vert = false; bool need_hide_edge = false; bool need_hide_poly = false; @@ -1014,16 +998,16 @@ void BM_mesh_bm_to_me(Main *bmain, BMesh *bm, Mesh *me, const struct BMeshToMesh * different than the BMesh's. */ BKE_mesh_clear_derived_normals(me); - me->cd_flag = BM_mesh_cd_flag_from_bmesh(bm); - i = 0; BM_ITER_MESH (v, &iter, bm, BM_VERTS_OF_MESH) { copy_v3_v3(mvert[i].co, v->co); - mvert[i].flag = BM_vert_flag_to_mflag(v); if (BM_elem_flag_test(v, BM_ELEM_HIDDEN)) { need_hide_vert = true; } + if (BM_elem_flag_test(v, BM_ELEM_SELECT)) { + need_select_vert = true; + } BM_elem_index_set(v, i); /* set_inline */ @@ -1045,6 +1029,9 @@ void BM_mesh_bm_to_me(Main *bmain, BMesh *bm, Mesh *me, const struct BMeshToMesh if (BM_elem_flag_test(e, BM_ELEM_HIDDEN)) { need_hide_edge = true; } + if (BM_elem_flag_test(e, BM_ELEM_SELECT)) { + need_select_edge = true; + } BM_elem_index_set(e, i); /* set_inline */ @@ -1053,10 +1040,6 @@ void BM_mesh_bm_to_me(Main *bmain, BMesh *bm, Mesh *me, const struct BMeshToMesh bmesh_quick_edgedraw_flag(&medge[i], e); - if (cd_edge_crease_offset != -1) { - medge[i].crease = BM_ELEM_CD_GET_FLOAT_AS_UCHAR(e, cd_edge_crease_offset); - } - i++; BM_CHECK_ELEMENT(e); } @@ -1075,6 +1058,9 @@ void BM_mesh_bm_to_me(Main *bmain, BMesh *bm, Mesh *me, const struct BMeshToMesh if (BM_elem_flag_test(f, BM_ELEM_HIDDEN)) { need_hide_poly = true; } + if (BM_elem_flag_test(f, BM_ELEM_SELECT)) { + need_select_poly = true; + } l_iter = l_first = BM_FACE_FIRST_LOOP(f); do { @@ -1103,10 +1089,10 @@ void BM_mesh_bm_to_me(Main *bmain, BMesh *bm, Mesh *me, const struct BMeshToMesh if (need_material_index) { BM_mesh_elem_table_ensure(bm, BM_FACE); - write_fn_to_attribute<int>( - me->attributes_for_write(), "material_index", ATTR_DOMAIN_FACE, true, [&](const int i) { - return static_cast<int>(BM_face_at_index(bm, i)->mat_nr); - }); + write_fn_to_attribute<int>(me->attributes_for_write(), + "material_index", + ATTR_DOMAIN_FACE, + [&](const int i) { return int(BM_face_at_index(bm, i)->mat_nr); }); } /* Patch hook indices and vertex parents. */ @@ -1175,6 +1161,8 @@ void BM_mesh_bm_to_me(Main *bmain, BMesh *bm, Mesh *me, const struct BMeshToMesh convert_bmesh_hide_flags_to_mesh_attributes( *bm, need_hide_vert, need_hide_edge, need_hide_poly, *me); + convert_bmesh_selection_flags_to_mesh_attributes( + *bm, need_select_vert, need_select_edge, need_select_poly, *me); { me->totselect = BLI_listbase_count(&(bm->selected)); @@ -1222,8 +1210,12 @@ void BM_mesh_bm_to_me(Main *bmain, BMesh *bm, Mesh *me, const struct BMeshToMesh BKE_mesh_runtime_clear_geometry(me); } +/* NOTE: The function is called from multiple threads with the same input BMesh and different + * mesh objects. */ void BM_mesh_bm_to_me_for_eval(BMesh *bm, Mesh *me, const CustomData_MeshMasks *cd_mask_extra) { + using namespace blender; + /* Must be an empty mesh. */ BLI_assert(me->totvert == 0); BLI_assert(cd_mask_extra == nullptr || (cd_mask_extra->vmask & CD_MASK_SHAPEKEY) == 0); @@ -1260,21 +1252,18 @@ void BM_mesh_bm_to_me_for_eval(BMesh *bm, Mesh *me, const CustomData_MeshMasks * MutableSpan<MPoly> mpoly = me->polys_for_write(); MutableSpan<MLoop> loops = me->loops_for_write(); MLoop *mloop = loops.data(); - unsigned int i, j; - - const int cd_edge_crease_offset = CustomData_get_offset(&bm->edata, CD_CREASE); - - bool need_hide_vert = false; - bool need_hide_edge = false; - bool need_hide_poly = false; - bool need_material_index = false; + uint i, j; /* Clear normals on the mesh completely, since the original vertex and polygon count might be * different than the BMesh's. */ BKE_mesh_clear_derived_normals(me); - me->runtime.deformed_only = true; + me->runtime->deformed_only = true; + bke::MutableAttributeAccessor mesh_attributes = me->attributes_for_write(); + + bke::SpanAttributeWriter<bool> hide_vert_attribute; + bke::SpanAttributeWriter<bool> select_vert_attribute; BM_ITER_MESH_INDEX (eve, &iter, bm, BM_VERTS_OF_MESH, i) { MVert *mv = &mvert[i]; @@ -1282,15 +1271,27 @@ void BM_mesh_bm_to_me_for_eval(BMesh *bm, Mesh *me, const CustomData_MeshMasks * BM_elem_index_set(eve, i); /* set_inline */ - mv->flag = BM_vert_flag_to_mflag(eve); if (BM_elem_flag_test(eve, BM_ELEM_HIDDEN)) { - need_hide_vert = true; + if (!hide_vert_attribute) { + hide_vert_attribute = mesh_attributes.lookup_or_add_for_write_span<bool>( + ".hide_vert", ATTR_DOMAIN_POINT); + } + hide_vert_attribute.span[i] = true; + } + if (BM_elem_flag_test(eve, BM_ELEM_SELECT)) { + if (!select_vert_attribute) { + select_vert_attribute = mesh_attributes.lookup_or_add_for_write_span<bool>( + ".select_vert", ATTR_DOMAIN_POINT); + } + select_vert_attribute.span[i] = true; } CustomData_from_bmesh_block(&bm->vdata, &me->vdata, eve->head.data, i); } bm->elem_index_dirty &= ~BM_VERT; + bke::SpanAttributeWriter<bool> hide_edge_attribute; + bke::SpanAttributeWriter<bool> select_edge_attribute; BM_ITER_MESH_INDEX (eed, &iter, bm, BM_EDGES_OF_MESH, i) { MEdge *med = &medge[i]; @@ -1301,7 +1302,18 @@ void BM_mesh_bm_to_me_for_eval(BMesh *bm, Mesh *me, const CustomData_MeshMasks * med->flag = BM_edge_flag_to_mflag(eed); if (BM_elem_flag_test(eed, BM_ELEM_HIDDEN)) { - need_hide_edge = true; + if (!hide_edge_attribute) { + hide_edge_attribute = mesh_attributes.lookup_or_add_for_write_span<bool>(".hide_edge", + ATTR_DOMAIN_EDGE); + } + hide_edge_attribute.span[i] = true; + } + if (BM_elem_flag_test(eed, BM_ELEM_SELECT)) { + if (!select_edge_attribute) { + select_edge_attribute = mesh_attributes.lookup_or_add_for_write_span<bool>( + ".select_edge", ATTR_DOMAIN_EDGE); + } + select_edge_attribute.span[i] = true; } /* Handle this differently to editmode switching, @@ -1312,15 +1324,14 @@ void BM_mesh_bm_to_me_for_eval(BMesh *bm, Mesh *me, const CustomData_MeshMasks * } } - if (cd_edge_crease_offset != -1) { - med->crease = BM_ELEM_CD_GET_FLOAT_AS_UCHAR(eed, cd_edge_crease_offset); - } - CustomData_from_bmesh_block(&bm->edata, &me->edata, eed->head.data, i); } bm->elem_index_dirty &= ~BM_EDGE; j = 0; + bke::SpanAttributeWriter<int> material_index_attribute; + bke::SpanAttributeWriter<bool> hide_poly_attribute; + bke::SpanAttributeWriter<bool> select_poly_attribute; BM_ITER_MESH_INDEX (efa, &iter, bm, BM_FACES_OF_MESH, i) { BMLoop *l_iter; BMLoop *l_first; @@ -1331,12 +1342,27 @@ void BM_mesh_bm_to_me_for_eval(BMesh *bm, Mesh *me, const CustomData_MeshMasks * mp->totloop = efa->len; mp->flag = BM_face_flag_to_mflag(efa); if (BM_elem_flag_test(efa, BM_ELEM_HIDDEN)) { - need_hide_poly = true; + if (!hide_poly_attribute) { + hide_poly_attribute = mesh_attributes.lookup_or_add_for_write_span<bool>(".hide_poly", + ATTR_DOMAIN_FACE); + } + hide_poly_attribute.span[i] = true; + } + if (BM_elem_flag_test(efa, BM_ELEM_SELECT)) { + if (!select_poly_attribute) { + select_poly_attribute = mesh_attributes.lookup_or_add_for_write_span<bool>( + ".select_poly", ATTR_DOMAIN_FACE); + } + select_poly_attribute.span[i] = true; } mp->loopstart = j; if (efa->mat_nr != 0) { - need_material_index = true; + if (!material_index_attribute) { + material_index_attribute = mesh_attributes.lookup_or_add_for_write_span<int>( + "material_index", ATTR_DOMAIN_FACE); + } + material_index_attribute.span[i] = efa->mat_nr; } l_iter = l_first = BM_FACE_FIRST_LOOP(efa); @@ -1355,16 +1381,13 @@ void BM_mesh_bm_to_me_for_eval(BMesh *bm, Mesh *me, const CustomData_MeshMasks * } bm->elem_index_dirty &= ~(BM_FACE | BM_LOOP); - if (need_material_index) { - BM_mesh_elem_table_ensure(bm, BM_FACE); - write_fn_to_attribute<int>( - me->attributes_for_write(), "material_index", ATTR_DOMAIN_FACE, true, [&](const int i) { - return static_cast<int>(BM_face_at_index(bm, i)->mat_nr); - }); - } - - convert_bmesh_hide_flags_to_mesh_attributes( - *bm, need_hide_vert, need_hide_edge, need_hide_poly, *me); + assert_bmesh_has_no_mesh_only_attributes(*bm); - me->cd_flag = BM_mesh_cd_flag_from_bmesh(bm); + material_index_attribute.finish(); + hide_vert_attribute.finish(); + hide_edge_attribute.finish(); + hide_poly_attribute.finish(); + select_vert_attribute.finish(); + select_edge_attribute.finish(); + select_poly_attribute.finish(); } diff --git a/source/blender/bmesh/intern/bmesh_mesh_convert.h b/source/blender/bmesh/intern/bmesh_mesh_convert.h index a04136afc1d..3f8e9e3dfef 100644 --- a/source/blender/bmesh/intern/bmesh_mesh_convert.h +++ b/source/blender/bmesh/intern/bmesh_mesh_convert.h @@ -13,10 +13,6 @@ struct CustomData_MeshMasks; struct Main; struct Mesh; -void BM_mesh_cd_flag_ensure(BMesh *bm, struct Mesh *mesh, char cd_flag); -void BM_mesh_cd_flag_apply(BMesh *bm, char cd_flag); -char BM_mesh_cd_flag_from_bmesh(BMesh *bm); - struct BMeshFromMeshParams { bool calc_face_normal; bool calc_vert_normal; diff --git a/source/blender/bmesh/intern/bmesh_mesh_normals.c b/source/blender/bmesh/intern/bmesh_mesh_normals.c index cd89a550279..6705ac5acca 100644 --- a/source/blender/bmesh/intern/bmesh_mesh_normals.c +++ b/source/blender/bmesh/intern/bmesh_mesh_normals.c @@ -1780,7 +1780,7 @@ void BM_lnorspace_invalidate(BMesh *bm, const bool do_invalidate_all) /* Note that we only handle unselected neighbor vertices here, main loop will take care of * selected ones. */ - if ((!BM_elem_flag_test(l->prev->v, BM_ELEM_SELECT)) && + if (!BM_elem_flag_test(l->prev->v, BM_ELEM_SELECT) && !BLI_BITMAP_TEST(done_verts, BM_elem_index_get(l->prev->v))) { BMLoop *l_prev; @@ -1791,7 +1791,7 @@ void BM_lnorspace_invalidate(BMesh *bm, const bool do_invalidate_all) BLI_BITMAP_ENABLE(done_verts, BM_elem_index_get(l_prev->v)); } - if ((!BM_elem_flag_test(l->next->v, BM_ELEM_SELECT)) && + if (!BM_elem_flag_test(l->next->v, BM_ELEM_SELECT) && !BLI_BITMAP_TEST(done_verts, BM_elem_index_get(l->next->v))) { BMLoop *l_next; diff --git a/source/blender/bmesh/intern/bmesh_mesh_partial_update.c b/source/blender/bmesh/intern/bmesh_mesh_partial_update.c index 757ca8f19b6..197af450f72 100644 --- a/source/blender/bmesh/intern/bmesh_mesh_partial_update.c +++ b/source/blender/bmesh/intern/bmesh_mesh_partial_update.c @@ -52,7 +52,7 @@ #define GROW(len_alloc) ((len_alloc) + ((len_alloc) - ((len_alloc) / 2))) #define GROW_ARRAY(mem, len_alloc) \ { \ - mem = MEM_reallocN(mem, (sizeof(*mem)) * ((len_alloc) = GROW(len_alloc))); \ + mem = MEM_reallocN(mem, sizeof(*mem) * ((len_alloc) = GROW(len_alloc))); \ } \ ((void)0) diff --git a/source/blender/bmesh/intern/bmesh_mods.c b/source/blender/bmesh/intern/bmesh_mods.c index 8b56e08c22b..a1842b598d5 100644 --- a/source/blender/bmesh/intern/bmesh_mods.c +++ b/source/blender/bmesh/intern/bmesh_mods.c @@ -62,7 +62,7 @@ bool BM_disk_dissolve(BMesh *bm, BMVert *v) e = v->e; do { e = bmesh_disk_edge_next(e, v); - if (!(BM_edge_share_face_check(e, v->e))) { + if (!BM_edge_share_face_check(e, v->e)) { keepedge = e; baseedge = v->e; break; @@ -192,7 +192,7 @@ BMFace *BM_face_split(BMesh *bm, BLI_assert(!BM_loop_is_adjacent(l_a, l_b)); /* could be an assert */ - if (UNLIKELY(BM_loop_is_adjacent(l_a, l_b)) || UNLIKELY((f != l_a->f || f != l_b->f))) { + if (UNLIKELY(BM_loop_is_adjacent(l_a, l_b)) || UNLIKELY(f != l_a->f || f != l_b->f)) { if (r_l) { *r_l = NULL; } diff --git a/source/blender/bmesh/intern/bmesh_polygon_edgenet.c b/source/blender/bmesh/intern/bmesh_polygon_edgenet.c index 29bd066f33c..81793ee9995 100644 --- a/source/blender/bmesh/intern/bmesh_polygon_edgenet.c +++ b/source/blender/bmesh/intern/bmesh_polygon_edgenet.c @@ -1273,7 +1273,7 @@ bool BM_face_split_edgenet_connect_islands(BMesh *bm, BMVert *v_other; /* NOTE: remapping will _never_ map a vertex to an already mapped vertex. */ - while (UNLIKELY((v_other = bm_face_split_edgenet_partial_connect(bm, v_delimit, f)))) { + while (UNLIKELY(v_other = bm_face_split_edgenet_partial_connect(bm, v_delimit, f))) { struct TempVertPair *tvp = BLI_memarena_alloc(mem_arena, sizeof(*tvp)); tvp->next = temp_vert_pairs.list; tvp->v_orig = v_delimit; diff --git a/source/blender/bmesh/intern/bmesh_query.c b/source/blender/bmesh/intern/bmesh_query.c index 8bc16324971..643b5750d76 100644 --- a/source/blender/bmesh/intern/bmesh_query.c +++ b/source/blender/bmesh/intern/bmesh_query.c @@ -580,7 +580,7 @@ bool BM_vert_is_edge_pair_manifold(const BMVert *v) const BMEdge *e = v->e; if (e) { BMEdge *e_other = BM_DISK_EDGE_NEXT(e, v); - if (((e_other != e) && (BM_DISK_EDGE_NEXT(e_other, v) == e))) { + if ((e_other != e) && (BM_DISK_EDGE_NEXT(e_other, v) == e)) { return BM_edge_is_manifold(e) && BM_edge_is_manifold(e_other); } } diff --git a/source/blender/bmesh/intern/bmesh_query.h b/source/blender/bmesh/intern/bmesh_query.h index 9d690395d72..c3a30df11d6 100644 --- a/source/blender/bmesh/intern/bmesh_query.h +++ b/source/blender/bmesh/intern/bmesh_query.h @@ -708,7 +708,7 @@ double BM_mesh_calc_volume(BMesh *bm, bool is_signed) ATTR_WARN_UNUSED_RESULT AT * Calculate isolated groups of faces with optional filtering. * * \param bm: the BMesh. - * \param r_groups_array: Array of ints to fill in, length of bm->totface + * \param r_groups_array: Array of integers to fill in, length of `bm->totface` * (or when hflag_test is set, the number of flagged faces). * \param r_group_index: index, length pairs into \a r_groups_array, size of return value * int pairs: (array_start, array_length). diff --git a/source/blender/bmesh/intern/bmesh_query_uv.cc b/source/blender/bmesh/intern/bmesh_query_uv.cc index 5a725407c6b..0e2385ff4e2 100644 --- a/source/blender/bmesh/intern/bmesh_query_uv.cc +++ b/source/blender/bmesh/intern/bmesh_query_uv.cc @@ -65,7 +65,7 @@ void BM_face_uv_calc_center_median_weighted(const BMFace *f, } while ((l_iter = l_iter->next) != l_first); if (totw != 0.0f) { - mul_v2_fl(r_cent, 1.0f / (float)totw); + mul_v2_fl(r_cent, 1.0f / float(totw)); } /* Reverse aspect. */ r_cent[0] /= aspect[0]; @@ -85,7 +85,7 @@ void BM_face_uv_calc_center_median(const BMFace *f, const int cd_loop_uv_offset, add_v2_v2(r_cent, luv->uv); } while ((l_iter = l_iter->next) != l_first); - mul_v2_fl(r_cent, 1.0f / (float)f->len); + mul_v2_fl(r_cent, 1.0f / float(f->len)); } float BM_face_uv_calc_cross(const BMFace *f, const int cd_loop_uv_offset) @@ -113,17 +113,6 @@ void BM_face_uv_minmax(const BMFace *f, float min[2], float max[2], const int cd } while ((l_iter = l_iter->next) != l_first); } -void BM_face_uv_transform(BMFace *f, const float matrix[2][2], const int cd_loop_uv_offset) -{ - BMLoop *l_iter; - BMLoop *l_first; - l_iter = l_first = BM_FACE_FIRST_LOOP(f); - do { - MLoopUV *luv = (MLoopUV *)BM_ELEM_CD_GET_VOID_P(l_iter, cd_loop_uv_offset); - mul_m2_v2(matrix, luv->uv); - } while ((l_iter = l_iter->next) != l_first); -} - bool BM_loop_uv_share_edge_check(BMLoop *l_a, BMLoop *l_b, const int cd_loop_uv_offset) { BLI_assert(l_a->e == l_b->e); diff --git a/source/blender/bmesh/intern/bmesh_query_uv.h b/source/blender/bmesh/intern/bmesh_query_uv.h index 2b0833f9185..6aa82653535 100644 --- a/source/blender/bmesh/intern/bmesh_query_uv.h +++ b/source/blender/bmesh/intern/bmesh_query_uv.h @@ -34,7 +34,6 @@ float BM_face_uv_calc_cross(const BMFace *f, int cd_loop_uv_offset) ATTR_WARN_UN ATTR_NONNULL(); void BM_face_uv_minmax(const BMFace *f, float min[2], float max[2], int cd_loop_uv_offset); -void BM_face_uv_transform(BMFace *f, const float matrix[2][2], int cd_loop_uv_offset); bool BM_loop_uv_share_edge_check_with_limit(BMLoop *l_a, BMLoop *l_b, diff --git a/source/blender/bmesh/intern/bmesh_walkers_impl.c b/source/blender/bmesh/intern/bmesh_walkers_impl.c index bd12287e63e..ef9892669ed 100644 --- a/source/blender/bmesh/intern/bmesh_walkers_impl.c +++ b/source/blender/bmesh/intern/bmesh_walkers_impl.c @@ -1062,7 +1062,7 @@ static void *bmw_EdgeLoopWalker_step(BMWalker *walker) l = NULL; break; } - } while ((++i != i_opposite)); + } while (++i != i_opposite); } else { l = NULL; diff --git a/source/blender/bmesh/operators/bmo_bridge.c b/source/blender/bmesh/operators/bmo_bridge.c index 1a2c52a321f..b6520fb48b3 100644 --- a/source/blender/bmesh/operators/bmo_bridge.c +++ b/source/blender/bmesh/operators/bmo_bridge.c @@ -14,6 +14,13 @@ #include "intern/bmesh_operators_private.h" /* own include */ +/** + * TODO(@campbellbarton): Many connected edge loops can cause an error attempting + * to create faces with duplicate vertices. While this needs to be investigated, + * it's simple enough to check for this case, see: T102232. + */ +#define USE_DUPLICATE_FACE_VERT_CHECK + #define EDGE_MARK 4 #define EDGE_OUT 8 #define FACE_OUT 16 @@ -147,7 +154,7 @@ static void bridge_loop_pair(BMesh *bm, } if (use_merge) { - BLI_assert((el_store_a_len == el_store_b_len)); + BLI_assert(el_store_a_len == el_store_b_len); } if (el_store_a_len != el_store_b_len) { @@ -386,61 +393,84 @@ static void bridge_loop_pair(BMesh *bm, f_example = l_a ? l_a->f : (l_b ? l_b->f : NULL); if (v_b != v_b_next) { - BMVert *v_arr[4] = {v_b, v_b_next, v_a_next, v_a}; - f = BM_face_exists(v_arr, 4); - if (f == NULL) { - /* copy if loop data if its is missing on one ring */ - f = BM_face_create_verts(bm, v_arr, 4, NULL, BM_CREATE_NOP, true); - - l_iter = BM_FACE_FIRST_LOOP(f); - if (l_b) { - BM_elem_attrs_copy(bm, bm, l_b, l_iter); - } - l_iter = l_iter->next; - if (l_b_next) { - BM_elem_attrs_copy(bm, bm, l_b_next, l_iter); - } - l_iter = l_iter->next; - if (l_a_next) { - BM_elem_attrs_copy(bm, bm, l_a_next, l_iter); - } - l_iter = l_iter->next; - if (l_a) { - BM_elem_attrs_copy(bm, bm, l_a, l_iter); +#ifdef USE_DUPLICATE_FACE_VERT_CHECK /* Only check for duplicates between loops. */ + BLI_assert((v_b != v_b_next) && (v_a_next != v_a)); + if (UNLIKELY(ELEM(v_b, v_a_next, v_a) || ELEM(v_b_next, v_a_next, v_a))) { + f = NULL; + } + else +#endif + { + BMVert *v_arr[4] = {v_b, v_b_next, v_a_next, v_a}; + f = BM_face_exists(v_arr, 4); + if (f == NULL) { + /* copy if loop data if its is missing on one ring */ + f = BM_face_create_verts(bm, v_arr, 4, NULL, BM_CREATE_NOP, true); + + l_iter = BM_FACE_FIRST_LOOP(f); + if (l_b) { + BM_elem_attrs_copy(bm, bm, l_b, l_iter); + } + l_iter = l_iter->next; + if (l_b_next) { + BM_elem_attrs_copy(bm, bm, l_b_next, l_iter); + } + l_iter = l_iter->next; + if (l_a_next) { + BM_elem_attrs_copy(bm, bm, l_a_next, l_iter); + } + l_iter = l_iter->next; + if (l_a) { + BM_elem_attrs_copy(bm, bm, l_a, l_iter); + } } } } else { - BMVert *v_arr[3] = {v_b, v_a_next, v_a}; - f = BM_face_exists(v_arr, 3); - if (f == NULL) { - /* fan-fill a triangle */ - f = BM_face_create_verts(bm, v_arr, 3, NULL, BM_CREATE_NOP, true); - - l_iter = BM_FACE_FIRST_LOOP(f); - if (l_b) { - BM_elem_attrs_copy(bm, bm, l_b, l_iter); - } - l_iter = l_iter->next; - if (l_a_next) { - BM_elem_attrs_copy(bm, bm, l_a_next, l_iter); - } - l_iter = l_iter->next; - if (l_a) { - BM_elem_attrs_copy(bm, bm, l_a, l_iter); +#ifdef USE_DUPLICATE_FACE_VERT_CHECK /* Only check for duplicates between loops. */ + BLI_assert(v_a_next != v_a); + if (UNLIKELY(ELEM(v_b, v_a_next, v_a))) { + f = NULL; + } + else +#endif + { + BMVert *v_arr[3] = {v_b, v_a_next, v_a}; + f = BM_face_exists(v_arr, 3); + if (f == NULL) { + /* fan-fill a triangle */ + f = BM_face_create_verts(bm, v_arr, 3, NULL, BM_CREATE_NOP, true); + + l_iter = BM_FACE_FIRST_LOOP(f); + if (l_b) { + BM_elem_attrs_copy(bm, bm, l_b, l_iter); + } + l_iter = l_iter->next; + if (l_a_next) { + BM_elem_attrs_copy(bm, bm, l_a_next, l_iter); + } + l_iter = l_iter->next; + if (l_a) { + BM_elem_attrs_copy(bm, bm, l_a, l_iter); + } } } } - if (f_example && (f_example != f)) { - BM_elem_attrs_copy(bm, bm, f_example, f); - } - BMO_face_flag_enable(bm, f, FACE_OUT); - BM_elem_flag_enable(f, BM_ELEM_TAG); +#ifdef USE_DUPLICATE_FACE_VERT_CHECK + if (f != NULL) +#endif + { + if (f_example && (f_example != f)) { + BM_elem_attrs_copy(bm, bm, f_example, f); + } + BMO_face_flag_enable(bm, f, FACE_OUT); + BM_elem_flag_enable(f, BM_ELEM_TAG); - /* tag all edges of the face, untag the loop edges after */ - if (use_edgeout) { - bm_face_edges_tag_out(bm, f); + /* tag all edges of the face, untag the loop edges after */ + if (use_edgeout) { + bm_face_edges_tag_out(bm, f); + } } if (el_a_next == el_a_first) { diff --git a/source/blender/bmesh/operators/bmo_connect.c b/source/blender/bmesh/operators/bmo_connect.c index 42de425103e..59a12db9241 100644 --- a/source/blender/bmesh/operators/bmo_connect.c +++ b/source/blender/bmesh/operators/bmo_connect.c @@ -18,7 +18,7 @@ #define VERT_INPUT 1 #define EDGE_OUT 1 -/* Edge spans 2 VERT_INPUT's, its a nop, +/* Edge spans 2 VERT_INPUT's, its a NOP, * but include in "edges.out" */ #define EDGE_OUT_ADJ 2 diff --git a/source/blender/bmesh/operators/bmo_fill_edgeloop.c b/source/blender/bmesh/operators/bmo_fill_edgeloop.c index 86d204ea6a7..56aecf5e5b2 100644 --- a/source/blender/bmesh/operators/bmo_fill_edgeloop.c +++ b/source/blender/bmesh/operators/bmo_fill_edgeloop.c @@ -114,7 +114,7 @@ void bmo_edgeloop_fill_exec(BMesh *bm, BMOperator *op) v = BM_edge_other_vert(e_next, v); e_prev = e_next; i++; - } while ((v != f_verts[0])); + } while (v != f_verts[0]); if (!BM_face_exists(f_verts, i)) { BMFace *f; diff --git a/source/blender/bmesh/operators/bmo_inset.c b/source/blender/bmesh/operators/bmo_inset.c index 1da0108bd6a..2a6b5459d1c 100644 --- a/source/blender/bmesh/operators/bmo_inset.c +++ b/source/blender/bmesh/operators/bmo_inset.c @@ -721,7 +721,7 @@ void bmo_inset_region_exec(BMesh *bm, BMOperator *op) (use_boundary && BM_edge_is_boundary(e) && BM_elem_flag_test(e->l->f, BM_ELEM_TAG)) || /* tag if edge is an interior edge in between a tagged and untagged face */ - (bm_edge_is_mixed_face_tag(e->l))) { + bm_edge_is_mixed_face_tag(e->l)) { /* tag */ BM_elem_flag_enable(e->v1, BM_ELEM_TAG); BM_elem_flag_enable(e->v2, BM_ELEM_TAG); diff --git a/source/blender/bmesh/operators/bmo_join_triangles.c b/source/blender/bmesh/operators/bmo_join_triangles.c index 1339efb3057..df749b591dc 100644 --- a/source/blender/bmesh/operators/bmo_join_triangles.c +++ b/source/blender/bmesh/operators/bmo_join_triangles.c @@ -22,7 +22,9 @@ #include "intern/bmesh_operators_private.h" /* own include */ -/* assumes edges are validated before reaching this poin */ +/** + * \note Assumes edges are validated before reaching this point. + */ static float quad_calc_error(const float v1[3], const float v2[3], const float v3[3], @@ -41,11 +43,11 @@ static float quad_calc_error(const float v1[3], normal_tri_v3(n1, v1, v2, v3); normal_tri_v3(n2, v1, v3, v4); - angle_a = (compare_v3v3(n1, n2, FLT_EPSILON)) ? 0.0f : angle_normalized_v3v3(n1, n2); + angle_a = compare_v3v3(n1, n2, FLT_EPSILON) ? 0.0f : angle_normalized_v3v3(n1, n2); normal_tri_v3(n1, v2, v3, v4); normal_tri_v3(n2, v4, v1, v2); - angle_b = (compare_v3v3(n1, n2, FLT_EPSILON)) ? 0.0f : angle_normalized_v3v3(n1, n2); + angle_b = compare_v3v3(n1, n2, FLT_EPSILON) ? 0.0f : angle_normalized_v3v3(n1, n2); diff = (angle_a + angle_b) / (float)(M_PI * 2); @@ -164,15 +166,15 @@ static float bm_edge_is_delimit(const BMEdge *e, const struct DelimitData *delim float angle; #endif - if ((delimit_data->do_seam) && (BM_elem_flag_test(e, BM_ELEM_SEAM))) { + if (delimit_data->do_seam && BM_elem_flag_test(e, BM_ELEM_SEAM)) { goto fail; } - if ((delimit_data->do_sharp) && (BM_elem_flag_test(e, BM_ELEM_SMOOTH) == 0)) { + if (delimit_data->do_sharp && (BM_elem_flag_test(e, BM_ELEM_SMOOTH) == 0)) { goto fail; } - if ((delimit_data->do_mat) && (f_a->mat_nr != f_b->mat_nr)) { + if (delimit_data->do_mat && (f_a->mat_nr != f_b->mat_nr)) { goto fail; } diff --git a/source/blender/bmesh/operators/bmo_normals.c b/source/blender/bmesh/operators/bmo_normals.c index 04eaa43c899..0d321e1de8d 100644 --- a/source/blender/bmesh/operators/bmo_normals.c +++ b/source/blender/bmesh/operators/bmo_normals.c @@ -3,7 +3,7 @@ /** \file * \ingroup bmesh * - * normal recalculation. + * Functionality for flipping faces to make normals consistent. */ #include "MEM_guardedalloc.h" @@ -47,7 +47,7 @@ static bool bmo_recalc_normal_loop_filter_cb(const BMLoop *l, void *UNUSED(user_ * +------------+ * </pre> * - * In the example above, the a\ face can point towards the \a center + * In the example above, the \a face can point towards the \a center * which would end up flipping the normals inwards. * * To take these spikes into account, find the furthest face-loop-vertex. diff --git a/source/blender/bmesh/operators/bmo_removedoubles.c b/source/blender/bmesh/operators/bmo_removedoubles.c index e3275555b86..bf04228efef 100644 --- a/source/blender/bmesh/operators/bmo_removedoubles.c +++ b/source/blender/bmesh/operators/bmo_removedoubles.c @@ -563,7 +563,7 @@ static void bmo_collapsecon_do_layer(BMesh *bm, const int layer, const short ofl CustomData_data_multiply(type, &max, 0.5f); CustomData_data_add(type, &min, &max); - /* snap CD (uv, vcol) points to their centroid */ + /* Snap custom-data (UV, vertex-colors) points to their centroid. */ while (!BLI_stack_is_empty(block_stack)) { void *block; BLI_stack_pop(block_stack, &block); @@ -657,10 +657,10 @@ static void bmesh_find_doubles_common(BMesh *bm, for (int i = 0; i < verts_len; i++) { BMVert *v_check = verts[i]; if (duplicates[i] == -1) { - /* nop (others can use as target) */ + /* NOP (others can use as target). */ } else if (duplicates[i] == i) { - /* keep (others can use as target) */ + /* Keep (others can use as target). */ } else { BMVert *v_other = verts[duplicates[i]]; diff --git a/source/blender/bmesh/operators/bmo_rotate_edges.c b/source/blender/bmesh/operators/bmo_rotate_edges.c index 50d7014efcd..53efd47ec9a 100644 --- a/source/blender/bmesh/operators/bmo_rotate_edges.c +++ b/source/blender/bmesh/operators/bmo_rotate_edges.c @@ -66,7 +66,7 @@ static float bm_edge_rotate_is_boundary(const BMEdge *e) do { BMEdge *e_iter = l_iter->e; const int e_iter_index = BM_elem_index_get(e_iter); - if ((e_iter_index != -1)) { + if (e_iter_index != -1) { if (count == 1) { return false; } diff --git a/source/blender/bmesh/operators/bmo_smooth_laplacian.c b/source/blender/bmesh/operators/bmo_smooth_laplacian.c index 08efe5383a8..575a88331da 100644 --- a/source/blender/bmesh/operators/bmo_smooth_laplacian.c +++ b/source/blender/bmesh/operators/bmo_smooth_laplacian.c @@ -223,7 +223,7 @@ static void init_laplacian_matrix(LaplacianSystem *sys) sys->vweights[vi_prev] += w1 + w2; sys->vweights[vi_curr] += w2 + w3; sys->vweights[vi_next] += w1 + w3; - } while (((void)(l_curr_index += 1), (l_iter = l_iter->next) != l_first)); + } while ((void)(l_curr_index += 1), (l_iter = l_iter->next) != l_first); } } @@ -293,7 +293,7 @@ static void fill_laplacian_matrix(LaplacianSystem *sys) ok_prev = ok_curr; ok_curr = ok_next; - } while (((void)(l_curr_index += 1), (l_iter = l_iter->next) != l_first)); + } while ((void)(l_curr_index += 1), (l_iter = l_iter->next) != l_first); } BM_ITER_MESH_INDEX (e, &eiter, sys->bm, BM_EDGES_OF_MESH, i) { if (BM_elem_flag_test(e, BM_ELEM_SELECT) || !BM_edge_is_boundary(e)) { diff --git a/source/blender/bmesh/operators/bmo_subdivide.c b/source/blender/bmesh/operators/bmo_subdivide.c index d6c64809e13..6b2df40549d 100644 --- a/source/blender/bmesh/operators/bmo_subdivide.c +++ b/source/blender/bmesh/operators/bmo_subdivide.c @@ -86,7 +86,7 @@ typedef struct SubDPattern { * split the edge only? */ -/* flags for all elements share a common bitfield space */ +/** Flags for all elements share a common bit-field space. */ #define SUBD_SPLIT 1 #define EDGE_PERCENT 2 @@ -966,7 +966,7 @@ void bmo_subdivide_edges_exec(BMesh *bm, BMOperator *op) patterns[5] = NULL; } - /* add a temporary shapekey layer to store displacements on current geometry */ + /* Add a temporary shape-key layer to store displacements on current geometry. */ BM_data_layer_add(bm, &bm->vdata, CD_SHAPEKEY); bmo_subd_init_shape_info(bm, ¶ms); diff --git a/source/blender/bmesh/operators/bmo_subdivide_edgering.c b/source/blender/bmesh/operators/bmo_subdivide_edgering.c index 3d2f5947539..6f41da7bb43 100644 --- a/source/blender/bmesh/operators/bmo_subdivide_edgering.c +++ b/source/blender/bmesh/operators/bmo_subdivide_edgering.c @@ -42,7 +42,8 @@ #define FACE_IN_STACK (1 << 2) /* -------------------------------------------------------------------- */ -/* Specialized Utility Funcs */ +/** \name Specialized Utility Functions + * \{ */ #ifndef NDEBUG static uint bm_verts_tag_count(BMesh *bm) @@ -183,9 +184,13 @@ finally: return has_overlap; } +/** \} */ + /* -------------------------------------------------------------------- */ -/* Edge Loop Pairs */ -/* key (ordered loop pointers) */ +/** \name Edge Loop Pairs + * + * key (ordered loop pointers). + * \{ */ static GSet *bm_edgering_pair_calc(BMesh *bm, ListBase *eloops_rim) { /** @@ -258,8 +263,11 @@ static GSet *bm_edgering_pair_calc(BMesh *bm, ListBase *eloops_rim) return eloop_pair_gs; } +/** \} */ + /* -------------------------------------------------------------------- */ -/* Subdivide an edge 'n' times and return an open edgeloop */ +/** \name Subdivide an edge 'n' times and return an open edgeloop + * \{ */ static void bm_edge_subdiv_as_loop( BMesh *bm, ListBase *eloops, BMEdge *e, BMVert *v_a, const int cuts) @@ -290,8 +298,11 @@ static void bm_edge_subdiv_as_loop( BLI_addtail(eloops, eloop); } +/** \} */ + /* -------------------------------------------------------------------- */ -/* LoopPair Cache (struct and util funcs) */ +/** \name Loop Pair Cache (struct and utilities functions) + * \{ */ /** * Use for finding spline handle direction from surrounding faces. @@ -510,8 +521,11 @@ static void bm_edgering_pair_store_free(LoopPairStore *lpair, const int interp_m MEM_freeN(lpair); } +/** \} */ + /* -------------------------------------------------------------------- */ -/* Interpolation Function */ +/** \name Interpolation Function + * \{ */ static void bm_edgering_pair_interpolate(BMesh *bm, LoopPairStore *lpair, @@ -1216,3 +1230,5 @@ cleanup: BMO_slot_buffer_from_enabled_flag(bm, op, op->slots_out, "faces.out", BM_FACE, FACE_OUT); } } + +/** \} */ diff --git a/source/blender/bmesh/tests/bmesh_core_test.cc b/source/blender/bmesh/tests/bmesh_core_test.cc index 000e4cf92a2..a0f6ea2706b 100644 --- a/source/blender/bmesh/tests/bmesh_core_test.cc +++ b/source/blender/bmesh/tests/bmesh_core_test.cc @@ -24,7 +24,7 @@ TEST(bmesh_core, BMVertCreate) EXPECT_EQ(bv1->co[1], 2.0f); EXPECT_EQ(bv1->co[2], 0.0f); EXPECT_TRUE(is_zero_v3(bv1->no)); - EXPECT_EQ(bv1->head.htype, (char)BM_VERT); + EXPECT_EQ(bv1->head.htype, char(BM_VERT)); EXPECT_EQ(bv1->head.hflag, 0); EXPECT_EQ(bv1->head.api_flag, 0); bv2 = BM_vert_create(bm, nullptr, nullptr, BM_CREATE_NOP); diff --git a/source/blender/bmesh/tools/bmesh_bevel.c b/source/blender/bmesh/tools/bmesh_bevel.c index aa2c93f7c5a..c45f9dbe49c 100644 --- a/source/blender/bmesh/tools/bmesh_bevel.c +++ b/source/blender/bmesh/tools/bmesh_bevel.c @@ -2058,7 +2058,7 @@ static void get_profile_point(BevelParams *bp, const Profile *pro, int i, int ns } else { BLI_assert(is_power_of_2_i(nseg) && nseg <= bp->pro_spacing.seg_2); - /* Find spacing between subsamples in prof_co_2. */ + /* Find spacing between sub-samples in `prof_co_2`. */ int subsample_spacing = bp->pro_spacing.seg_2 / nseg; copy_v3_v3(r_co, pro->prof_co_2 + 3 * i * subsample_spacing); } @@ -4697,7 +4697,7 @@ static VMesh *pipe_adj_vmesh(BevelParams *bp, BevVert *bv, BoundVert *vpipe) * vertices to snap to the midline on the pipe, not just to one plane or the other. */ bool even = (ns % 2) == 0; bool midline = even && k == half_ns && - ((i == 0 && j == half_ns) || (ELEM(i, ipipe1, ipipe2))); + ((i == 0 && j == half_ns) || ELEM(i, ipipe1, ipipe2)); snap_to_pipe_profile(vpipe, midline, mesh_vert(vm, i, j, k)->co); } } @@ -4799,7 +4799,7 @@ static float projected_boundary_area(BevVert *bv, BMFace *f) find_face_internal_boundverts(bv, f, unsnapped); do { float *co = v->nv.v->co; - if (v == unsnapped[0] || v == unsnapped[1] || v == unsnapped[2]) { + if (ELEM(v, unsnapped[0], unsnapped[1], unsnapped[2])) { mul_v2_m3v3(proj_co[i], axis_mat, co); } else { @@ -4922,7 +4922,7 @@ static void build_center_ngon(BevelParams *bp, BMesh *bm, BevVert *bv, int mat_n BLI_array_append(vv, mesh_vert(vm, i, ns2, ns2)->v); if (frep) { BLI_array_append(vf, frep); - if (v == frep_unsnapped[0] || v == frep_unsnapped[1] || v == frep_unsnapped[2]) { + if (ELEM(v, frep_unsnapped[0], frep_unsnapped[1], frep_unsnapped[2])) { BLI_array_append(ve, NULL); } else { @@ -5299,7 +5299,7 @@ static void snap_edges_for_vmesh_vert(int i, int previ = (i + n_bndv - 1) % n_bndv; /* Make jj and kk be the j and k indices for this corner. */ int jj = corner < 2 ? j : j + 1; - int kk = (corner == 0 || corner == 3) ? k : k + 1; + int kk = ELEM(corner, 0, 3) ? k : k + 1; if (jj < ns2 && kk < ns2) { ; /* No snap. */ } @@ -5376,7 +5376,7 @@ static void bevel_build_rings(BevelParams *bp, BMesh *bm, BevVert *bv, BoundVert for (int i = 0; i < n_bndv; i++) { for (int j = 0; j <= ns2; j++) { for (int k = 0; k <= ns; k++) { - if (j == 0 && (ELEM(k, 0, ns))) { + if (j == 0 && ELEM(k, 0, ns)) { continue; /* Boundary corners already made. */ } if (!is_canon(vm, i, j, k)) { @@ -5765,7 +5765,7 @@ static BMFace *bevel_build_poly(BevelParams *bp, BMesh *bm, BevVert *bv) BLI_array_append(bmverts, bndv->nv.v); if (repface) { BLI_array_append(bmfaces, repface); - if (bndv == unsnapped[0] || bndv == unsnapped[1] || bndv == unsnapped[2]) { + if (ELEM(bndv, unsnapped[0], unsnapped[1], unsnapped[2])) { BLI_array_append(bmedges, NULL); } else { @@ -6285,7 +6285,7 @@ static void find_bevel_edge_order(BMesh *bm, BevVert *bv, BMEdge *first_bme) BMLoop *l; BM_ITER_ELEM (l, &iter, bme, BM_LOOPS_OF_EDGE) { BMFace *f = l->f; - if ((l->prev->e == bme2 || l->next->e == bme2)) { + if (l->prev->e == bme2 || l->next->e == bme2) { if (!bestf || l->v == bv->v) { bestf = f; } @@ -7083,7 +7083,7 @@ static void bevel_build_edge_polygons(BMesh *bm, BevelParams *bp, BMEdge *bme) } } - /* Fix UVs along end edge joints. A nop unless other side built already. */ + /* Fix UVs along end edge joints. A NOP unless other side built already. */ /* TODO: If some seam, may want to do selective merge. */ if (!bv1->any_seam && bv1->vmesh->mesh_kind == M_NONE) { bev_merge_end_uvs(bm, bv1, e1); diff --git a/source/blender/bmesh/tools/bmesh_bisect_plane.c b/source/blender/bmesh/tools/bmesh_bisect_plane.c index 3d7bacf7080..444f45277ca 100644 --- a/source/blender/bmesh/tools/bmesh_bisect_plane.c +++ b/source/blender/bmesh/tools/bmesh_bisect_plane.c @@ -170,7 +170,7 @@ static void bm_face_bisect_verts( BLI_assert(BM_VERT_DIR(l_iter->v) == 0); /* If both are -1 or 1, or both are zero: don't flip 'inside' var while walking. */ - BM_VERT_SKIP(l_iter->v) = (((BM_VERT_DIR(l_iter->prev->v) ^ BM_VERT_DIR(l_iter->next->v))) == + BM_VERT_SKIP(l_iter->v) = ((BM_VERT_DIR(l_iter->prev->v) ^ BM_VERT_DIR(l_iter->next->v)) == 0); STACK_PUSH(vert_split_arr, l_iter->v); @@ -463,7 +463,7 @@ void BM_mesh_bisect_plane(BMesh *bm, } vert_is_center_disable(v); - BM_VERT_DIR(v) = plane_point_test_v3(plane, v->co, eps, &(BM_VERT_DIST(v))); + BM_VERT_DIR(v) = plane_point_test_v3(plane, v->co, eps, &BM_VERT_DIST(v)); if (BM_VERT_DIR(v) == 0) { if (oflag_center) { diff --git a/source/blender/bmesh/tools/bmesh_boolean.cc b/source/blender/bmesh/tools/bmesh_boolean.cc index 216c73564c8..288a0d9ab74 100644 --- a/source/blender/bmesh/tools/bmesh_boolean.cc +++ b/source/blender/bmesh/tools/bmesh_boolean.cc @@ -187,7 +187,7 @@ static bool apply_mesh_output_to_bmesh(BMesh *bm, IMesh &m_out, bool keep_hidden float co[3]; const double3 &d_co = vertp->co; for (int i = 0; i < 3; ++i) { - co[i] = static_cast<float>(d_co[i]); + co[i] = float(d_co[i]); } BMVert *bmv = BM_vert_create(bm, co, nullptr, BM_CREATE_NOP); new_bmvs[v] = bmv; @@ -466,16 +466,16 @@ bool BM_mesh_boolean_knife(BMesh *bm, blender::meshintersect::BoolOpType::None); } #else -bool BM_mesh_boolean(BMesh *UNUSED(bm), +bool BM_mesh_boolean(BMesh * /*bm*/, struct BMLoop *(*looptris)[3], - const int UNUSED(looptris_tot), + const int /*looptris_tot*/, int (*test_fn)(BMFace *, void *), - void *UNUSED(user_data), - const int UNUSED(nshapes), - const bool UNUSED(use_self), - const bool UNUSED(keep_hidden), - const bool UNUSED(hole_tolerant), - const int UNUSED(boolean_mode)) + void * /*user_data*/, + const int /*nshapes*/, + const bool /*use_self*/, + const bool /*keep_hidden*/, + const bool /*hole_tolerant*/, + const int /*boolean_mode*/) { UNUSED_VARS(looptris, test_fn); return false; @@ -489,16 +489,16 @@ bool BM_mesh_boolean(BMesh *UNUSED(bm), * TODO: need to ensure that "selected/non-selected" flag of original faces gets propagated * to the intersection result faces. */ -bool BM_mesh_boolean_knife(BMesh *UNUSED(bm), +bool BM_mesh_boolean_knife(BMesh * /*bm*/, struct BMLoop *(*looptris)[3], - const int UNUSED(looptris_tot), + const int /*looptris_tot*/, int (*test_fn)(BMFace *, void *), - void *UNUSED(user_data), - const int UNUSED(nshapes), - const bool UNUSED(use_self), - const bool UNUSED(use_separate_all), - const bool UNUSED(hole_tolerant), - const bool UNUSED(keep_hidden)) + void * /*user_data*/, + const int /*nshapes*/, + const bool /*use_self*/, + const bool /*use_separate_all*/, + const bool /*hole_tolerant*/, + const bool /*keep_hidden*/) { UNUSED_VARS(looptris, test_fn); return false; diff --git a/source/blender/bmesh/tools/bmesh_decimate_collapse.c b/source/blender/bmesh/tools/bmesh_decimate_collapse.c index 81a392d38a5..1ea799f64e0 100644 --- a/source/blender/bmesh/tools/bmesh_decimate_collapse.c +++ b/source/blender/bmesh/tools/bmesh_decimate_collapse.c @@ -304,7 +304,7 @@ static void bm_decim_build_edge_cost_single(BMEdge *e, const float e_weight = 2.0f - (vweights[BM_elem_index_get(e->v1)] + vweights[BM_elem_index_get(e->v2)]); if (e_weight) { - cost += (BM_edge_calc_length(e) * ((e_weight * vweight_factor))); + cost += (BM_edge_calc_length(e) * (e_weight * vweight_factor)); } } @@ -618,9 +618,9 @@ static void bm_decim_triangulate_end(BMesh *bm, const int edges_tri_tot) (BM_loop_is_manifold(l) && ((l)->v != (l)->radial_next->v) && \ (l_a_index == BM_elem_index_get(l)) && (l_a_index == BM_elem_index_get((l)->radial_next))) - if ((l_a->f->len == 3 && l_b->f->len == 3) && (!CAN_LOOP_MERGE(l_a->next)) && - (!CAN_LOOP_MERGE(l_a->prev)) && (!CAN_LOOP_MERGE(l_b->next)) && - (!CAN_LOOP_MERGE(l_b->prev))) { + if ((l_a->f->len == 3 && l_b->f->len == 3) && !CAN_LOOP_MERGE(l_a->next) && + !CAN_LOOP_MERGE(l_a->prev) && !CAN_LOOP_MERGE(l_b->next) && + !CAN_LOOP_MERGE(l_b->prev)) { BMVert *vquad[4] = { e->v1, BM_vert_in_edge(e, l_a->next->v) ? l_a->prev->v : l_a->next->v, diff --git a/source/blender/bmesh/tools/bmesh_decimate_dissolve.c b/source/blender/bmesh/tools/bmesh_decimate_dissolve.c index 41c995a52bf..8a11815bd4c 100644 --- a/source/blender/bmesh/tools/bmesh_decimate_dissolve.c +++ b/source/blender/bmesh/tools/bmesh_decimate_dissolve.c @@ -330,7 +330,7 @@ void BM_mesh_decimate_dissolve_ex(BMesh *bm, } while ((BLI_heap_is_empty(eheap) == false) && - (BLI_heap_node_value((enode_top = BLI_heap_top(eheap))) < angle_limit_cos_neg)) { + (BLI_heap_node_value(enode_top = BLI_heap_top(eheap)) < angle_limit_cos_neg)) { BMFace *f_new = NULL; BMEdge *e; @@ -451,7 +451,7 @@ void BM_mesh_decimate_dissolve_ex(BMesh *bm, } while ((BLI_heap_is_empty(vheap) == false) && - (BLI_heap_node_value((vnode_top = BLI_heap_top(vheap))) < angle_limit)) { + (BLI_heap_node_value(vnode_top = BLI_heap_top(vheap)) < angle_limit)) { BMEdge *e_new = NULL; BMVert *v; diff --git a/source/blender/bmesh/tools/bmesh_decimate_unsubdivide.c b/source/blender/bmesh/tools/bmesh_decimate_unsubdivide.c index bd479bad945..02f0a25ea06 100644 --- a/source/blender/bmesh/tools/bmesh_decimate_unsubdivide.c +++ b/source/blender/bmesh/tools/bmesh_decimate_unsubdivide.c @@ -229,14 +229,15 @@ void BM_mesh_decimate_unsubdivide_ex(BMesh *bm, const int iterations, const bool #ifdef USE_WALKER /* Walk over selected elements starting at active */ - BMW_init(&walker, - bm, - BMW_CONNECTED_VERTEX, - ELE_VERT_TAG, - BMW_MASK_NOP, - BMW_MASK_NOP, - BMW_FLAG_NOP, /* don't use BMW_FLAG_TEST_HIDDEN here since we want to desel all */ - BMW_NIL_LAY); + BMW_init( + &walker, + bm, + BMW_CONNECTED_VERTEX, + ELE_VERT_TAG, + BMW_MASK_NOP, + BMW_MASK_NOP, + BMW_FLAG_NOP, /* don't use #BMW_FLAG_TEST_HIDDEN here since we want to deselect all. */ + BMW_NIL_LAY); BLI_assert(walker.order == BMW_BREADTH_FIRST); for (v = BMW_begin(&walker, v_first); v != NULL; v = BMW_step(&walker)) { diff --git a/source/blender/bmesh/tools/bmesh_edgenet.c b/source/blender/bmesh/tools/bmesh_edgenet.c index 110017739b9..020f2613f7d 100644 --- a/source/blender/bmesh/tools/bmesh_edgenet.c +++ b/source/blender/bmesh/tools/bmesh_edgenet.c @@ -37,7 +37,7 @@ enum { */ static bool bm_edge_step_ok(BMEdge *e) { - return BM_elem_flag_test(e, BM_ELEM_TAG) && (ELEM(e->l, NULL, e->l->radial_next)); + return BM_elem_flag_test(e, BM_ELEM_TAG) && ELEM(e->l, NULL, e->l->radial_next); } static int bm_edge_face(BMEdge *e) diff --git a/source/blender/bmesh/tools/bmesh_edgesplit.c b/source/blender/bmesh/tools/bmesh_edgesplit.c index a703b5338ef..03ff6b39d0e 100644 --- a/source/blender/bmesh/tools/bmesh_edgesplit.c +++ b/source/blender/bmesh/tools/bmesh_edgesplit.c @@ -51,8 +51,8 @@ void BM_mesh_edgesplit(BMesh *bm, */ 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); } diff --git a/source/blender/bmesh/tools/bmesh_intersect.c b/source/blender/bmesh/tools/bmesh_intersect.c index 8e1dfbebe47..a06efe8da96 100644 --- a/source/blender/bmesh/tools/bmesh_intersect.c +++ b/source/blender/bmesh/tools/bmesh_intersect.c @@ -1263,7 +1263,7 @@ bool BM_mesh_intersect(BMesh *bm, /* only start on an edge-case */ /* pass */ } - else if ((!BM_elem_flag_test(v_a, BM_ELEM_TAG)) && (!BM_elem_flag_test(v_b, BM_ELEM_TAG))) { + else if (!BM_elem_flag_test(v_a, BM_ELEM_TAG) && !BM_elem_flag_test(v_b, BM_ELEM_TAG)) { /* simple case, single edge spans face */ BMVert **splice_pair; BM_elem_flag_enable(e_pair[1], BM_ELEM_TAG); @@ -1490,7 +1490,7 @@ bool BM_mesh_intersect(BMesh *bm, (void)use_separate; #endif /* USE_SEPARATE */ - if ((boolean_mode != BMESH_ISECT_BOOLEAN_NONE)) { + if (boolean_mode != BMESH_ISECT_BOOLEAN_NONE) { BVHTree *tree_pair[2] = {tree_a, tree_b}; /* group vars */ diff --git a/source/blender/bmesh/tools/bmesh_path.c b/source/blender/bmesh/tools/bmesh_path.c index 5f1003ad808..764ce323923 100644 --- a/source/blender/bmesh/tools/bmesh_path.c +++ b/source/blender/bmesh/tools/bmesh_path.c @@ -231,7 +231,7 @@ static void edgetag_add_adjacent(HeapSimple *heap, BM_ITER_ELEM (v, &viter, e_a, BM_VERTS_OF_EDGE) { /* Don't walk over previous vertex. */ - if ((edges_prev[e_a_index]) && (BM_vert_in_edge(edges_prev[e_a_index], v))) { + if ((edges_prev[e_a_index]) && BM_vert_in_edge(edges_prev[e_a_index], v)) { continue; } diff --git a/source/blender/bmesh/tools/bmesh_path_region.c b/source/blender/bmesh/tools/bmesh_path_region.c index 1e464108b84..a90bf87ebb0 100644 --- a/source/blender/bmesh/tools/bmesh_path_region.c +++ b/source/blender/bmesh/tools/bmesh_path_region.c @@ -228,7 +228,7 @@ static LinkNode *mesh_calc_path_region_elem(BMesh *bm, /* Walk along the chain, fill in values until we reach a vertex with 3+ edges. */ { BMEdge *e_chain = e; - while (BM_vert_is_edge_pair_manifold(v_b) && ((depths[side][v_b_index] == -1))) { + while (BM_vert_is_edge_pair_manifold(v_b) && (depths[side][v_b_index] == -1)) { depths[side][v_b_index] = pass; BMEdge *e_chain_next = BM_DISK_EDGE_NEXT(e_chain, v_b); diff --git a/source/blender/bmesh/tools/bmesh_path_uv.c b/source/blender/bmesh/tools/bmesh_path_uv.c index 6531677fce6..ecc92fd09a4 100644 --- a/source/blender/bmesh/tools/bmesh_path_uv.c +++ b/source/blender/bmesh/tools/bmesh_path_uv.c @@ -354,7 +354,7 @@ struct LinkNode *BM_mesh_calc_path_uv_edge(BMesh *bm, while (!BLI_heapsimple_is_empty(heap)) { l = BLI_heapsimple_pop_min(heap); - if ((l->e == l_dst->e) && (BM_loop_uv_share_edge_check(l, l_dst, params->cd_loop_uv_offset))) { + if ((l->e == l_dst->e) && BM_loop_uv_share_edge_check(l, l_dst, params->cd_loop_uv_offset)) { break; } @@ -364,7 +364,7 @@ struct LinkNode *BM_mesh_calc_path_uv_edge(BMesh *bm, } } - if ((l->e == l_dst->e) && (BM_loop_uv_share_edge_check(l, l_dst, params->cd_loop_uv_offset))) { + if ((l->e == l_dst->e) && BM_loop_uv_share_edge_check(l, l_dst, params->cd_loop_uv_offset)) { do { BLI_linklist_prepend(&path, l); } while ((l = loops_prev[BM_elem_index_get(l)])); diff --git a/source/blender/bmesh/tools/bmesh_region_match.c b/source/blender/bmesh/tools/bmesh_region_match.c index d693755053c..8e971aeddb0 100644 --- a/source/blender/bmesh/tools/bmesh_region_match.c +++ b/source/blender/bmesh/tools/bmesh_region_match.c @@ -510,7 +510,7 @@ static void bm_uuidwalk_pass_add(UUIDWalk *uuidwalk, do { if (!BLI_ghash_haskey(uuidwalk->faces_uuid, l_iter_radial->f) && !BLI_gset_haskey(faces_step_next, l_iter_radial->f) && - (bm_uuidwalk_face_test(uuidwalk, l_iter_radial->f))) { + bm_uuidwalk_face_test(uuidwalk, l_iter_radial->f)) { BLI_gset_insert(faces_step_next, l_iter_radial->f); /* add to fstep */ diff --git a/source/blender/bmesh/tools/bmesh_wireframe.c b/source/blender/bmesh/tools/bmesh_wireframe.c index 14ec45f14b0..bdc36559e05 100644 --- a/source/blender/bmesh/tools/bmesh_wireframe.c +++ b/source/blender/bmesh/tools/bmesh_wireframe.c @@ -175,7 +175,7 @@ void BM_mesh_wireframe(BMesh *bm, BMVert **verts_neg = MEM_mallocN(sizeof(BMVert *) * totvert_orig, __func__); BMVert **verts_pos = MEM_mallocN(sizeof(BMVert *) * totvert_orig, __func__); - /* Will over-alloc, but makes for easy lookups by index to keep aligned. */ + /* Will over-allocate, but makes for easy lookups by index to keep aligned. */ BMVert **verts_boundary = use_boundary ? MEM_mallocN(sizeof(BMVert *) * totvert_orig, __func__) : NULL; |