From e0d4aede4da8a1f670f53fe597140111b9726234 Mon Sep 17 00:00:00 2001 From: Campbell Barton Date: Fri, 22 Jul 2022 16:49:37 +1000 Subject: BMesh: move bmesh_mesh to C++ This allows parts of the code to be threaded more easily. --- source/blender/bmesh/CMakeLists.txt | 2 +- source/blender/bmesh/intern/bmesh_mesh.c | 1354 ----------------------------- source/blender/bmesh/intern/bmesh_mesh.cc | 1350 ++++++++++++++++++++++++++++ 3 files changed, 1351 insertions(+), 1355 deletions(-) delete mode 100644 source/blender/bmesh/intern/bmesh_mesh.c create mode 100644 source/blender/bmesh/intern/bmesh_mesh.cc (limited to 'source') diff --git a/source/blender/bmesh/CMakeLists.txt b/source/blender/bmesh/CMakeLists.txt index 31492cd5c13..0d1eeab8eec 100644 --- a/source/blender/bmesh/CMakeLists.txt +++ b/source/blender/bmesh/CMakeLists.txt @@ -80,7 +80,7 @@ set(SRC intern/bmesh_log.h intern/bmesh_marking.c intern/bmesh_marking.h - intern/bmesh_mesh.c + intern/bmesh_mesh.cc intern/bmesh_mesh.h intern/bmesh_mesh_convert.cc intern/bmesh_mesh_convert.h diff --git a/source/blender/bmesh/intern/bmesh_mesh.c b/source/blender/bmesh/intern/bmesh_mesh.c deleted file mode 100644 index 7dba854b9ef..00000000000 --- a/source/blender/bmesh/intern/bmesh_mesh.c +++ /dev/null @@ -1,1354 +0,0 @@ -/* SPDX-License-Identifier: GPL-2.0-or-later */ - -/** \file - * \ingroup bmesh - * - * BM mesh level functions. - */ - -#include "MEM_guardedalloc.h" - -#include "DNA_listBase.h" -#include "DNA_scene_types.h" - -#include "BLI_listbase.h" -#include "BLI_math.h" -#include "BLI_utildefines.h" - -#include "BKE_customdata.h" -#include "BKE_mesh.h" - -#include "bmesh.h" - -const BMAllocTemplate bm_mesh_allocsize_default = {512, 1024, 2048, 512}; -const BMAllocTemplate bm_mesh_chunksize_default = {512, 1024, 2048, 512}; - -static void bm_mempool_init_ex(const BMAllocTemplate *allocsize, - const bool use_toolflags, - BLI_mempool **r_vpool, - BLI_mempool **r_epool, - BLI_mempool **r_lpool, - BLI_mempool **r_fpool) -{ - size_t vert_size, edge_size, loop_size, face_size; - - if (use_toolflags == true) { - vert_size = sizeof(BMVert_OFlag); - edge_size = sizeof(BMEdge_OFlag); - loop_size = sizeof(BMLoop); - face_size = sizeof(BMFace_OFlag); - } - else { - vert_size = sizeof(BMVert); - edge_size = sizeof(BMEdge); - loop_size = sizeof(BMLoop); - face_size = sizeof(BMFace); - } - - if (r_vpool) { - *r_vpool = BLI_mempool_create( - vert_size, allocsize->totvert, bm_mesh_chunksize_default.totvert, BLI_MEMPOOL_ALLOW_ITER); - } - if (r_epool) { - *r_epool = BLI_mempool_create( - edge_size, allocsize->totedge, bm_mesh_chunksize_default.totedge, BLI_MEMPOOL_ALLOW_ITER); - } - if (r_lpool) { - *r_lpool = BLI_mempool_create( - loop_size, allocsize->totloop, bm_mesh_chunksize_default.totloop, BLI_MEMPOOL_NOP); - } - if (r_fpool) { - *r_fpool = BLI_mempool_create( - face_size, allocsize->totface, bm_mesh_chunksize_default.totface, BLI_MEMPOOL_ALLOW_ITER); - } -} - -static void bm_mempool_init(BMesh *bm, const BMAllocTemplate *allocsize, const bool use_toolflags) -{ - bm_mempool_init_ex(allocsize, use_toolflags, &bm->vpool, &bm->epool, &bm->lpool, &bm->fpool); - -#ifdef USE_BMESH_HOLES - bm->looplistpool = BLI_mempool_create(sizeof(BMLoopList), 512, 512, BLI_MEMPOOL_NOP); -#endif -} - -void BM_mesh_elem_toolflags_ensure(BMesh *bm) -{ - BLI_assert(bm->use_toolflags); - - if (bm->vtoolflagpool && bm->etoolflagpool && bm->ftoolflagpool) { - return; - } - - bm->vtoolflagpool = BLI_mempool_create(sizeof(BMFlagLayer), bm->totvert, 512, BLI_MEMPOOL_NOP); - bm->etoolflagpool = BLI_mempool_create(sizeof(BMFlagLayer), bm->totedge, 512, BLI_MEMPOOL_NOP); - bm->ftoolflagpool = BLI_mempool_create(sizeof(BMFlagLayer), bm->totface, 512, BLI_MEMPOOL_NOP); - - BMIter iter; - BMVert_OFlag *v_olfag; - BLI_mempool *toolflagpool = bm->vtoolflagpool; - BM_ITER_MESH (v_olfag, &iter, bm, BM_VERTS_OF_MESH) { - v_olfag->oflags = BLI_mempool_calloc(toolflagpool); - } - - BMEdge_OFlag *e_olfag; - toolflagpool = bm->etoolflagpool; - BM_ITER_MESH (e_olfag, &iter, bm, BM_EDGES_OF_MESH) { - e_olfag->oflags = BLI_mempool_calloc(toolflagpool); - } - - BMFace_OFlag *f_olfag; - toolflagpool = bm->ftoolflagpool; - BM_ITER_MESH (f_olfag, &iter, bm, BM_FACES_OF_MESH) { - f_olfag->oflags = BLI_mempool_calloc(toolflagpool); - } - - bm->totflags = 1; -} - -void BM_mesh_elem_toolflags_clear(BMesh *bm) -{ - if (bm->vtoolflagpool) { - BLI_mempool_destroy(bm->vtoolflagpool); - bm->vtoolflagpool = NULL; - } - if (bm->etoolflagpool) { - BLI_mempool_destroy(bm->etoolflagpool); - bm->etoolflagpool = NULL; - } - if (bm->ftoolflagpool) { - BLI_mempool_destroy(bm->ftoolflagpool); - bm->ftoolflagpool = NULL; - } -} - -BMesh *BM_mesh_create(const BMAllocTemplate *allocsize, const struct BMeshCreateParams *params) -{ - /* allocate the structure */ - BMesh *bm = MEM_callocN(sizeof(BMesh), __func__); - - /* allocate the memory pools for the mesh elements */ - bm_mempool_init(bm, allocsize, params->use_toolflags); - - /* allocate one flag pool that we don't get rid of. */ - bm->use_toolflags = params->use_toolflags; - bm->toolflag_index = 0; - bm->totflags = 0; - - CustomData_reset(&bm->vdata); - CustomData_reset(&bm->edata); - CustomData_reset(&bm->ldata); - CustomData_reset(&bm->pdata); - - return bm; -} - -void BM_mesh_data_free(BMesh *bm) -{ - BMVert *v; - BMEdge *e; - BMLoop *l; - BMFace *f; - - BMIter iter; - BMIter itersub; - - const bool is_ldata_free = CustomData_bmesh_has_free(&bm->ldata); - const bool is_pdata_free = CustomData_bmesh_has_free(&bm->pdata); - - /* Check if we have to call free, if not we can avoid a lot of looping */ - if (CustomData_bmesh_has_free(&(bm->vdata))) { - BM_ITER_MESH (v, &iter, bm, BM_VERTS_OF_MESH) { - CustomData_bmesh_free_block(&(bm->vdata), &(v->head.data)); - } - } - if (CustomData_bmesh_has_free(&(bm->edata))) { - BM_ITER_MESH (e, &iter, bm, BM_EDGES_OF_MESH) { - CustomData_bmesh_free_block(&(bm->edata), &(e->head.data)); - } - } - - if (is_ldata_free || is_pdata_free) { - BM_ITER_MESH (f, &iter, bm, BM_FACES_OF_MESH) { - if (is_pdata_free) { - CustomData_bmesh_free_block(&(bm->pdata), &(f->head.data)); - } - if (is_ldata_free) { - BM_ITER_ELEM (l, &itersub, f, BM_LOOPS_OF_FACE) { - CustomData_bmesh_free_block(&(bm->ldata), &(l->head.data)); - } - } - } - } - - /* Free custom data pools, This should probably go in CustomData_free? */ - if (bm->vdata.totlayer) { - BLI_mempool_destroy(bm->vdata.pool); - } - if (bm->edata.totlayer) { - BLI_mempool_destroy(bm->edata.pool); - } - if (bm->ldata.totlayer) { - BLI_mempool_destroy(bm->ldata.pool); - } - if (bm->pdata.totlayer) { - BLI_mempool_destroy(bm->pdata.pool); - } - - /* free custom data */ - CustomData_free(&bm->vdata, 0); - CustomData_free(&bm->edata, 0); - CustomData_free(&bm->ldata, 0); - CustomData_free(&bm->pdata, 0); - - /* destroy element pools */ - BLI_mempool_destroy(bm->vpool); - BLI_mempool_destroy(bm->epool); - BLI_mempool_destroy(bm->lpool); - BLI_mempool_destroy(bm->fpool); - - if (bm->vtable) { - MEM_freeN(bm->vtable); - } - if (bm->etable) { - MEM_freeN(bm->etable); - } - if (bm->ftable) { - MEM_freeN(bm->ftable); - } - - /* destroy flag pool */ - BM_mesh_elem_toolflags_clear(bm); - -#ifdef USE_BMESH_HOLES - BLI_mempool_destroy(bm->looplistpool); -#endif - - BLI_freelistN(&bm->selected); - - if (bm->lnor_spacearr) { - BKE_lnor_spacearr_free(bm->lnor_spacearr); - MEM_freeN(bm->lnor_spacearr); - } - - BMO_error_clear(bm); -} - -void BM_mesh_clear(BMesh *bm) -{ - const bool use_toolflags = bm->use_toolflags; - - /* free old mesh */ - BM_mesh_data_free(bm); - memset(bm, 0, sizeof(BMesh)); - - /* allocate the memory pools for the mesh elements */ - bm_mempool_init(bm, &bm_mesh_allocsize_default, use_toolflags); - - bm->use_toolflags = use_toolflags; - bm->toolflag_index = 0; - bm->totflags = 0; - - CustomData_reset(&bm->vdata); - CustomData_reset(&bm->edata); - CustomData_reset(&bm->ldata); - CustomData_reset(&bm->pdata); -} - -void BM_mesh_free(BMesh *bm) -{ - BM_mesh_data_free(bm); - - if (bm->py_handle) { - /* keep this out of 'BM_mesh_data_free' because we want python - * to be able to clear the mesh and maintain access. */ - bpy_bm_generic_invalidate(bm->py_handle); - bm->py_handle = NULL; - } - - MEM_freeN(bm); -} - -void bmesh_edit_begin(BMesh *UNUSED(bm), BMOpTypeFlag UNUSED(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 - * (loop cuts, edge subdivides, etc) are not reflected in the higher levels of - * the mesh at all, which doesn't seem right. Turning off completely for now, - * until this is shown to be better for certain types of mesh edits. */ -#ifdef BMOP_UNTAN_MULTIRES_ENABLED - /* switch multires data out of tangent space */ - if ((type_flag & BMO_OPTYPE_FLAG_UNTAN_MULTIRES) && - CustomData_has_layer(&bm->ldata, CD_MDISPS)) { - bmesh_mdisps_space_set(bm, MULTIRES_SPACE_TANGENT, MULTIRES_SPACE_ABSOLUTE); - - /* ensure correct normals, if possible */ - bmesh_rationalize_normals(bm, 0); - BM_mesh_normals_update(bm); - } -#endif -} - -void bmesh_edit_end(BMesh *bm, BMOpTypeFlag type_flag) -{ - ListBase select_history; - - /* BMO_OPTYPE_FLAG_UNTAN_MULTIRES disabled for now, see comment above in bmesh_edit_begin. */ -#ifdef BMOP_UNTAN_MULTIRES_ENABLED - /* switch multires data into tangent space */ - if ((flag & BMO_OPTYPE_FLAG_UNTAN_MULTIRES) && CustomData_has_layer(&bm->ldata, CD_MDISPS)) { - /* set normals to their previous winding */ - bmesh_rationalize_normals(bm, 1); - bmesh_mdisps_space_set(bm, MULTIRES_SPACE_ABSOLUTE, MULTIRES_SPACE_TANGENT); - } - else if (flag & BMO_OP_FLAG_RATIONALIZE_NORMALS) { - bmesh_rationalize_normals(bm, 1); - } -#endif - - /* compute normals, clear temp flags and flush selections */ - if (type_flag & BMO_OPTYPE_FLAG_NORMALS_CALC) { - bm->spacearr_dirty |= BM_SPACEARR_DIRTY_ALL; - BM_mesh_normals_update(bm); - } - - if ((type_flag & BMO_OPTYPE_FLAG_SELECT_VALIDATE) == 0) { - select_history = bm->selected; - BLI_listbase_clear(&bm->selected); - } - - if (type_flag & BMO_OPTYPE_FLAG_SELECT_FLUSH) { - BM_mesh_select_mode_flush(bm); - } - - if ((type_flag & BMO_OPTYPE_FLAG_SELECT_VALIDATE) == 0) { - bm->selected = select_history; - } - if (type_flag & BMO_OPTYPE_FLAG_INVALIDATE_CLNOR_ALL) { - bm->spacearr_dirty |= BM_SPACEARR_DIRTY_ALL; - } -} - -void BM_mesh_elem_index_ensure_ex(BMesh *bm, const char htype, int elem_offset[4]) -{ - -#ifdef DEBUG - BM_ELEM_INDEX_VALIDATE(bm, "Should Never Fail!", __func__); -#endif - - if (elem_offset == NULL) { - /* Simple case. */ - const char htype_needed = bm->elem_index_dirty & htype; - if (htype_needed == 0) { - goto finally; - } - } - - if (htype & BM_VERT) { - if ((bm->elem_index_dirty & BM_VERT) || (elem_offset && elem_offset[0])) { - BMIter iter; - BMElem *ele; - - int index = elem_offset ? elem_offset[0] : 0; - BM_ITER_MESH (ele, &iter, bm, BM_VERTS_OF_MESH) { - BM_elem_index_set(ele, index++); /* set_ok */ - } - BLI_assert(elem_offset || index == bm->totvert); - } - else { - // printf("%s: skipping vert index calc!\n", __func__); - } - } - - if (htype & BM_EDGE) { - if ((bm->elem_index_dirty & BM_EDGE) || (elem_offset && elem_offset[1])) { - BMIter iter; - BMElem *ele; - - int index = elem_offset ? elem_offset[1] : 0; - BM_ITER_MESH (ele, &iter, bm, BM_EDGES_OF_MESH) { - BM_elem_index_set(ele, index++); /* set_ok */ - } - BLI_assert(elem_offset || index == bm->totedge); - } - else { - // printf("%s: skipping edge index calc!\n", __func__); - } - } - - if (htype & (BM_FACE | BM_LOOP)) { - if ((bm->elem_index_dirty & (BM_FACE | BM_LOOP)) || - (elem_offset && (elem_offset[2] || elem_offset[3]))) { - BMIter iter; - BMElem *ele; - - const bool update_face = (htype & BM_FACE) && (bm->elem_index_dirty & BM_FACE); - const bool update_loop = (htype & BM_LOOP) && (bm->elem_index_dirty & BM_LOOP); - - int index_loop = elem_offset ? elem_offset[2] : 0; - int index = elem_offset ? elem_offset[3] : 0; - - BM_ITER_MESH (ele, &iter, bm, BM_FACES_OF_MESH) { - if (update_face) { - BM_elem_index_set(ele, index++); /* set_ok */ - } - - if (update_loop) { - BMLoop *l_iter, *l_first; - - l_iter = l_first = BM_FACE_FIRST_LOOP((BMFace *)ele); - do { - BM_elem_index_set(l_iter, index_loop++); /* set_ok */ - } while ((l_iter = l_iter->next) != l_first); - } - } - - BLI_assert(elem_offset || !update_face || index == bm->totface); - if (update_loop) { - BLI_assert(elem_offset || !update_loop || index_loop == bm->totloop); - } - } - else { - // printf("%s: skipping face/loop index calc!\n", __func__); - } - } - -finally: - bm->elem_index_dirty &= ~htype; - if (elem_offset) { - if (htype & BM_VERT) { - elem_offset[0] += bm->totvert; - if (elem_offset[0] != bm->totvert) { - bm->elem_index_dirty |= BM_VERT; - } - } - if (htype & BM_EDGE) { - elem_offset[1] += bm->totedge; - if (elem_offset[1] != bm->totedge) { - bm->elem_index_dirty |= BM_EDGE; - } - } - if (htype & BM_LOOP) { - elem_offset[2] += bm->totloop; - if (elem_offset[2] != bm->totloop) { - bm->elem_index_dirty |= BM_LOOP; - } - } - if (htype & BM_FACE) { - elem_offset[3] += bm->totface; - if (elem_offset[3] != bm->totface) { - bm->elem_index_dirty |= BM_FACE; - } - } - } -} - -void BM_mesh_elem_index_ensure(BMesh *bm, const char htype) -{ - BM_mesh_elem_index_ensure_ex(bm, htype, NULL); -} - -void BM_mesh_elem_index_validate( - BMesh *bm, const char *location, const char *func, const char *msg_a, const char *msg_b) -{ - const char iter_types[3] = {BM_VERTS_OF_MESH, BM_EDGES_OF_MESH, BM_FACES_OF_MESH}; - - const char flag_types[3] = {BM_VERT, BM_EDGE, BM_FACE}; - const char *type_names[3] = {"vert", "edge", "face"}; - - BMIter iter; - BMElem *ele; - int i; - bool is_any_error = 0; - - for (i = 0; i < 3; i++) { - const bool is_dirty = (flag_types[i] & bm->elem_index_dirty) != 0; - int index = 0; - bool is_error = false; - int err_val = 0; - int err_idx = 0; - - BM_ITER_MESH (ele, &iter, bm, iter_types[i]) { - if (!is_dirty) { - if (BM_elem_index_get(ele) != index) { - err_val = BM_elem_index_get(ele); - err_idx = index; - is_error = true; - break; - } - } - index++; - } - - 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)) { - -#if 0 /* mostly annoying */ - - /* dirty may have been incorrectly set */ - fprintf(stderr, - "Invalid Dirty: at %s, %s (%s), dirty flag was set but all index values are " - "correct, '%s', '%s'\n", - location, - func, - type_names[i], - msg_a, - msg_b); -#endif - } - } - -#if 0 /* mostly annoying, even in debug mode */ -# ifdef DEBUG - if (is_any_error == 0) { - fprintf(stderr, "Valid Index Success: at %s, %s, '%s', '%s'\n", location, func, msg_a, msg_b); - } -# endif -#endif - (void)is_any_error; /* shut up the compiler */ -} - -/* debug check only - no need to optimize */ -#ifndef NDEBUG -bool BM_mesh_elem_table_check(BMesh *bm) -{ - BMIter iter; - BMElem *ele; - int i; - - if (bm->vtable && ((bm->elem_table_dirty & BM_VERT) == 0)) { - BM_ITER_MESH_INDEX (ele, &iter, bm, BM_VERTS_OF_MESH, i) { - if (ele != (BMElem *)bm->vtable[i]) { - return false; - } - } - } - - if (bm->etable && ((bm->elem_table_dirty & BM_EDGE) == 0)) { - BM_ITER_MESH_INDEX (ele, &iter, bm, BM_EDGES_OF_MESH, i) { - if (ele != (BMElem *)bm->etable[i]) { - return false; - } - } - } - - if (bm->ftable && ((bm->elem_table_dirty & BM_FACE) == 0)) { - BM_ITER_MESH_INDEX (ele, &iter, bm, BM_FACES_OF_MESH, i) { - if (ele != (BMElem *)bm->ftable[i]) { - return false; - } - } - } - - return true; -} -#endif - -void BM_mesh_elem_table_ensure(BMesh *bm, const char htype) -{ - /* assume if the array is non-null then its valid and no need to recalc */ - const char htype_needed = - (((bm->vtable && ((bm->elem_table_dirty & BM_VERT) == 0)) ? 0 : BM_VERT) | - ((bm->etable && ((bm->elem_table_dirty & BM_EDGE) == 0)) ? 0 : BM_EDGE) | - ((bm->ftable && ((bm->elem_table_dirty & BM_FACE) == 0)) ? 0 : BM_FACE)) & - htype; - - BLI_assert((htype & ~BM_ALL_NOLOOP) == 0); - - /* in debug mode double check we didn't need to recalculate */ - BLI_assert(BM_mesh_elem_table_check(bm) == true); - - if (htype_needed == 0) { - goto finally; - } - - if (htype_needed & BM_VERT) { - if (bm->vtable && bm->totvert <= bm->vtable_tot && bm->totvert * 2 >= bm->vtable_tot) { - /* pass (re-use the array) */ - } - else { - if (bm->vtable) { - MEM_freeN(bm->vtable); - } - bm->vtable = MEM_mallocN(sizeof(void **) * bm->totvert, "bm->vtable"); - bm->vtable_tot = bm->totvert; - } - } - if (htype_needed & BM_EDGE) { - if (bm->etable && bm->totedge <= bm->etable_tot && bm->totedge * 2 >= bm->etable_tot) { - /* pass (re-use the array) */ - } - else { - if (bm->etable) { - MEM_freeN(bm->etable); - } - bm->etable = MEM_mallocN(sizeof(void **) * bm->totedge, "bm->etable"); - bm->etable_tot = bm->totedge; - } - } - if (htype_needed & BM_FACE) { - if (bm->ftable && bm->totface <= bm->ftable_tot && bm->totface * 2 >= bm->ftable_tot) { - /* pass (re-use the array) */ - } - else { - if (bm->ftable) { - MEM_freeN(bm->ftable); - } - bm->ftable = MEM_mallocN(sizeof(void **) * bm->totface, "bm->ftable"); - bm->ftable_tot = bm->totface; - } - } - - if (htype_needed & BM_VERT) { - BM_iter_as_array(bm, BM_VERTS_OF_MESH, NULL, (void **)bm->vtable, bm->totvert); - } - - if (htype_needed & BM_EDGE) { - BM_iter_as_array(bm, BM_EDGES_OF_MESH, NULL, (void **)bm->etable, bm->totedge); - } - - if (htype_needed & BM_FACE) { - BM_iter_as_array(bm, BM_FACES_OF_MESH, NULL, (void **)bm->ftable, bm->totface); - } - -finally: - /* Only clear dirty flags when all the pointers and data are actually valid. - * This prevents possible threading issues when dirty flag check failed but - * data wasn't ready still. - */ - bm->elem_table_dirty &= ~htype_needed; -} - -void BM_mesh_elem_table_init(BMesh *bm, const char htype) -{ - BLI_assert((htype & ~BM_ALL_NOLOOP) == 0); - - /* force recalc */ - BM_mesh_elem_table_free(bm, BM_ALL_NOLOOP); - BM_mesh_elem_table_ensure(bm, htype); -} - -void BM_mesh_elem_table_free(BMesh *bm, const char htype) -{ - if (htype & BM_VERT) { - MEM_SAFE_FREE(bm->vtable); - } - - if (htype & BM_EDGE) { - MEM_SAFE_FREE(bm->etable); - } - - if (htype & BM_FACE) { - MEM_SAFE_FREE(bm->ftable); - } -} - -BMVert *BM_vert_at_index_find(BMesh *bm, const int index) -{ - return BLI_mempool_findelem(bm->vpool, index); -} - -BMEdge *BM_edge_at_index_find(BMesh *bm, const int index) -{ - return BLI_mempool_findelem(bm->epool, index); -} - -BMFace *BM_face_at_index_find(BMesh *bm, const int index) -{ - return BLI_mempool_findelem(bm->fpool, index); -} - -BMLoop *BM_loop_at_index_find(BMesh *bm, const int index) -{ - BMIter iter; - BMFace *f; - int i = index; - BM_ITER_MESH (f, &iter, bm, BM_FACES_OF_MESH) { - if (i < f->len) { - BMLoop *l_first, *l_iter; - l_iter = l_first = BM_FACE_FIRST_LOOP(f); - do { - if (i == 0) { - return l_iter; - } - i -= 1; - } while ((l_iter = l_iter->next) != l_first); - } - i -= f->len; - } - return NULL; -} - -BMVert *BM_vert_at_index_find_or_table(BMesh *bm, const int index) -{ - if ((bm->elem_table_dirty & BM_VERT) == 0) { - return (index < bm->totvert) ? bm->vtable[index] : NULL; - } - return BM_vert_at_index_find(bm, index); -} - -BMEdge *BM_edge_at_index_find_or_table(BMesh *bm, const int index) -{ - if ((bm->elem_table_dirty & BM_EDGE) == 0) { - return (index < bm->totedge) ? bm->etable[index] : NULL; - } - return BM_edge_at_index_find(bm, index); -} - -BMFace *BM_face_at_index_find_or_table(BMesh *bm, const int index) -{ - if ((bm->elem_table_dirty & BM_FACE) == 0) { - return (index < bm->totface) ? bm->ftable[index] : NULL; - } - return BM_face_at_index_find(bm, index); -} - -int BM_mesh_elem_count(BMesh *bm, const char htype) -{ - BLI_assert((htype & ~BM_ALL_NOLOOP) == 0); - - switch (htype) { - case BM_VERT: - return bm->totvert; - case BM_EDGE: - return bm->totedge; - case BM_FACE: - return bm->totface; - default: { - BLI_assert(0); - return 0; - } - } -} - -void BM_mesh_remap(BMesh *bm, const uint *vert_idx, const uint *edge_idx, const uint *face_idx) -{ - /* Mapping old to new pointers. */ - GHash *vptr_map = NULL, *eptr_map = NULL, *fptr_map = NULL; - BMIter iter, iterl; - BMVert *ve; - BMEdge *ed; - BMFace *fa; - BMLoop *lo; - - if (!(vert_idx || edge_idx || face_idx)) { - return; - } - - BM_mesh_elem_table_ensure( - bm, (vert_idx ? BM_VERT : 0) | (edge_idx ? BM_EDGE : 0) | (face_idx ? BM_FACE : 0)); - - /* Remap Verts */ - if (vert_idx) { - BMVert **verts_pool, *verts_copy, **vep; - int i, totvert = bm->totvert; - const uint *new_idx; - /* Special case: Python uses custom data layers to hold PyObject references. - * These have to be kept in place, else the PyObjects we point to, won't point back to us. */ - const int cd_vert_pyptr = CustomData_get_offset(&bm->vdata, CD_BM_ELEM_PYPTR); - - /* Init the old-to-new vert pointers mapping */ - vptr_map = BLI_ghash_ptr_new_ex("BM_mesh_remap vert pointers mapping", bm->totvert); - - /* Make a copy of all vertices. */ - verts_pool = bm->vtable; - verts_copy = MEM_mallocN(sizeof(BMVert) * totvert, "BM_mesh_remap verts copy"); - void **pyptrs = (cd_vert_pyptr != -1) ? MEM_mallocN(sizeof(void *) * totvert, __func__) : NULL; - for (i = totvert, ve = verts_copy + totvert - 1, vep = verts_pool + totvert - 1; i--; - ve--, vep--) { - *ve = **vep; - // printf("*vep: %p, verts_pool[%d]: %p\n", *vep, i, verts_pool[i]); - if (cd_vert_pyptr != -1) { - void **pyptr = BM_ELEM_CD_GET_VOID_P(((BMElem *)ve), cd_vert_pyptr); - pyptrs[i] = *pyptr; - } - } - - /* Copy back verts to their new place, and update old2new pointers mapping. */ - new_idx = vert_idx + totvert - 1; - ve = verts_copy + totvert - 1; - vep = verts_pool + totvert - 1; /* old, org pointer */ - for (i = totvert; i--; new_idx--, ve--, vep--) { - BMVert *new_vep = verts_pool[*new_idx]; - *new_vep = *ve; -#if 0 - printf( - "mapping vert from %d to %d (%p/%p to %p)\n", i, *new_idx, *vep, verts_pool[i], new_vep); -#endif - BLI_ghash_insert(vptr_map, *vep, new_vep); - if (cd_vert_pyptr != -1) { - void **pyptr = BM_ELEM_CD_GET_VOID_P(((BMElem *)new_vep), cd_vert_pyptr); - *pyptr = pyptrs[*new_idx]; - } - } - bm->elem_index_dirty |= BM_VERT; - bm->elem_table_dirty |= BM_VERT; - - MEM_freeN(verts_copy); - if (pyptrs) { - MEM_freeN(pyptrs); - } - } - - /* Remap Edges */ - if (edge_idx) { - BMEdge **edges_pool, *edges_copy, **edp; - int i, totedge = bm->totedge; - const uint *new_idx; - /* Special case: Python uses custom data layers to hold PyObject references. - * These have to be kept in place, else the PyObjects we point to, won't point back to us. */ - const int cd_edge_pyptr = CustomData_get_offset(&bm->edata, CD_BM_ELEM_PYPTR); - - /* Init the old-to-new vert pointers mapping */ - eptr_map = BLI_ghash_ptr_new_ex("BM_mesh_remap edge pointers mapping", bm->totedge); - - /* Make a copy of all vertices. */ - edges_pool = bm->etable; - edges_copy = MEM_mallocN(sizeof(BMEdge) * totedge, "BM_mesh_remap edges copy"); - void **pyptrs = (cd_edge_pyptr != -1) ? MEM_mallocN(sizeof(void *) * totedge, __func__) : NULL; - for (i = totedge, ed = edges_copy + totedge - 1, edp = edges_pool + totedge - 1; i--; - ed--, edp--) { - *ed = **edp; - if (cd_edge_pyptr != -1) { - void **pyptr = BM_ELEM_CD_GET_VOID_P(((BMElem *)ed), cd_edge_pyptr); - pyptrs[i] = *pyptr; - } - } - - /* Copy back verts to their new place, and update old2new pointers mapping. */ - new_idx = edge_idx + totedge - 1; - ed = edges_copy + totedge - 1; - edp = edges_pool + totedge - 1; /* old, org pointer */ - for (i = totedge; i--; new_idx--, ed--, edp--) { - BMEdge *new_edp = edges_pool[*new_idx]; - *new_edp = *ed; - BLI_ghash_insert(eptr_map, *edp, new_edp); -#if 0 - printf( - "mapping edge from %d to %d (%p/%p to %p)\n", i, *new_idx, *edp, edges_pool[i], new_edp); -#endif - if (cd_edge_pyptr != -1) { - void **pyptr = BM_ELEM_CD_GET_VOID_P(((BMElem *)new_edp), cd_edge_pyptr); - *pyptr = pyptrs[*new_idx]; - } - } - bm->elem_index_dirty |= BM_EDGE; - bm->elem_table_dirty |= BM_EDGE; - - MEM_freeN(edges_copy); - if (pyptrs) { - MEM_freeN(pyptrs); - } - } - - /* Remap Faces */ - if (face_idx) { - BMFace **faces_pool, *faces_copy, **fap; - int i, totface = bm->totface; - const uint *new_idx; - /* Special case: Python uses custom data layers to hold PyObject references. - * These have to be kept in place, else the PyObjects we point to, won't point back to us. */ - const int cd_poly_pyptr = CustomData_get_offset(&bm->pdata, CD_BM_ELEM_PYPTR); - - /* Init the old-to-new vert pointers mapping */ - fptr_map = BLI_ghash_ptr_new_ex("BM_mesh_remap face pointers mapping", bm->totface); - - /* Make a copy of all vertices. */ - faces_pool = bm->ftable; - faces_copy = MEM_mallocN(sizeof(BMFace) * totface, "BM_mesh_remap faces copy"); - void **pyptrs = (cd_poly_pyptr != -1) ? MEM_mallocN(sizeof(void *) * totface, __func__) : NULL; - for (i = totface, fa = faces_copy + totface - 1, fap = faces_pool + totface - 1; i--; - fa--, fap--) { - *fa = **fap; - if (cd_poly_pyptr != -1) { - void **pyptr = BM_ELEM_CD_GET_VOID_P(((BMElem *)fa), cd_poly_pyptr); - pyptrs[i] = *pyptr; - } - } - - /* Copy back verts to their new place, and update old2new pointers mapping. */ - new_idx = face_idx + totface - 1; - fa = faces_copy + totface - 1; - fap = faces_pool + totface - 1; /* old, org pointer */ - for (i = totface; i--; new_idx--, fa--, fap--) { - BMFace *new_fap = faces_pool[*new_idx]; - *new_fap = *fa; - BLI_ghash_insert(fptr_map, *fap, new_fap); - if (cd_poly_pyptr != -1) { - void **pyptr = BM_ELEM_CD_GET_VOID_P(((BMElem *)new_fap), cd_poly_pyptr); - *pyptr = pyptrs[*new_idx]; - } - } - - bm->elem_index_dirty |= BM_FACE | BM_LOOP; - bm->elem_table_dirty |= BM_FACE; - - MEM_freeN(faces_copy); - if (pyptrs) { - MEM_freeN(pyptrs); - } - } - - /* And now, fix all vertices/edges/faces/loops pointers! */ - /* Verts' pointers, only edge pointers... */ - if (eptr_map) { - BM_ITER_MESH (ve, &iter, bm, BM_VERTS_OF_MESH) { - // printf("Vert e: %p -> %p\n", ve->e, BLI_ghash_lookup(eptr_map, ve->e)); - if (ve->e) { - ve->e = BLI_ghash_lookup(eptr_map, ve->e); - BLI_assert(ve->e); - } - } - } - - /* Edges' pointers, only vert pointers (as we don't mess with loops!), - * and - ack! - edge pointers, - * as we have to handle disk-links. */ - if (vptr_map || eptr_map) { - BM_ITER_MESH (ed, &iter, bm, BM_EDGES_OF_MESH) { - if (vptr_map) { -#if 0 - printf("Edge v1: %p -> %p\n", ed->v1, BLI_ghash_lookup(vptr_map, ed->v1)); - printf("Edge v2: %p -> %p\n", ed->v2, BLI_ghash_lookup(vptr_map, ed->v2)); -#endif - ed->v1 = BLI_ghash_lookup(vptr_map, ed->v1); - ed->v2 = BLI_ghash_lookup(vptr_map, ed->v2); - BLI_assert(ed->v1); - BLI_assert(ed->v2); - } - if (eptr_map) { -#if 0 - printf("Edge v1_disk_link prev: %p -> %p\n", - ed->v1_disk_link.prev, - BLI_ghash_lookup(eptr_map, ed->v1_disk_link.prev)); - printf("Edge v1_disk_link next: %p -> %p\n", - ed->v1_disk_link.next, - BLI_ghash_lookup(eptr_map, ed->v1_disk_link.next)); - printf("Edge v2_disk_link prev: %p -> %p\n", - ed->v2_disk_link.prev, - BLI_ghash_lookup(eptr_map, ed->v2_disk_link.prev)); - printf("Edge v2_disk_link next: %p -> %p\n", - ed->v2_disk_link.next, - BLI_ghash_lookup(eptr_map, ed->v2_disk_link.next)); -#endif - ed->v1_disk_link.prev = BLI_ghash_lookup(eptr_map, ed->v1_disk_link.prev); - ed->v1_disk_link.next = BLI_ghash_lookup(eptr_map, ed->v1_disk_link.next); - ed->v2_disk_link.prev = BLI_ghash_lookup(eptr_map, ed->v2_disk_link.prev); - ed->v2_disk_link.next = BLI_ghash_lookup(eptr_map, ed->v2_disk_link.next); - BLI_assert(ed->v1_disk_link.prev); - BLI_assert(ed->v1_disk_link.next); - BLI_assert(ed->v2_disk_link.prev); - BLI_assert(ed->v2_disk_link.next); - } - } - } - - /* Faces' pointers (loops, in fact), always needed... */ - BM_ITER_MESH (fa, &iter, bm, BM_FACES_OF_MESH) { - BM_ITER_ELEM (lo, &iterl, fa, BM_LOOPS_OF_FACE) { - if (vptr_map) { - // printf("Loop v: %p -> %p\n", lo->v, BLI_ghash_lookup(vptr_map, lo->v)); - lo->v = BLI_ghash_lookup(vptr_map, lo->v); - BLI_assert(lo->v); - } - if (eptr_map) { - // printf("Loop e: %p -> %p\n", lo->e, BLI_ghash_lookup(eptr_map, lo->e)); - lo->e = BLI_ghash_lookup(eptr_map, lo->e); - BLI_assert(lo->e); - } - if (fptr_map) { - // printf("Loop f: %p -> %p\n", lo->f, BLI_ghash_lookup(fptr_map, lo->f)); - lo->f = BLI_ghash_lookup(fptr_map, lo->f); - BLI_assert(lo->f); - } - } - } - - /* Selection history */ - { - BMEditSelection *ese; - for (ese = bm->selected.first; ese; ese = ese->next) { - switch (ese->htype) { - case BM_VERT: - if (vptr_map) { - ese->ele = BLI_ghash_lookup(vptr_map, ese->ele); - BLI_assert(ese->ele); - } - break; - case BM_EDGE: - if (eptr_map) { - ese->ele = BLI_ghash_lookup(eptr_map, ese->ele); - BLI_assert(ese->ele); - } - break; - case BM_FACE: - if (fptr_map) { - ese->ele = BLI_ghash_lookup(fptr_map, ese->ele); - BLI_assert(ese->ele); - } - break; - } - } - } - - if (fptr_map) { - if (bm->act_face) { - bm->act_face = BLI_ghash_lookup(fptr_map, bm->act_face); - BLI_assert(bm->act_face); - } - } - - if (vptr_map) { - BLI_ghash_free(vptr_map, NULL, NULL); - } - if (eptr_map) { - BLI_ghash_free(eptr_map, NULL, NULL); - } - if (fptr_map) { - BLI_ghash_free(fptr_map, NULL, NULL); - } -} - -void BM_mesh_rebuild(BMesh *bm, - const struct BMeshCreateParams *params, - BLI_mempool *vpool_dst, - BLI_mempool *epool_dst, - BLI_mempool *lpool_dst, - BLI_mempool *fpool_dst) -{ - const char remap = (vpool_dst ? BM_VERT : 0) | (epool_dst ? BM_EDGE : 0) | - (lpool_dst ? BM_LOOP : 0) | (fpool_dst ? BM_FACE : 0); - - BMVert **vtable_dst = (remap & BM_VERT) ? MEM_mallocN(bm->totvert * sizeof(BMVert *), __func__) : - NULL; - BMEdge **etable_dst = (remap & BM_EDGE) ? MEM_mallocN(bm->totedge * sizeof(BMEdge *), __func__) : - NULL; - BMLoop **ltable_dst = (remap & BM_LOOP) ? MEM_mallocN(bm->totloop * sizeof(BMLoop *), __func__) : - NULL; - BMFace **ftable_dst = (remap & BM_FACE) ? MEM_mallocN(bm->totface * sizeof(BMFace *), __func__) : - NULL; - - const bool use_toolflags = params->use_toolflags; - - if (remap & BM_VERT) { - BMIter iter; - int index; - BMVert *v_src; - BM_ITER_MESH_INDEX (v_src, &iter, bm, BM_VERTS_OF_MESH, index) { - BMVert *v_dst = BLI_mempool_alloc(vpool_dst); - memcpy(v_dst, v_src, sizeof(BMVert)); - if (use_toolflags) { - ((BMVert_OFlag *)v_dst)->oflags = bm->vtoolflagpool ? - BLI_mempool_calloc(bm->vtoolflagpool) : - NULL; - } - - vtable_dst[index] = v_dst; - BM_elem_index_set(v_src, index); /* set_ok */ - } - } - - if (remap & BM_EDGE) { - BMIter iter; - int index; - BMEdge *e_src; - BM_ITER_MESH_INDEX (e_src, &iter, bm, BM_EDGES_OF_MESH, index) { - BMEdge *e_dst = BLI_mempool_alloc(epool_dst); - memcpy(e_dst, e_src, sizeof(BMEdge)); - if (use_toolflags) { - ((BMEdge_OFlag *)e_dst)->oflags = bm->etoolflagpool ? - BLI_mempool_calloc(bm->etoolflagpool) : - NULL; - } - - etable_dst[index] = e_dst; - BM_elem_index_set(e_src, index); /* set_ok */ - } - } - - if (remap & (BM_LOOP | BM_FACE)) { - BMIter iter; - int index, index_loop = 0; - BMFace *f_src; - BM_ITER_MESH_INDEX (f_src, &iter, bm, BM_FACES_OF_MESH, index) { - - if (remap & BM_FACE) { - BMFace *f_dst = BLI_mempool_alloc(fpool_dst); - memcpy(f_dst, f_src, sizeof(BMFace)); - if (use_toolflags) { - ((BMFace_OFlag *)f_dst)->oflags = bm->ftoolflagpool ? - BLI_mempool_calloc(bm->ftoolflagpool) : - NULL; - } - - ftable_dst[index] = f_dst; - BM_elem_index_set(f_src, index); /* set_ok */ - } - - /* handle loops */ - if (remap & BM_LOOP) { - BMLoop *l_iter_src, *l_first_src; - l_iter_src = l_first_src = BM_FACE_FIRST_LOOP((BMFace *)f_src); - do { - BMLoop *l_dst = BLI_mempool_alloc(lpool_dst); - memcpy(l_dst, l_iter_src, sizeof(BMLoop)); - ltable_dst[index_loop] = l_dst; - BM_elem_index_set(l_iter_src, index_loop++); /* set_ok */ - } while ((l_iter_src = l_iter_src->next) != l_first_src); - } - } - } - -#define MAP_VERT(ele) vtable_dst[BM_elem_index_get(ele)] -#define MAP_EDGE(ele) etable_dst[BM_elem_index_get(ele)] -#define MAP_LOOP(ele) ltable_dst[BM_elem_index_get(ele)] -#define MAP_FACE(ele) ftable_dst[BM_elem_index_get(ele)] - -#define REMAP_VERT(ele) \ - { \ - if (remap & BM_VERT) { \ - ele = MAP_VERT(ele); \ - } \ - } \ - ((void)0) -#define REMAP_EDGE(ele) \ - { \ - if (remap & BM_EDGE) { \ - ele = MAP_EDGE(ele); \ - } \ - } \ - ((void)0) -#define REMAP_LOOP(ele) \ - { \ - if (remap & BM_LOOP) { \ - ele = MAP_LOOP(ele); \ - } \ - } \ - ((void)0) -#define REMAP_FACE(ele) \ - { \ - if (remap & BM_FACE) { \ - ele = MAP_FACE(ele); \ - } \ - } \ - ((void)0) - - /* verts */ - { - for (int i = 0; i < bm->totvert; i++) { - BMVert *v = vtable_dst[i]; - if (v->e) { - REMAP_EDGE(v->e); - } - } - } - - /* edges */ - { - for (int i = 0; i < bm->totedge; i++) { - BMEdge *e = etable_dst[i]; - REMAP_VERT(e->v1); - REMAP_VERT(e->v2); - REMAP_EDGE(e->v1_disk_link.next); - REMAP_EDGE(e->v1_disk_link.prev); - REMAP_EDGE(e->v2_disk_link.next); - REMAP_EDGE(e->v2_disk_link.prev); - if (e->l) { - REMAP_LOOP(e->l); - } - } - } - - /* faces */ - { - for (int i = 0; i < bm->totface; i++) { - BMFace *f = ftable_dst[i]; - REMAP_LOOP(f->l_first); - - { - BMLoop *l_iter, *l_first; - l_iter = l_first = BM_FACE_FIRST_LOOP((BMFace *)f); - do { - REMAP_VERT(l_iter->v); - REMAP_EDGE(l_iter->e); - REMAP_FACE(l_iter->f); - - REMAP_LOOP(l_iter->radial_next); - REMAP_LOOP(l_iter->radial_prev); - REMAP_LOOP(l_iter->next); - REMAP_LOOP(l_iter->prev); - } while ((l_iter = l_iter->next) != l_first); - } - } - } - - LISTBASE_FOREACH (BMEditSelection *, ese, &bm->selected) { - switch (ese->htype) { - case BM_VERT: - if (remap & BM_VERT) { - ese->ele = (BMElem *)MAP_VERT(ese->ele); - } - break; - case BM_EDGE: - if (remap & BM_EDGE) { - ese->ele = (BMElem *)MAP_EDGE(ese->ele); - } - break; - case BM_FACE: - if (remap & BM_FACE) { - ese->ele = (BMElem *)MAP_FACE(ese->ele); - } - break; - } - } - - if (bm->act_face) { - REMAP_FACE(bm->act_face); - } - -#undef MAP_VERT -#undef MAP_EDGE -#undef MAP_LOOP -#undef MAP_EDGE - -#undef REMAP_VERT -#undef REMAP_EDGE -#undef REMAP_LOOP -#undef REMAP_EDGE - - /* Cleanup, re-use local tables if the current mesh had tables allocated. - * could use irrespective but it may use more memory than the caller wants - * (and not be needed). */ - if (remap & BM_VERT) { - if (bm->vtable) { - SWAP(BMVert **, vtable_dst, bm->vtable); - bm->vtable_tot = bm->totvert; - bm->elem_table_dirty &= ~BM_VERT; - } - MEM_freeN(vtable_dst); - BLI_mempool_destroy(bm->vpool); - bm->vpool = vpool_dst; - } - - if (remap & BM_EDGE) { - if (bm->etable) { - SWAP(BMEdge **, etable_dst, bm->etable); - bm->etable_tot = bm->totedge; - bm->elem_table_dirty &= ~BM_EDGE; - } - MEM_freeN(etable_dst); - BLI_mempool_destroy(bm->epool); - bm->epool = epool_dst; - } - - if (remap & BM_LOOP) { - /* no loop table */ - MEM_freeN(ltable_dst); - BLI_mempool_destroy(bm->lpool); - bm->lpool = lpool_dst; - } - - if (remap & BM_FACE) { - if (bm->ftable) { - SWAP(BMFace **, ftable_dst, bm->ftable); - bm->ftable_tot = bm->totface; - bm->elem_table_dirty &= ~BM_FACE; - } - MEM_freeN(ftable_dst); - BLI_mempool_destroy(bm->fpool); - bm->fpool = fpool_dst; - } -} - -void BM_mesh_toolflags_set(BMesh *bm, bool use_toolflags) -{ - if (bm->use_toolflags == use_toolflags) { - return; - } - - const BMAllocTemplate allocsize = BMALLOC_TEMPLATE_FROM_BM(bm); - - BLI_mempool *vpool_dst = NULL; - BLI_mempool *epool_dst = NULL; - BLI_mempool *fpool_dst = NULL; - - bm_mempool_init_ex(&allocsize, use_toolflags, &vpool_dst, &epool_dst, NULL, &fpool_dst); - - if (use_toolflags == false) { - BLI_mempool_destroy(bm->vtoolflagpool); - BLI_mempool_destroy(bm->etoolflagpool); - BLI_mempool_destroy(bm->ftoolflagpool); - - bm->vtoolflagpool = NULL; - bm->etoolflagpool = NULL; - bm->ftoolflagpool = NULL; - } - - BM_mesh_rebuild(bm, - &((struct BMeshCreateParams){ - .use_toolflags = use_toolflags, - }), - vpool_dst, - epool_dst, - NULL, - fpool_dst); - - bm->use_toolflags = use_toolflags; -} - -/* -------------------------------------------------------------------- */ -/** \name BMesh Coordinate Access - * \{ */ - -void BM_mesh_vert_coords_get(BMesh *bm, float (*vert_coords)[3]) -{ - BMIter iter; - BMVert *v; - int i; - BM_ITER_MESH_INDEX (v, &iter, bm, BM_VERTS_OF_MESH, i) { - copy_v3_v3(vert_coords[i], v->co); - } -} - -float (*BM_mesh_vert_coords_alloc(BMesh *bm, int *r_vert_len))[3] -{ - float(*vert_coords)[3] = MEM_mallocN(bm->totvert * sizeof(*vert_coords), __func__); - BM_mesh_vert_coords_get(bm, vert_coords); - *r_vert_len = bm->totvert; - return vert_coords; -} - -void BM_mesh_vert_coords_apply(BMesh *bm, const float (*vert_coords)[3]) -{ - BMIter iter; - BMVert *v; - int i; - BM_ITER_MESH_INDEX (v, &iter, bm, BM_VERTS_OF_MESH, i) { - copy_v3_v3(v->co, vert_coords[i]); - } -} - -void BM_mesh_vert_coords_apply_with_mat4(BMesh *bm, - const float (*vert_coords)[3], - const float mat[4][4]) -{ - BMIter iter; - BMVert *v; - int i; - BM_ITER_MESH_INDEX (v, &iter, bm, BM_VERTS_OF_MESH, i) { - mul_v3_m4v3(v->co, mat, vert_coords[i]); - } -} - -/** \} */ diff --git a/source/blender/bmesh/intern/bmesh_mesh.cc b/source/blender/bmesh/intern/bmesh_mesh.cc new file mode 100644 index 00000000000..c16d874e3ec --- /dev/null +++ b/source/blender/bmesh/intern/bmesh_mesh.cc @@ -0,0 +1,1350 @@ +/* SPDX-License-Identifier: GPL-2.0-or-later */ + +/** \file + * \ingroup bmesh + * + * BM mesh level functions. + */ + +#include "MEM_guardedalloc.h" + +#include "DNA_listBase.h" +#include "DNA_scene_types.h" + +#include "BLI_listbase.h" +#include "BLI_math.h" +#include "BLI_utildefines.h" + +#include "BKE_customdata.h" +#include "BKE_mesh.h" + +#include "bmesh.h" + +const BMAllocTemplate bm_mesh_allocsize_default = {512, 1024, 2048, 512}; +const BMAllocTemplate bm_mesh_chunksize_default = {512, 1024, 2048, 512}; + +static void bm_mempool_init_ex(const BMAllocTemplate *allocsize, + const bool use_toolflags, + BLI_mempool **r_vpool, + BLI_mempool **r_epool, + BLI_mempool **r_lpool, + BLI_mempool **r_fpool) +{ + size_t vert_size, edge_size, loop_size, face_size; + + if (use_toolflags == true) { + vert_size = sizeof(BMVert_OFlag); + edge_size = sizeof(BMEdge_OFlag); + loop_size = sizeof(BMLoop); + face_size = sizeof(BMFace_OFlag); + } + else { + vert_size = sizeof(BMVert); + edge_size = sizeof(BMEdge); + loop_size = sizeof(BMLoop); + face_size = sizeof(BMFace); + } + + if (r_vpool) { + *r_vpool = BLI_mempool_create( + vert_size, allocsize->totvert, bm_mesh_chunksize_default.totvert, BLI_MEMPOOL_ALLOW_ITER); + } + if (r_epool) { + *r_epool = BLI_mempool_create( + edge_size, allocsize->totedge, bm_mesh_chunksize_default.totedge, BLI_MEMPOOL_ALLOW_ITER); + } + if (r_lpool) { + *r_lpool = BLI_mempool_create( + loop_size, allocsize->totloop, bm_mesh_chunksize_default.totloop, BLI_MEMPOOL_NOP); + } + if (r_fpool) { + *r_fpool = BLI_mempool_create( + face_size, allocsize->totface, bm_mesh_chunksize_default.totface, BLI_MEMPOOL_ALLOW_ITER); + } +} + +static void bm_mempool_init(BMesh *bm, const BMAllocTemplate *allocsize, const bool use_toolflags) +{ + bm_mempool_init_ex(allocsize, use_toolflags, &bm->vpool, &bm->epool, &bm->lpool, &bm->fpool); + +#ifdef USE_BMESH_HOLES + bm->looplistpool = BLI_mempool_create(sizeof(BMLoopList), 512, 512, BLI_MEMPOOL_NOP); +#endif +} + +void BM_mesh_elem_toolflags_ensure(BMesh *bm) +{ + BLI_assert(bm->use_toolflags); + + if (bm->vtoolflagpool && bm->etoolflagpool && bm->ftoolflagpool) { + return; + } + + bm->vtoolflagpool = BLI_mempool_create(sizeof(BMFlagLayer), bm->totvert, 512, BLI_MEMPOOL_NOP); + bm->etoolflagpool = BLI_mempool_create(sizeof(BMFlagLayer), bm->totedge, 512, BLI_MEMPOOL_NOP); + bm->ftoolflagpool = BLI_mempool_create(sizeof(BMFlagLayer), bm->totface, 512, BLI_MEMPOOL_NOP); + + BMIter iter; + BMVert_OFlag *v_olfag; + BLI_mempool *toolflagpool = bm->vtoolflagpool; + BM_ITER_MESH (v_olfag, &iter, bm, BM_VERTS_OF_MESH) { + v_olfag->oflags = (BMFlagLayer *)BLI_mempool_calloc(toolflagpool); + } + + BMEdge_OFlag *e_olfag; + toolflagpool = bm->etoolflagpool; + BM_ITER_MESH (e_olfag, &iter, bm, BM_EDGES_OF_MESH) { + e_olfag->oflags = (BMFlagLayer *)BLI_mempool_calloc(toolflagpool); + } + + BMFace_OFlag *f_olfag; + toolflagpool = bm->ftoolflagpool; + BM_ITER_MESH (f_olfag, &iter, bm, BM_FACES_OF_MESH) { + f_olfag->oflags = (BMFlagLayer *)BLI_mempool_calloc(toolflagpool); + } + + bm->totflags = 1; +} + +void BM_mesh_elem_toolflags_clear(BMesh *bm) +{ + if (bm->vtoolflagpool) { + BLI_mempool_destroy(bm->vtoolflagpool); + bm->vtoolflagpool = nullptr; + } + if (bm->etoolflagpool) { + BLI_mempool_destroy(bm->etoolflagpool); + bm->etoolflagpool = nullptr; + } + if (bm->ftoolflagpool) { + BLI_mempool_destroy(bm->ftoolflagpool); + bm->ftoolflagpool = nullptr; + } +} + +BMesh *BM_mesh_create(const BMAllocTemplate *allocsize, const struct BMeshCreateParams *params) +{ + /* allocate the structure */ + BMesh *bm = (BMesh *)MEM_callocN(sizeof(BMesh), __func__); + + /* allocate the memory pools for the mesh elements */ + bm_mempool_init(bm, allocsize, params->use_toolflags); + + /* allocate one flag pool that we don't get rid of. */ + bm->use_toolflags = params->use_toolflags; + bm->toolflag_index = 0; + bm->totflags = 0; + + CustomData_reset(&bm->vdata); + CustomData_reset(&bm->edata); + CustomData_reset(&bm->ldata); + CustomData_reset(&bm->pdata); + + return bm; +} + +void BM_mesh_data_free(BMesh *bm) +{ + BMVert *v; + BMEdge *e; + BMLoop *l; + BMFace *f; + + BMIter iter; + BMIter itersub; + + const bool is_ldata_free = CustomData_bmesh_has_free(&bm->ldata); + const bool is_pdata_free = CustomData_bmesh_has_free(&bm->pdata); + + /* Check if we have to call free, if not we can avoid a lot of looping */ + if (CustomData_bmesh_has_free(&(bm->vdata))) { + BM_ITER_MESH (v, &iter, bm, BM_VERTS_OF_MESH) { + CustomData_bmesh_free_block(&(bm->vdata), &(v->head.data)); + } + } + if (CustomData_bmesh_has_free(&(bm->edata))) { + BM_ITER_MESH (e, &iter, bm, BM_EDGES_OF_MESH) { + CustomData_bmesh_free_block(&(bm->edata), &(e->head.data)); + } + } + + if (is_ldata_free || is_pdata_free) { + BM_ITER_MESH (f, &iter, bm, BM_FACES_OF_MESH) { + if (is_pdata_free) { + CustomData_bmesh_free_block(&(bm->pdata), &(f->head.data)); + } + if (is_ldata_free) { + BM_ITER_ELEM (l, &itersub, f, BM_LOOPS_OF_FACE) { + CustomData_bmesh_free_block(&(bm->ldata), &(l->head.data)); + } + } + } + } + + /* Free custom data pools, This should probably go in CustomData_free? */ + if (bm->vdata.totlayer) { + BLI_mempool_destroy(bm->vdata.pool); + } + if (bm->edata.totlayer) { + BLI_mempool_destroy(bm->edata.pool); + } + if (bm->ldata.totlayer) { + BLI_mempool_destroy(bm->ldata.pool); + } + if (bm->pdata.totlayer) { + BLI_mempool_destroy(bm->pdata.pool); + } + + /* free custom data */ + CustomData_free(&bm->vdata, 0); + CustomData_free(&bm->edata, 0); + CustomData_free(&bm->ldata, 0); + CustomData_free(&bm->pdata, 0); + + /* destroy element pools */ + BLI_mempool_destroy(bm->vpool); + BLI_mempool_destroy(bm->epool); + BLI_mempool_destroy(bm->lpool); + BLI_mempool_destroy(bm->fpool); + + if (bm->vtable) { + MEM_freeN(bm->vtable); + } + if (bm->etable) { + MEM_freeN(bm->etable); + } + if (bm->ftable) { + MEM_freeN(bm->ftable); + } + + /* destroy flag pool */ + BM_mesh_elem_toolflags_clear(bm); + +#ifdef USE_BMESH_HOLES + BLI_mempool_destroy(bm->looplistpool); +#endif + + BLI_freelistN(&bm->selected); + + if (bm->lnor_spacearr) { + BKE_lnor_spacearr_free(bm->lnor_spacearr); + MEM_freeN(bm->lnor_spacearr); + } + + BMO_error_clear(bm); +} + +void BM_mesh_clear(BMesh *bm) +{ + const bool use_toolflags = bm->use_toolflags; + + /* free old mesh */ + BM_mesh_data_free(bm); + memset(bm, 0, sizeof(BMesh)); + + /* allocate the memory pools for the mesh elements */ + bm_mempool_init(bm, &bm_mesh_allocsize_default, use_toolflags); + + bm->use_toolflags = use_toolflags; + bm->toolflag_index = 0; + bm->totflags = 0; + + CustomData_reset(&bm->vdata); + CustomData_reset(&bm->edata); + CustomData_reset(&bm->ldata); + CustomData_reset(&bm->pdata); +} + +void BM_mesh_free(BMesh *bm) +{ + BM_mesh_data_free(bm); + + if (bm->py_handle) { + /* keep this out of 'BM_mesh_data_free' because we want python + * to be able to clear the mesh and maintain access. */ + bpy_bm_generic_invalidate((BPy_BMGeneric *)bm->py_handle); + bm->py_handle = nullptr; + } + + MEM_freeN(bm); +} + +void bmesh_edit_begin(BMesh *UNUSED(bm), BMOpTypeFlag UNUSED(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 + * (loop cuts, edge subdivides, etc) are not reflected in the higher levels of + * the mesh at all, which doesn't seem right. Turning off completely for now, + * until this is shown to be better for certain types of mesh edits. */ +#ifdef BMOP_UNTAN_MULTIRES_ENABLED + /* switch multires data out of tangent space */ + if ((type_flag & BMO_OPTYPE_FLAG_UNTAN_MULTIRES) && + CustomData_has_layer(&bm->ldata, CD_MDISPS)) { + bmesh_mdisps_space_set(bm, MULTIRES_SPACE_TANGENT, MULTIRES_SPACE_ABSOLUTE); + + /* ensure correct normals, if possible */ + bmesh_rationalize_normals(bm, 0); + BM_mesh_normals_update(bm); + } +#endif +} + +void bmesh_edit_end(BMesh *bm, BMOpTypeFlag type_flag) +{ + ListBase select_history; + + /* BMO_OPTYPE_FLAG_UNTAN_MULTIRES disabled for now, see comment above in bmesh_edit_begin. */ +#ifdef BMOP_UNTAN_MULTIRES_ENABLED + /* switch multires data into tangent space */ + if ((flag & BMO_OPTYPE_FLAG_UNTAN_MULTIRES) && CustomData_has_layer(&bm->ldata, CD_MDISPS)) { + /* set normals to their previous winding */ + bmesh_rationalize_normals(bm, 1); + bmesh_mdisps_space_set(bm, MULTIRES_SPACE_ABSOLUTE, MULTIRES_SPACE_TANGENT); + } + else if (flag & BMO_OP_FLAG_RATIONALIZE_NORMALS) { + bmesh_rationalize_normals(bm, 1); + } +#endif + + /* compute normals, clear temp flags and flush selections */ + if (type_flag & BMO_OPTYPE_FLAG_NORMALS_CALC) { + bm->spacearr_dirty |= BM_SPACEARR_DIRTY_ALL; + BM_mesh_normals_update(bm); + } + + if ((type_flag & BMO_OPTYPE_FLAG_SELECT_VALIDATE) == 0) { + select_history = bm->selected; + BLI_listbase_clear(&bm->selected); + } + + if (type_flag & BMO_OPTYPE_FLAG_SELECT_FLUSH) { + BM_mesh_select_mode_flush(bm); + } + + if ((type_flag & BMO_OPTYPE_FLAG_SELECT_VALIDATE) == 0) { + bm->selected = select_history; + } + if (type_flag & BMO_OPTYPE_FLAG_INVALIDATE_CLNOR_ALL) { + bm->spacearr_dirty |= BM_SPACEARR_DIRTY_ALL; + } +} + +void BM_mesh_elem_index_ensure_ex(BMesh *bm, const char htype, int elem_offset[4]) +{ + +#ifdef DEBUG + BM_ELEM_INDEX_VALIDATE(bm, "Should Never Fail!", __func__); +#endif + + if (elem_offset == nullptr) { + /* Simple case. */ + const char htype_needed = bm->elem_index_dirty & htype; + if (htype_needed == 0) { + goto finally; + } + } + + if (htype & BM_VERT) { + if ((bm->elem_index_dirty & BM_VERT) || (elem_offset && elem_offset[0])) { + BMIter iter; + BMElem *ele; + + int index = elem_offset ? elem_offset[0] : 0; + BM_ITER_MESH (ele, &iter, bm, BM_VERTS_OF_MESH) { + BM_elem_index_set(ele, index++); /* set_ok */ + } + BLI_assert(elem_offset || index == bm->totvert); + } + else { + // printf("%s: skipping vert index calc!\n", __func__); + } + } + + if (htype & BM_EDGE) { + if ((bm->elem_index_dirty & BM_EDGE) || (elem_offset && elem_offset[1])) { + BMIter iter; + BMElem *ele; + + int index = elem_offset ? elem_offset[1] : 0; + BM_ITER_MESH (ele, &iter, bm, BM_EDGES_OF_MESH) { + BM_elem_index_set(ele, index++); /* set_ok */ + } + BLI_assert(elem_offset || index == bm->totedge); + } + else { + // printf("%s: skipping edge index calc!\n", __func__); + } + } + + if (htype & (BM_FACE | BM_LOOP)) { + if ((bm->elem_index_dirty & (BM_FACE | BM_LOOP)) || + (elem_offset && (elem_offset[2] || elem_offset[3]))) { + BMIter iter; + BMElem *ele; + + const bool update_face = (htype & BM_FACE) && (bm->elem_index_dirty & BM_FACE); + const bool update_loop = (htype & BM_LOOP) && (bm->elem_index_dirty & BM_LOOP); + + int index_loop = elem_offset ? elem_offset[2] : 0; + int index = elem_offset ? elem_offset[3] : 0; + + BM_ITER_MESH (ele, &iter, bm, BM_FACES_OF_MESH) { + if (update_face) { + BM_elem_index_set(ele, index++); /* set_ok */ + } + + if (update_loop) { + BMLoop *l_iter, *l_first; + + l_iter = l_first = BM_FACE_FIRST_LOOP((BMFace *)ele); + do { + BM_elem_index_set(l_iter, index_loop++); /* set_ok */ + } while ((l_iter = l_iter->next) != l_first); + } + } + + BLI_assert(elem_offset || !update_face || index == bm->totface); + if (update_loop) { + BLI_assert(elem_offset || !update_loop || index_loop == bm->totloop); + } + } + else { + // printf("%s: skipping face/loop index calc!\n", __func__); + } + } + +finally: + bm->elem_index_dirty &= ~htype; + if (elem_offset) { + if (htype & BM_VERT) { + elem_offset[0] += bm->totvert; + if (elem_offset[0] != bm->totvert) { + bm->elem_index_dirty |= BM_VERT; + } + } + if (htype & BM_EDGE) { + elem_offset[1] += bm->totedge; + if (elem_offset[1] != bm->totedge) { + bm->elem_index_dirty |= BM_EDGE; + } + } + if (htype & BM_LOOP) { + elem_offset[2] += bm->totloop; + if (elem_offset[2] != bm->totloop) { + bm->elem_index_dirty |= BM_LOOP; + } + } + if (htype & BM_FACE) { + elem_offset[3] += bm->totface; + if (elem_offset[3] != bm->totface) { + bm->elem_index_dirty |= BM_FACE; + } + } + } +} + +void BM_mesh_elem_index_ensure(BMesh *bm, const char htype) +{ + BM_mesh_elem_index_ensure_ex(bm, htype, nullptr); +} + +void BM_mesh_elem_index_validate( + BMesh *bm, const char *location, const char *func, const char *msg_a, const char *msg_b) +{ + const char iter_types[3] = {BM_VERTS_OF_MESH, BM_EDGES_OF_MESH, BM_FACES_OF_MESH}; + + const char flag_types[3] = {BM_VERT, BM_EDGE, BM_FACE}; + const char *type_names[3] = {"vert", "edge", "face"}; + + BMIter iter; + BMElem *ele; + int i; + bool is_any_error = false; + + for (i = 0; i < 3; i++) { + const bool is_dirty = (flag_types[i] & bm->elem_index_dirty) != 0; + int index = 0; + bool is_error = false; + int err_val = 0; + int err_idx = 0; + + BM_ITER_MESH (ele, &iter, bm, iter_types[i]) { + if (!is_dirty) { + if (BM_elem_index_get(ele) != index) { + err_val = BM_elem_index_get(ele); + err_idx = index; + is_error = true; + break; + } + } + index++; + } + + 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)) { + +#if 0 /* mostly annoying */ + + /* dirty may have been incorrectly set */ + fprintf(stderr, + "Invalid Dirty: at %s, %s (%s), dirty flag was set but all index values are " + "correct, '%s', '%s'\n", + location, + func, + type_names[i], + msg_a, + msg_b); +#endif + } + } + +#if 0 /* mostly annoying, even in debug mode */ +# ifdef DEBUG + if (is_any_error == 0) { + fprintf(stderr, "Valid Index Success: at %s, %s, '%s', '%s'\n", location, func, msg_a, msg_b); + } +# endif +#endif + (void)is_any_error; /* shut up the compiler */ +} + +/* debug check only - no need to optimize */ +#ifndef NDEBUG +bool BM_mesh_elem_table_check(BMesh *bm) +{ + BMIter iter; + BMElem *ele; + int i; + + if (bm->vtable && ((bm->elem_table_dirty & BM_VERT) == 0)) { + BM_ITER_MESH_INDEX (ele, &iter, bm, BM_VERTS_OF_MESH, i) { + if (ele != (BMElem *)bm->vtable[i]) { + return false; + } + } + } + + if (bm->etable && ((bm->elem_table_dirty & BM_EDGE) == 0)) { + BM_ITER_MESH_INDEX (ele, &iter, bm, BM_EDGES_OF_MESH, i) { + if (ele != (BMElem *)bm->etable[i]) { + return false; + } + } + } + + if (bm->ftable && ((bm->elem_table_dirty & BM_FACE) == 0)) { + BM_ITER_MESH_INDEX (ele, &iter, bm, BM_FACES_OF_MESH, i) { + if (ele != (BMElem *)bm->ftable[i]) { + return false; + } + } + } + + return true; +} +#endif + +void BM_mesh_elem_table_ensure(BMesh *bm, const char htype) +{ + /* assume if the array is non-null then its valid and no need to recalc */ + const char htype_needed = + (((bm->vtable && ((bm->elem_table_dirty & BM_VERT) == 0)) ? 0 : BM_VERT) | + ((bm->etable && ((bm->elem_table_dirty & BM_EDGE) == 0)) ? 0 : BM_EDGE) | + ((bm->ftable && ((bm->elem_table_dirty & BM_FACE) == 0)) ? 0 : BM_FACE)) & + htype; + + BLI_assert((htype & ~BM_ALL_NOLOOP) == 0); + + /* in debug mode double check we didn't need to recalculate */ + BLI_assert(BM_mesh_elem_table_check(bm) == true); + + if (htype_needed == 0) { + goto finally; + } + + if (htype_needed & BM_VERT) { + if (bm->vtable && bm->totvert <= bm->vtable_tot && bm->totvert * 2 >= bm->vtable_tot) { + /* pass (re-use the array) */ + } + else { + if (bm->vtable) { + MEM_freeN(bm->vtable); + } + bm->vtable = (BMVert **)MEM_mallocN(sizeof(void **) * bm->totvert, "bm->vtable"); + bm->vtable_tot = bm->totvert; + } + BM_iter_as_array(bm, BM_VERTS_OF_MESH, nullptr, (void **)bm->vtable, bm->totvert); + } + if (htype_needed & BM_EDGE) { + if (bm->etable && bm->totedge <= bm->etable_tot && bm->totedge * 2 >= bm->etable_tot) { + /* pass (re-use the array) */ + } + else { + if (bm->etable) { + MEM_freeN(bm->etable); + } + bm->etable = (BMEdge **)MEM_mallocN(sizeof(void **) * bm->totedge, "bm->etable"); + bm->etable_tot = bm->totedge; + } + BM_iter_as_array(bm, BM_EDGES_OF_MESH, nullptr, (void **)bm->etable, bm->totedge); + } + if (htype_needed & BM_FACE) { + if (bm->ftable && bm->totface <= bm->ftable_tot && bm->totface * 2 >= bm->ftable_tot) { + /* pass (re-use the array) */ + } + else { + if (bm->ftable) { + MEM_freeN(bm->ftable); + } + bm->ftable = (BMFace **)MEM_mallocN(sizeof(void **) * bm->totface, "bm->ftable"); + bm->ftable_tot = bm->totface; + } + BM_iter_as_array(bm, BM_FACES_OF_MESH, nullptr, (void **)bm->ftable, bm->totface); + } + +finally: + /* Only clear dirty flags when all the pointers and data are actually valid. + * This prevents possible threading issues when dirty flag check failed but + * data wasn't ready still. + */ + bm->elem_table_dirty &= ~htype_needed; +} + +void BM_mesh_elem_table_init(BMesh *bm, const char htype) +{ + BLI_assert((htype & ~BM_ALL_NOLOOP) == 0); + + /* force recalc */ + BM_mesh_elem_table_free(bm, BM_ALL_NOLOOP); + BM_mesh_elem_table_ensure(bm, htype); +} + +void BM_mesh_elem_table_free(BMesh *bm, const char htype) +{ + if (htype & BM_VERT) { + MEM_SAFE_FREE(bm->vtable); + } + + if (htype & BM_EDGE) { + MEM_SAFE_FREE(bm->etable); + } + + if (htype & BM_FACE) { + MEM_SAFE_FREE(bm->ftable); + } +} + +BMVert *BM_vert_at_index_find(BMesh *bm, const int index) +{ + return (BMVert *)BLI_mempool_findelem(bm->vpool, index); +} + +BMEdge *BM_edge_at_index_find(BMesh *bm, const int index) +{ + return (BMEdge *)BLI_mempool_findelem(bm->epool, index); +} + +BMFace *BM_face_at_index_find(BMesh *bm, const int index) +{ + return (BMFace *)BLI_mempool_findelem(bm->fpool, index); +} + +BMLoop *BM_loop_at_index_find(BMesh *bm, const int index) +{ + BMIter iter; + BMFace *f; + int i = index; + BM_ITER_MESH (f, &iter, bm, BM_FACES_OF_MESH) { + if (i < f->len) { + BMLoop *l_first, *l_iter; + l_iter = l_first = BM_FACE_FIRST_LOOP(f); + do { + if (i == 0) { + return l_iter; + } + i -= 1; + } while ((l_iter = l_iter->next) != l_first); + } + i -= f->len; + } + return nullptr; +} + +BMVert *BM_vert_at_index_find_or_table(BMesh *bm, const int index) +{ + if ((bm->elem_table_dirty & BM_VERT) == 0) { + return (index < bm->totvert) ? bm->vtable[index] : nullptr; + } + return BM_vert_at_index_find(bm, index); +} + +BMEdge *BM_edge_at_index_find_or_table(BMesh *bm, const int index) +{ + if ((bm->elem_table_dirty & BM_EDGE) == 0) { + return (index < bm->totedge) ? bm->etable[index] : nullptr; + } + return BM_edge_at_index_find(bm, index); +} + +BMFace *BM_face_at_index_find_or_table(BMesh *bm, const int index) +{ + if ((bm->elem_table_dirty & BM_FACE) == 0) { + return (index < bm->totface) ? bm->ftable[index] : nullptr; + } + return BM_face_at_index_find(bm, index); +} + +int BM_mesh_elem_count(BMesh *bm, const char htype) +{ + BLI_assert((htype & ~BM_ALL_NOLOOP) == 0); + + switch (htype) { + case BM_VERT: + return bm->totvert; + case BM_EDGE: + return bm->totedge; + case BM_FACE: + return bm->totface; + default: { + BLI_assert(0); + return 0; + } + } +} + +void BM_mesh_remap(BMesh *bm, const uint *vert_idx, const uint *edge_idx, const uint *face_idx) +{ + /* Mapping old to new pointers. */ + GHash *vptr_map = nullptr, *eptr_map = nullptr, *fptr_map = nullptr; + BMIter iter, iterl; + BMVert *ve; + BMEdge *ed; + BMFace *fa; + BMLoop *lo; + + if (!(vert_idx || edge_idx || face_idx)) { + return; + } + + BM_mesh_elem_table_ensure( + bm, (vert_idx ? BM_VERT : 0) | (edge_idx ? BM_EDGE : 0) | (face_idx ? BM_FACE : 0)); + + /* Remap Verts */ + if (vert_idx) { + BMVert **verts_pool, *verts_copy, **vep; + int i, totvert = bm->totvert; + const uint *new_idx; + /* Special case: Python uses custom data layers to hold PyObject references. + * These have to be kept in place, else the PyObjects we point to, won't point back to us. */ + const int cd_vert_pyptr = CustomData_get_offset(&bm->vdata, CD_BM_ELEM_PYPTR); + + /* Init the old-to-new vert pointers mapping */ + vptr_map = BLI_ghash_ptr_new_ex("BM_mesh_remap vert pointers mapping", bm->totvert); + + /* Make a copy of all vertices. */ + verts_pool = bm->vtable; + verts_copy = (BMVert *)MEM_mallocN(sizeof(BMVert) * totvert, "BM_mesh_remap verts copy"); + void **pyptrs = (cd_vert_pyptr != -1) ? + (void **)MEM_mallocN(sizeof(void *) * totvert, __func__) : + nullptr; + for (i = totvert, ve = verts_copy + totvert - 1, vep = verts_pool + totvert - 1; i--; + ve--, vep--) { + *ve = **vep; + // printf("*vep: %p, verts_pool[%d]: %p\n", *vep, i, verts_pool[i]); + if (cd_vert_pyptr != -1) { + void **pyptr = (void **)BM_ELEM_CD_GET_VOID_P(((BMElem *)ve), cd_vert_pyptr); + pyptrs[i] = *pyptr; + } + } + + /* Copy back verts to their new place, and update old2new pointers mapping. */ + new_idx = vert_idx + totvert - 1; + ve = verts_copy + totvert - 1; + vep = verts_pool + totvert - 1; /* old, org pointer */ + for (i = totvert; i--; new_idx--, ve--, vep--) { + BMVert *new_vep = verts_pool[*new_idx]; + *new_vep = *ve; +#if 0 + printf( + "mapping vert from %d to %d (%p/%p to %p)\n", i, *new_idx, *vep, verts_pool[i], new_vep); +#endif + BLI_ghash_insert(vptr_map, *vep, new_vep); + if (cd_vert_pyptr != -1) { + void **pyptr = (void **)BM_ELEM_CD_GET_VOID_P(((BMElem *)new_vep), cd_vert_pyptr); + *pyptr = pyptrs[*new_idx]; + } + } + bm->elem_index_dirty |= BM_VERT; + bm->elem_table_dirty |= BM_VERT; + + MEM_freeN(verts_copy); + if (pyptrs) { + MEM_freeN(pyptrs); + } + } + + /* Remap Edges */ + if (edge_idx) { + BMEdge **edges_pool, *edges_copy, **edp; + int i, totedge = bm->totedge; + const uint *new_idx; + /* Special case: Python uses custom data layers to hold PyObject references. + * These have to be kept in place, else the PyObjects we point to, won't point back to us. */ + const int cd_edge_pyptr = CustomData_get_offset(&bm->edata, CD_BM_ELEM_PYPTR); + + /* Init the old-to-new vert pointers mapping */ + eptr_map = BLI_ghash_ptr_new_ex("BM_mesh_remap edge pointers mapping", bm->totedge); + + /* Make a copy of all vertices. */ + edges_pool = bm->etable; + edges_copy = (BMEdge *)MEM_mallocN(sizeof(BMEdge) * totedge, "BM_mesh_remap edges copy"); + void **pyptrs = (cd_edge_pyptr != -1) ? + (void **)MEM_mallocN(sizeof(void *) * totedge, __func__) : + nullptr; + for (i = totedge, ed = edges_copy + totedge - 1, edp = edges_pool + totedge - 1; i--; + ed--, edp--) { + *ed = **edp; + if (cd_edge_pyptr != -1) { + void **pyptr = (void **)BM_ELEM_CD_GET_VOID_P(((BMElem *)ed), cd_edge_pyptr); + pyptrs[i] = *pyptr; + } + } + + /* Copy back verts to their new place, and update old2new pointers mapping. */ + new_idx = edge_idx + totedge - 1; + ed = edges_copy + totedge - 1; + edp = edges_pool + totedge - 1; /* old, org pointer */ + for (i = totedge; i--; new_idx--, ed--, edp--) { + BMEdge *new_edp = edges_pool[*new_idx]; + *new_edp = *ed; + BLI_ghash_insert(eptr_map, *edp, new_edp); +#if 0 + printf( + "mapping edge from %d to %d (%p/%p to %p)\n", i, *new_idx, *edp, edges_pool[i], new_edp); +#endif + if (cd_edge_pyptr != -1) { + void **pyptr = (void **)BM_ELEM_CD_GET_VOID_P(((BMElem *)new_edp), cd_edge_pyptr); + *pyptr = pyptrs[*new_idx]; + } + } + bm->elem_index_dirty |= BM_EDGE; + bm->elem_table_dirty |= BM_EDGE; + + MEM_freeN(edges_copy); + if (pyptrs) { + MEM_freeN(pyptrs); + } + } + + /* Remap Faces */ + if (face_idx) { + BMFace **faces_pool, *faces_copy, **fap; + int i, totface = bm->totface; + const uint *new_idx; + /* Special case: Python uses custom data layers to hold PyObject references. + * These have to be kept in place, else the PyObjects we point to, won't point back to us. */ + const int cd_poly_pyptr = CustomData_get_offset(&bm->pdata, CD_BM_ELEM_PYPTR); + + /* Init the old-to-new vert pointers mapping */ + fptr_map = BLI_ghash_ptr_new_ex("BM_mesh_remap face pointers mapping", bm->totface); + + /* Make a copy of all vertices. */ + faces_pool = bm->ftable; + faces_copy = (BMFace *)MEM_mallocN(sizeof(BMFace) * totface, "BM_mesh_remap faces copy"); + void **pyptrs = (cd_poly_pyptr != -1) ? + (void **)MEM_mallocN(sizeof(void *) * totface, __func__) : + nullptr; + for (i = totface, fa = faces_copy + totface - 1, fap = faces_pool + totface - 1; i--; + fa--, fap--) { + *fa = **fap; + if (cd_poly_pyptr != -1) { + void **pyptr = (void **)BM_ELEM_CD_GET_VOID_P(((BMElem *)fa), cd_poly_pyptr); + pyptrs[i] = *pyptr; + } + } + + /* Copy back verts to their new place, and update old2new pointers mapping. */ + new_idx = face_idx + totface - 1; + fa = faces_copy + totface - 1; + fap = faces_pool + totface - 1; /* old, org pointer */ + for (i = totface; i--; new_idx--, fa--, fap--) { + BMFace *new_fap = faces_pool[*new_idx]; + *new_fap = *fa; + BLI_ghash_insert(fptr_map, *fap, new_fap); + if (cd_poly_pyptr != -1) { + void **pyptr = (void **)BM_ELEM_CD_GET_VOID_P(((BMElem *)new_fap), cd_poly_pyptr); + *pyptr = pyptrs[*new_idx]; + } + } + + bm->elem_index_dirty |= BM_FACE | BM_LOOP; + bm->elem_table_dirty |= BM_FACE; + + MEM_freeN(faces_copy); + if (pyptrs) { + MEM_freeN(pyptrs); + } + } + + /* And now, fix all vertices/edges/faces/loops pointers! */ + /* Verts' pointers, only edge pointers... */ + if (eptr_map) { + BM_ITER_MESH (ve, &iter, bm, BM_VERTS_OF_MESH) { + // printf("Vert e: %p -> %p\n", ve->e, BLI_ghash_lookup(eptr_map, ve->e)); + if (ve->e) { + ve->e = (BMEdge *)BLI_ghash_lookup(eptr_map, ve->e); + BLI_assert(ve->e); + } + } + } + + /* Edges' pointers, only vert pointers (as we don't mess with loops!), + * and - ack! - edge pointers, + * as we have to handle disk-links. */ + if (vptr_map || eptr_map) { + BM_ITER_MESH (ed, &iter, bm, BM_EDGES_OF_MESH) { + if (vptr_map) { +#if 0 + printf("Edge v1: %p -> %p\n", ed->v1, BLI_ghash_lookup(vptr_map, ed->v1)); + printf("Edge v2: %p -> %p\n", ed->v2, BLI_ghash_lookup(vptr_map, ed->v2)); +#endif + ed->v1 = (BMVert *)BLI_ghash_lookup(vptr_map, ed->v1); + ed->v2 = (BMVert *)BLI_ghash_lookup(vptr_map, ed->v2); + BLI_assert(ed->v1); + BLI_assert(ed->v2); + } + if (eptr_map) { +#if 0 + printf("Edge v1_disk_link prev: %p -> %p\n", + ed->v1_disk_link.prev, + BLI_ghash_lookup(eptr_map, ed->v1_disk_link.prev)); + printf("Edge v1_disk_link next: %p -> %p\n", + ed->v1_disk_link.next, + BLI_ghash_lookup(eptr_map, ed->v1_disk_link.next)); + printf("Edge v2_disk_link prev: %p -> %p\n", + ed->v2_disk_link.prev, + BLI_ghash_lookup(eptr_map, ed->v2_disk_link.prev)); + printf("Edge v2_disk_link next: %p -> %p\n", + ed->v2_disk_link.next, + BLI_ghash_lookup(eptr_map, ed->v2_disk_link.next)); +#endif + ed->v1_disk_link.prev = (BMEdge *)BLI_ghash_lookup(eptr_map, ed->v1_disk_link.prev); + ed->v1_disk_link.next = (BMEdge *)BLI_ghash_lookup(eptr_map, ed->v1_disk_link.next); + ed->v2_disk_link.prev = (BMEdge *)BLI_ghash_lookup(eptr_map, ed->v2_disk_link.prev); + ed->v2_disk_link.next = (BMEdge *)BLI_ghash_lookup(eptr_map, ed->v2_disk_link.next); + BLI_assert(ed->v1_disk_link.prev); + BLI_assert(ed->v1_disk_link.next); + BLI_assert(ed->v2_disk_link.prev); + BLI_assert(ed->v2_disk_link.next); + } + } + } + + /* Faces' pointers (loops, in fact), always needed... */ + BM_ITER_MESH (fa, &iter, bm, BM_FACES_OF_MESH) { + BM_ITER_ELEM (lo, &iterl, fa, BM_LOOPS_OF_FACE) { + if (vptr_map) { + // printf("Loop v: %p -> %p\n", lo->v, BLI_ghash_lookup(vptr_map, lo->v)); + lo->v = (BMVert *)BLI_ghash_lookup(vptr_map, lo->v); + BLI_assert(lo->v); + } + if (eptr_map) { + // printf("Loop e: %p -> %p\n", lo->e, BLI_ghash_lookup(eptr_map, lo->e)); + lo->e = (BMEdge *)BLI_ghash_lookup(eptr_map, lo->e); + BLI_assert(lo->e); + } + if (fptr_map) { + // printf("Loop f: %p -> %p\n", lo->f, BLI_ghash_lookup(fptr_map, lo->f)); + lo->f = (BMFace *)BLI_ghash_lookup(fptr_map, lo->f); + BLI_assert(lo->f); + } + } + } + + /* Selection history */ + { + BMEditSelection *ese; + for (ese = (BMEditSelection *)bm->selected.first; ese; ese = ese->next) { + switch (ese->htype) { + case BM_VERT: + if (vptr_map) { + ese->ele = (BMElem *)BLI_ghash_lookup(vptr_map, ese->ele); + BLI_assert(ese->ele); + } + break; + case BM_EDGE: + if (eptr_map) { + ese->ele = (BMElem *)BLI_ghash_lookup(eptr_map, ese->ele); + BLI_assert(ese->ele); + } + break; + case BM_FACE: + if (fptr_map) { + ese->ele = (BMElem *)BLI_ghash_lookup(fptr_map, ese->ele); + BLI_assert(ese->ele); + } + break; + } + } + } + + if (fptr_map) { + if (bm->act_face) { + bm->act_face = (BMFace *)BLI_ghash_lookup(fptr_map, bm->act_face); + BLI_assert(bm->act_face); + } + } + + if (vptr_map) { + BLI_ghash_free(vptr_map, nullptr, nullptr); + } + if (eptr_map) { + BLI_ghash_free(eptr_map, nullptr, nullptr); + } + if (fptr_map) { + BLI_ghash_free(fptr_map, nullptr, nullptr); + } +} + +void BM_mesh_rebuild(BMesh *bm, + const struct BMeshCreateParams *params, + BLI_mempool *vpool_dst, + BLI_mempool *epool_dst, + BLI_mempool *lpool_dst, + BLI_mempool *fpool_dst) +{ + const char remap = (vpool_dst ? BM_VERT : 0) | (epool_dst ? BM_EDGE : 0) | + (lpool_dst ? BM_LOOP : 0) | (fpool_dst ? BM_FACE : 0); + + BMVert **vtable_dst = (remap & BM_VERT) ? + (BMVert **)MEM_mallocN(bm->totvert * sizeof(BMVert *), __func__) : + nullptr; + BMEdge **etable_dst = (remap & BM_EDGE) ? + (BMEdge **)MEM_mallocN(bm->totedge * sizeof(BMEdge *), __func__) : + nullptr; + BMLoop **ltable_dst = (remap & BM_LOOP) ? + (BMLoop **)MEM_mallocN(bm->totloop * sizeof(BMLoop *), __func__) : + nullptr; + BMFace **ftable_dst = (remap & BM_FACE) ? + (BMFace **)MEM_mallocN(bm->totface * sizeof(BMFace *), __func__) : + nullptr; + + const bool use_toolflags = params->use_toolflags; + + if (remap & BM_VERT) { + BMIter iter; + int index; + BMVert *v_src; + BM_ITER_MESH_INDEX (v_src, &iter, bm, BM_VERTS_OF_MESH, index) { + BMVert *v_dst = (BMVert *)BLI_mempool_alloc(vpool_dst); + memcpy(v_dst, v_src, sizeof(BMVert)); + if (use_toolflags) { + ((BMVert_OFlag *)v_dst)->oflags = bm->vtoolflagpool ? (BMFlagLayer *)BLI_mempool_calloc( + bm->vtoolflagpool) : + nullptr; + } + + vtable_dst[index] = v_dst; + BM_elem_index_set(v_src, index); /* set_ok */ + } + } + + if (remap & BM_EDGE) { + BMIter iter; + int index; + BMEdge *e_src; + BM_ITER_MESH_INDEX (e_src, &iter, bm, BM_EDGES_OF_MESH, index) { + BMEdge *e_dst = (BMEdge *)BLI_mempool_alloc(epool_dst); + memcpy(e_dst, e_src, sizeof(BMEdge)); + if (use_toolflags) { + ((BMEdge_OFlag *)e_dst)->oflags = bm->etoolflagpool ? (BMFlagLayer *)BLI_mempool_calloc( + bm->etoolflagpool) : + nullptr; + } + + etable_dst[index] = e_dst; + BM_elem_index_set(e_src, index); /* set_ok */ + } + } + + if (remap & (BM_LOOP | BM_FACE)) { + BMIter iter; + int index, index_loop = 0; + BMFace *f_src; + BM_ITER_MESH_INDEX (f_src, &iter, bm, BM_FACES_OF_MESH, index) { + + if (remap & BM_FACE) { + BMFace *f_dst = (BMFace *)BLI_mempool_alloc(fpool_dst); + memcpy(f_dst, f_src, sizeof(BMFace)); + if (use_toolflags) { + ((BMFace_OFlag *)f_dst)->oflags = bm->ftoolflagpool ? (BMFlagLayer *)BLI_mempool_calloc( + bm->ftoolflagpool) : + nullptr; + } + + ftable_dst[index] = f_dst; + BM_elem_index_set(f_src, index); /* set_ok */ + } + + /* handle loops */ + if (remap & BM_LOOP) { + BMLoop *l_iter_src, *l_first_src; + l_iter_src = l_first_src = BM_FACE_FIRST_LOOP((BMFace *)f_src); + do { + BMLoop *l_dst = (BMLoop *)BLI_mempool_alloc(lpool_dst); + memcpy(l_dst, l_iter_src, sizeof(BMLoop)); + ltable_dst[index_loop] = l_dst; + BM_elem_index_set(l_iter_src, index_loop++); /* set_ok */ + } while ((l_iter_src = l_iter_src->next) != l_first_src); + } + } + } + +#define MAP_VERT(ele) vtable_dst[BM_elem_index_get(ele)] +#define MAP_EDGE(ele) etable_dst[BM_elem_index_get(ele)] +#define MAP_LOOP(ele) ltable_dst[BM_elem_index_get(ele)] +#define MAP_FACE(ele) ftable_dst[BM_elem_index_get(ele)] + +#define REMAP_VERT(ele) \ + { \ + if (remap & BM_VERT) { \ + ele = MAP_VERT(ele); \ + } \ + } \ + ((void)0) +#define REMAP_EDGE(ele) \ + { \ + if (remap & BM_EDGE) { \ + ele = MAP_EDGE(ele); \ + } \ + } \ + ((void)0) +#define REMAP_LOOP(ele) \ + { \ + if (remap & BM_LOOP) { \ + ele = MAP_LOOP(ele); \ + } \ + } \ + ((void)0) +#define REMAP_FACE(ele) \ + { \ + if (remap & BM_FACE) { \ + ele = MAP_FACE(ele); \ + } \ + } \ + ((void)0) + + /* verts */ + { + for (int i = 0; i < bm->totvert; i++) { + BMVert *v = vtable_dst[i]; + if (v->e) { + REMAP_EDGE(v->e); + } + } + } + + /* edges */ + { + for (int i = 0; i < bm->totedge; i++) { + BMEdge *e = etable_dst[i]; + REMAP_VERT(e->v1); + REMAP_VERT(e->v2); + REMAP_EDGE(e->v1_disk_link.next); + REMAP_EDGE(e->v1_disk_link.prev); + REMAP_EDGE(e->v2_disk_link.next); + REMAP_EDGE(e->v2_disk_link.prev); + if (e->l) { + REMAP_LOOP(e->l); + } + } + } + + /* faces */ + { + for (int i = 0; i < bm->totface; i++) { + BMFace *f = ftable_dst[i]; + REMAP_LOOP(f->l_first); + + { + BMLoop *l_iter, *l_first; + l_iter = l_first = BM_FACE_FIRST_LOOP((BMFace *)f); + do { + REMAP_VERT(l_iter->v); + REMAP_EDGE(l_iter->e); + REMAP_FACE(l_iter->f); + + REMAP_LOOP(l_iter->radial_next); + REMAP_LOOP(l_iter->radial_prev); + REMAP_LOOP(l_iter->next); + REMAP_LOOP(l_iter->prev); + } while ((l_iter = l_iter->next) != l_first); + } + } + } + + LISTBASE_FOREACH (BMEditSelection *, ese, &bm->selected) { + switch (ese->htype) { + case BM_VERT: + if (remap & BM_VERT) { + ese->ele = (BMElem *)MAP_VERT(ese->ele); + } + break; + case BM_EDGE: + if (remap & BM_EDGE) { + ese->ele = (BMElem *)MAP_EDGE(ese->ele); + } + break; + case BM_FACE: + if (remap & BM_FACE) { + ese->ele = (BMElem *)MAP_FACE(ese->ele); + } + break; + } + } + + if (bm->act_face) { + REMAP_FACE(bm->act_face); + } + +#undef MAP_VERT +#undef MAP_EDGE +#undef MAP_LOOP +#undef MAP_EDGE + +#undef REMAP_VERT +#undef REMAP_EDGE +#undef REMAP_LOOP +#undef REMAP_EDGE + + /* Cleanup, re-use local tables if the current mesh had tables allocated. + * could use irrespective but it may use more memory than the caller wants + * (and not be needed). */ + if (remap & BM_VERT) { + if (bm->vtable) { + SWAP(BMVert **, vtable_dst, bm->vtable); + bm->vtable_tot = bm->totvert; + bm->elem_table_dirty &= ~BM_VERT; + } + MEM_freeN(vtable_dst); + BLI_mempool_destroy(bm->vpool); + bm->vpool = vpool_dst; + } + + if (remap & BM_EDGE) { + if (bm->etable) { + SWAP(BMEdge **, etable_dst, bm->etable); + bm->etable_tot = bm->totedge; + bm->elem_table_dirty &= ~BM_EDGE; + } + MEM_freeN(etable_dst); + BLI_mempool_destroy(bm->epool); + bm->epool = epool_dst; + } + + if (remap & BM_LOOP) { + /* no loop table */ + MEM_freeN(ltable_dst); + BLI_mempool_destroy(bm->lpool); + bm->lpool = lpool_dst; + } + + if (remap & BM_FACE) { + if (bm->ftable) { + SWAP(BMFace **, ftable_dst, bm->ftable); + bm->ftable_tot = bm->totface; + bm->elem_table_dirty &= ~BM_FACE; + } + MEM_freeN(ftable_dst); + BLI_mempool_destroy(bm->fpool); + bm->fpool = fpool_dst; + } +} + +void BM_mesh_toolflags_set(BMesh *bm, bool use_toolflags) +{ + if (bm->use_toolflags == use_toolflags) { + return; + } + + const BMAllocTemplate allocsize = BMALLOC_TEMPLATE_FROM_BM(bm); + + BLI_mempool *vpool_dst = nullptr; + BLI_mempool *epool_dst = nullptr; + BLI_mempool *fpool_dst = nullptr; + + bm_mempool_init_ex(&allocsize, use_toolflags, &vpool_dst, &epool_dst, nullptr, &fpool_dst); + + if (use_toolflags == false) { + BLI_mempool_destroy(bm->vtoolflagpool); + BLI_mempool_destroy(bm->etoolflagpool); + BLI_mempool_destroy(bm->ftoolflagpool); + + bm->vtoolflagpool = nullptr; + bm->etoolflagpool = nullptr; + bm->ftoolflagpool = nullptr; + } + struct BMeshCreateParams params = {}; + params.use_toolflags = use_toolflags; + + BM_mesh_rebuild(bm, ¶ms, vpool_dst, epool_dst, nullptr, fpool_dst); + + bm->use_toolflags = use_toolflags; +} + +/* -------------------------------------------------------------------- */ +/** \name BMesh Coordinate Access + * \{ */ + +void BM_mesh_vert_coords_get(BMesh *bm, float (*vert_coords)[3]) +{ + BMIter iter; + BMVert *v; + int i; + BM_ITER_MESH_INDEX (v, &iter, bm, BM_VERTS_OF_MESH, i) { + copy_v3_v3(vert_coords[i], v->co); + } +} + +float (*BM_mesh_vert_coords_alloc(BMesh *bm, int *r_vert_len))[3] +{ + float(*vert_coords)[3] = (float(*)[3])MEM_mallocN(bm->totvert * sizeof(*vert_coords), __func__); + BM_mesh_vert_coords_get(bm, vert_coords); + *r_vert_len = bm->totvert; + return vert_coords; +} + +void BM_mesh_vert_coords_apply(BMesh *bm, const float (*vert_coords)[3]) +{ + BMIter iter; + BMVert *v; + int i; + BM_ITER_MESH_INDEX (v, &iter, bm, BM_VERTS_OF_MESH, i) { + copy_v3_v3(v->co, vert_coords[i]); + } +} + +void BM_mesh_vert_coords_apply_with_mat4(BMesh *bm, + const float (*vert_coords)[3], + const float mat[4][4]) +{ + BMIter iter; + BMVert *v; + int i; + BM_ITER_MESH_INDEX (v, &iter, bm, BM_VERTS_OF_MESH, i) { + mul_v3_m4v3(v->co, mat, vert_coords[i]); + } +} + +/** \} */ -- cgit v1.2.3