BMesh: move bmesh_mesh to C++

This allows parts of the code to be threaded more easily.

2 files changed, 99 insertions, 103 deletions

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.cc
index 7dba854b9ef..c16d874e3ec 100644
--- a/source/blender/bmesh/intern/bmesh_mesh.c
+++ b/source/blender/bmesh/intern/bmesh_mesh.cc
@@ -88,19 +88,19 @@ void BM_mesh_elem_toolflags_ensure(BMesh *bm)
   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);
+    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 = BLI_mempool_calloc(toolflagpool);
+    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 = BLI_mempool_calloc(toolflagpool);
+    f_olfag->oflags = (BMFlagLayer *)BLI_mempool_calloc(toolflagpool);
   }
 
   bm->totflags = 1;
@@ -110,22 +110,22 @@ void BM_mesh_elem_toolflags_clear(BMesh *bm)
 {
   if (bm->vtoolflagpool) {
     BLI_mempool_destroy(bm->vtoolflagpool);
-    bm->vtoolflagpool = NULL;
+    bm->vtoolflagpool = nullptr;
   }
   if (bm->etoolflagpool) {
     BLI_mempool_destroy(bm->etoolflagpool);
-    bm->etoolflagpool = NULL;
+    bm->etoolflagpool = nullptr;
   }
   if (bm->ftoolflagpool) {
     BLI_mempool_destroy(bm->ftoolflagpool);
-    bm->ftoolflagpool = NULL;
+    bm->ftoolflagpool = nullptr;
   }
 }
 
 BMesh *BM_mesh_create(const BMAllocTemplate *allocsize, const struct BMeshCreateParams *params)
 {
   /* allocate the structure */
-  BMesh *bm = MEM_callocN(sizeof(BMesh), __func__);
+  BMesh *bm = (BMesh *)MEM_callocN(sizeof(BMesh), __func__);
 
   /* allocate the memory pools for the mesh elements */
   bm_mempool_init(bm, allocsize, params->use_toolflags);
@@ -262,8 +262,8 @@ void BM_mesh_free(BMesh *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;
+    bpy_bm_generic_invalidate((BPy_BMGeneric *)bm->py_handle);
+    bm->py_handle = nullptr;
   }
 
   MEM_freeN(bm);
@@ -336,7 +336,7 @@ void BM_mesh_elem_index_ensure_ex(BMesh *bm, const char htype, int elem_offset[4
   BM_ELEM_INDEX_VALIDATE(bm, "Should Never Fail!", __func__);
 #endif
 
-  if (elem_offset == NULL) {
+  if (elem_offset == nullptr) {
     /* Simple case. */
     const char htype_needed = bm->elem_index_dirty & htype;
     if (htype_needed == 0) {
@@ -445,7 +445,7 @@ finally:
 
 void BM_mesh_elem_index_ensure(BMesh *bm, const char htype)
 {
-  BM_mesh_elem_index_ensure_ex(bm, htype, NULL);
+  BM_mesh_elem_index_ensure_ex(bm, htype, nullptr);
 }
 
 void BM_mesh_elem_index_validate(
@@ -459,7 +459,7 @@ void BM_mesh_elem_index_validate(
   BMIter iter;
   BMElem *ele;
   int i;
-  bool is_any_error = 0;
+  bool is_any_error = false;
 
   for (i = 0; i < 3; i++) {
     const bool is_dirty = (flag_types[i] & bm->elem_index_dirty) != 0;
@@ -581,9 +581,10 @@ void BM_mesh_elem_table_ensure(BMesh *bm, const char htype)
       if (bm->vtable) {
         MEM_freeN(bm->vtable);
       }
-      bm->vtable = MEM_mallocN(sizeof(void **) * bm->totvert, "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) {
@@ -593,9 +594,10 @@ void BM_mesh_elem_table_ensure(BMesh *bm, const char htype)
       if (bm->etable) {
         MEM_freeN(bm->etable);
       }
-      bm->etable = MEM_mallocN(sizeof(void **) * bm->totedge, "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) {
@@ -605,21 +607,10 @@ void BM_mesh_elem_table_ensure(BMesh *bm, const char htype)
       if (bm->ftable) {
         MEM_freeN(bm->ftable);
       }
-      bm->ftable = MEM_mallocN(sizeof(void **) * bm->totface, "bm->ftable");
+      bm->ftable = (BMFace **)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);
+    BM_iter_as_array(bm, BM_FACES_OF_MESH, nullptr, (void **)bm->ftable, bm->totface);
   }
 
 finally:
@@ -656,17 +647,17 @@ void BM_mesh_elem_table_free(BMesh *bm, const char htype)
 
 BMVert *BM_vert_at_index_find(BMesh *bm, const int index)
 {
-  return BLI_mempool_findelem(bm->vpool, index);
+  return (BMVert *)BLI_mempool_findelem(bm->vpool, index);
 }
 
 BMEdge *BM_edge_at_index_find(BMesh *bm, const int index)
 {
-  return BLI_mempool_findelem(bm->epool, index);
+  return (BMEdge *)BLI_mempool_findelem(bm->epool, index);
 }
 
 BMFace *BM_face_at_index_find(BMesh *bm, const int index)
 {
-  return BLI_mempool_findelem(bm->fpool, index);
+  return (BMFace *)BLI_mempool_findelem(bm->fpool, index);
 }
 
 BMLoop *BM_loop_at_index_find(BMesh *bm, const int index)
@@ -687,13 +678,13 @@ BMLoop *BM_loop_at_index_find(BMesh *bm, const int index)
     }
     i -= f->len;
   }
-  return NULL;
+  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] : NULL;
+    return (index < bm->totvert) ? bm->vtable[index] : nullptr;
   }
   return BM_vert_at_index_find(bm, index);
 }
@@ -701,7 +692,7 @@ BMVert *BM_vert_at_index_find_or_table(BMesh *bm, const int 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 (index < bm->totedge) ? bm->etable[index] : nullptr;
   }
   return BM_edge_at_index_find(bm, index);
 }
@@ -709,7 +700,7 @@ BMEdge *BM_edge_at_index_find_or_table(BMesh *bm, const int 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 (index < bm->totface) ? bm->ftable[index] : nullptr;
   }
   return BM_face_at_index_find(bm, index);
 }
@@ -735,7 +726,7 @@ int BM_mesh_elem_count(BMesh *bm, const char htype)
 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;
+  GHash *vptr_map = nullptr, *eptr_map = nullptr, *fptr_map = nullptr;
   BMIter iter, iterl;
   BMVert *ve;
   BMEdge *ed;
@@ -763,14 +754,16 @@ void BM_mesh_remap(BMesh *bm, const uint *vert_idx, const uint *edge_idx, const
 
     /* 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;
+    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 = BM_ELEM_CD_GET_VOID_P(((BMElem *)ve), cd_vert_pyptr);
+        void **pyptr = (void **)BM_ELEM_CD_GET_VOID_P(((BMElem *)ve), cd_vert_pyptr);
         pyptrs[i] = *pyptr;
       }
     }
@@ -788,7 +781,7 @@ void BM_mesh_remap(BMesh *bm, const uint *vert_idx, const uint *edge_idx, const
 #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);
+        void **pyptr = (void **)BM_ELEM_CD_GET_VOID_P(((BMElem *)new_vep), cd_vert_pyptr);
         *pyptr = pyptrs[*new_idx];
       }
     }
@@ -815,13 +808,15 @@ void BM_mesh_remap(BMesh *bm, const uint *vert_idx, const uint *edge_idx, const
 
     /* 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;
+    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 = BM_ELEM_CD_GET_VOID_P(((BMElem *)ed), cd_edge_pyptr);
+        void **pyptr = (void **)BM_ELEM_CD_GET_VOID_P(((BMElem *)ed), cd_edge_pyptr);
         pyptrs[i] = *pyptr;
       }
     }
@@ -839,7 +834,7 @@ void BM_mesh_remap(BMesh *bm, const uint *vert_idx, const uint *edge_idx, const
           "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);
+        void **pyptr = (void **)BM_ELEM_CD_GET_VOID_P(((BMElem *)new_edp), cd_edge_pyptr);
         *pyptr = pyptrs[*new_idx];
       }
     }
@@ -866,13 +861,15 @@ void BM_mesh_remap(BMesh *bm, const uint *vert_idx, const uint *edge_idx, const
 
     /* 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;
+    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 = BM_ELEM_CD_GET_VOID_P(((BMElem *)fa), cd_poly_pyptr);
+        void **pyptr = (void **)BM_ELEM_CD_GET_VOID_P(((BMElem *)fa), cd_poly_pyptr);
         pyptrs[i] = *pyptr;
       }
     }
@@ -886,7 +883,7 @@ void BM_mesh_remap(BMesh *bm, const uint *vert_idx, const uint *edge_idx, const
       *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);
+        void **pyptr = (void **)BM_ELEM_CD_GET_VOID_P(((BMElem *)new_fap), cd_poly_pyptr);
         *pyptr = pyptrs[*new_idx];
       }
     }
@@ -906,7 +903,7 @@ void BM_mesh_remap(BMesh *bm, const uint *vert_idx, const uint *edge_idx, const
     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);
+        ve->e = (BMEdge *)BLI_ghash_lookup(eptr_map, ve->e);
         BLI_assert(ve->e);
       }
     }
@@ -922,8 +919,8 @@ void BM_mesh_remap(BMesh *bm, const uint *vert_idx, const uint *edge_idx, const
         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);
+        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);
       }
@@ -942,10 +939,10 @@ void BM_mesh_remap(BMesh *bm, const uint *vert_idx, const uint *edge_idx, const
                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);
+        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);
@@ -959,17 +956,17 @@ void BM_mesh_remap(BMesh *bm, const uint *vert_idx, const uint *edge_idx, const
     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);
+        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 = 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 = BLI_ghash_lookup(fptr_map, lo->f);
+        lo->f = (BMFace *)BLI_ghash_lookup(fptr_map, lo->f);
         BLI_assert(lo->f);
       }
     }
@@ -978,23 +975,23 @@ void BM_mesh_remap(BMesh *bm, const uint *vert_idx, const uint *edge_idx, const
   /* Selection history */
   {
     BMEditSelection *ese;
-    for (ese = bm->selected.first; ese; ese = ese->next) {
+    for (ese = (BMEditSelection *)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);
+            ese->ele = (BMElem *)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);
+            ese->ele = (BMElem *)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);
+            ese->ele = (BMElem *)BLI_ghash_lookup(fptr_map, ese->ele);
             BLI_assert(ese->ele);
           }
           break;
@@ -1004,19 +1001,19 @@ void BM_mesh_remap(BMesh *bm, const uint *vert_idx, const uint *edge_idx, const
 
   if (fptr_map) {
     if (bm->act_face) {
-      bm->act_face = BLI_ghash_lookup(fptr_map, 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, NULL, NULL);
+    BLI_ghash_free(vptr_map, nullptr, nullptr);
   }
   if (eptr_map) {
-    BLI_ghash_free(eptr_map, NULL, NULL);
+    BLI_ghash_free(eptr_map, nullptr, nullptr);
   }
   if (fptr_map) {
-    BLI_ghash_free(fptr_map, NULL, NULL);
+    BLI_ghash_free(fptr_map, nullptr, nullptr);
   }
 }
 
@@ -1030,14 +1027,18 @@ void BM_mesh_rebuild(BMesh *bm,
   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;
+  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;
 
@@ -1046,12 +1047,12 @@ void BM_mesh_rebuild(BMesh *bm,
     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);
+      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 ?
-                                              BLI_mempool_calloc(bm->vtoolflagpool) :
-                                              NULL;
+        ((BMVert_OFlag *)v_dst)->oflags = bm->vtoolflagpool ? (BMFlagLayer *)BLI_mempool_calloc(
+                                                                  bm->vtoolflagpool) :
+                                                              nullptr;
       }
 
       vtable_dst[index] = v_dst;
@@ -1064,12 +1065,12 @@ void BM_mesh_rebuild(BMesh *bm,
     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);
+      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 ?
-                                              BLI_mempool_calloc(bm->etoolflagpool) :
-                                              NULL;
+        ((BMEdge_OFlag *)e_dst)->oflags = bm->etoolflagpool ? (BMFlagLayer *)BLI_mempool_calloc(
+                                                                  bm->etoolflagpool) :
+                                                              nullptr;
       }
 
       etable_dst[index] = e_dst;
@@ -1084,12 +1085,12 @@ void BM_mesh_rebuild(BMesh *bm,
     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);
+        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 ?
-                                                BLI_mempool_calloc(bm->ftoolflagpool) :
-                                                NULL;
+          ((BMFace_OFlag *)f_dst)->oflags = bm->ftoolflagpool ? (BMFlagLayer *)BLI_mempool_calloc(
+                                                                    bm->ftoolflagpool) :
+                                                                nullptr;
         }
 
         ftable_dst[index] = f_dst;
@@ -1101,7 +1102,7 @@ void BM_mesh_rebuild(BMesh *bm,
         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);
+          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 */
@@ -1279,30 +1280,25 @@ void BM_mesh_toolflags_set(BMesh *bm, bool use_toolflags)
 
   const BMAllocTemplate allocsize = BMALLOC_TEMPLATE_FROM_BM(bm);
 
-  BLI_mempool *vpool_dst = NULL;
-  BLI_mempool *epool_dst = NULL;
-  BLI_mempool *fpool_dst = NULL;
+  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, NULL, &fpool_dst);
+  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 = NULL;
-    bm->etoolflagpool = NULL;
-    bm->ftoolflagpool = NULL;
+    bm->vtoolflagpool = nullptr;
+    bm->etoolflagpool = nullptr;
+    bm->ftoolflagpool = nullptr;
   }
+  struct BMeshCreateParams params = {};
+  params.use_toolflags = use_toolflags;
 
-  BM_mesh_rebuild(bm,
-                  &((struct BMeshCreateParams){
-                      .use_toolflags = use_toolflags,
-                  }),
-                  vpool_dst,
-                  epool_dst,
-                  NULL,
-                  fpool_dst);
+  BM_mesh_rebuild(bm, &params, vpool_dst, epool_dst, nullptr, fpool_dst);
 
   bm->use_toolflags = use_toolflags;
 }
@@ -1323,7 +1319,7 @@ void BM_mesh_vert_coords_get(BMesh *bm, float (*vert_coords)[3])
 
 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__);
+  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;