Merge branch 'master' into refactor-mesh-uv-map-generic

28 files changed, 222 insertions, 205 deletions

diff --git a/source/blender/modifiers/intern/MOD_array.c b/source/blender/modifiers/intern/MOD_array.c
index 36988f07ef4..3ee61286f09 100644
--- a/source/blender/modifiers/intern/MOD_array.c
+++ b/source/blender/modifiers/intern/MOD_array.c
@@ -279,9 +279,9 @@ static void mesh_merge_transform(Mesh *result,
   MEdge *me;
   MLoop *ml;
   MPoly *mp;
-  MVert *result_verts = BKE_mesh_vertices_for_write(result);
+  MVert *result_verts = BKE_mesh_verts_for_write(result);
   MEdge *result_edges = BKE_mesh_edges_for_write(result);
-  MPoly *result_polys = BKE_mesh_polygons_for_write(result);
+  MPoly *result_polys = BKE_mesh_polys_for_write(result);
   MLoop *result_loops = BKE_mesh_loops_for_write(result);
 
   CustomData_copy_data(&cap_mesh->vdata, &result->vdata, 0, cap_verts_index, cap_nverts);
@@ -294,7 +294,7 @@ static void mesh_merge_transform(Mesh *result,
   for (i = 0; i < cap_nverts; i++, mv++) {
     mul_m4_v3(cap_offset, mv->co);
     /* Reset MVert flags for caps */
-    mv->flag = mv->bweight = 0;
+    mv->flag = 0;
   }
 
   /* We have to correct normals too, if we do not tag them as dirty later! */
@@ -430,9 +430,9 @@ static Mesh *arrayModifier_doArray(ArrayModifierData *amd,
   /* Build up offset array, accumulating all settings options. */
 
   unit_m4(offset);
-  const MVert *src_verts = BKE_mesh_vertices(mesh);
+  const MVert *src_verts = BKE_mesh_verts(mesh);
   const MEdge *src_edges = BKE_mesh_edges(mesh);
-  const MPoly *src_polys = BKE_mesh_polygons(mesh);
+  const MPoly *src_polys = BKE_mesh_polys(mesh);
   const MLoop *src_loops = BKE_mesh_loops(mesh);
 
   if (amd->offset_type & MOD_ARR_OFF_CONST) {
@@ -482,7 +482,7 @@ static Mesh *arrayModifier_doArray(ArrayModifierData *amd,
   }
 
   /* About 67 million vertices max seems a decent limit for now. */
-  const size_t max_vertices_num = 1 << 26;
+  const size_t max_verts_num = 1 << 26;
 
   /* calculate the maximum number of copies which will fit within the
    * prescribed length */
@@ -500,7 +500,7 @@ static Mesh *arrayModifier_doArray(ArrayModifierData *amd,
        * vertices.
        */
       if (((size_t)count * (size_t)chunk_nverts + (size_t)start_cap_nverts +
-           (size_t)end_cap_nverts) > max_vertices_num) {
+           (size_t)end_cap_nverts) > max_verts_num) {
         count = 1;
         offset_is_too_small = true;
       }
@@ -522,7 +522,7 @@ static Mesh *arrayModifier_doArray(ArrayModifierData *amd,
    * vertices.
    */
   else if (((size_t)count * (size_t)chunk_nverts + (size_t)start_cap_nverts +
-            (size_t)end_cap_nverts) > max_vertices_num) {
+            (size_t)end_cap_nverts) > max_verts_num) {
     count = 1;
     BKE_modifier_set_error(ctx->object,
                            &amd->modifier,
@@ -543,9 +543,9 @@ static Mesh *arrayModifier_doArray(ArrayModifierData *amd,
   /* Initialize a result dm */
   result = BKE_mesh_new_nomain_from_template(
       mesh, result_nverts, result_nedges, 0, result_nloops, result_npolys);
-  MVert *result_verts = BKE_mesh_vertices_for_write(result);
+  MVert *result_verts = BKE_mesh_verts_for_write(result);
   MEdge *result_edges = BKE_mesh_edges_for_write(result);
-  MPoly *result_polys = BKE_mesh_polygons_for_write(result);
+  MPoly *result_polys = BKE_mesh_polys_for_write(result);
   MLoop *result_loops = BKE_mesh_loops_for_write(result);
 
   if (use_merge) {
@@ -560,8 +560,8 @@ static Mesh *arrayModifier_doArray(ArrayModifierData *amd,
   CustomData_copy_data(&mesh->ldata, &result->ldata, 0, 0, chunk_nloops);
   CustomData_copy_data(&mesh->pdata, &result->pdata, 0, 0, chunk_npolys);
 
-  /* Subsurf for eg won't have mesh data in the custom data arrays.
-   * now add mvert/medge/mpoly layers. */
+  /* Subdivision-surface for eg won't have mesh data in the custom-data arrays.
+   * Now add #MVert/#MEdge/#MPoly layers. */
   if (!CustomData_has_layer(&mesh->vdata, CD_MVERT)) {
     memcpy(result_verts, src_verts, sizeof(MVert) * mesh->totvert);
   }
diff --git a/source/blender/modifiers/intern/MOD_bevel.c b/source/blender/modifiers/intern/MOD_bevel.c
index ee9a2856ab0..668843188ab 100644
--- a/source/blender/modifiers/intern/MOD_bevel.c
+++ b/source/blender/modifiers/intern/MOD_bevel.c
@@ -74,6 +74,10 @@ static void requiredDataMask(Object *UNUSED(ob),
   if (bmd->defgrp_name[0] != '\0') {
     r_cddata_masks->vmask |= CD_MASK_MDEFORMVERT;
   }
+  if (bmd->lim_flags & MOD_BEVEL_WEIGHT) {
+    r_cddata_masks->vmask |= CD_MASK_BWEIGHT;
+    r_cddata_masks->emask |= CD_MASK_BWEIGHT;
+  }
 }
 
 /*
diff --git a/source/blender/modifiers/intern/MOD_boolean.cc b/source/blender/modifiers/intern/MOD_boolean.cc
index 39667a3f1d5..b266e71e99a 100644
--- a/source/blender/modifiers/intern/MOD_boolean.cc
+++ b/source/blender/modifiers/intern/MOD_boolean.cc
@@ -144,7 +144,7 @@ static Mesh *get_quick_mesh(
           invert_m4_m4(imat, ob_self->obmat);
           mul_m4_m4m4(omat, imat, ob_operand_ob->obmat);
 
-          MutableSpan<MVert> verts = result->vertices_for_write();
+          MutableSpan<MVert> verts = result->verts_for_write();
           for (const int i : verts.index_range()) {
             mul_m4_v3(omat, verts[i].co);
           }
diff --git a/source/blender/modifiers/intern/MOD_build.c b/source/blender/modifiers/intern/MOD_build.c
index 02d56560fc5..78724d6a2a1 100644
--- a/source/blender/modifiers/intern/MOD_build.c
+++ b/source/blender/modifiers/intern/MOD_build.c
@@ -75,9 +75,9 @@ static Mesh *modifyMesh(ModifierData *md, const ModifierEvalContext *ctx, struct
   const int vert_src_num = mesh->totvert;
   const int edge_src_num = mesh->totedge;
   const int poly_src_num = mesh->totpoly;
-  const MVert *mvert_src = BKE_mesh_vertices(mesh);
+  const MVert *mvert_src = BKE_mesh_verts(mesh);
   const MEdge *medge_src = BKE_mesh_edges(mesh);
-  const MPoly *mpoly_src = BKE_mesh_polygons(mesh);
+  const MPoly *mpoly_src = BKE_mesh_polys(mesh);
   const MLoop *mloop_src = BKE_mesh_loops(mesh);
 
   vertMap = MEM_malloc_arrayN(vert_src_num, sizeof(*vertMap), "build modifier vertMap");
@@ -202,9 +202,9 @@ static Mesh *modifyMesh(ModifierData *md, const ModifierEvalContext *ctx, struct
   /* now we know the number of verts, edges and faces, we can create the mesh. */
   result = BKE_mesh_new_nomain_from_template(
       mesh, BLI_ghash_len(vertHash), BLI_ghash_len(edgeHash), 0, loops_dst_num, faces_dst_num);
-  MVert *result_verts = BKE_mesh_vertices_for_write(result);
+  MVert *result_verts = BKE_mesh_verts_for_write(result);
   MEdge *result_edges = BKE_mesh_edges_for_write(result);
-  MPoly *result_polys = BKE_mesh_polygons_for_write(result);
+  MPoly *result_polys = BKE_mesh_polys_for_write(result);
   MLoop *result_loops = BKE_mesh_loops_for_write(result);
 
   /* copy the vertices across */
diff --git a/source/blender/modifiers/intern/MOD_collision.c b/source/blender/modifiers/intern/MOD_collision.c
index 3ae83cb2244..e38bf96500e 100644
--- a/source/blender/modifiers/intern/MOD_collision.c
+++ b/source/blender/modifiers/intern/MOD_collision.c
@@ -145,7 +145,7 @@ static void deformVerts(ModifierData *md,
 
     if (collmd->time_xnew == -1000) { /* first time */
 
-      collmd->x = MEM_dupallocN(BKE_mesh_vertices(mesh_src)); /* frame start position */
+      collmd->x = MEM_dupallocN(BKE_mesh_verts(mesh_src)); /* frame start position */
 
       for (uint i = 0; i < mvert_num; i++) {
         /* we save global positions */
@@ -182,7 +182,7 @@ static void deformVerts(ModifierData *md,
       collmd->xnew = tempVert;
       collmd->time_x = collmd->time_xnew;
 
-      memcpy(collmd->xnew, BKE_mesh_vertices(mesh_src), mvert_num * sizeof(MVert));
+      memcpy(collmd->xnew, BKE_mesh_verts(mesh_src), mvert_num * sizeof(MVert));
 
       bool is_static = true;
 
diff --git a/source/blender/modifiers/intern/MOD_correctivesmooth.c b/source/blender/modifiers/intern/MOD_correctivesmooth.c
index 30afb993cc7..16f2205796c 100644
--- a/source/blender/modifiers/intern/MOD_correctivesmooth.c
+++ b/source/blender/modifiers/intern/MOD_correctivesmooth.c
@@ -132,7 +132,7 @@ static void mesh_get_weights(const MDeformVert *dvert,
 static void mesh_get_boundaries(Mesh *mesh, float *smooth_weights)
 {
   const MEdge *medge = BKE_mesh_edges(mesh);
-  const MPoly *mpoly = BKE_mesh_polygons(mesh);
+  const MPoly *mpoly = BKE_mesh_polys(mesh);
   const MLoop *mloop = BKE_mesh_loops(mesh);
   uint mpoly_num, medge_num, i;
   ushort *boundaries;
@@ -452,7 +452,7 @@ static void calc_tangent_spaces(Mesh *mesh, float (*vertexCos)[3], float (*r_tan
 #ifndef USE_TANGENT_CALC_INLINE
   const uint mvert_num = (uint)dm->getNumVerts(dm);
 #endif
-  const MPoly *mpoly = BKE_mesh_polygons(mesh);
+  const MPoly *mpoly = BKE_mesh_polys(mesh);
   const MLoop *mloop = BKE_mesh_loops(mesh);
   uint i;
 
diff --git a/source/blender/modifiers/intern/MOD_datatransfer.c b/source/blender/modifiers/intern/MOD_datatransfer.c
index 729a912b079..2d917310818 100644
--- a/source/blender/modifiers/intern/MOD_datatransfer.c
+++ b/source/blender/modifiers/intern/MOD_datatransfer.c
@@ -179,9 +179,9 @@ static Mesh *modifyMesh(ModifierData *md, const ModifierEvalContext *ctx, Mesh *
     BLI_SPACE_TRANSFORM_SETUP(space_transform, ctx->object, ob_source);
   }
 
-  const MVert *me_verts = BKE_mesh_vertices(me);
+  const MVert *me_verts = BKE_mesh_verts(me);
   const MEdge *me_edges = BKE_mesh_edges(me);
-  const MVert *result_verts = BKE_mesh_vertices(result);
+  const MVert *result_verts = BKE_mesh_verts(result);
   const MEdge *result_edges = BKE_mesh_edges(result);
 
   if (((result == me) || (me_verts == result_verts) || (me_edges == result_edges)) &&
diff --git a/source/blender/modifiers/intern/MOD_displace.c b/source/blender/modifiers/intern/MOD_displace.c
index 00a6cb5878f..ddaea289246 100644
--- a/source/blender/modifiers/intern/MOD_displace.c
+++ b/source/blender/modifiers/intern/MOD_displace.c
@@ -286,7 +286,7 @@ static void displaceModifier_do(DisplaceModifierData *dmd,
     return;
   }
 
-  mvert = BKE_mesh_vertices_for_write(mesh);
+  mvert = BKE_mesh_verts_for_write(mesh);
   MOD_get_vgroup(ob, mesh, dmd->defgrp_name, &dvert, &defgrp_index);
 
   if (defgrp_index >= 0 && dvert == NULL) {
diff --git a/source/blender/modifiers/intern/MOD_explode.c b/source/blender/modifiers/intern/MOD_explode.c
index e5579819cf0..c8f1ef73d5e 100644
--- a/source/blender/modifiers/intern/MOD_explode.c
+++ b/source/blender/modifiers/intern/MOD_explode.c
@@ -100,7 +100,7 @@ static void createFacepa(ExplodeModifierData *emd, ParticleSystemModifierData *p
   int i, p, v1, v2, v3, v4 = 0;
   const bool invert_vgroup = (emd->flag & eExplodeFlag_INVERT_VGROUP) != 0;
 
-  mvert = BKE_mesh_vertices_for_write(mesh);
+  mvert = BKE_mesh_verts_for_write(mesh);
   mface = (MFace *)CustomData_get_layer(&mesh->fdata, CD_MFACE);
   totvert = mesh->totvert;
   totface = mesh->totface;
@@ -730,8 +730,8 @@ static Mesh *cutEdges(ExplodeModifierData *emd, Mesh *mesh)
 
   layers_num = CustomData_number_of_layers(&split_m->fdata, CD_MTFACE);
 
-  const MVert *mesh_verts = BKE_mesh_vertices(mesh);
-  MVert *split_m_verts = BKE_mesh_vertices_for_write(split_m);
+  const MVert *mesh_verts = BKE_mesh_verts(mesh);
+  MVert *split_m_verts = BKE_mesh_verts_for_write(split_m);
 
   /* copy new faces & verts (is it really this painful with custom data??) */
   for (i = 0; i < totvert; i++) {
@@ -989,8 +989,8 @@ static Mesh *explodeMesh(ExplodeModifierData *emd,
 
   psmd->psys->lattice_deform_data = psys_create_lattice_deform_data(&sim);
 
-  const MVert *mesh_verts = BKE_mesh_vertices(mesh);
-  MVert *explode_verts = BKE_mesh_vertices_for_write(explode);
+  const MVert *mesh_verts = BKE_mesh_verts(mesh);
+  MVert *explode_verts = BKE_mesh_verts_for_write(explode);
 
   /* duplicate & displace vertices */
   ehi = BLI_edgehashIterator_new(vertpahash);
diff --git a/source/blender/modifiers/intern/MOD_laplaciansmooth.c b/source/blender/modifiers/intern/MOD_laplaciansmooth.c
index d74c1e7ac2d..13193d7eb11 100644
--- a/source/blender/modifiers/intern/MOD_laplaciansmooth.c
+++ b/source/blender/modifiers/intern/MOD_laplaciansmooth.c
@@ -388,7 +388,7 @@ static void laplaciansmoothModifier_do(
     return;
   }
 
-  sys->mpoly = BKE_mesh_polygons(mesh);
+  sys->mpoly = BKE_mesh_polys(mesh);
   sys->mloop = BKE_mesh_loops(mesh);
   sys->medges = BKE_mesh_edges(mesh);
   sys->vertexCos = vertexCos;
diff --git a/source/blender/modifiers/intern/MOD_mask.cc b/source/blender/modifiers/intern/MOD_mask.cc
index cfa0299da66..b3ee6a1f4ca 100644
--- a/source/blender/modifiers/intern/MOD_mask.cc
+++ b/source/blender/modifiers/intern/MOD_mask.cc
@@ -143,9 +143,9 @@ static void invert_boolean_array(MutableSpan<bool> array)
   }
 }
 
-static void compute_masked_vertices(Span<bool> vertex_mask,
-                                    MutableSpan<int> r_vertex_map,
-                                    uint *r_verts_masked_num)
+static void compute_masked_verts(Span<bool> vertex_mask,
+                                 MutableSpan<int> r_vertex_map,
+                                 uint *r_verts_masked_num)
 {
   BLI_assert(vertex_mask.size() == r_vertex_map.size());
 
@@ -223,15 +223,15 @@ static void computed_masked_edges_smooth(const Mesh *mesh,
   *r_verts_add_num = verts_add_num;
 }
 
-static void computed_masked_polygons(const Mesh *mesh,
-                                     Span<bool> vertex_mask,
-                                     Vector<int> &r_masked_poly_indices,
-                                     Vector<int> &r_loop_starts,
-                                     uint *r_polys_masked_num,
-                                     uint *r_loops_masked_num)
+static void computed_masked_polys(const Mesh *mesh,
+                                  Span<bool> vertex_mask,
+                                  Vector<int> &r_masked_poly_indices,
+                                  Vector<int> &r_loop_starts,
+                                  uint *r_polys_masked_num,
+                                  uint *r_loops_masked_num)
 {
   BLI_assert(mesh->totvert == vertex_mask.size());
-  const Span<MPoly> polys = mesh->polygons();
+  const Span<MPoly> polys = mesh->polys();
   const Span<MLoop> loops = mesh->loops();
 
   r_masked_poly_indices.reserve(mesh->totpoly);
@@ -261,15 +261,15 @@ static void computed_masked_polygons(const Mesh *mesh,
   *r_loops_masked_num = loops_masked_num;
 }
 
-static void compute_interpolated_polygons(const Mesh *mesh,
-                                          Span<bool> vertex_mask,
-                                          uint verts_add_num,
-                                          uint loops_masked_num,
-                                          Vector<int> &r_masked_poly_indices,
-                                          Vector<int> &r_loop_starts,
-                                          uint *r_edges_add_num,
-                                          uint *r_polys_add_num,
-                                          uint *r_loops_add_num)
+static void compute_interpolated_polys(const Mesh *mesh,
+                                       Span<bool> vertex_mask,
+                                       uint verts_add_num,
+                                       uint loops_masked_num,
+                                       Vector<int> &r_masked_poly_indices,
+                                       Vector<int> &r_loop_starts,
+                                       uint *r_edges_add_num,
+                                       uint *r_polys_add_num,
+                                       uint *r_loops_add_num)
 {
   BLI_assert(mesh->totvert == vertex_mask.size());
 
@@ -277,7 +277,7 @@ static void compute_interpolated_polygons(const Mesh *mesh,
   /* NOTE: this reserve can only lift the capacity if there are ngons, which get split. */
   r_masked_poly_indices.reserve(r_masked_poly_indices.size() + verts_add_num);
   r_loop_starts.reserve(r_loop_starts.size() + verts_add_num);
-  const Span<MPoly> polys = mesh->polygons();
+  const Span<MPoly> polys = mesh->polys();
   const Span<MLoop> loops = mesh->loops();
 
   uint edges_add_num = 0;
@@ -333,13 +333,13 @@ static void compute_interpolated_polygons(const Mesh *mesh,
   *r_loops_add_num = loops_add_num;
 }
 
-static void copy_masked_vertices_to_new_mesh(const Mesh &src_mesh,
-                                             Mesh &dst_mesh,
-                                             Span<int> vertex_map)
+static void copy_masked_verts_to_new_mesh(const Mesh &src_mesh,
+                                          Mesh &dst_mesh,
+                                          Span<int> vertex_map)
 {
   BLI_assert(src_mesh.totvert == vertex_map.size());
-  const Span<MVert> src_verts = src_mesh.vertices();
-  MutableSpan<MVert> dst_verts = dst_mesh.vertices_for_write();
+  const Span<MVert> src_verts = src_mesh.verts();
+  MutableSpan<MVert> dst_verts = dst_mesh.verts_for_write();
 
   for (const int i_src : vertex_map.index_range()) {
     const int i_dst = vertex_map[i_src];
@@ -378,9 +378,9 @@ static void add_interp_verts_copy_edges_to_new_mesh(const Mesh &src_mesh,
 {
   BLI_assert(src_mesh.totvert == vertex_mask.size());
   BLI_assert(src_mesh.totedge == r_edge_map.size());
-  const Span<MVert> src_verts = src_mesh.vertices();
+  const Span<MVert> src_verts = src_mesh.verts();
   const Span<MEdge> src_edges = src_mesh.edges();
-  MutableSpan<MVert> dst_verts = dst_mesh.vertices_for_write();
+  MutableSpan<MVert> dst_verts = dst_mesh.verts_for_write();
   MutableSpan<MEdge> dst_edges = dst_mesh.edges_for_write();
 
   uint vert_index = dst_mesh.totvert - verts_add_num;
@@ -466,9 +466,9 @@ static void copy_masked_polys_to_new_mesh(const Mesh &src_mesh,
                                           Span<int> new_loop_starts,
                                           int polys_masked_num)
 {
-  const Span<MPoly> src_polys = src_mesh.polygons();
+  const Span<MPoly> src_polys = src_mesh.polys();
   const Span<MLoop> src_loops = src_mesh.loops();
-  MutableSpan<MPoly> dst_polys = dst_mesh.polygons_for_write();
+  MutableSpan<MPoly> dst_polys = dst_mesh.polys_for_write();
   MutableSpan<MLoop> dst_loops = dst_mesh.loops_for_write();
 
   for (const int i_dst : IndexRange(polys_masked_num)) {
@@ -507,10 +507,10 @@ static void add_interpolated_polys_to_new_mesh(const Mesh &src_mesh,
                                                int polys_masked_num,
                                                int edges_add_num)
 {
-  const Span<MPoly> src_polys = src_mesh.polygons();
+  const Span<MPoly> src_polys = src_mesh.polys();
   const Span<MLoop> src_loops = src_mesh.loops();
   MutableSpan<MEdge> dst_edges = dst_mesh.edges_for_write();
-  MutableSpan<MPoly> dst_polys = dst_mesh.polygons_for_write();
+  MutableSpan<MPoly> dst_polys = dst_mesh.polys_for_write();
   MutableSpan<MLoop> dst_loops = dst_mesh.loops_for_write();
 
   int edge_index = dst_mesh.totedge - edges_add_num;
@@ -692,7 +692,7 @@ static Mesh *modifyMesh(ModifierData *md, const ModifierEvalContext *UNUSED(ctx)
 
   Array<int> vertex_map(mesh->totvert);
   uint verts_masked_num;
-  compute_masked_vertices(vertex_mask, vertex_map, &verts_masked_num);
+  compute_masked_verts(vertex_mask, vertex_map, &verts_masked_num);
 
   Array<int> edge_map(mesh->totedge);
   uint edges_masked_num;
@@ -709,26 +709,26 @@ static Mesh *modifyMesh(ModifierData *md, const ModifierEvalContext *UNUSED(ctx)
   Vector<int> new_loop_starts;
   uint polys_masked_num;
   uint loops_masked_num;
-  computed_masked_polygons(mesh,
-                           vertex_mask,
-                           masked_poly_indices,
-                           new_loop_starts,
-                           &polys_masked_num,
-                           &loops_masked_num);
+  computed_masked_polys(mesh,
+                        vertex_mask,
+                        masked_poly_indices,
+                        new_loop_starts,
+                        &polys_masked_num,
+                        &loops_masked_num);
 
   uint edges_add_num = 0;
   uint polys_add_num = 0;
   uint loops_add_num = 0;
   if (use_interpolation) {
-    compute_interpolated_polygons(mesh,
-                                  vertex_mask,
-                                  verts_add_num,
-                                  loops_masked_num,
-                                  masked_poly_indices,
-                                  new_loop_starts,
-                                  &edges_add_num,
-                                  &polys_add_num,
-                                  &loops_add_num);
+    compute_interpolated_polys(mesh,
+                               vertex_mask,
+                               verts_add_num,
+                               loops_masked_num,
+                               masked_poly_indices,
+                               new_loop_starts,
+                               &edges_add_num,
+                               &polys_add_num,
+                               &loops_add_num);
   }
 
   Mesh *result = BKE_mesh_new_nomain_from_template(mesh,
@@ -738,7 +738,7 @@ static Mesh *modifyMesh(ModifierData *md, const ModifierEvalContext *UNUSED(ctx)
                                                    loops_masked_num + loops_add_num,
                                                    polys_masked_num + polys_add_num);
 
-  copy_masked_vertices_to_new_mesh(*mesh, *result, vertex_map);
+  copy_masked_verts_to_new_mesh(*mesh, *result, vertex_map);
   if (use_interpolation) {
     add_interp_verts_copy_edges_to_new_mesh(*mesh,
                                             *result,
diff --git a/source/blender/modifiers/intern/MOD_meshcache.c b/source/blender/modifiers/intern/MOD_meshcache.c
index 162ff3fe4ff..822da40edb7 100644
--- a/source/blender/modifiers/intern/MOD_meshcache.c
+++ b/source/blender/modifiers/intern/MOD_meshcache.c
@@ -182,14 +182,14 @@ static void meshcache_do(MeshCacheModifierData *mcmd,
       float(*vertexCos_Source)[3] = MEM_malloc_arrayN(
           verts_num, sizeof(*vertexCos_Source), __func__);
       float(*vertexCos_New)[3] = MEM_malloc_arrayN(verts_num, sizeof(*vertexCos_New), __func__);
-      const MVert *mv = BKE_mesh_vertices(me);
+      const MVert *mv = BKE_mesh_verts(me);
 
       for (i = 0; i < verts_num; i++, mv++) {
         copy_v3_v3(vertexCos_Source[i], mv->co);
       }
 
       BKE_mesh_calc_relative_deform(
-          BKE_mesh_polygons(me),
+          BKE_mesh_polys(me),
           me->totpoly,
           BKE_mesh_loops(me),
           me->totvert,
diff --git a/source/blender/modifiers/intern/MOD_meshsequencecache.cc b/source/blender/modifiers/intern/MOD_meshsequencecache.cc
index bdaa90af5d8..f30e6a95787 100644
--- a/source/blender/modifiers/intern/MOD_meshsequencecache.cc
+++ b/source/blender/modifiers/intern/MOD_meshsequencecache.cc
@@ -178,18 +178,18 @@ static Mesh *modifyMesh(ModifierData *md, const ModifierEvalContext *ctx, Mesh *
   }
 
   if (me != nullptr) {
-    const Span<MVert> mesh_verts = mesh->vertices();
+    const Span<MVert> mesh_verts = mesh->verts();
     const Span<MEdge> mesh_edges = mesh->edges();
-    const Span<MPoly> mesh_polys = mesh->polygons();
-    const Span<MVert> me_vertices = me->vertices();
+    const Span<MPoly> mesh_polys = mesh->polys();
+    const Span<MVert> me_verts = me->verts();
     const Span<MEdge> me_edges = me->edges();
-    const Span<MPoly> me_polygons = me->polygons();
+    const Span<MPoly> me_polys = me->polys();
 
     /* TODO(sybren+bastien): possibly check relevant custom data layers (UV/color depending on
      * flags) and duplicate those too.
      * XXX(Hans): This probably isn't true anymore with various CoW improvements, etc. */
-    if ((me_vertices.data() == mesh_verts.data()) || (me_edges.data() == mesh_edges.data()) ||
-        (me_polygons.data() == mesh_polys.data())) {
+    if ((me_verts.data() == mesh_verts.data()) || (me_edges.data() == mesh_edges.data()) ||
+        (me_polys.data() == mesh_polys.data())) {
       /* We need to duplicate data here, otherwise we'll modify org mesh, see T51701. */
       mesh = reinterpret_cast<Mesh *>(
           BKE_id_copy_ex(nullptr,
diff --git a/source/blender/modifiers/intern/MOD_normal_edit.c b/source/blender/modifiers/intern/MOD_normal_edit.c
index 41d6e339999..6e94acaa9eb 100644
--- a/source/blender/modifiers/intern/MOD_normal_edit.c
+++ b/source/blender/modifiers/intern/MOD_normal_edit.c
@@ -53,7 +53,7 @@ static void generate_vert_coordinates(Mesh *mesh,
 
   INIT_MINMAX(min_co, max_co);
 
-  const MVert *mv = BKE_mesh_vertices(mesh);
+  const MVert *mv = BKE_mesh_verts(mesh);
   for (int i = 0; i < mesh->totvert; i++, mv++) {
     copy_v3_v3(r_cos[i], mv->co);
     if (r_size != NULL && ob_center == NULL) {
@@ -523,9 +523,9 @@ static Mesh *normalEditModifier_do(NormalEditModifierData *enmd,
   const int edges_num = result->totedge;
   const int loops_num = result->totloop;
   const int polys_num = result->totpoly;
-  const MVert *verts = BKE_mesh_vertices(result);
+  const MVert *verts = BKE_mesh_verts(result);
   MEdge *edges = BKE_mesh_edges_for_write(result);
-  const MPoly *polys = BKE_mesh_polygons(result);
+  const MPoly *polys = BKE_mesh_polys(result);
   MLoop *loops = BKE_mesh_loops_for_write(result);
 
   int defgrp_index;
diff --git a/source/blender/modifiers/intern/MOD_ocean.c b/source/blender/modifiers/intern/MOD_ocean.c
index 5f4cf23d20b..b944c94f5ef 100644
--- a/source/blender/modifiers/intern/MOD_ocean.c
+++ b/source/blender/modifiers/intern/MOD_ocean.c
@@ -169,9 +169,9 @@ typedef struct GenerateOceanGeometryData {
   float ix, iy;
 } GenerateOceanGeometryData;
 
-static void generate_ocean_geometry_vertices(void *__restrict userdata,
-                                             const int y,
-                                             const TaskParallelTLS *__restrict UNUSED(tls))
+static void generate_ocean_geometry_verts(void *__restrict userdata,
+                                          const int y,
+                                          const TaskParallelTLS *__restrict UNUSED(tls))
 {
   GenerateOceanGeometryData *gogd = userdata;
   int x;
@@ -185,9 +185,9 @@ static void generate_ocean_geometry_vertices(void *__restrict userdata,
   }
 }
 
-static void generate_ocean_geometry_polygons(void *__restrict userdata,
-                                             const int y,
-                                             const TaskParallelTLS *__restrict UNUSED(tls))
+static void generate_ocean_geometry_polys(void *__restrict userdata,
+                                          const int y,
+                                          const TaskParallelTLS *__restrict UNUSED(tls))
 {
   GenerateOceanGeometryData *gogd = userdata;
   int x;
@@ -273,8 +273,8 @@ static Mesh *generate_ocean_geometry(OceanModifierData *omd, Mesh *mesh_orig, co
   result = BKE_mesh_new_nomain(verts_num, 0, 0, polys_num * 4, polys_num);
   BKE_mesh_copy_parameters_for_eval(result, mesh_orig);
 
-  gogd.mverts = BKE_mesh_vertices_for_write(result);
-  gogd.mpolys = BKE_mesh_polygons_for_write(result);
+  gogd.mverts = BKE_mesh_verts_for_write(result);
+  gogd.mpolys = BKE_mesh_polys_for_write(result);
   gogd.mloops = BKE_mesh_loops_for_write(result);
 
   TaskParallelSettings settings;
@@ -282,10 +282,10 @@ static Mesh *generate_ocean_geometry(OceanModifierData *omd, Mesh *mesh_orig, co
   settings.use_threading = use_threading;
 
   /* create vertices */
-  BLI_task_parallel_range(0, gogd.res_y + 1, &gogd, generate_ocean_geometry_vertices, &settings);
+  BLI_task_parallel_range(0, gogd.res_y + 1, &gogd, generate_ocean_geometry_verts, &settings);
 
   /* create faces */
-  BLI_task_parallel_range(0, gogd.res_y, &gogd, generate_ocean_geometry_polygons, &settings);
+  BLI_task_parallel_range(0, gogd.res_y, &gogd, generate_ocean_geometry_polys, &settings);
 
   BKE_mesh_calc_edges(result, false, false);
 
@@ -366,8 +366,8 @@ static Mesh *doOcean(ModifierData *md, const ModifierEvalContext *ctx, Mesh *mes
   CLAMP(cfra_for_cache, omd->bakestart, omd->bakeend);
   cfra_for_cache -= omd->bakestart; /* shift to 0 based */
 
-  MVert *verts = BKE_mesh_vertices_for_write(result);
-  MPoly *polys = BKE_mesh_polygons_for_write(result);
+  MVert *verts = BKE_mesh_verts_for_write(result);
+  MPoly *polys = BKE_mesh_polys_for_write(result);
 
   /* add vcols before displacement - allows lookup based on position */
 
diff --git a/source/blender/modifiers/intern/MOD_particleinstance.c b/source/blender/modifiers/intern/MOD_particleinstance.c
index 599c056f27c..6c69e616f83 100644
--- a/source/blender/modifiers/intern/MOD_particleinstance.c
+++ b/source/blender/modifiers/intern/MOD_particleinstance.c
@@ -317,12 +317,12 @@ static Mesh *modifyMesh(ModifierData *md, const ModifierEvalContext *ctx, Mesh *
 
   result = BKE_mesh_new_nomain_from_template(mesh, maxvert, maxedge, 0, maxloop, maxpoly);
 
-  const MVert *orig_mvert = BKE_mesh_vertices(mesh);
-  const MPoly *orig_mpoly = BKE_mesh_polygons(mesh);
+  const MVert *orig_mvert = BKE_mesh_verts(mesh);
+  const MPoly *orig_mpoly = BKE_mesh_polys(mesh);
   const MLoop *orig_mloop = BKE_mesh_loops(mesh);
-  MVert *mvert = BKE_mesh_vertices_for_write(result);
+  MVert *mvert = BKE_mesh_verts_for_write(result);
   MEdge *edges = BKE_mesh_edges_for_write(result);
-  MPoly *mpoly = BKE_mesh_polygons_for_write(result);
+  MPoly *mpoly = BKE_mesh_polys_for_write(result);
   MLoop *mloop = BKE_mesh_loops_for_write(result);
 
   MLoopCol *mloopcols_index = CustomData_get_layer_named(
diff --git a/source/blender/modifiers/intern/MOD_remesh.c b/source/blender/modifiers/intern/MOD_remesh.c
index 37d711a4bfa..4241ca5a591 100644
--- a/source/blender/modifiers/intern/MOD_remesh.c
+++ b/source/blender/modifiers/intern/MOD_remesh.c
@@ -60,7 +60,7 @@ static void init_dualcon_mesh(DualConInput *input, Mesh *mesh)
 {
   memset(input, 0, sizeof(DualConInput));
 
-  input->co = (void *)BKE_mesh_vertices(mesh);
+  input->co = (void *)BKE_mesh_verts(mesh);
   input->co_stride = sizeof(MVert);
   input->totco = mesh->totvert;
 
@@ -96,8 +96,8 @@ static void *dualcon_alloc_output(int totvert, int totquad)
   }
 
   output->mesh = BKE_mesh_new_nomain(totvert, 0, 0, 4 * totquad, totquad);
-  output->verts = BKE_mesh_vertices_for_write(output->mesh);
-  output->polys = BKE_mesh_polygons_for_write(output->mesh);
+  output->verts = BKE_mesh_verts_for_write(output->mesh);
+  output->polys = BKE_mesh_polys_for_write(output->mesh);
   output->loops = BKE_mesh_loops_for_write(output->mesh);
 
   return output;
@@ -200,7 +200,7 @@ static Mesh *modifyMesh(ModifierData *md, const ModifierEvalContext *UNUSED(ctx)
   }
 
   if (rmd->flag & MOD_REMESH_SMOOTH_SHADING) {
-    MPoly *mpoly = BKE_mesh_polygons_for_write(result);
+    MPoly *mpoly = BKE_mesh_polys_for_write(result);
     int i, totpoly = result->totpoly;
 
     /* Apply smooth shading to output faces */
diff --git a/source/blender/modifiers/intern/MOD_screw.c b/source/blender/modifiers/intern/MOD_screw.c
index 7cdeaeade9f..a965c414620 100644
--- a/source/blender/modifiers/intern/MOD_screw.c
+++ b/source/blender/modifiers/intern/MOD_screw.c
@@ -388,14 +388,14 @@ static Mesh *modifyMesh(ModifierData *md, const ModifierEvalContext *ctx, Mesh *
   result = BKE_mesh_new_nomain_from_template(
       mesh, (int)maxVerts, (int)maxEdges, 0, (int)maxPolys * 4, (int)maxPolys);
 
-  const MVert *mvert_orig = BKE_mesh_vertices(mesh);
+  const MVert *mvert_orig = BKE_mesh_verts(mesh);
   const MEdge *medge_orig = BKE_mesh_edges(mesh);
-  const MPoly *mpoly_orig = BKE_mesh_polygons(mesh);
+  const MPoly *mpoly_orig = BKE_mesh_polys(mesh);
   const MLoop *mloop_orig = BKE_mesh_loops(mesh);
 
-  MVert *mvert_new = BKE_mesh_vertices_for_write(result);
+  MVert *mvert_new = BKE_mesh_verts_for_write(result);
   MEdge *medge_new = BKE_mesh_edges_for_write(result);
-  MPoly *mpoly_new = BKE_mesh_polygons_for_write(result);
+  MPoly *mpoly_new = BKE_mesh_polys_for_write(result);
   MLoop *mloop_new = BKE_mesh_loops_for_write(result);
 
   if (!CustomData_has_layer(&result->pdata, CD_ORIGINDEX)) {
diff --git a/source/blender/modifiers/intern/MOD_skin.c b/source/blender/modifiers/intern/MOD_skin.c
index 5b9b496b0d3..ae8fcb42553 100644
--- a/source/blender/modifiers/intern/MOD_skin.c
+++ b/source/blender/modifiers/intern/MOD_skin.c
@@ -889,7 +889,7 @@ static Mesh *subdivide_base(const Mesh *orig)
   float radrat;
 
   const MVertSkin *orignode = CustomData_get_layer(&orig->vdata, CD_MVERT_SKIN);
-  const MVert *origvert = BKE_mesh_vertices(orig);
+  const MVert *origvert = BKE_mesh_verts(orig);
   const MEdge *origedge = BKE_mesh_edges(orig);
   const MDeformVert *origdvert = BKE_mesh_deform_verts(orig);
   int orig_vert_num = orig->totvert;
@@ -916,7 +916,7 @@ static Mesh *subdivide_base(const Mesh *orig)
   Mesh *result = BKE_mesh_new_nomain_from_template(
       orig, orig_vert_num + subd_num, orig_edge_num + subd_num, 0, 0, 0);
 
-  MVert *outvert = BKE_mesh_vertices_for_write(result);
+  MVert *outvert = BKE_mesh_verts_for_write(result);
   MEdge *outedge = BKE_mesh_edges_for_write(result);
   MVertSkin *outnode = CustomData_get_layer(&result->vdata, CD_MVERT_SKIN);
   MDeformVert *outdvert = NULL;
@@ -1918,7 +1918,7 @@ static Mesh *base_skin(Mesh *origmesh, SkinModifierData *smd, eSkinErrorFlag *r_
 
   nodes = CustomData_get_layer(&origmesh->vdata, CD_MVERT_SKIN);
 
-  mvert = BKE_mesh_vertices(origmesh);
+  mvert = BKE_mesh_verts(origmesh);
   dvert = BKE_mesh_deform_verts(origmesh);
   medge = BKE_mesh_edges(origmesh);
   verts_num = origmesh->totvert;
diff --git a/source/blender/modifiers/intern/MOD_solidify_extrude.c b/source/blender/modifiers/intern/MOD_solidify_extrude.c
index d7b2db87a60..1456254c31f 100644
--- a/source/blender/modifiers/intern/MOD_solidify_extrude.c
+++ b/source/blender/modifiers/intern/MOD_solidify_extrude.c
@@ -66,7 +66,7 @@ static void mesh_calc_hq_normal(Mesh *mesh,
   const int verts_num = mesh->totvert;
   const int edges_num = mesh->totedge;
   const int polys_num = mesh->totpoly;
-  const MPoly *mpoly = BKE_mesh_polygons(mesh);
+  const MPoly *mpoly = BKE_mesh_polys(mesh);
   const MLoop *mloop = BKE_mesh_loops(mesh);
   const MEdge *medge = BKE_mesh_edges(mesh);
 
@@ -215,9 +215,9 @@ Mesh *MOD_solidify_extrude_modifyMesh(ModifierData *md, const ModifierEvalContex
 
   MOD_get_vgroup(ctx->object, mesh, smd->defgrp_name, &dvert, &defgrp_index);
 
-  const MVert *orig_mvert = BKE_mesh_vertices(mesh);
+  const MVert *orig_mvert = BKE_mesh_verts(mesh);
   const MEdge *orig_medge = BKE_mesh_edges(mesh);
-  const MPoly *orig_mpoly = BKE_mesh_polygons(mesh);
+  const MPoly *orig_mpoly = BKE_mesh_polys(mesh);
   const MLoop *orig_mloop = BKE_mesh_loops(mesh);
 
   if (need_poly_normals) {
@@ -335,16 +335,11 @@ Mesh *MOD_solidify_extrude_modifyMesh(ModifierData *md, const ModifierEvalContex
                                              (int)((loops_num * stride) + newLoops),
                                              (int)((polys_num * stride) + newPolys));
 
-  MVert *mvert = BKE_mesh_vertices_for_write(result);
+  MVert *mvert = BKE_mesh_verts_for_write(result);
   MEdge *medge = BKE_mesh_edges_for_write(result);
-  MPoly *mpoly = BKE_mesh_polygons_for_write(result);
+  MPoly *mpoly = BKE_mesh_polys_for_write(result);
   MLoop *mloop = BKE_mesh_loops_for_write(result);
 
-  if (do_bevel_convex) {
-    /* Make sure bweight is enabled. */
-    result->cd_flag |= ME_CDFLAG_EDGE_BWEIGHT;
-  }
-
   if (do_shell) {
     CustomData_copy_data(&mesh->vdata, &result->vdata, 0, 0, (int)verts_num);
     CustomData_copy_data(&mesh->vdata, &result->vdata, 0, (int)verts_num, (int)verts_num);
@@ -392,6 +387,12 @@ Mesh *MOD_solidify_extrude_modifyMesh(ModifierData *md, const ModifierEvalContex
     CustomData_copy_data(&mesh->pdata, &result->pdata, 0, 0, (int)polys_num);
   }
 
+  float *result_edge_bweight = NULL;
+  if (do_bevel_convex) {
+    result_edge_bweight = CustomData_add_layer(
+        &result->edata, CD_BWEIGHT, CD_SET_DEFAULT, NULL, result->totedge);
+  }
+
   /* initializes: (i_end, do_shell_align, mv). */
 #define INIT_VERT_ARRAY_OFFSETS(test) \
   if (((ofs_new >= ofs_orig) == do_flip) == test) { \
@@ -671,20 +672,18 @@ Mesh *MOD_solidify_extrude_modifyMesh(ModifierData *md, const ModifierEvalContex
       for (uint i = 0; i < edges_num; i++) {
         if (edge_users[i] == INVALID_PAIR) {
           float angle = edge_angs[i];
-          medge[i].bweight = (char)clamp_i(
-              (int)medge[i].bweight + (int)((angle < M_PI ? clamp_f(bevel_convex, 0.0f, 1.0f) :
-                                                            clamp_f(bevel_convex, -1.0f, 0.0f)) *
-                                            255),
-              0,
-              255);
+          result_edge_bweight[i] = clamp_f(result_edge_bweight[i] +
+                                               (angle < M_PI ? clamp_f(bevel_convex, 0.0f, 1.0f) :
+                                                               clamp_f(bevel_convex, -1.0f, 0.0f)),
+                                           0.0f,
+                                           1.0f);
           if (do_shell) {
-            medge[i + edges_num].bweight = (char)clamp_i(
-                (int)medge[i + edges_num].bweight +
-                    (int)((angle > M_PI ? clamp_f(bevel_convex, 0.0f, 1.0f) :
-                                          clamp_f(bevel_convex, -1.0f, 0.0f)) *
-                          255),
+            result_edge_bweight[i + edges_num] = clamp_f(
+                result_edge_bweight[i + edges_num] + (angle > M_PI ?
+                                                          clamp_f(bevel_convex, 0.0f, 1.0f) :
+                                                          clamp_f(bevel_convex, -1.0f, 0.0f)),
                 0,
-                255);
+                1.0f);
           }
         }
       }
@@ -900,20 +899,17 @@ Mesh *MOD_solidify_extrude_modifyMesh(ModifierData *md, const ModifierEvalContex
       for (i = 0; i < edges_num; i++) {
         if (edge_users[i] == INVALID_PAIR) {
           float angle = edge_angs[i];
-          medge[i].bweight = (char)clamp_i(
-              (int)medge[i].bweight + (int)((angle < M_PI ? clamp_f(bevel_convex, 0, 1) :
-                                                            clamp_f(bevel_convex, -1, 0)) *
-                                            255),
-              0,
-              255);
+          result_edge_bweight[i] = clamp_f(result_edge_bweight[i] +
+                                               (angle < M_PI ? clamp_f(bevel_convex, 0.0f, 1.0f) :
+                                                               clamp_f(bevel_convex, -1.0f, 0.0f)),
+                                           0.0f,
+                                           1.0f);
           if (do_shell) {
-            medge[i + edges_num].bweight = (char)clamp_i(
-                (int)medge[i + edges_num].bweight +
-                    (int)((angle > M_PI ? clamp_f(bevel_convex, 0, 1) :
-                                          clamp_f(bevel_convex, -1, 0)) *
-                          255),
-                0,
-                255);
+            result_edge_bweight[i + edges_num] = clamp_f(
+                result_edge_bweight[i + edges_num] +
+                    (angle > M_PI ? clamp_f(bevel_convex, 0, 1) : clamp_f(bevel_convex, -1, 0)),
+                0.0f,
+                1.0f);
           }
         }
       }
diff --git a/source/blender/modifiers/intern/MOD_solidify_nonmanifold.c b/source/blender/modifiers/intern/MOD_solidify_nonmanifold.c
index 0bce954a67a..d3aff5c58c5 100644
--- a/source/blender/modifiers/intern/MOD_solidify_nonmanifold.c
+++ b/source/blender/modifiers/intern/MOD_solidify_nonmanifold.c
@@ -184,11 +184,15 @@ Mesh *MOD_solidify_nonmanifold_modifyMesh(ModifierData *md,
 
   const bool do_flat_faces = dvert && (smd->flag & MOD_SOLIDIFY_NONMANIFOLD_FLAT_FACES);
 
-  const MVert *orig_mvert = BKE_mesh_vertices(mesh);
+  const MVert *orig_mvert = BKE_mesh_verts(mesh);
   const MEdge *orig_medge = BKE_mesh_edges(mesh);
-  const MPoly *orig_mpoly = BKE_mesh_polygons(mesh);
+  const MPoly *orig_mpoly = BKE_mesh_polys(mesh);
   const MLoop *orig_mloop = BKE_mesh_loops(mesh);
 
+  /* These might be null. */
+  const float *orig_vert_bweight = CustomData_get_layer(&mesh->vdata, CD_BWEIGHT);
+  const float *orig_edge_bweight = CustomData_get_layer(&mesh->edata, CD_BWEIGHT);
+
   uint new_verts_num = 0;
   uint new_edges_num = 0;
   uint new_loops_num = 0;
@@ -1957,17 +1961,18 @@ Mesh *MOD_solidify_nonmanifold_modifyMesh(ModifierData *md,
                                              (int)(new_loops_num),
                                              (int)(new_polys_num));
 
-  MVert *mvert = BKE_mesh_vertices_for_write(result);
+  MVert *mvert = BKE_mesh_verts_for_write(result);
   MEdge *medge = BKE_mesh_edges_for_write(result);
-  MPoly *mpoly = BKE_mesh_polygons_for_write(result);
+  MPoly *mpoly = BKE_mesh_polys_for_write(result);
   MLoop *mloop = BKE_mesh_loops_for_write(result);
 
   int *origindex_edge = CustomData_get_layer(&result->edata, CD_ORIGINDEX);
   int *origindex_poly = CustomData_get_layer(&result->pdata, CD_ORIGINDEX);
 
-  if (bevel_convex != 0.0f || (result->cd_flag & ME_CDFLAG_VERT_BWEIGHT) != 0) {
-    /* make sure bweight is enabled */
-    result->cd_flag |= ME_CDFLAG_EDGE_BWEIGHT;
+  float *result_edge_bweight = CustomData_get_layer(&result->edata, CD_BWEIGHT);
+  if (bevel_convex != 0.0f || orig_vert_bweight != NULL) {
+    result_edge_bweight = CustomData_add_layer(
+        &result->edata, CD_BWEIGHT, CD_SET_DEFAULT, NULL, result->totedge);
   }
 
   /* Checks that result has dvert data. */
@@ -2038,17 +2043,18 @@ Mesh *MOD_solidify_nonmanifold_modifyMesh(ModifierData *md,
             medge[insert].v2 = v2;
             medge[insert].flag = orig_medge[(*l)->old_edge].flag | ME_EDGEDRAW | ME_EDGERENDER;
             medge[insert].crease = orig_medge[(*l)->old_edge].crease;
-            medge[insert].bweight = orig_medge[(*l)->old_edge].bweight;
+            if (result_edge_bweight) {
+              result_edge_bweight[insert] = orig_edge_bweight[(*l)->old_edge];
+            }
             if (bevel_convex != 0.0f && (*l)->faces[1] != NULL) {
-              medge[insert].bweight = (char)clamp_i(
-                  (int)medge[insert].bweight + (int)(((*l)->angle > M_PI + FLT_EPSILON ?
-                                                          clamp_f(bevel_convex, 0.0f, 1.0f) :
-                                                          ((*l)->angle < M_PI - FLT_EPSILON ?
-                                                               clamp_f(bevel_convex, -1.0f, 0.0f) :
-                                                               0)) *
-                                                     255),
-                  0,
-                  255);
+              result_edge_bweight[insert] = clamp_f(
+                  result_edge_bweight[insert] +
+                      ((*l)->angle > M_PI + FLT_EPSILON ?
+                           clamp_f(bevel_convex, 0.0f, 1.0f) :
+                           ((*l)->angle < M_PI - FLT_EPSILON ? clamp_f(bevel_convex, -1.0f, 0.0f) :
+                                                               0)),
+                  0.0f,
+                  1.0f);
             }
             (*l)->new_edge = insert;
           }
@@ -2113,13 +2119,14 @@ Mesh *MOD_solidify_nonmanifold_modifyMesh(ModifierData *md,
         EdgeGroup *last_g = NULL;
         EdgeGroup *first_g = NULL;
         char mv_crease = vertex_crease ? (char)(vertex_crease[i] * 255.0f) : 0;
+        float mv_bweight = orig_vert_bweight ? orig_vert_bweight[i] : 0.0f;
         /* Data calculation cache. */
         char max_crease;
         char last_max_crease = 0;
         char first_max_crease = 0;
-        char max_bweight;
-        char last_max_bweight = 0;
-        char first_max_bweight = 0;
+        float max_bweight;
+        float last_max_bweight = 0.0f;
+        float first_max_bweight = 0.0f;
         short flag;
         short last_flag = 0;
         short first_flag = 0;
@@ -2142,20 +2149,24 @@ Mesh *MOD_solidify_nonmanifold_modifyMesh(ModifierData *md,
                   max_crease = ed->crease;
                 }
                 if (g->edges[k]->new_edge != MOD_SOLIDIFY_EMPTY_TAG) {
-                  char bweight = medge[g->edges[k]->new_edge].bweight;
-                  if (bweight > max_bweight) {
-                    max_bweight = bweight;
+                  if (result_edge_bweight) {
+                    float bweight = result_edge_bweight[g->edges[k]->new_edge];
+                    if (bweight > max_bweight) {
+                      max_bweight = bweight;
+                    }
                   }
                 }
                 flag |= ed->flag;
               }
             }
 
-            const char bweight_open_edge = min_cc(
-                orig_medge[g->edges[0]->old_edge].bweight,
-                orig_medge[g->edges[g->edges_len - 1]->old_edge].bweight);
+            const float bweight_open_edge =
+                orig_edge_bweight ?
+                    min_ff(orig_edge_bweight[g->edges[0]->old_edge],
+                           orig_edge_bweight[g->edges[g->edges_len - 1]->old_edge]) :
+                    0.0f;
             if (bweight_open_edge > 0) {
-              max_bweight = min_cc(bweight_open_edge, max_bweight);
+              max_bweight = min_ff(bweight_open_edge, max_bweight);
             }
             else {
               if (bevel_convex < 0.0f) {
@@ -2183,8 +2194,11 @@ Mesh *MOD_solidify_nonmanifold_modifyMesh(ModifierData *md,
               medge[edge_index].flag = ME_EDGEDRAW | ME_EDGERENDER |
                                        ((last_flag | flag) & (ME_SEAM | ME_SHARP));
               medge[edge_index].crease = max_cc(mv_crease, min_cc(last_max_crease, max_crease));
-              medge[edge_index++].bweight = max_cc(mv->bweight,
-                                                   min_cc(last_max_bweight, max_bweight));
+              if (result_edge_bweight) {
+                result_edge_bweight[edge_index] = max_ff(mv_bweight,
+                                                         min_ff(last_max_bweight, max_bweight));
+              }
+              edge_index++;
             }
             last_g = g;
             last_max_crease = max_crease;
@@ -2212,8 +2226,11 @@ Mesh *MOD_solidify_nonmanifold_modifyMesh(ModifierData *md,
                                        ((last_flag | first_flag) & (ME_SEAM | ME_SHARP));
               medge[edge_index].crease = max_cc(mv_crease,
                                                 min_cc(last_max_crease, first_max_crease));
-              medge[edge_index++].bweight = max_cc(mv->bweight,
-                                                   min_cc(last_max_bweight, first_max_bweight));
+              if (result_edge_bweight) {
+                result_edge_bweight[edge_index] = max_ff(
+                    mv_bweight, min_ff(last_max_bweight, first_max_bweight));
+              }
+              edge_index++;
 
               /* Loop data. */
               int *loops = MEM_malloc_arrayN(j, sizeof(*loops), "loops in solidify");
diff --git a/source/blender/modifiers/intern/MOD_surface.c b/source/blender/modifiers/intern/MOD_surface.c
index 93da7969a09..c5e117635b5 100644
--- a/source/blender/modifiers/intern/MOD_surface.c
+++ b/source/blender/modifiers/intern/MOD_surface.c
@@ -151,7 +151,7 @@ static void deformVerts(ModifierData *md,
     }
 
     /* convert to global coordinates and calculate velocity */
-    MVert *verts = BKE_mesh_vertices_for_write(surmd->mesh);
+    MVert *verts = BKE_mesh_verts_for_write(surmd->mesh);
     for (i = 0, x = surmd->x, v = surmd->v; i < mesh_verts_num; i++, x++, v++) {
       float *vec = verts[i].co;
       mul_m4_v3(ctx->object->obmat, vec);
diff --git a/source/blender/modifiers/intern/MOD_surfacedeform.c b/source/blender/modifiers/intern/MOD_surfacedeform.c
index 50071cad1b9..e0083b37ef0 100644
--- a/source/blender/modifiers/intern/MOD_surfacedeform.c
+++ b/source/blender/modifiers/intern/MOD_surfacedeform.c
@@ -1171,8 +1171,8 @@ static bool surfacedeformBind(Object *ob,
                               Mesh *mesh)
 {
   BVHTreeFromMesh treeData = {NULL};
-  const MVert *mvert = BKE_mesh_vertices(target);
-  const MPoly *mpoly = BKE_mesh_polygons(target);
+  const MVert *mvert = BKE_mesh_verts(target);
+  const MPoly *mpoly = BKE_mesh_polys(target);
   const MEdge *medge = BKE_mesh_edges(target);
   const MLoop *mloop = BKE_mesh_loops(target);
   uint tedges_num = target->totedge;
diff --git a/source/blender/modifiers/intern/MOD_util.c b/source/blender/modifiers/intern/MOD_util.c
index e1907c7fce1..218c5b8a4bb 100644
--- a/source/blender/modifiers/intern/MOD_util.c
+++ b/source/blender/modifiers/intern/MOD_util.c
@@ -94,7 +94,7 @@ void MOD_get_texture_coords(MappingInfoModifierData *dmd,
   /* UVs need special handling, since they come from faces */
   if (texmapping == MOD_DISP_MAP_UV) {
     if (CustomData_has_layer(&mesh->ldata, CD_PROP_FLOAT2)) {
-      const MPoly *mpoly = BKE_mesh_polygons(mesh);
+      const MPoly *mpoly = BKE_mesh_polys(mesh);
       const MPoly *mp;
       const MLoop *mloop = BKE_mesh_loops(mesh);
       BLI_bitmap *done = BLI_BITMAP_NEW(verts_num, __func__);
@@ -129,7 +129,7 @@ void MOD_get_texture_coords(MappingInfoModifierData *dmd,
     texmapping = MOD_DISP_MAP_LOCAL;
   }
 
-  const MVert *mv = BKE_mesh_vertices(mesh);
+  const MVert *mv = BKE_mesh_verts(mesh);
   for (i = 0; i < verts_num; i++, mv++, r_texco++) {
     switch (texmapping) {
       case MOD_DISP_MAP_LOCAL:
diff --git a/source/blender/modifiers/intern/MOD_uvproject.c b/source/blender/modifiers/intern/MOD_uvproject.c
index d4834584952..98244e07b72 100644
--- a/source/blender/modifiers/intern/MOD_uvproject.c
+++ b/source/blender/modifiers/intern/MOD_uvproject.c
@@ -203,7 +203,7 @@ static Mesh *uvprojectModifier_do(UVProjectModifierData *umd,
     }
   }
 
-  const MPoly *polys = BKE_mesh_polygons(mesh);
+  const MPoly *polys = BKE_mesh_polys(mesh);
   const MLoop *loops = BKE_mesh_loops(mesh);
 
   /* apply coords as UVs */
diff --git a/source/blender/modifiers/intern/MOD_uvwarp.c b/source/blender/modifiers/intern/MOD_uvwarp.c
index 0bfd53cf898..cd7273e24f5 100644
--- a/source/blender/modifiers/intern/MOD_uvwarp.c
+++ b/source/blender/modifiers/intern/MOD_uvwarp.c
@@ -195,7 +195,7 @@ static Mesh *modifyMesh(ModifierData *md, const ModifierEvalContext *ctx, Mesh *
   /* make sure we're using an existing layer */
   CustomData_validate_layer_name(&mesh->ldata, CD_PROP_FLOAT2, umd->uvlayer_name, uvname);
 
-  const MPoly *polys = BKE_mesh_polygons(mesh);
+  const MPoly *polys = BKE_mesh_polys(mesh);
   const MLoop *loops = BKE_mesh_loops(mesh);
   polys_num = mesh->totpoly;
   loops_num = mesh->totloop;
diff --git a/source/blender/modifiers/intern/MOD_volume_to_mesh.cc b/source/blender/modifiers/intern/MOD_volume_to_mesh.cc
index 215436e4a8d..0065012db97 100644
--- a/source/blender/modifiers/intern/MOD_volume_to_mesh.cc
+++ b/source/blender/modifiers/intern/MOD_volume_to_mesh.cc
@@ -51,7 +51,7 @@ static void initData(ModifierData *md)
   VolumeToMeshModifierData *vmmd = reinterpret_cast<VolumeToMeshModifierData *>(md);
   vmmd->object = nullptr;
   vmmd->threshold = 0.1f;
-  strncpy(vmmd->grid_name, "density", MAX_NAME);
+  STRNCPY(vmmd->grid_name, "density");
   vmmd->adaptivity = 0.0f;
   vmmd->resolution_mode = VOLUME_TO_MESH_RESOLUTION_MODE_GRID;
   vmmd->voxel_amount = 32;
diff --git a/source/blender/modifiers/intern/MOD_weighted_normal.c b/source/blender/modifiers/intern/MOD_weighted_normal.c
index c6c0ce58463..ba441581770 100644
--- a/source/blender/modifiers/intern/MOD_weighted_normal.c
+++ b/source/blender/modifiers/intern/MOD_weighted_normal.c
@@ -362,7 +362,7 @@ static void apply_weights_vertex_normal(WeightedNormalModifierData *wnmd,
                                      clnors);
   }
   else {
-    /* TODO: Ideally, we could add an option to BKE_mesh_normals_loop_custom_[from_vertices_]set()
+    /* TODO: Ideally, we could add an option to `BKE_mesh_normals_loop_custom_[from_verts_]set()`
      * to keep current clnors instead of resetting them to default auto-computed ones,
      * when given new custom normal is zero-vec.
      * But this is not exactly trivial change, better to keep this optimization for later...
@@ -379,18 +379,18 @@ static void apply_weights_vertex_normal(WeightedNormalModifierData *wnmd,
         copy_v3_v3(vert_normals[mv_index], items_data[mv_index].normal);
       }
 
-      BKE_mesh_normals_loop_custom_from_vertices_set(mvert,
-                                                     wn_data->vert_normals,
-                                                     vert_normals,
-                                                     verts_num,
-                                                     medge,
-                                                     edges_num,
-                                                     mloop,
-                                                     loops_num,
-                                                     mpoly,
-                                                     polynors,
-                                                     polys_num,
-                                                     clnors);
+      BKE_mesh_normals_loop_custom_from_verts_set(mvert,
+                                                  wn_data->vert_normals,
+                                                  vert_normals,
+                                                  verts_num,
+                                                  medge,
+                                                  edges_num,
+                                                  mloop,
+                                                  loops_num,
+                                                  mpoly,
+                                                  polynors,
+                                                  polys_num,
+                                                  clnors);
 
       MEM_freeN(vert_normals);
     }
@@ -579,9 +579,9 @@ static Mesh *modifyMesh(ModifierData *md, const ModifierEvalContext *ctx, Mesh *
   const int edges_num = result->totedge;
   const int loops_num = result->totloop;
   const int polys_num = result->totpoly;
-  const MVert *mvert = BKE_mesh_vertices(result);
+  const MVert *mvert = BKE_mesh_verts(result);
   MEdge *medge = BKE_mesh_edges_for_write(result);
-  const MPoly *mpoly = BKE_mesh_polygons(result);
+  const MPoly *mpoly = BKE_mesh_polys(result);
   const MLoop *mloop = BKE_mesh_loops(result);
 
   /* Right now: