Blender V5.3
mesh_split_edges.cc
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2023 Blender Authors
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later */
4
8
9#include "BLI_array_utils.hh"
10#include "BLI_index_mask.hh"
12#include "BLI_ordered_edge.hh"
13
14#include "BKE_attribute.hh"
15#include "BKE_attribute_math.hh"
17#include "BKE_customdata.hh"
18#include "BKE_deform.hh"
19#include "BKE_mesh.hh"
20#include "BKE_mesh_mapping.hh"
21
22#include "DNA_object_types.h"
23
24#include "GEO_mesh_selection.hh"
26#include "GEO_randomize.hh"
27
28namespace blender::geometry {
29
30static void propagate_vert_attributes(Mesh &mesh, const Span<int> new_to_old_verts_map)
31{
32 /* These types aren't supported for interpolation below. */
36 &mesh.vert_data, mesh.verts_num, mesh.verts_num + new_to_old_verts_map.size());
37 mesh.verts_num += new_to_old_verts_map.size();
38 mesh.attribute_storage.wrap().resize(bke::AttrDomain::Point, mesh.verts_num);
39
40 Set<StringRef> vertex_group_names;
41 for (bDeformGroup &group : mesh.vertex_group_names) {
42 vertex_group_names.add(group.name);
43 }
44 if (!vertex_group_names.is_empty() && !mesh.deform_verts().is_empty()) {
45 MutableSpan<MDeformVert> dverts = mesh.deform_verts_for_write();
47 dverts, new_to_old_verts_map, dverts.take_back(new_to_old_verts_map.size()));
48 }
49
50 bke::MutableAttributeAccessor attributes = mesh.attributes_for_write();
51 attributes.foreach_attribute([&](const bke::AttributeIter &iter) {
53 return;
54 }
55 if (iter.domain != bke::AttrDomain::Point) {
56 return;
57 }
58 if (iter.data_type == bke::AttrType::String) {
59 return;
60 }
61 if (vertex_group_names.contains(iter.name)) {
62 return;
63 }
65 if (!attribute) {
66 return;
67 }
69 new_to_old_verts_map,
70 attribute.span.take_back(new_to_old_verts_map.size()));
71 attribute.finish();
72 });
73 if (float3 *orco = static_cast<float3 *>(
74 CustomData_get_layer_for_write(&mesh.vert_data, CD_ORCO, mesh.verts_num)))
75 {
76 array_utils::gather(Span(orco, mesh.verts_num),
77 new_to_old_verts_map,
78 MutableSpan(orco, mesh.verts_num).take_back(new_to_old_verts_map.size()));
79 }
80 if (int *orig_indices = static_cast<int *>(
82 {
84 Span(orig_indices, mesh.verts_num),
85 new_to_old_verts_map,
86 MutableSpan(orig_indices, mesh.verts_num).take_back(new_to_old_verts_map.size()));
87 }
88}
89
90static void propagate_edge_attributes(Mesh &mesh, const Span<int> new_to_old_edge_map)
91{
92 CustomData_realloc(&mesh.edge_data, mesh.edges_num, mesh.edges_num + new_to_old_edge_map.size());
93 mesh.edges_num += new_to_old_edge_map.size();
94 mesh.attribute_storage.wrap().resize(bke::AttrDomain::Edge, mesh.edges_num);
95
96 bke::MutableAttributeAccessor attributes = mesh.attributes_for_write();
97 attributes.foreach_attribute([&](const bke::AttributeIter &iter) {
99 return;
100 }
101 if (iter.domain != bke::AttrDomain::Edge) {
102 return;
103 }
104 if (iter.data_type == bke::AttrType::String) {
105 return;
106 }
107 if (iter.name == ".edge_verts") {
108 /* Edge vertices are updated and combined with new edges separately. */
109 return;
110 }
112 if (!attribute) {
113 return;
114 }
116 attribute.span, new_to_old_edge_map, attribute.span.take_back(new_to_old_edge_map.size()));
117 attribute.finish();
118 });
119
120 if (int *orig_indices = static_cast<int *>(
121 CustomData_get_layer_for_write(&mesh.edge_data, CD_ORIGINDEX, mesh.edges_num)))
122 {
124 Span(orig_indices, mesh.edges_num),
125 new_to_old_edge_map,
126 MutableSpan(orig_indices, mesh.edges_num).take_back(new_to_old_edge_map.size()));
127 }
128}
129
137static int corner_on_edge_connected_to_vert(const Span<int> corner_verts,
138 const int corner,
139 const IndexRange face,
140 const int vert)
141{
142 if (corner_verts[corner] == vert) {
143 return corner;
144 }
145 const int other = bke::mesh::face_corner_next(face, corner);
146 BLI_assert(corner_verts[other] == vert);
147 return other;
148}
149
151
161 const Span<int> corner_verts,
162 const Span<int> corner_edges,
163 const GroupedSpan<int> edge_to_corner_map,
164 const Span<int> corner_to_face_map,
165 const BitSpan split_edges,
166 const Span<int> connected_corners,
167 const int vert)
168{
169 Vector<CornerGroup> groups;
170 /* Each corner should only be added to a single group. */
171 BitVector<> used_corners(connected_corners.size());
172 for (const int start_corner : connected_corners) {
173 CornerGroup group;
174 Vector<int> corner_stack({start_corner});
175 while (!corner_stack.is_empty()) {
176 const int corner = corner_stack.pop_last();
177 const int i = connected_corners.first_index(corner);
178 if (used_corners[i]) {
179 continue;
180 }
181 used_corners[i].set();
182 group.append(corner);
183 const int face = corner_to_face_map[corner];
184 const int prev_corner = bke::mesh::face_corner_prev(faces[face], corner);
185 /* Travel across the two edges neighboring this vertex, if they aren't split. */
186 for (const int edge : {corner_edges[corner], corner_edges[prev_corner]}) {
187 if (split_edges[edge]) {
188 continue;
189 }
190 for (const int other_corner : edge_to_corner_map[edge]) {
191 const int other_face = corner_to_face_map[other_corner];
192 if (other_face == face) {
193 /* Avoid continuing back to the same face. */
194 continue;
195 }
196 const int neighbor_corner = corner_on_edge_connected_to_vert(
197 corner_verts, other_corner, faces[other_face], vert);
198 corner_stack.append(neighbor_corner);
199 }
200 }
201 }
202 if (!group.is_empty()) {
203 groups.append(std::move(group));
204 }
205 }
206
207 return groups;
208}
209
210/* Calculate groups of corners that are contiguously connected to each input vertex.
211 * BLI_NOINLINE because MSVC 17.7 has a codegen bug here, given there is only a single call to this
212 * function, not inlining it for all platforms won't affect performance. See
213 * https://developercommunity.visualstudio.com/t/10448291 for details. */
215 const OffsetIndices<int> faces,
216 const Span<int> corner_verts,
217 const Span<int> corner_edges,
218 const GroupedSpan<int> vert_to_corner_map,
219 const GroupedSpan<int> edge_to_corner_map,
220 const Span<int> corner_to_face_map,
221 const BitSpan split_edges,
222 const IndexMask &affected_verts)
223{
224 Array<Vector<CornerGroup>> corner_groups(affected_verts.size(), NoInitialization());
225 affected_verts.foreach_index(
226 [&](const int vert, const int mask) {
227 new (&corner_groups[mask])
229 corner_verts,
230 corner_edges,
231 edge_to_corner_map,
232 corner_to_face_map,
234 vert_to_corner_map[vert],
235 vert));
236 },
238 return corner_groups;
239}
240
246
249 const BitSpan loose_edges,
250 const BitSpan split_edges,
251 const int vert)
252{
253 VertLooseEdges info;
254 for (const int edge : vert_to_edge_map[vert]) {
255 if (loose_edges[edge]) {
256 if (split_edges[edge]) {
257 info.selected.append(edge);
258 }
259 else {
260 info.unselected.append(edge);
261 }
262 }
263 }
264 return info;
265}
266
279 const IndexMask &affected_verts,
280 const Span<Vector<CornerGroup>> corner_groups,
281 const GroupedSpan<int> vert_to_edge_map,
282 const BitSpan loose_edges,
283 const BitSpan split_edges,
284 Array<int> &offset_data)
285{
286 offset_data.reinitialize(affected_verts.size() + 1);
287 MutableSpan<int> new_verts_nums = offset_data;
288 threading::parallel_for(affected_verts.index_range(), 2048, [&](const IndexRange range) {
289 /* Start with -1 for the reused vertex. None of the final sizes should be negative. */
290 new_verts_nums.slice(range).fill(-1);
291 for (const int i : range) {
292 new_verts_nums[i] += corner_groups[i].size();
293 }
294 });
295 if (!loose_edges.is_empty()) {
296 affected_verts.foreach_index(
297 [&](const int vert, const int mask) {
298 const VertLooseEdges info = calc_vert_loose_edges(
299 vert_to_edge_map, loose_edges, split_edges, vert);
300 new_verts_nums[mask] += info.selected.size();
301 if (corner_groups[mask].is_empty()) {
302 /* Loose edges share their vertex with a corner group if possible. */
303 new_verts_nums[mask] += info.unselected.size() > 0;
304 }
305 },
307 }
309}
310
316static void update_corner_verts(const int orig_verts_num,
317 const Span<Vector<CornerGroup>> corner_groups,
318 const OffsetIndices<int> new_verts_by_affected_vert,
319 MutableSpan<int> new_corner_verts)
320{
321 threading::parallel_for(corner_groups.index_range(), 512, [&](const IndexRange range) {
322 for (const int new_vert : range) {
323 const Span<CornerGroup> groups = corner_groups[new_vert];
324 const IndexRange new_verts = new_verts_by_affected_vert[new_vert];
325 for (const int group : groups.index_range().drop_back(1)) {
326 const int new_vert = orig_verts_num + new_verts[group];
327 new_corner_verts.fill_indices(groups[group].as_span(), new_vert);
328 }
329 }
330 });
331}
332
334 const Span<int> corner_verts,
335 const Span<int> corner_to_face_map,
336 const int corner)
337{
338 const int face = corner_to_face_map[corner];
339 const int corner_next = bke::mesh::face_corner_next(faces[face], corner);
340 return OrderedEdge(corner_verts[corner], corner_verts[corner_next]);
341}
342
351 const Span<int> corner_verts,
352 const GroupedSpan<int> edge_to_corner_map,
353 const Span<int> corner_to_face_map,
354 const IndexMask &selected_edges,
355 MutableSpan<int2> edges,
356 MutableSpan<int> corner_edges,
357 MutableSpan<int> r_new_edge_offsets)
358{
359 /* Calculate the offset of new edges assuming no new edges are identical and are merged. */
360 selected_edges.foreach_index_optimized<int>(
361 [&](const int edge, const int mask) {
362 r_new_edge_offsets[mask] = std::max<int>(edge_to_corner_map[edge].size() - 1, 0);
363 },
365 const OffsetIndices offsets = offset_indices::accumulate_counts_to_offsets(r_new_edge_offsets);
366
367 Array<int2> new_edges(offsets.total_size());
368
369 /* Count the number of final new edges per edge, to use as offsets if there are duplicates. */
370 Array<int> num_edges_per_edge_merged(r_new_edge_offsets.size());
371 std::atomic<bool> found_duplicate = false;
372
373 /* The first new edge for each selected edge is reused-- we modify the existing edge in
374 * place. Simply reusing the first new edge isn't enough because deduplication might make
375 * multiple new edges reuse the original. */
376 Array<bool> is_reused(corner_verts.size(), false);
377
378 /* Calculate per-original split edge deduplication of new edges, which are stored by the
379 * corner vertices of connected faces. Update corner verts to store the updated indices. */
380 selected_edges.foreach_index(
381 [&](const int edge, const int mask) {
382 if (edge_to_corner_map[edge].is_empty()) {
383 /* Handle loose edges. */
384 num_edges_per_edge_merged[mask] = 0;
385 return;
386 }
387
388 const int new_edges_start = offsets[mask].start();
389 Vector<OrderedEdge> deduplication;
390 for (const int corner : edge_to_corner_map[edge]) {
391 const OrderedEdge edge = edge_from_corner(
392 faces, corner_verts, corner_to_face_map, corner);
393 int index = deduplication.first_index_of_try(edge);
394 if (index != -1) [[unlikely]] {
395 found_duplicate.store(true, std::memory_order_relaxed);
396 }
397 else {
398 index = deduplication.append_and_get_index(edge);
399 }
400
401 if (index == 0) {
402 is_reused[corner] = true;
403 }
404 else {
405 corner_edges[corner] = edges.size() + new_edges_start + index - 1;
406 }
407 }
408
409 const int new_edges_num = deduplication.size() - 1;
410
411 edges[edge] = int2(deduplication.first().v_low, deduplication.first().v_high);
412 new_edges.as_mutable_span()
413 .slice(new_edges_start, new_edges_num)
414 .copy_from(deduplication.as_span().drop_front(1).cast<int2>());
415
416 num_edges_per_edge_merged[mask] = new_edges_num;
417 },
419
420 if (!found_duplicate) {
421 /* No edges were merged, we can use the existing output array and offsets. */
422 return new_edges;
423 }
424
425 /* Update corner edges to remove the "holes" left by merged new edges. */
427 num_edges_per_edge_merged);
428 selected_edges.foreach_index(
429 [&](const int edge, const int mask) {
430 const int difference = offsets[mask].start() - offsets_merged[mask].start();
431 for (const int corner : edge_to_corner_map[edge]) {
432 if (!is_reused[corner]) {
433 corner_edges[corner] -= difference;
434 }
435 }
436 },
438
439 /* Create new edges without the empty slots for the duplicates */
440 Array<int2> new_edges_merged(offsets_merged.total_size());
441 threading::parallel_for(offsets_merged.index_range(), 1024, [&](const IndexRange range) {
442 for (const int i : range) {
443 new_edges_merged.as_mutable_span()
444 .slice(offsets_merged[i])
445 .copy_from(new_edges.as_span().slice(offsets[i].start(), offsets_merged[i].size()));
446 }
447 });
448
449 r_new_edge_offsets.copy_from(num_edges_per_edge_merged);
450 return new_edges_merged;
451}
452
454 const Span<int> corner_verts,
455 const GroupedSpan<int> edge_to_corner_map,
456 const Span<int> corner_to_face_map,
457 const IndexMask &unselected_edges,
458 MutableSpan<int2> edges)
459{
460 unselected_edges.foreach_index(
461 [&](const int edge) {
462 const Span<int> edge_corners = edge_to_corner_map[edge];
463 if (edge_corners.is_empty()) {
464 return;
465 }
466 const int corner = edge_corners.first();
467 const OrderedEdge new_edge = edge_from_corner(
468 faces, corner_verts, corner_to_face_map, corner);
469 edges[edge] = int2(new_edge.v_low, new_edge.v_high);
470 },
472}
473
474static void swap_edge_vert(int2 &edge, const int old_vert, const int new_vert)
475{
476 if (edge[0] == old_vert) {
477 edge[0] = new_vert;
478 }
479 else if (edge[1] == old_vert) {
480 edge[1] = new_vert;
481 }
482}
483
489static void reassign_loose_edge_verts(const int orig_verts_num,
490 const IndexMask &affected_verts,
491 const GroupedSpan<int> vert_to_edge_map,
492 const BitSpan loose_edges,
493 const BitSpan split_edges,
494 const Span<Vector<CornerGroup>> corner_groups,
495 const OffsetIndices<int> new_verts_by_affected_vert,
496 MutableSpan<int2> edges)
497{
498 affected_verts.foreach_index(
499 [&](const int vert, const int mask) {
500 const IndexRange new_verts = new_verts_by_affected_vert[mask];
501 /* Account for the reuse of the original vertex by non-loose corner groups. In practice
502 * this means using the new vertices for each split loose edge until we run out of new
503 * vertices. We then expect the count to match up with the number of new vertices reserved
504 * by #calc_vert_ranges_per_old_vert. */
505 int new_vert_i = std::max<int>(corner_groups[mask].size() - 1, 0);
506 if (new_vert_i == new_verts.size()) {
507 return;
508 }
509 const VertLooseEdges vert_info = calc_vert_loose_edges(
510 vert_to_edge_map, loose_edges, split_edges, vert);
511 for (const int edge : vert_info.selected) {
512 const int new_vert = orig_verts_num + new_verts[new_vert_i];
513 swap_edge_vert(edges[edge], vert, new_vert);
514 new_vert_i++;
515 if (new_vert_i == new_verts.size()) {
516 return;
517 }
518 }
519 const int new_vert = orig_verts_num + new_verts[new_vert_i];
520 for (const int orig_edge : vert_info.unselected) {
521 swap_edge_vert(edges[orig_edge], vert, new_vert);
522 }
523 },
525}
526
532{
533 Array<int> map(offsets.total_size());
534 mask.foreach_index(
535 [&](const int i, const int mask) { map.as_mutable_span().slice(offsets[mask]).fill(i); },
537 return map;
538}
539
541 const IndexMask &selected_edges,
542 const bke::AttributeFilter & /*attribute_filter*/)
543{
544 const int orig_verts_num = mesh.verts_num;
545 const Span<int2> orig_edges = mesh.edges();
546 const OffsetIndices faces = mesh.faces();
547
548 IndexMaskMemory memory;
549 const IndexMask affected_verts = vert_selection_from_edge(
550 orig_edges, selected_edges, orig_verts_num, memory);
551 BitVector<> selection_bits(orig_edges.size());
552 selected_edges.to_bits(selection_bits);
553 const IndexMask &loose_edges = mesh.loose_edges();
554 BitVector<> loose_edge_bits;
555 if (!loose_edges.is_empty()) {
556 loose_edge_bits.resize(orig_edges.size());
557 loose_edges.to_bits(loose_edge_bits);
558 }
559
560 const GroupedSpan<int> vert_to_corner_map = mesh.vert_to_corner_map();
561
562 Array<int> edge_to_corner_offsets;
563 Array<int> edge_to_corner_indices;
564 const GroupedSpan<int> edge_to_corner_map = bke::mesh::build_edge_to_corner_map(
565 mesh.corner_edges(), orig_edges.size(), edge_to_corner_offsets, edge_to_corner_indices);
566
567 Array<int> vert_to_edge_offsets;
568 Array<int> vert_to_edge_indices;
569 GroupedSpan<int> vert_to_edge_map;
570 if (!loose_edges.is_empty()) {
571 vert_to_edge_map = bke::mesh::build_vert_to_edge_map(
572 orig_edges, orig_verts_num, vert_to_edge_offsets, vert_to_edge_indices);
573 }
574
575 const Array<int> corner_to_face_map = mesh.corner_to_face_map();
576
577 const Array<Vector<CornerGroup>> corner_groups = calc_all_corner_groups(faces,
578 mesh.corner_verts(),
579 mesh.corner_edges(),
580 vert_to_corner_map,
581 edge_to_corner_map,
582 corner_to_face_map,
583 selection_bits,
584 affected_verts);
585
586 Array<int> vert_new_vert_offset_data;
587 const OffsetIndices new_verts_by_affected_vert = calc_vert_ranges_per_old_vert(
588 affected_verts,
589 corner_groups,
590 vert_to_edge_map,
591 loose_edge_bits,
592 selection_bits,
593 vert_new_vert_offset_data);
594
595 MutableSpan<int> corner_verts = mesh.corner_verts_for_write();
596 update_corner_verts(orig_verts_num, corner_groups, new_verts_by_affected_vert, corner_verts);
597
598 Array<int> new_edge_offsets(selected_edges.size() + 1);
599 Array<int2> new_edges = calc_new_edges(faces,
600 corner_verts,
601 edge_to_corner_map,
602 corner_to_face_map,
603 selected_edges,
604 mesh.edges_for_write(),
605 mesh.corner_edges_for_write(),
606 new_edge_offsets);
607 const IndexMask unselected_edges = selected_edges.complement(orig_edges.index_range(), memory);
609 corner_verts,
610 edge_to_corner_map,
611 corner_to_face_map,
612 unselected_edges,
613 mesh.edges_for_write());
614
615 if (!loose_edges.is_empty()) {
616 reassign_loose_edge_verts(orig_verts_num,
617 affected_verts,
618 vert_to_edge_map,
619 loose_edge_bits,
620 selection_bits,
621 corner_groups,
622 new_verts_by_affected_vert,
623 mesh.edges_for_write());
624 }
625
626 const Array<int> edge_map = offsets_to_map(selected_edges, new_edge_offsets.as_span());
628 mesh.edges_for_write().take_back(new_edges.size()).copy_from(new_edges);
629
630 const Array<int> vert_map = offsets_to_map(affected_verts, new_verts_by_affected_vert);
632
633 mesh.tag_edges_split();
634
637}
638
639} // namespace blender::geometry
CustomData interface, see also DNA_customdata_types.h.
support for deformation groups and hooks.
Object is a sort of wrapper for general info.
#define BLI_NOINLINE
int64_t size() const
Definition BLI_array.hh:267
Span< T > as_span() const
Definition BLI_array.hh:254
MutableSpan< T > as_mutable_span()
Definition BLI_array.hh:259
void reinitialize(const int64_t new_size)
Definition BLI_array.hh:430
constexpr int64_t size() const
constexpr int64_t size() const
Definition BLI_span.hh:499
constexpr MutableSpan take_back(const int64_t n) const
Definition BLI_span.hh:646
bool contains(const Key &key) const
Definition BLI_set.hh:310
bool add(const Key &key)
Definition BLI_set.hh:248
bool is_empty() const
Definition BLI_set.hh:614
constexpr Span()=default
constexpr const T & first() const
Definition BLI_span.hh:319
constexpr int64_t first_index(const T &search_value) const
Definition BLI_span.hh:381
constexpr int64_t size() const
Definition BLI_span.hh:256
constexpr IndexRange index_range() const
Definition BLI_span.hh:405
constexpr bool is_empty() const
Definition BLI_span.hh:264
int64_t size() const
int64_t append_and_get_index(const T &value)
void append(const T &value)
bool is_empty() const
Span< T > as_span() const
const T & first() const
int64_t first_index_of_try(const T &value) const
void resize(const int64_t new_size_in_bits, const bool value=false)
void foreach_attribute(const FunctionRef< void(const AttributeIter &)> fn) const
std::optional< AttrStorageType > storage_type
GSpanAttributeWriter lookup_for_write_span(StringRef name)
void foreach_index_optimized(Fn &&fn, Mode mode=exec_mode::serial) const
void foreach_index(Fn &&fn, Mode mode=exec_mode::serial) const
void to_bits(MutableBitSpan r_bits, int64_t offset=0) const
IndexMask complement(const IndexMask &universe, LinearAllocator<> &memory) const
#define attribute(slot)
void gather(const GVArray &src, const IndexMask &indices, GMutableSpan dst, exec_mode::Mode mode=exec_mode::parallel)
void gather(GSpan src, Span< int > map, GMutableSpan dst)
GroupedSpan< int > build_edge_to_corner_map(Span< int > corner_edges, int edges_num, Array< int > &r_offsets, Array< int > &r_indices)
int face_corner_prev(const IndexRange face, const int corner)
Definition BKE_mesh.hh:306
int face_corner_next(const IndexRange face, const int corner)
Definition BKE_mesh.hh:315
GroupedSpan< int > build_vert_to_edge_map(Span< int2 > edges, int verts_num, Array< int > &r_offsets, Array< int > &r_indices)
void gather_deform_verts(Span< MDeformVert > src, Span< int > indices, MutableSpan< MDeformVert > dst)
Definition deform.cc:1774
constexpr ParallelGrainSize grain_size(int grain_size)
void debug_randomize_edge_order(Mesh *mesh)
Definition randomize.cc:138
static Array< int > offsets_to_map(const IndexMask &mask, const OffsetIndices< int > offsets)
static Vector< CornerGroup > calc_corner_groups_for_vertex(const OffsetIndices< int > faces, const Span< int > corner_verts, const Span< int > corner_edges, const GroupedSpan< int > edge_to_corner_map, const Span< int > corner_to_face_map, const BitSpan split_edges, const Span< int > connected_corners, const int vert)
static void reassign_loose_edge_verts(const int orig_verts_num, const IndexMask &affected_verts, const GroupedSpan< int > vert_to_edge_map, const BitSpan loose_edges, const BitSpan split_edges, const Span< Vector< CornerGroup > > corner_groups, const OffsetIndices< int > new_verts_by_affected_vert, MutableSpan< int2 > edges)
static Array< int2 > calc_new_edges(const OffsetIndices< int > faces, const Span< int > corner_verts, const GroupedSpan< int > edge_to_corner_map, const Span< int > corner_to_face_map, const IndexMask &selected_edges, MutableSpan< int2 > edges, MutableSpan< int > corner_edges, MutableSpan< int > r_new_edge_offsets)
static void propagate_vert_attributes(Mesh &mesh, const Span< int > new_to_old_verts_map)
Vector< int > CornerGroup
static OrderedEdge edge_from_corner(const OffsetIndices< int > faces, const Span< int > corner_verts, const Span< int > corner_to_face_map, const int corner)
static BLI_NOINLINE Array< Vector< CornerGroup > > calc_all_corner_groups(const OffsetIndices< int > faces, const Span< int > corner_verts, const Span< int > corner_edges, const GroupedSpan< int > vert_to_corner_map, const GroupedSpan< int > edge_to_corner_map, const Span< int > corner_to_face_map, const BitSpan split_edges, const IndexMask &affected_verts)
static OffsetIndices< int > calc_vert_ranges_per_old_vert(const IndexMask &affected_verts, const Span< Vector< CornerGroup > > corner_groups, const GroupedSpan< int > vert_to_edge_map, const BitSpan loose_edges, const BitSpan split_edges, Array< int > &offset_data)
void debug_randomize_vert_order(Mesh *mesh)
Definition randomize.cc:115
static VertLooseEdges calc_vert_loose_edges(const GroupedSpan< int > vert_to_edge_map, const BitSpan loose_edges, const BitSpan split_edges, const int vert)
static void swap_edge_vert(int2 &edge, const int old_vert, const int new_vert)
void split_edges(Mesh &mesh, const IndexMask &selected_edges, const bke::AttributeFilter &attribute_filter={})
static int corner_on_edge_connected_to_vert(const Span< int > corner_verts, const int corner, const IndexRange face, const int vert)
static void update_unselected_edges(const OffsetIndices< int > faces, const Span< int > corner_verts, const GroupedSpan< int > edge_to_corner_map, const Span< int > corner_to_face_map, const IndexMask &unselected_edges, MutableSpan< int2 > edges)
static void propagate_edge_attributes(Mesh &mesh, const Span< int > new_to_old_edge_map)
IndexMask vert_selection_from_edge(Span< int2 > edges, const IndexMask &edge_mask, int verts_num, IndexMaskMemory &memory)
static void update_corner_verts(const int orig_verts_num, const Span< Vector< CornerGroup > > corner_groups, const OffsetIndices< int > new_verts_by_affected_vert, MutableSpan< int > new_corner_verts)
OffsetIndices< int > accumulate_counts_to_offsets(MutableSpan< int > counts_to_offsets, int start_offset=0)
void parallel_for(const IndexRange range, const int64_t grain_size, const Function &function, const TaskSizeHints &size_hints=detail::TaskSizeHints_Static(1))
Definition BLI_task.hh:69
BLI_assert(slot->slot_subtype.map==BMO_OP_SLOT_SUBTYPE_MAP_FLT)
bool CustomData_free_layers(CustomData *data, eCustomDataType type)
void CustomData_realloc(CustomData *data, int old_size, int new_size, eCDAllocType alloctype=CD_CONSTRUCT)
VecBase< int32_t, 2 > int2
void * CustomData_get_layer_for_write(CustomData *data, eCustomDataType type, int totelem)
VecBase< float, 3 > float3