Cleanup: Move BKE_mesh_calc_edges to bke namespace

Also use reference for mesh argument, and move edges calculation
from legacy faces to "legacy" file.

source/blender/blenkernel/BKE_mesh.h

@@ -313,8 +313,6 @@ void BKE_lnor_spacearr_tls_join(MLoopNorSpaceArray *lnors_spacearr,
 
 MLoopNorSpace *BKE_lnor_space_create(MLoopNorSpaceArray *lnors_spacearr);
 
-#ifdef __cplusplus
-
 /**
  * Should only be called once.
  * Beware, this modifies ref_vec and other_vec in place!
@@ -327,8 +325,6 @@ void BKE_lnor_space_define(MLoopNorSpace *lnor_space,
                            const float vec_other[3],
                            blender::Span<blender::float3> edge_vectors);
 
-#endif
-
 /**
  * Add a new given loop to given lnor_space.
  * Depending on \a lnor_space->data_type, we expect \a bm_loop to be a pointer to BMLoop struct
@@ -516,17 +512,6 @@ bool BKE_mesh_validate_all_customdata(struct CustomData *vert_data,
 
 void BKE_mesh_strip_loose_faces(struct Mesh *mesh);
 
-/**
- * Calculate edges from faces.
- */
-void BKE_mesh_calc_edges(struct Mesh *mesh, bool keep_existing_edges, bool select_new_edges);
-/**
- * Calculate/create edges from tessface data
- *
- * \param mesh: The mesh to add edges into
- */
-void BKE_mesh_calc_edges_tessface(struct Mesh *mesh);
-
 /* In DerivedMesh.cc */
 void BKE_mesh_wrapper_deferred_finalize_mdata(struct Mesh *me_eval);
 
@@ -548,9 +533,3 @@ char *BKE_mesh_debug_info(const struct Mesh *mesh)
     ATTR_NONNULL(1) ATTR_MALLOC ATTR_WARN_UNUSED_RESULT;
 void BKE_mesh_debug_print(const struct Mesh *mesh) ATTR_NONNULL(1);
 #endif
-
-/* -------------------------------------------------------------------- */
-/** \name Inline Mesh Data Access
- * \{ */
-
-/** \} */

source/blender/blenkernel/BKE_mesh.hh

@@ -302,6 +302,9 @@ inline int edge_other_vert(const int2 edge, const int vert)
 
 }  // namespace mesh
 
+/** Calculate edges from faces. */
+void mesh_calc_edges(Mesh &mesh, bool keep_existing_edges, bool select_new_edges);
+
 void mesh_flip_faces(Mesh &mesh, const IndexMask &selection);
 
 /** Set mesh vertex normals to known-correct values, avoiding future lazy computation. */

source/blender/blenkernel/BKE_mesh_legacy_convert.hh

@@ -116,6 +116,11 @@ void BKE_mesh_do_versions_cd_flag_init(Mesh *mesh);
 
 void BKE_main_mesh_legacy_convert_auto_smooth(Main &bmain);
 
+/**
+ * Calculate/create edges from tessface data
+ */
+void BKE_mesh_calc_edges_tessface(Mesh *mesh);
+
 /* Inlines */
 
 /* NOTE(@sybren): Instead of -1 that function uses ORIGINDEX_NONE as defined in BKE_customdata.hh,

source/blender/blenkernel/intern/fluid.cc

@@ -3370,13 +3370,15 @@ static Mesh *create_liquid_geometry(FluidDomainSettings *fds,
 
   material_indices.finish();
 
-  BKE_mesh_calc_edges(mesh, false, false);
+  mesh_calc_edges(*mesh, false, false);
 
   return mesh;
 }
 
 static Mesh *create_smoke_geometry(FluidDomainSettings *fds, Mesh *orgmesh, Object *ob)
 {
+  using namespace blender;
+  using namespace blender::bke;
   Mesh *result;
   float min[3];
   float max[3];
@@ -3494,7 +3496,7 @@ static Mesh *create_smoke_geometry(FluidDomainSettings *fds, Mesh *orgmesh, Obje
     }
   }
 
-  BKE_mesh_calc_edges(result, false, false);
+  mesh_calc_edges(*result, false, false);
   return result;
 }
 

source/blender/blenkernel/intern/mball_tessellate.cc

@@ -1493,7 +1493,7 @@ Mesh *BKE_mball_polygonize(Depsgraph *depsgraph, Scene *scene, Object *ob)
   }
   blender::bke::mesh_vert_normals_assign(*mesh, std::move(process.no));
 
-  BKE_mesh_calc_edges(mesh, false, false);
+  blender::bke::mesh_calc_edges(*mesh, false, false);
 
   return mesh;
 }

source/blender/blenkernel/intern/mesh_boolean_convert.cc

@@ -775,9 +775,7 @@ static Mesh *imesh_to_mesh(IMesh *im, MeshesToIMeshInfo &mim)
   }
   dst_material_indices.finish();
 
-  /* BKE_mesh_calc_edges will calculate and populate all the
-   * MEdges from the MPolys. */
-  BKE_mesh_calc_edges(result, false, false);
+  bke::mesh_calc_edges(*result, false, false);
   merge_edge_customdata_layers(result, mim);
 
   /* Now that the MEdges are populated, we can copy over the required attributes and custom layers.

source/blender/blenkernel/intern/mesh_calc_edges.cc

@@ -6,25 +6,21 @@
  * \ingroup bke
  */
 
-#include "DNA_mesh_types.h"
-#include "DNA_meshdata_types.h"
-#include "DNA_object_types.h"
-
 #include "BLI_map.hh"
 #include "BLI_ordered_edge.hh"
 #include "BLI_task.hh"
 #include "BLI_threads.h"
-#include "BLI_timeit.hh"
 
 #include "BKE_attribute.hh"
-#include "BKE_customdata.hh"
 #include "BKE_mesh.hh"
 
