Rename polygons to polys and vertices to verts

13 files changed, 117 insertions, 106 deletions

diff --git a/source/blender/modifiers/intern/MOD_array.c b/source/blender/modifiers/intern/MOD_array.c
index 2bc0015cf46..3bba1ac07a6 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_vertices = BKE_mesh_vertices_for_write(result);
+  MVert *result_verts = BKE_mesh_vertices_for_write(result);
   MEdge *result_edges = BKE_mesh_edges_for_write(result);
-  MPoly *result_polygons = BKE_mesh_polygons_for_write(result);
+  MPoly *result_polys = BKE_mesh_polygons_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);
@@ -289,7 +289,7 @@ static void mesh_merge_transform(Mesh *result,
   CustomData_copy_data(&cap_mesh->ldata, &result->ldata, 0, cap_loops_index, cap_nloops);
   CustomData_copy_data(&cap_mesh->pdata, &result->pdata, 0, cap_polys_index, cap_npolys);
 
-  mv = result_vertices + cap_verts_index;
+  mv = result_verts + cap_verts_index;
 
   for (i = 0; i < cap_nverts; i++, mv++) {
     mul_m4_v3(cap_offset, mv->co);
@@ -320,7 +320,7 @@ static void mesh_merge_transform(Mesh *result,
   }
 
   /* adjust cap poly loopstart indices */
-  mp = result_polygons + cap_polys_index;
+  mp = result_polys + cap_polys_index;
   for (i = 0; i < cap_npolys; i++, mp++) {
     mp->loopstart += cap_loops_index;
   }
@@ -430,9 +430,9 @@ static Mesh *arrayModifier_doArray(ArrayModifierData *amd,
   /* Build up offset array, accumulating all settings options. */
 
   unit_m4(offset);
-  const MVert *src_vertices = BKE_mesh_vertices(mesh);
+  const MVert *src_verts = BKE_mesh_vertices(mesh);
   const MEdge *src_edges = BKE_mesh_edges(mesh);
-  const MPoly *src_polygons = BKE_mesh_polygons(mesh);
+  const MPoly *src_polys = BKE_mesh_polygons(mesh);
   const MLoop *src_loops = BKE_mesh_loops(mesh);
 
   if (amd->offset_type & MOD_ARR_OFF_CONST) {
@@ -444,7 +444,7 @@ static Mesh *arrayModifier_doArray(ArrayModifierData *amd,
     const MVert *src_mv;
 
     INIT_MINMAX(min, max);
-    for (src_mv = src_vertices, j = chunk_nverts; j--; src_mv++) {
+    for (src_mv = src_verts, j = chunk_nverts; j--; src_mv++) {
       minmax_v3v3_v3(min, max, src_mv->co);
     }
 
@@ -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_vertices = BKE_mesh_vertices_for_write(result);
+  MVert *result_verts = BKE_mesh_vertices_for_write(result);
   MEdge *result_edges = BKE_mesh_edges_for_write(result);
-  MPoly *result_polygons = BKE_mesh_polygons_for_write(result);
+  MPoly *result_polys = BKE_mesh_polygons_for_write(result);
   MLoop *result_loops = BKE_mesh_loops_for_write(result);
 
   if (use_merge) {
@@ -563,14 +563,14 @@ static Mesh *arrayModifier_doArray(ArrayModifierData *amd,
   /* Subsurf 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_vertices, src_vertices, sizeof(MVert) * mesh->totvert);
+    memcpy(result_verts, src_verts, sizeof(MVert) * mesh->totvert);
   }
   if (!CustomData_has_layer(&mesh->edata, CD_MEDGE)) {
     memcpy(result_edges, src_edges, sizeof(MEdge) * mesh->totedge);
   }
   if (!CustomData_has_layer(&mesh->pdata, CD_MPOLY)) {
     memcpy(result_loops, src_loops, sizeof(MLoop) * mesh->totloop);
-    memcpy(result_polygons, src_polygons, sizeof(MPoly) * mesh->totpoly);
+    memcpy(result_polys, src_polys, sizeof(MPoly) * mesh->totpoly);
   }
 
   /* Remember first chunk, in case of cap merge */
@@ -601,7 +601,7 @@ static Mesh *arrayModifier_doArray(ArrayModifierData *amd,
     /* apply offset to all new verts */
     for (i = 0; i < chunk_nverts; i++) {
       const int i_dst = vert_offset + i;
-      mul_m4_v3(current_offset, result_vertices[i_dst].co);
+      mul_m4_v3(current_offset, result_verts[i_dst].co);
 
       /* We have to correct normals too, if we do not tag them as dirty! */
       if (!use_recalc_normals) {
@@ -618,7 +618,7 @@ static Mesh *arrayModifier_doArray(ArrayModifierData *amd,
       me->v2 += c * chunk_nverts;
     }
 
-    mp = result_polygons + c * chunk_npolys;
+    mp = result_polys + c * chunk_npolys;
     for (i = 0; i < chunk_npolys; i++, mp++) {
       mp->loopstart += c * chunk_nloops;
     }
@@ -645,8 +645,8 @@ static Mesh *arrayModifier_doArray(ArrayModifierData *amd,
             while (target != -1 && !ELEM(full_doubles_map[target], -1, target)) {
               /* If target is already mapped, we only follow that mapping if final target remains
                * close enough from current vert (otherwise no mapping at all). */
-              if (compare_len_v3v3(result_vertices[this_chunk_index].co,
-                                   result_vertices[full_doubles_map[target]].co,
+              if (compare_len_v3v3(result_verts[this_chunk_index].co,
+                                   result_verts[full_doubles_map[target]].co,
                                    amd->merge_dist)) {
                 target = full_doubles_map[target];
               }
@@ -660,7 +660,7 @@ static Mesh *arrayModifier_doArray(ArrayModifierData *amd,
       }
       else {
         dm_mvert_map_doubles(full_doubles_map,
-                             result_vertices,
+                             result_verts,
                              (c - 1) * chunk_nverts,
                              chunk_nverts,
                              c * chunk_nverts,
@@ -698,7 +698,7 @@ static Mesh *arrayModifier_doArray(ArrayModifierData *amd,
   if (use_merge && (amd->flags & MOD_ARR_MERGEFINAL) && (count > 1)) {
     /* Merge first and last copies */
     dm_mvert_map_doubles(full_doubles_map,
-                         result_vertices,
+                         result_verts,
                          last_chunk_start,
                          last_chunk_nverts,
                          first_chunk_start,
@@ -728,7 +728,7 @@ static Mesh *arrayModifier_doArray(ArrayModifierData *amd,
     /* Identify doubles with first chunk */
     if (use_merge) {
       dm_mvert_map_doubles(full_doubles_map,
-                           result_vertices,
+                           result_verts,
                            first_chunk_start,
                            first_chunk_nverts,
                            start_cap_start,
@@ -758,7 +758,7 @@ static Mesh *arrayModifier_doArray(ArrayModifierData *amd,
     /* Identify doubles with last chunk */
     if (use_merge) {
       dm_mvert_map_doubles(full_doubles_map,
-                           result_vertices,
+                           result_verts,
                            last_chunk_start,
                            last_chunk_nverts,
                            end_cap_start,
diff --git a/source/blender/modifiers/intern/MOD_boolean.cc b/source/blender/modifiers/intern/MOD_boolean.cc
index df5be29749b..dc1ad7841b4 100644
--- a/source/blender/modifiers/intern/MOD_boolean.cc
+++ b/source/blender/modifiers/intern/MOD_boolean.cc
@@ -144,9 +144,9 @@ static Mesh *get_quick_mesh(
           invert_m4_m4(imat, ob_self->obmat);
           mul_m4_m4m4(omat, imat, ob_operand_ob->obmat);
 
-          MutableSpan<MVert> vertices = blender::bke::mesh_vertices_for_write(*result);
-          for (const int i : vertices.index_range()) {
-            mul_m4_v3(omat, vertices[i].co);
+          MutableSpan<MVert> verts = blender::bke::mesh_vertices_for_write(*result);
+          for (const int i : verts.index_range()) {
+            mul_m4_v3(omat, verts[i].co);
           }
 
           BKE_mesh_tag_coords_changed(result);
diff --git a/source/blender/modifiers/intern/MOD_build.c b/source/blender/modifiers/intern/MOD_build.c
index 4c27fe60546..02d56560fc5 100644
--- a/source/blender/modifiers/intern/MOD_build.c
+++ b/source/blender/modifiers/intern/MOD_build.c
@@ -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_vertices = BKE_mesh_vertices_for_write(result);
+  MVert *result_verts = BKE_mesh_vertices_for_write(result);
   MEdge *result_edges = BKE_mesh_edges_for_write(result);
-  MPoly *result_polygons = BKE_mesh_polygons_for_write(result);
+  MPoly *result_polys = BKE_mesh_polygons_for_write(result);
   MLoop *result_loops = BKE_mesh_loops_for_write(result);
 
   /* copy the vertices across */
@@ -215,7 +215,7 @@ static Mesh *modifyMesh(ModifierData *md, const ModifierEvalContext *ctx, struct
     int newIndex = POINTER_AS_INT(BLI_ghashIterator_getValue(&gh_iter));
 
     source = mvert_src[oldIndex];
-    dest = &result_vertices[newIndex];
+    dest = &result_verts[newIndex];
 
     CustomData_copy_data(&mesh->vdata, &result->vdata, oldIndex, newIndex, 1);
     *dest = source;
@@ -237,7 +237,7 @@ static Mesh *modifyMesh(ModifierData *md, const ModifierEvalContext *ctx, struct
     *dest = source;
   }
 
-  mpoly_dst = result_polygons;
+  mpoly_dst = result_polys;
   ml_dst = result_loops;
 
   /* copy the faces across, remapping indices */
diff --git a/source/blender/modifiers/intern/MOD_datatransfer.c b/source/blender/modifiers/intern/MOD_datatransfer.c
index 21ef22b27fc..729a912b079 100644
--- a/source/blender/modifiers/intern/MOD_datatransfer.c
+++ b/source/blender/modifiers/intern/MOD_datatransfer.c
@@ -179,12 +179,12 @@ static Mesh *modifyMesh(ModifierData *md, const ModifierEvalContext *ctx, Mesh *
     BLI_SPACE_TRANSFORM_SETUP(space_transform, ctx->object, ob_source);
   }
 
-  const MVert *me_vertices = BKE_mesh_vertices(me);
+  const MVert *me_verts = BKE_mesh_vertices(me);
   const MEdge *me_edges = BKE_mesh_edges(me);
-  const MVert *result_vertices = BKE_mesh_vertices(result);
+  const MVert *result_verts = BKE_mesh_vertices(result);
   const MEdge *result_edges = BKE_mesh_edges(result);
 
-  if (((result == me) || (me_vertices == result_vertices) || (me_edges == result_edges)) &&
+  if (((result == me) || (me_verts == result_verts) || (me_edges == result_edges)) &&
       (dtmd->data_types & DT_TYPES_AFFECT_MESH)) {
     /* We need to duplicate data here, otherwise setting custom normals, edges' sharpness, etc.,
      * could modify org mesh, see T43671. */
diff --git a/source/blender/modifiers/intern/MOD_explode.c b/source/blender/modifiers/intern/MOD_explode.c
index 543db48bda4..e5579819cf0 100644
--- a/source/blender/modifiers/intern/MOD_explode.c
+++ b/source/blender/modifiers/intern/MOD_explode.c
@@ -730,15 +730,15 @@ static Mesh *cutEdges(ExplodeModifierData *emd, Mesh *mesh)
 
   layers_num = CustomData_number_of_layers(&split_m->fdata, CD_MTFACE);
 
-  const MVert *mesh_vertices = BKE_mesh_vertices(mesh);
-  MVert *split_m_vertices = BKE_mesh_vertices_for_write(split_m);
+  const MVert *mesh_verts = BKE_mesh_vertices(mesh);
+  MVert *split_m_verts = BKE_mesh_vertices_for_write(split_m);
 
   /* copy new faces & verts (is it really this painful with custom data??) */
   for (i = 0; i < totvert; i++) {
     MVert source;
     MVert *dest;
-    source = mesh_vertices[i];
-    dest = &split_m_vertices[i];
+    source = mesh_verts[i];
+    dest = &split_m_verts[i];
 
     CustomData_copy_data(&mesh->vdata, &split_m->vdata, i, i, 1);
     *dest = source;
@@ -759,14 +759,14 @@ static Mesh *cutEdges(ExplodeModifierData *emd, Mesh *mesh)
   for (; !BLI_edgehashIterator_isDone(ehi); BLI_edgehashIterator_step(ehi)) {
     BLI_edgehashIterator_getKey(ehi, &ed_v1, &ed_v2);
     esplit = POINTER_AS_INT(BLI_edgehashIterator_getValue(ehi));
-    mv = &split_m_vertices[ed_v2];
-    dupve = &split_m_vertices[esplit];
+    mv = &split_m_verts[ed_v2];
+    dupve = &split_m_verts[esplit];
 
     CustomData_copy_data(&split_m->vdata, &split_m->vdata, ed_v2, esplit, 1);
 
     *dupve = *mv;
 
-    mv = &split_m_vertices[ed_v1];
+    mv = &split_m_verts[ed_v1];
 
     mid_v3_v3v3(dupve->co, dupve->co, mv->co);
   }
@@ -989,8 +989,8 @@ static Mesh *explodeMesh(ExplodeModifierData *emd,
 
   psmd->psys->lattice_deform_data = psys_create_lattice_deform_data(&sim);
 
-  const MVert *mesh_vertices = BKE_mesh_vertices(mesh);
-  MVert *explode_vertices = BKE_mesh_vertices_for_write(explode);
+  const MVert *mesh_verts = BKE_mesh_vertices(mesh);
+  MVert *explode_verts = BKE_mesh_vertices_for_write(explode);
 
   /* duplicate & displace vertices */
   ehi = BLI_edgehashIterator_new(vertpahash);
@@ -1003,8 +1003,8 @@ static Mesh *explodeMesh(ExplodeModifierData *emd,
     ed_v2 -= totvert;
     v = POINTER_AS_INT(BLI_edgehashIterator_getValue(ehi));
 
-    source = mesh_vertices[ed_v1];
-    dest = &explode_vertices[v];
+    source = mesh_verts[ed_v1];
+    dest = &explode_verts[v];
 
     CustomData_copy_data(&mesh->vdata, &explode->vdata, ed_v1, v, 1);
 
@@ -1019,7 +1019,7 @@ static Mesh *explodeMesh(ExplodeModifierData *emd,
       state.time = ctime;
       psys_get_particle_state(&sim, ed_v2, &state, 1);
 
-      vertco = explode_vertices[v].co;
+      vertco = explode_verts[v].co;
       mul_m4_v3(ctx->object->obmat, vertco);
 
       sub_v3_v3(vertco, birth.co);
diff --git a/source/blender/modifiers/intern/MOD_mask.cc b/source/blender/modifiers/intern/MOD_mask.cc
index be0f81a73aa..2676ad7e863 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> polygons = blender::bke::mesh_polygons(*mesh);
+  const Span<MPoly> polys = blender::bke::mesh_polygons(*mesh);
   const Span<MLoop> loops = blender::bke::mesh_loops(*mesh);
 
   r_masked_poly_indices.reserve(mesh->totpoly);
@@ -239,7 +239,7 @@ static void computed_masked_polygons(const Mesh *mesh,
 
   uint loops_masked_num = 0;
   for (int i : IndexRange(mesh->totpoly)) {
-    const MPoly &poly_src = polygons[i];
+    const MPoly &poly_src = polys[i];
 
     bool all_verts_in_mask = true;
     Span<MLoop> loops_src = loops.slice(poly_src.loopstart, poly_src.totloop);
@@ -277,14 +277,14 @@ 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> polygons = blender::bke::mesh_polygons(*mesh);
+  const Span<MPoly> polys = blender::bke::mesh_polygons(*mesh);
   const Span<MLoop> loops = blender::bke::mesh_loops(*mesh);
 
   uint edges_add_num = 0;
   uint polys_add_num = 0;
   uint loops_add_num = 0;
   for (int i : IndexRange(mesh->totpoly)) {
-    const MPoly &poly_src = polygons[i];
+    const MPoly &poly_src = polys[i];
 
     int in_count = 0;
     int start = -1;
@@ -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_vertices = blender::bke::mesh_vertices(src_mesh);
-  MutableSpan<MVert> dst_vertices = blender::bke::mesh_vertices_for_write(dst_mesh);
+  const Span<MVert> src_verts = blender::bke::mesh_vertices(src_mesh);
+  MutableSpan<MVert> dst_verts = blender::bke::mesh_vertices_for_write(dst_mesh);
 
   for (const int i_src : vertex_map.index_range()) {
     const int i_dst = vertex_map[i_src];
@@ -347,8 +347,8 @@ static void copy_masked_vertices_to_new_mesh(const Mesh &src_mesh,
       continue;
     }
 
-    const MVert &v_src = src_vertices[i_src];
-    MVert &v_dst = dst_vertices[i_dst];
+    const MVert &v_src = src_verts[i_src];
+    MVert &v_dst = dst_verts[i_dst];
 
     v_dst = v_src;
     CustomData_copy_data(&src_mesh.vdata, &dst_mesh.vdata, i_src, i_dst, 1);
@@ -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_vertices = blender::bke::mesh_vertices(src_mesh);
+  const Span<MVert> src_verts = blender::bke::mesh_vertices(src_mesh);
   const Span<MEdge> src_edges = blender::bke::mesh_edges(src_mesh);
-  MutableSpan<MVert> dst_vertices = blender::bke::mesh_vertices_for_write(dst_mesh);
+  MutableSpan<MVert> dst_verts = blender::bke::mesh_vertices_for_write(dst_mesh);
   MutableSpan<MEdge> dst_edges = blender::bke::mesh_edges_for_write(dst_mesh);
 
   uint vert_index = dst_mesh.totvert - verts_add_num;
@@ -420,9 +420,9 @@ static void add_interp_verts_copy_edges_to_new_mesh(const Mesh &src_mesh,
       float weights[2] = {1.0f - fac, fac};
       CustomData_interp(
           &src_mesh.vdata, &dst_mesh.vdata, (int *)&e_src.v1, weights, nullptr, 2, vert_index);
-      MVert &v = dst_vertices[vert_index];
-      const MVert &v1 = src_vertices[e_src.v1];
-      const MVert &v2 = src_vertices[e_src.v2];
+      MVert &v = dst_verts[vert_index];
+      const MVert &v1 = src_verts[e_src.v1];
+      const MVert &v2 = src_verts[e_src.v2];
 
       interp_v3_v3v3(v.co, v1.co, v2.co, fac);
       vert_index++;
@@ -466,16 +466,16 @@ 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_polygons = blender::bke::mesh_polygons(src_mesh);
+  const Span<MPoly> src_polys = blender::bke::mesh_polygons(src_mesh);
   const Span<MLoop> src_loops = blender::bke::mesh_loops(src_mesh);
-  MutableSpan<MPoly> dst_polygons = blender::bke::mesh_polygons_for_write(dst_mesh);
+  MutableSpan<MPoly> dst_polys = blender::bke::mesh_polygons_for_write(dst_mesh);
   MutableSpan<MLoop> dst_loops = blender::bke::mesh_loops_for_write(dst_mesh);
 
   for (const int i_dst : IndexRange(polys_masked_num)) {
     const int i_src = masked_poly_indices[i_dst];
 
-    const MPoly &mp_src = src_polygons[i_src];
-    MPoly &mp_dst = dst_polygons[i_dst];
+    const MPoly &mp_src = src_polys[i_src];
+    MPoly &mp_dst = dst_polys[i_dst];
     const int i_ml_src = mp_src.loopstart;
     const int i_ml_dst = new_loop_starts[i_dst];
 
@@ -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_polygons = blender::bke::mesh_polygons(src_mesh);
+  const Span<MPoly> src_polys = blender::bke::mesh_polygons(src_mesh);
   const Span<MLoop> src_loops = blender::bke::mesh_loops(src_mesh);
   MutableSpan<MEdge> dst_edges = blender::bke::mesh_edges_for_write(dst_mesh);
-  MutableSpan<MPoly> dst_polygons = blender::bke::mesh_polygons_for_write(dst_mesh);
+  MutableSpan<MPoly> dst_polys = blender::bke::mesh_polygons_for_write(dst_mesh);
   MutableSpan<MLoop> dst_loops = blender::bke::mesh_loops_for_write(dst_mesh);
 
   int edge_index = dst_mesh.totedge - edges_add_num;
@@ -527,8 +527,8 @@ static void add_interpolated_polys_to_new_mesh(const Mesh &src_mesh,
       last_i_src = i_src;
     }
 
-    const MPoly &mp_src = src_polygons[i_src];
-    MPoly &mp_dst = dst_polygons[i_dst];
+    const MPoly &mp_src = src_polys[i_src];
+    MPoly &mp_dst = dst_polys[i_dst];
     const int i_ml_src = mp_src.loopstart;
     int i_ml_dst = new_loop_starts[i_dst];
     const int mp_totloop = (i_dst + 1 < new_loop_starts.size() ? new_loop_starts[i_dst + 1] :
diff --git a/source/blender/modifiers/intern/MOD_meshsequencecache.cc b/source/blender/modifiers/intern/MOD_meshsequencecache.cc
index 44d7b42a746..918689ff36e 100644
--- a/source/blender/modifiers/intern/MOD_meshsequencecache.cc
+++ b/source/blender/modifiers/intern/MOD_meshsequencecache.cc
@@ -178,17 +178,17 @@ static Mesh *modifyMesh(ModifierData *md, const ModifierEvalContext *ctx, Mesh *
   }
 
   if (me != nullptr) {
-    const Span<MVert> mesh_vertices = blender::bke::mesh_vertices(*mesh);
+    const Span<MVert> mesh_verts = blender::bke::mesh_vertices(*mesh);
     const Span<MEdge> mesh_edges = blender::bke::mesh_edges(*mesh);
-    const Span<MPoly> mesh_polygons = blender::bke::mesh_polygons(*mesh);
+    const Span<MPoly> mesh_polys = blender::bke::mesh_polygons(*mesh);
     const Span<MVert> me_vertices = blender::bke::mesh_vertices(*me);
     const Span<MEdge> me_edges = blender::bke::mesh_edges(*me);
     const Span<MPoly> me_polygons = blender::bke::mesh_polygons(*me);
 
     /* TODO(sybren+bastien): possibly check relevant custom data layers (UV/color depending on
      * flags) and duplicate those too. */
-    if ((me_vertices.data() == mesh_vertices.data()) || (me_edges.data() == mesh_edges.data()) ||
-        (me_polygons.data() == mesh_polygons.data())) {
+    if ((me_vertices.data() == mesh_verts.data()) || (me_edges.data() == mesh_edges.data()) ||
+        (me_polygons.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 f7684d35890..62272741125 100644
--- a/source/blender/modifiers/intern/MOD_normal_edit.c
+++ b/source/blender/modifiers/intern/MOD_normal_edit.c
@@ -508,31 +508,42 @@ static Mesh *normalEditModifier_do(NormalEditModifierData *enmd,
     return mesh;
   }
 
-  const int verts_num = mesh->totvert;
-  const int edges_num = mesh->totedge;
-  const int loops_num = mesh->totloop;
-  const int polys_num = mesh->totpoly;
-  const MVert *vertices = BKE_mesh_vertices(mesh);
-  MEdge *edges = BKE_mesh_edges_for_write(mesh);
-  const MPoly *polygons = BKE_mesh_polygons(mesh);
-  MLoop *loops = BKE_mesh_loops_for_write(mesh);
+  Mesh *result;
+  if (BKE_mesh_edges(mesh) == BKE_mesh_edges(((Mesh *)ob->data))) {
+    /* We need to duplicate data here, otherwise setting custom normals
+     * (which may also affect sharp edges) could
+     * modify original mesh, see T43671. */
+    result = (Mesh *)BKE_id_copy_ex(NULL, &mesh->id, NULL, LIB_ID_COPY_LOCALIZE);
+  }
+  else {
+    result = mesh;
+  }
+
+  const int verts_num = result->totvert;
+  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);
+  MEdge *edges = BKE_mesh_edges_for_write(result);
+  const MPoly *polys = BKE_mesh_polygons(result);
+  MLoop *loops = BKE_mesh_loops_for_write(result);
 
   int defgrp_index;
   const MDeformVert *dvert;
 
   float(*loopnors)[3] = NULL;
 
-  CustomData *ldata = &mesh->ldata;
+  CustomData *ldata = &result->ldata;
 
-  const float(*vert_normals)[3] = BKE_mesh_vertex_normals_ensure(mesh);
-  const float(*poly_normals)[3] = BKE_mesh_poly_normals_ensure(mesh);
+  const float(*vert_normals)[3] = BKE_mesh_vertex_normals_ensure(result);
+  const float(*poly_normals)[3] = BKE_mesh_poly_normals_ensure(result);
 
   short(*clnors)[2] = CustomData_get_layer(ldata, CD_CUSTOMLOOPNORMAL);
   if (use_current_clnors) {
     clnors = CustomData_duplicate_referenced_layer(ldata, CD_CUSTOMLOOPNORMAL, loops_num);
     loopnors = MEM_malloc_arrayN((size_t)loops_num, sizeof(*loopnors), __func__);
 
-    BKE_mesh_normals_loop_split(vertices,
+    BKE_mesh_normals_loop_split(verts,
                                 vert_normals,
                                 verts_num,
                                 edges,
@@ -540,11 +551,11 @@ static Mesh *normalEditModifier_do(NormalEditModifierData *enmd,
                                 loops,
                                 loopnors,
                                 loops_num,
-                                polygons,
+                                polys,
                                 poly_normals,
                                 polys_num,
                                 true,
-                                mesh->smoothresh,
+                                result->smoothresh,
                                 NULL,
                                 clnors,
                                 NULL);
@@ -554,13 +565,13 @@ static Mesh *normalEditModifier_do(NormalEditModifierData *enmd,
     clnors = CustomData_add_layer(ldata, CD_CUSTOMLOOPNORMAL, CD_CALLOC, NULL, loops_num);
   }
 
-  MOD_get_vgroup(ob, mesh, enmd->defgrp_name, &dvert, &defgrp_index);
+  MOD_get_vgroup(ob, result, enmd->defgrp_name, &dvert, &defgrp_index);
 
   if (enmd->mode == MOD_NORMALEDIT_MODE_RADIAL) {
     normalEditModifier_do_radial(enmd,
                                  ctx,
                                  ob,
-                                 mesh,
+                                 result,
                                  clnors,
                                  loopnors,
                                  poly_normals,
@@ -570,20 +581,20 @@ static Mesh *normalEditModifier_do(NormalEditModifierData *enmd,
                                  dvert,
                                  defgrp_index,
                                  use_invert_vgroup,
-                                 vertices,
+                                 verts,
                                  verts_num,
                                  edges,
                                  edges_num,
                                  loops,
                                  loops_num,
-                                 polygons,
+                                 polys,
                                  polys_num);
   }
   else if (enmd->mode == MOD_NORMALEDIT_MODE_DIRECTIONAL) {
     normalEditModifier_do_directional(enmd,
                                       ctx,
                                       ob,
-                                      mesh,
+                                      result,
                                       clnors,
                                       loopnors,
                                       poly_normals,
@@ -593,21 +604,21 @@ static Mesh *normalEditModifier_do(NormalEditModifierData *enmd,
                                       dvert,
                                       defgrp_index,
                                       use_invert_vgroup,
-                                      vertices,
+                                      verts,
                                       verts_num,
                                       edges,
                                       edges_num,
                                       loops,
                                       loops_num,
-                                      polygons,
+                                      polys,
                                       polys_num);
   }
 
   MEM_SAFE_FREE(loopnors);
 
-  mesh->runtime.is_original_bmesh = false;
+  result->runtime.is_original_bmesh = false;
 
-  return mesh;
+  return result;
 }
 
 static void initData(ModifierData *md)
diff --git a/source/blender/modifiers/intern/MOD_ocean.c b/source/blender/modifiers/intern/MOD_ocean.c
index 3c53f4268b4..95273d92217 100644
--- a/source/blender/modifiers/intern/MOD_ocean.c
+++ b/source/blender/modifiers/intern/MOD_ocean.c
@@ -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 *vertices = BKE_mesh_vertices_for_write(result);
-  MPoly *polygons = BKE_mesh_polygons_for_write(result);
+  MVert *verts = BKE_mesh_vertices_for_write(result);
+  MPoly *polys = BKE_mesh_polygons_for_write(result);
 
   /* add vcols before displacement - allows lookup based on position */
 
@@ -388,7 +388,7 @@ static Mesh *doOcean(ModifierData *md, const ModifierEvalContext *ctx, Mesh *mes
       if (mloopcols) { /* unlikely to fail */
         MPoly *mp;
 
-        for (i = 0, mp = polygons; i < polys_num; i++, mp++) {
+        for (i = 0, mp = polys; i < polys_num; i++, mp++) {
           MLoop *ml = &mloops[mp->loopstart];
           MLoopCol *mlcol = &mloopcols[mp->loopstart];
 
@@ -398,7 +398,7 @@ static Mesh *doOcean(ModifierData *md, const ModifierEvalContext *ctx, Mesh *mes
           }
 
           for (j = mp->totloop; j--; ml++, mlcol++) {
-            const float *vco = vertices[ml->v].co;
+            const float *vco = verts[ml->v].co;
             const float u = OCEAN_CO(size_co_inv, vco[0]);
             const float v = OCEAN_CO(size_co_inv, vco[1]);
             float foam;
@@ -447,7 +447,7 @@ static Mesh *doOcean(ModifierData *md, const ModifierEvalContext *ctx, Mesh *mes
     const int verts_num = result->totvert;
 
     for (i = 0; i < verts_num; i++) {
-      float *vco = vertices[i].co;
+      float *vco = verts[i].co;
       const float u = OCEAN_CO(size_co_inv, vco[0]);
       const float v = OCEAN_CO(size_co_inv, vco[1]);
 
diff --git a/source/blender/modifiers/intern/MOD_remesh.c b/source/blender/modifiers/intern/MOD_remesh.c
index 624c8866f88..37d711a4bfa 100644
--- a/source/blender/modifiers/intern/MOD_remesh.c
+++ b/source/blender/modifiers/intern/MOD_remesh.c
@@ -80,8 +80,8 @@ static void init_dualcon_mesh(DualConInput *input, Mesh *mesh)
  * keep track of the current elements */
 typedef struct {
   Mesh *mesh;
-  MVert *vertices;
-  MPoly *polygons;
+  MVert *verts;
+  MPoly *polys;
   MLoop *loops;
   int curvert, curface;
 } DualConOutput;
@@ -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->vertices = BKE_mesh_vertices_for_write(output->mesh);
-  output->polygons = BKE_mesh_polygons_for_write(output->mesh);
+  output->verts = BKE_mesh_vertices_for_write(output->mesh);
+  output->polys = BKE_mesh_polygons_for_write(output->mesh);
   output->loops = BKE_mesh_loops_for_write(output->mesh);
 
   return output;
@@ -109,7 +109,7 @@ static void dualcon_add_vert(void *output_v, const float co[3])
 
   BLI_assert(output->curvert < output->mesh->totvert);
 
-  copy_v3_v3(output->vertices[output->curvert].co, co);
+  copy_v3_v3(output->verts[output->curvert].co, co);
   output->curvert++;
 }
 
@@ -123,7 +123,7 @@ static void dualcon_add_quad(void *output_v, const int vert_indices[4])
   UNUSED_VARS_NDEBUG(mesh);
 
   MLoop *mloop = output->loops;
-  MPoly *cur_poly = &output->polygons[output->curface];
+  MPoly *cur_poly = &output->polys[output->curface];
 
   cur_poly->loopstart = output->curface * 4;
   cur_poly->totloop = 4;
diff --git a/source/blender/modifiers/intern/MOD_surface.c b/source/blender/modifiers/intern/MOD_surface.c
index 9def7a82a47..93da7969a09 100644
--- a/source/blender/modifiers/intern/MOD_surface.c
+++ b/source/blender/modifiers/intern/MOD_surface.c
@@ -151,9 +151,9 @@ static void deformVerts(ModifierData *md,
     }
 
     /* convert to global coordinates and calculate velocity */
-    MVert *vertices = BKE_mesh_vertices_for_write(surmd->mesh);
+    MVert *verts = BKE_mesh_vertices_for_write(surmd->mesh);
     for (i = 0, x = surmd->x, v = surmd->v; i < mesh_verts_num; i++, x++, v++) {
-      float *vec = vertices[i].co;
+      float *vec = verts[i].co;
       mul_m4_v3(ctx->object->obmat, vec);
 
       if (init) {
diff --git a/source/blender/modifiers/intern/MOD_uvproject.c b/source/blender/modifiers/intern/MOD_uvproject.c
index 40af4c0fb22..c9fc2ef3d7c 100644
--- a/source/blender/modifiers/intern/MOD_uvproject.c
+++ b/source/blender/modifiers/intern/MOD_uvproject.c
@@ -204,11 +204,11 @@ static Mesh *uvprojectModifier_do(UVProjectModifierData *umd,
     }
   }
 
-  const MPoly *polygons = BKE_mesh_polygons(mesh);
+  const MPoly *polys = BKE_mesh_polygons(mesh);
   const MLoop *loops = BKE_mesh_loops(mesh);
 
   /* apply coords as UVs */
-  for (i = 0, mp = polygons; i < polys_num; i++, mp++) {
+  for (i = 0, mp = polys; i < polys_num; i++, mp++) {
     if (projectors_num == 1) {
       if (projectors[0].uci) {
         uint fidx = mp->totloop - 1;
diff --git a/source/blender/modifiers/intern/MOD_uvwarp.c b/source/blender/modifiers/intern/MOD_uvwarp.c
index f77a7c8278e..9561f177cf1 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 *polygons = BKE_mesh_polygons(mesh);
+  const MPoly *polys = BKE_mesh_polygons(mesh);
   const MLoop *loops = BKE_mesh_loops(mesh);
   polys_num = mesh->totpoly;
   loops_num = mesh->totloop;
@@ -206,7 +206,7 @@ static Mesh *modifyMesh(ModifierData *md, const ModifierEvalContext *ctx, Mesh *
   MOD_get_vgroup(ctx->object, mesh, umd->vgroup_name, &dvert, &defgrp_index);
 
   UVWarpData data = {
-      .mpoly = polygons,
+      .mpoly = polys,
       .mloop = loops,
       .mloopuv = mloopuv,
       .dvert = dvert,