Mesh: Rewrite and fix split edges code

Saves about 100ms out of 550

@@ -74,3 +69,3 @@
       continue;
     }
-    if (id.is_anonymous() && !propagation_info.propagate(id.anonymous_id())) {
+    if (id.name() == ".edge_verts") {

@@ -159,3 +107,1 @@
-                                 const Span<Vector<int>> edge_to_loop_map,
-                                 MutableSpan<int> corner_verts,
-                                 MutableSpan<int> new_to_old_verts_map)
+static BitVector<> selection_to_bit_vector(const IndexMask &selection, const int universe_size)

@@ -294,3 +195,1 @@
-void split_edges(Mesh &mesh,
-                 const IndexMask &mask,
-                 const bke::AnonymousAttributePropagationInfo &propagation_info)
+/* Calculate groups of edges that are contiguously connected to each input vertex. */

@@ -311,1 +220,3 @@
-    vert_to_edge_map[edges[i][1]].append(i);
+/** Selected and unselected loose edges attached to a vertex. */
+struct VertLooseEdges {
+  Vector<int> split;

@@ -343,1 +246,3 @@
-  threading::parallel_for(edges.index_range(), 512, [&](const IndexRange range) {
+/**
+ * Every affected vertex maps to potentially multiple output vertices. Create a mapping from
+ * affected vertex index to the of output vertex (indices are to those sets, not indices in arrays

@@ -344,0 +262,4 @@
+{
+  offset_data.reinitialize(affected_verts.size() + 1);
+  threading::parallel_for(affected_verts.index_range(), 2048, [&](const IndexRange range) {
+    offset_data.as_mutable_span().slice(range).fill(-1);

@@ -360,2 +284,2 @@
-      vert_to_edge_map[edge[0]].append(duplicate_i);
-      vert_to_edge_map[edge[1]].append(duplicate_i);
+/**
+ * Update corner verts so that each fan of edges gets its own vertex. For the last "new vertex" we

@@ -427,0 +457,4 @@
+
+  Array<int> vert_to_corner_offsets;
+  Array<int> vert_to_corner_indices;
+  const GroupedSpan<int> vert_to_corner_map = bke::mesh::build_vert_to_loop_map(

@@ -444,2 +533,4 @@
 
   BKE_mesh_tag_edges_split(&mesh);
+
+  BLI_assert(BKE_mesh_is_valid(&mesh));

@@ -197,2 +132,4 @@
+  return other;
 }
 
+using CornerFan = Vector<int>;

@@ -198,2 +134,4 @@
 
+using CornerFan = Vector<int>;
+
 /**

@@ -344,0 +262,4 @@
+                                                        const BitSpan split_edges,
+                                                        Array<int> &offset_data)
+{
+  offset_data.reinitialize(affected_verts.size() + 1);

@@ -344,0 +264,4 @@
+{
+  offset_data.reinitialize(affected_verts.size() + 1);
+  threading::parallel_for(affected_verts.index_range(), 2048, [&](const IndexRange range) {
+    /* Start with -1 for the reused vertex. None of the final sizes should be negative. */

@@ -344,0 +265,4 @@
+  offset_data.reinitialize(affected_verts.size() + 1);
+  threading::parallel_for(affected_verts.index_range(), 2048, [&](const IndexRange range) {
+    /* Start with -1 for the reused vertex. None of the final sizes should be negative. */
+    offset_data.as_mutable_span().slice(range).fill(-1);

@@ -366,0 +313,4 @@
+ * indices. Using this fact we can avoid the need to use a more expensive data structure to
+ * deduplicate the result edges.
+ */
+static BitVector<> calc_merged_new_edges(const int orig_verts_num,

@@ -373,0 +348,4 @@
+                                  const BitSpan output_single_edge,
+                                  MutableSpan<int2> edges,
+                                  MutableSpan<int> corner_edges,
+                                  Vector<int2> &new_edges,

@@ -383,2 +376,3 @@
     }
-  });
+  }
+  return new_edges;

@@ -332,0 +340,4 @@
+                                  const IndexMask &selected_edges,
+                                  MutableSpan<int2> edges,
+                                  MutableSpan<int> corner_edges,
+                                  MutableSpan<int> r_new_edge_offsets)

@@ -343,3 +352,1 @@
-  threading::parallel_for(edges.index_range(), 512, [&](const IndexRange range) {
-    for (const int i : range) {
-      edge_to_loop_map[i].extend(orig_edge_to_loop_map[i]);
+  offsets_no_merge.last() = no_merge_count;

@@ -346,0 +353,4 @@
+
+  Array<int2> no_merge_new_edges(no_merge_count);
+
+  /* The first new edge for each selected edge is reused, instead we modify the existing edge in

@@ -359,3 +403,1 @@
-    for (const int duplicate_i : IndexRange(edge_offsets[edge_i], num_edge_duplicates[edge_i])) {
-      vert_to_edge_map[edge[0]].append(duplicate_i);
-      vert_to_edge_map[edge[1]].append(duplicate_i);
+  if (merged_offsets.total_size() == no_merge_new_edges.size()) {

@@ -425,2 +491,2 @@
-      corner_edges[corner] = new_edges.index_of_or_add_as(OrderedEdge(vert_1, vert_2));
-    }
+/**
+ * Transform the #OffsetIndices storage of new vertices per source vertex into a more