-namespace blender::bke::calc_edges {
+namespace blender::bke {
+
+namespace calc_edges {
 
 /**
  * Return a hash value that is likely to be different in the low bits from the normal `hash()`
- * function. This is necessary to avoid collisions in #BKE_mesh_calc_edges.
+ * function. This is necessary to avoid collisions in #mesh_calc_edges.
  */
 static uint64_t edge_hash_2(const OrderedEdge &edge)
 {
@@ -38,22 +34,21 @@ union OrigEdgeOrIndex {
 };
 using EdgeMap = Map<OrderedEdge, OrigEdgeOrIndex>;
 
-static void reserve_hash_maps(const Mesh *mesh,
+static void reserve_hash_maps(const Mesh &mesh,
                               const bool keep_existing_edges,
                               MutableSpan<EdgeMap> edge_maps)
 {
-  const int totedge_guess = std::max(keep_existing_edges ? mesh->edges_num : 0,
-                                     mesh->faces_num * 2);
+  const int totedge_guess = std::max(keep_existing_edges ? mesh.edges_num : 0, mesh.faces_num * 2);
   threading::parallel_for_each(
       edge_maps, [&](EdgeMap &edge_map) { edge_map.reserve(totedge_guess / edge_maps.size()); });
 }
 
-static void add_existing_edges_to_hash_maps(Mesh *mesh,
+static void add_existing_edges_to_hash_maps(Mesh &mesh,
                                             MutableSpan<EdgeMap> edge_maps,
                                             uint32_t parallel_mask)
 {
   /* Assume existing edges are valid. */
-  const Span<int2> edges = mesh->edges();
+  const Span<int2> edges = mesh.edges();
   threading::parallel_for_each(edge_maps, [&](EdgeMap &edge_map) {
     const int task_index = &edge_map - edge_maps.data();
     for (const int2 &edge : edges) {
@@ -66,12 +61,12 @@ static void add_existing_edges_to_hash_maps(Mesh *mesh,
   });
 }
 
-static void add_face_edges_to_hash_maps(Mesh *mesh,
+static void add_face_edges_to_hash_maps(Mesh &mesh,
                                         MutableSpan<EdgeMap> edge_maps,
                                         uint32_t parallel_mask)
 {
-  const OffsetIndices faces = mesh->faces();
-  const Span<int> corner_verts = mesh->corner_verts();
+  const OffsetIndices faces = mesh.faces();
+  const Span<int> corner_verts = mesh.corner_verts();
   threading::parallel_for_each(edge_maps, [&](EdgeMap &edge_map) {
     const int task_index = &edge_map - edge_maps.data();
     for (const int i : faces.index_range()) {
@@ -160,38 +155,34 @@ static void update_edge_indices_in_face_loops(const OffsetIndices<int> faces,
   });
 }
 
-static int get_parallel_maps_count(const Mesh *mesh)
+static int get_parallel_maps_count(const Mesh &mesh)
 {
   /* Don't use parallelization when the mesh is small. */
-  if (mesh->faces_num < 1000) {
+  if (mesh.faces_num < 1000) {
     return 1;
   }
   /* Use at most 8 separate hash tables. Using more threads has diminishing returns. These threads
-   * can better do something more useful instead. */
+   * are better off doing something more useful instead. */
   const int system_thread_count = BLI_system_thread_count();
   return power_of_2_min_i(std::min(8, system_thread_count));
 }
 
 static void clear_hash_tables(MutableSpan<EdgeMap> edge_maps)
 {
-  threading::parallel_for_each(edge_maps, [](EdgeMap &edge_map) { edge_map.clear(); });
+  threading::parallel_for_each(edge_maps, [](EdgeMap &edge_map) { edge_map.clear_and_shrink(); });
 }
 
-}  // namespace blender::bke::calc_edges
+}  // namespace calc_edges
 
-void BKE_mesh_calc_edges(Mesh *mesh, bool keep_existing_edges, const bool select_new_edges)
+void mesh_calc_edges(Mesh &mesh, bool keep_existing_edges, const bool select_new_edges)
 {
-  using namespace blender;
-  using namespace blender::bke;
-  using namespace blender::bke::calc_edges;
-
   /* Parallelization is achieved by having multiple hash tables for different subsets of edges.
    * Each edge is assigned to one of the hash maps based on the lower bits of a hash value. */
-  const int parallel_maps = get_parallel_maps_count(mesh);
+  const int parallel_maps = calc_edges::get_parallel_maps_count(mesh);
   BLI_assert(is_power_of_2_i(parallel_maps));
   const uint32_t parallel_mask = uint32_t(parallel_maps) - 1;
-  Array<EdgeMap> edge_maps(parallel_maps);
-  reserve_hash_maps(mesh, keep_existing_edges, edge_maps);
+  Array<calc_edges::EdgeMap> edge_maps(parallel_maps);
+  calc_edges::reserve_hash_maps(mesh, keep_existing_edges, edge_maps);
 
   /* Add all edges. */
   if (keep_existing_edges) {
@@ -201,36 +192,33 @@ void BKE_mesh_calc_edges(Mesh *mesh, bool keep_existing_edges, const bool select
 
   /* Compute total number of edges. */
   int new_totedge = 0;
-  for (EdgeMap &edge_map : edge_maps) {
+  for (calc_edges::EdgeMap &edge_map : edge_maps) {
     new_totedge += edge_map.size();
   }
 
   /* Create new edges. */
-  MutableAttributeAccessor attributes = mesh->attributes_for_write();
+  MutableAttributeAccessor attributes = mesh.attributes_for_write();
   attributes.add<int>(".corner_edge", AttrDomain::Corner, AttributeInitConstruct());
   MutableSpan<int2> new_edges{
       static_cast<int2 *>(MEM_calloc_arrayN(new_totedge, sizeof(int2), __func__)), new_totedge};
   calc_edges::serialize_and_initialize_deduplicated_edges(edge_maps, new_edges);
-  calc_edges::update_edge_indices_in_face_loops(mesh->faces(),
-                                                mesh->corner_verts(),
-                                                edge_maps,
-                                                parallel_mask,
-                                                mesh->corner_edges_for_write());
+  calc_edges::update_edge_indices_in_face_loops(
+      mesh.faces(), mesh.corner_verts(), edge_maps, parallel_mask, mesh.corner_edges_for_write());
 
   /* Free old CustomData and assign new one. */
-  CustomData_free(&mesh->edge_data, mesh->edges_num);
-  CustomData_reset(&mesh->edge_data);
-  mesh->edges_num = new_totedge;
+  CustomData_free(&mesh.edge_data, mesh.edges_num);
+  CustomData_reset(&mesh.edge_data);
+  mesh.edges_num = new_totedge;
   attributes.add<int2>(".edge_verts", AttrDomain::Edge, AttributeInitMoveArray(new_edges.data()));
 
   if (select_new_edges) {
-    MutableAttributeAccessor attributes = mesh->attributes_for_write();
+    MutableAttributeAccessor attributes = mesh.attributes_for_write();
     SpanAttributeWriter<bool> select_edge = attributes.lookup_or_add_for_write_span<bool>(
         ".select_edge", AttrDomain::Edge);
     if (select_edge) {
       int new_edge_index = 0;
-      for (const EdgeMap &edge_map : edge_maps) {
-        for (EdgeMap::Item item : edge_map.items()) {
+      for (const calc_edges::EdgeMap &edge_map : edge_maps) {
+        for (calc_edges::EdgeMap::Item item : edge_map.items()) {
           if (item.value.original_edge == nullptr) {
             select_edge.span[new_edge_index] = true;
           }
@@ -243,9 +231,11 @@ void BKE_mesh_calc_edges(Mesh *mesh, bool keep_existing_edges, const bool select
 
   if (!keep_existing_edges) {
     /* All edges are rebuilt from the faces, so there are no loose edges. */
-    mesh->tag_loose_edges_none();
+    mesh.tag_loose_edges_none();
   }
 
   /* Explicitly clear edge maps, because that way it can be parallelized. */
   clear_hash_tables(edge_maps);
 }
+
+}  // namespace blender::bke

source/blender/blenkernel/intern/mesh_convert.cc

@@ -302,7 +302,7 @@ static Mesh *mesh_nurbs_displist_to_mesh(const Curve *cu, const ListBase *dispba
   }
 
   if (faces_num) {
-    BKE_mesh_calc_edges(mesh, true, false);
+    mesh_calc_edges(*mesh, true, false);
   }
 
   material_indices.finish();

source/blender/blenkernel/intern/mesh_legacy_convert.cc

@@ -2342,3 +2342,46 @@ void mesh_sculpt_mask_to_generic(Mesh &mesh)
 }  // namespace blender::bke
 
 /** \} */
+
+void BKE_mesh_calc_edges_tessface(Mesh *mesh)
+{
+  const int nulegacy_faces = mesh->totface_legacy;
+  blender::VectorSet<blender::OrderedEdge> eh;
+  eh.reserve(nulegacy_faces);
+  MFace *legacy_faces = (MFace *)CustomData_get_layer_for_write(
+      &mesh->fdata_legacy, CD_MFACE, mesh->totface_legacy);
+
+  MFace *mf = legacy_faces;
+  for (int i = 0; i < nulegacy_faces; i++, mf++) {
+    eh.add({mf->v1, mf->v2});
+    eh.add({mf->v2, mf->v3});
+
+    if (mf->v4) {
+      eh.add({mf->v3, mf->v4});
+      eh.add({mf->v4, mf->v1});
+    }
+    else {
+      eh.add({mf->v3, mf->v1});
+    }
+  }
+
+  const int numEdges = eh.size();
+
+  /* write new edges into a temporary CustomData */
+  CustomData edgeData;
+  CustomData_reset(&edgeData);
+  CustomData_add_layer_named(&edgeData, CD_PROP_INT32_2D, CD_CONSTRUCT, numEdges, ".edge_verts");
+  CustomData_add_layer(&edgeData, CD_ORIGINDEX, CD_SET_DEFAULT, numEdges);
+
+  blender::int2 *ege = (blender::int2 *)CustomData_get_layer_named_for_write(
+      &edgeData, CD_PROP_INT32_2D, ".edge_verts", mesh->edges_num);
+  int *index = (int *)CustomData_get_layer_for_write(&edgeData, CD_ORIGINDEX, mesh->edges_num);
+
+  memset(index, ORIGINDEX_NONE, sizeof(int) * numEdges);
+  MutableSpan(ege, numEdges).copy_from(eh.as_span().cast<blender::int2>());
+
+  /* free old CustomData and assign new one */
+  CustomData_free(&mesh->edge_data, mesh->edges_num);
+  mesh->edge_data = edgeData;
+  mesh->edges_num = numEdges;
+}

source/blender/blenkernel/intern/mesh_remesh_voxel.cc

@@ -67,6 +67,8 @@ static Mesh *remesh_quadriflow(const Mesh *input_mesh,
                                void (*update_cb)(void *, float progress, int *cancel),
                                void *update_cb_data)
 {
+  using namespace blender;
+  using namespace blender::bke;
   const Span<float3> input_positions = input_mesh->vert_positions();
   const Span<int> input_corner_verts = input_mesh->corner_verts();
   const Span<int3> corner_tris = input_mesh->corner_tris();
@@ -139,7 +141,7 @@ static Mesh *remesh_quadriflow(const Mesh *input_mesh,
     corner_verts[loopstart + 3] = qrd.out_faces[loopstart + 3];
   }
 
-  BKE_mesh_calc_edges(mesh, false, false);
+  mesh_calc_edges(*mesh, false, false);
 
   MEM_freeN(qrd.out_faces);
   MEM_freeN(qrd.out_verts);
@@ -217,6 +219,8 @@ static Mesh *remesh_voxel_volume_to_mesh(const openvdb::FloatGrid::Ptr level_set
                                          const float adaptivity,
                                          const bool relax_disoriented_triangles)
 {
+  using namespace blender;
+  using namespace blender::bke;
   std::vector<openvdb::Vec3s> vertices;
   std::vector<openvdb::Vec4I> quads;
   std::vector<openvdb::Vec3I> tris;
@@ -255,7 +259,7 @@ static Mesh *remesh_voxel_volume_to_mesh(const openvdb::FloatGrid::Ptr level_set
     mesh_corner_verts[loopstart + 2] = tris[i][0];
   }
 
-  BKE_mesh_calc_edges(mesh, false, false);
+  mesh_calc_edges(*mesh, false, false);
 
   return mesh;
 }

source/blender/blenkernel/intern/mesh_validate.cc

@@ -229,6 +229,7 @@ bool BKE_mesh_validate_arrays(Mesh *mesh,
                               bool *r_changed)
 {
   using namespace blender;
+  using namespace blender::bke;
 #define REMOVE_EDGE_TAG(_me) \
   { \
     _me[0] = _me[1]; \
@@ -861,7 +862,7 @@ bool BKE_mesh_validate_arrays(Mesh *mesh,
     }
 
     if (recalc_flag.edges) {
-      BKE_mesh_calc_edges(mesh, true, false);
+      mesh_calc_edges(*mesh, true, false);
     }
   }
 
@@ -1324,52 +1325,3 @@ void mesh_strip_edges(Mesh *mesh)
 }
 
 /** \} */
-
-/* -------------------------------------------------------------------- */
-/** \name Mesh Edge Calculation
- * \{ */
-
-void BKE_mesh_calc_edges_tessface(Mesh *mesh)
-{
-  const int nulegacy_faces = mesh->totface_legacy;
-  blender::VectorSet<blender::OrderedEdge> eh;
-  eh.reserve(nulegacy_faces);
-  MFace *legacy_faces = (MFace *)CustomData_get_layer_for_write(
-      &mesh->fdata_legacy, CD_MFACE, mesh->totface_legacy);
-
-  MFace *mf = legacy_faces;
-  for (int i = 0; i < nulegacy_faces; i++, mf++) {
-    eh.add({mf->v1, mf->v2});
-    eh.add({mf->v2, mf->v3});
-
-    if (mf->v4) {
-      eh.add({mf->v3, mf->v4});
-      eh.add({mf->v4, mf->v1});
-    }
-    else {
-      eh.add({mf->v3, mf->v1});
-    }
-  }
-
-  const int numEdges = eh.size();
-
-  /* write new edges into a temporary CustomData */
-  CustomData edgeData;
-  CustomData_reset(&edgeData);
-  CustomData_add_layer_named(&edgeData, CD_PROP_INT32_2D, CD_CONSTRUCT, numEdges, ".edge_verts");
-  CustomData_add_layer(&edgeData, CD_ORIGINDEX, CD_SET_DEFAULT, numEdges);
-
-  blender::int2 *ege = (blender::int2 *)CustomData_get_layer_named_for_write(
-      &edgeData, CD_PROP_INT32_2D, ".edge_verts", mesh->edges_num);
-  int *index = (int *)CustomData_get_layer_for_write(&edgeData, CD_ORIGINDEX, mesh->edges_num);
-
-  memset(index, ORIGINDEX_NONE, sizeof(int) * numEdges);
-  MutableSpan(ege, numEdges).copy_from(eh.as_span().cast<blender::int2>());
-
-  /* free old CustomData and assign new one */
-  CustomData_free(&mesh->edge_data, mesh->edges_num);
-  mesh->edge_data = edgeData;
-  mesh->edges_num = numEdges;
-}
-
-/** \} */

source/blender/blenkernel/intern/volume_to_mesh.cc

@@ -181,7 +181,7 @@ Mesh *volume_to_mesh(const openvdb::GridBase &grid,
                               mesh->face_offsets_for_write(),
                               mesh->corner_verts_for_write());
 
-  BKE_mesh_calc_edges(mesh, false, false);
+  mesh_calc_edges(*mesh, false, false);
   mesh_smooth_set(*mesh, false);
 
   mesh->tag_overlapping_none();

source/blender/editors/sculpt_paint/paint_mask.cc

@@ -1648,8 +1648,7 @@ static void sculpt_gesture_trim_geometry_generate(SculptGestureContext *sgcontex
   }
 
   bke::mesh_smooth_set(*trim_operation->mesh, false);
-
-  BKE_mesh_calc_edges(trim_operation->mesh, false, false);
+  bke::mesh_calc_edges(*trim_operation->mesh, false, false);
   sculpt_gesture_trim_normals_update(sgcontext);
 }
 

source/blender/geometry/intern/mesh_primitive_cuboid.cc

@@ -292,8 +292,8 @@ static void calculate_corner_verts(const CuboidConfig &config, MutableSpan<int>
 static void calculate_uvs(const CuboidConfig &config, Mesh *mesh, const bke::AttributeIDRef &uv_id)
 {
   bke::MutableAttributeAccessor attributes = mesh->attributes_for_write();
-  bke::SpanAttributeWriter<float2> uv_attribute =
-      attributes.lookup_or_add_for_write_only_span<float2>(uv_id, bke::AttrDomain::Corner);
+  bke::SpanAttributeWriter uv_attribute = attributes.lookup_or_add_for_write_only_span<float2>(
+      uv_id, bke::AttrDomain::Corner);
   MutableSpan<float2> uvs = uv_attribute.span;
 
   int loop_index = 0;
@@ -381,7 +381,7 @@ Mesh *create_cuboid_mesh(const float3 &size,
   calculate_positions(config, positions);
   offset_indices::fill_constant_group_size(4, 0, mesh->face_offsets_for_write());
   calculate_corner_verts(config, corner_verts);
-  BKE_mesh_calc_edges(mesh, false, false);
+  bke::mesh_calc_edges(*mesh, false, false);
 
   if (uv_id) {
     calculate_uvs(config, mesh, uv_id);

source/blender/io/alembic/intern/abc_reader_mesh.cc

@@ -241,7 +241,7 @@ static void read_mpolys(CDStreamConfig &config, const AbcMeshData &mesh_data)
     }
   }
 
-  BKE_mesh_calc_edges(config.mesh, false, false);
+  bke::mesh_calc_edges(*config.mesh, false, false);
   if (seen_invalid_geometry) {
     if (config.modifier_error_message) {
       *config.modifier_error_message = "Mesh hash invalid geometry; more details on the console";

source/blender/io/collada/MeshImporter.cpp

@@ -1162,7 +1162,7 @@ bool MeshImporter::write_geometry(const COLLADAFW::Geometry *geom)
   blender::Vector<blender::float3> loop_normals;
   read_polys(mesh, blender_mesh, loop_normals);
 
-  BKE_mesh_calc_edges(blender_mesh, false, false);
+  blender::bke::mesh_calc_edges(*blender_mesh, false, false);
 
   /* We must apply custom normals after edges have been calculated, because
    * BKE_mesh_set_custom_normals()'s internals expect mesh->medge to be populated

source/blender/io/ply/importer/ply_import_mesh.cc

@@ -71,8 +71,8 @@ Mesh *convert_ply_to_mesh(PlyData &data, const PLYImportParams &params)
   /* Vertex colors */
   if (!data.vertex_colors.is_empty() && params.vertex_colors != PLY_VERTEX_COLOR_NONE) {
     /* Create a data layer for vertex colors and set them. */
-    bke::SpanAttributeWriter<ColorGeometry4f> colors =
-        attributes.lookup_or_add_for_write_span<ColorGeometry4f>("Col", bke::AttrDomain::Point);
+    bke::SpanAttributeWriter colors = attributes.lookup_or_add_for_write_span<ColorGeometry4f>(
+        "Col", bke::AttrDomain::Point);
 
     if (params.vertex_colors == PLY_VERTEX_COLOR_SRGB) {
       for (const int i : data.vertex_colors.index_range()) {
@@ -100,7 +100,7 @@ Mesh *convert_ply_to_mesh(PlyData &data, const PLYImportParams &params)
   }
 
   /* Calculate edges from the rest of the mesh. */
-  BKE_mesh_calc_edges(mesh, true, false);
+  bke::mesh_calc_edges(*mesh, true, false);
 
   /* If we have custom vertex normals, set them (note: important to do this
    * after initializing the loops). */

source/blender/io/stl/importer/stl_import_mesh.cc

@@ -82,7 +82,7 @@ Mesh *STLMeshHelper::to_mesh()
   array_utils::copy(tris_.as_span().cast<int>(), mesh->corner_verts_for_write());
 
   /* NOTE: edges must be calculated first before setting custom normals. */
-  BKE_mesh_calc_edges(mesh, false, false);
+  bke::mesh_calc_edges(*mesh, false, false);
 
   if (use_custom_normals_ && loop_normals_.size() == mesh->corners_num) {
     BKE_mesh_set_custom_normals(mesh, reinterpret_cast<float(*)[3]>(loop_normals_.data()));

source/blender/io/usd/intern/usd_reader_mesh.cc

@@ -357,7 +357,7 @@ void USDMeshReader::read_mpolys(Mesh *mesh)
     }
   }
 
-  BKE_mesh_calc_edges(mesh, false, false);
+  bke::mesh_calc_edges(*mesh, false, false);
 }
 
 template<typename T>

source/blender/io/usd/intern/usd_reader_shape.cc

@@ -159,7 +159,7 @@ Mesh *USDShapeReader::read_mesh(Mesh *existing_mesh,
     corner_verts[i] = face_indices[i];
   }
 
-  BKE_mesh_calc_edges(active_mesh, false, false);
+  bke::mesh_calc_edges(*active_mesh, false, false);
   return active_mesh;
 }
 

source/blender/io/wavefront_obj/importer/obj_import_mesh.cc

@@ -268,7 +268,7 @@ void MeshFromGeometry::create_edges(Mesh *mesh)
 
   /* Set argument `update` to true so that existing, explicitly imported edges can be merged
    * with the new ones created from polygons. */
-  BKE_mesh_calc_edges(mesh, true, false);
+  bke::mesh_calc_edges(*mesh, true, false);
 }
 
 void MeshFromGeometry::create_uv_verts(Mesh *mesh)

source/blender/makesrna/intern/rna_mesh_api.cc

@@ -168,7 +168,7 @@ static void rna_Mesh_update(Mesh *mesh,
                             const bool calc_edges_loose)
 {
   if (calc_edges || ((mesh->faces_num || mesh->totface_legacy) && mesh->edges_num == 0)) {
-    BKE_mesh_calc_edges(mesh, calc_edges, true);
+    blender::bke::mesh_calc_edges(*mesh, calc_edges, true);
   }
 
   if (calc_edges_loose) {

source/blender/modifiers/intern/MOD_ocean.cc

@@ -271,7 +271,7 @@ static Mesh *generate_ocean_geometry(OceanModifierData *omd, Mesh *mesh_orig, co
   /* create faces */
   BLI_task_parallel_range(0, gogd.res_y, &gogd, generate_ocean_geometry_faces, &settings);
 
-  BKE_mesh_calc_edges(result, false, false);
+  blender::bke::mesh_calc_edges(*result, false, false);
 
   /* add uvs */
   if (CustomData_number_of_layers(&result->corner_data, CD_PROP_FLOAT2) < MAX_MTFACE) {

source/blender/modifiers/intern/MOD_remesh.cc

@@ -200,7 +200,7 @@ static Mesh *modify_mesh(ModifierData *md, const ModifierEvalContext * /*ctx*/,
   bke::mesh_smooth_set(*result, rmd->flag & MOD_REMESH_SMOOTH_SHADING);
 
   BKE_mesh_copy_parameters_for_eval(result, mesh);
-  BKE_mesh_calc_edges(result, true, false);
+  bke::mesh_calc_edges(*result, true, false);
 
   blender::geometry::debug_randomize_mesh_order(result);
 

source/blender/nodes/geometry/nodes/node_geo_curve_fill.cc

@@ -247,7 +247,7 @@ static Mesh *cdts_to_mesh(const Span<meshintersect::CDT_result<double>> results)
 
   /* The delaunay triangulation doesn't seem to return all of the necessary all_edges, even in
    * triangulation mode. */
-  BKE_mesh_calc_edges(mesh, true, false);
+  bke::mesh_calc_edges(*mesh, true, false);
   bke::mesh_smooth_set(*mesh, false);
 
   mesh->tag_overlapping_none();

source/blender/nodes/geometry/nodes/node_geo_volume_to_mesh.cc

@@ -150,7 +150,7 @@ static Mesh *create_mesh_from_volume_grids(Span<const openvdb::GridBase *> grids
                                      corner_verts);
   }
 
-  BKE_mesh_calc_edges(mesh, false, false);
+  bke::mesh_calc_edges(*mesh, false, false);
   bke::mesh_smooth_set(*mesh, false);
 
   mesh->tag_overlapping_none();