Cleanup: Tweak naming for recently added mesh accessors

Use `verts` instead of `vertices` and `polys` instead of `polygons`
in the API added in 05952aa94d33eeb50. This aligns better with
existing naming where the shorter names are much more common.

26 files changed, 80 insertions, 80 deletions

diff --git a/source/blender/modifiers/intern/MOD_array.c b/source/blender/modifiers/intern/MOD_array.c
index 3bba1ac07a6..42fe0107217 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);
@@ -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) {
@@ -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) {
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..e0428042caa 100644
--- a/source/blender/modifiers/intern/MOD_mask.cc
+++ b/source/blender/modifiers/intern/MOD_mask.cc
@@ -231,7 +231,7 @@ static void computed_masked_polygons(const Mesh *mesh,
                                      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);
@@ -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;
@@ -338,8 +338,8 @@ static void copy_masked_vertices_to_new_mesh(const Mesh &src_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;
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..1a41fa4cd3b 100644
--- a/source/blender/modifiers/intern/MOD_meshsequencecache.cc
+++ b/source/blender/modifiers/intern/MOD_meshsequencecache.cc
@@ -178,12 +178,12 @@ 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_vertices = me->verts();
     const Span<MEdge> me_edges = me->edges();
-    const Span<MPoly> me_polygons = me->polygons();
+    const Span<MPoly> me_polygons = me->polys();
 
     /* TODO(sybren+bastien): possibly check relevant custom data layers (UV/color depending on
      * flags) and duplicate those too.
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 cca49b42208..9c6f7ff4069 100644
--- a/source/blender/modifiers/intern/MOD_ocean.c
+++ b/source/blender/modifiers/intern/MOD_ocean.c
@@ -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;
@@ -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 d657d658e46..acaeb9b2777 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..343aa3920d9 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,9 +335,9 @@ 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) {
diff --git a/source/blender/modifiers/intern/MOD_solidify_nonmanifold.c b/source/blender/modifiers/intern/MOD_solidify_nonmanifold.c
index 0bce954a67a..e73df0d1c12 100644
--- a/source/blender/modifiers/intern/MOD_solidify_nonmanifold.c
+++ b/source/blender/modifiers/intern/MOD_solidify_nonmanifold.c
@@ -184,9 +184,9 @@ 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);
 
   uint new_verts_num = 0;
@@ -1957,9 +1957,9 @@ 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);
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 654d2c51c34..bc1a04d65ce 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_MLOOPUV)) {
-      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__);
@@ -130,7 +130,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 9af201c924f..8db92fefd31 100644
--- a/source/blender/modifiers/intern/MOD_uvproject.c
+++ b/source/blender/modifiers/intern/MOD_uvproject.c
@@ -204,7 +204,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 9561f177cf1..ba6e18f6b7e 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_MLOOPUV, 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_weighted_normal.c b/source/blender/modifiers/intern/MOD_weighted_normal.c
index c6c0ce58463..05c6eea9f8b 100644
--- a/source/blender/modifiers/intern/MOD_weighted_normal.c
+++ b/source/blender/modifiers/intern/MOD_weighted_normal.c
@@ -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: