346 [&](
const int face) {
347 return std::ranges::any_of(corner_verts.slice(faces[face]),
348 [&](const int vert) { return vert_affected[vert]; });
357 affected_faces.index_range(),
360 [&](
const IndexRange range,
int maybe_new_faces_num) {
361 affected_faces.slice(range).foreach_index([&](const int face_index) {
362 const IndexRange face = faces[face_index];
363 if (face.size() <= 5) {
367 int corner_ctx_num = 0;
368 for (const int corner : face) {
369 const int corner_next = bke::mesh::face_corner_next(face, corner);
370 if (vert_affected[corner_verts[corner]] || vert_affected[corner_verts[corner_next]]) {
374 if (corner_ctx_num > 1) {
375 maybe_new_faces_num += std::min(int(face.size() / 3), corner_ctx_num) - 1;
378 return maybe_new_faces_num;
382 Array<int> corner_next(corner_verts.size());
383 Array<int> face_to_weld_face(faces.size());
384 Vector<WeldFace> weld_faces;
385 weld_faces.reserve(affected_faces.size() + maybe_new_faces_num);
386 weld_faces.resize(affected_faces.size());
388 affected_faces.foreach_index(
389 [&](
const int face_index,
const int weld_face_index) {
390 const IndexRange face = faces[face_index];
391 for (
const int corner : face.drop_back(1)) {
392 corner_next[corner] = corner + 1;
394 corner_next[face.last()] = face.first();
396 WeldFace &weld_face = weld_faces[weld_face_index];
398 weld_face.face_src = face_index;
399 weld_face.corner_start = face.first();
400 weld_face.corner_end = face.last();
401 weld_face.corners_num = face.size();
402 face_to_weld_face[face_index] = weld_face_index;
404 exec_mode::grain_size(1024));
405 index_mask::masked_fill(face_to_weld_face.as_mutable_span(),
407 affected_faces.complement(faces.index_range(), memory));
409 r_weld_mesh->weld_faces = std::move(weld_faces);
410 r_weld_mesh->new_faces_num = 0;
411 r_weld_mesh->corner_next = std::move(corner_next);
412 r_weld_mesh->face_to_weld_face = std::move(face_to_weld_face);
430 int removed_corners_num = 0;
433 int corner_a_prev = corner_end;
436 const int vert_a = vert_src_to_target[corner_verts[corner_a]];
437 if (!vert_affected[vert_a]) {
439 corner_a_prev = corner_a;
440 corner_a = corner_next[corner_a];
445 int lb_prev = corner_a;
446 int corner_b = corner_next[corner_a];
448 const int vert_b = vert_src_to_target[corner_verts[corner_b]];
449 if (vert_a != vert_b) {
452 corner_b = corner_next[corner_b];
456 int dist_b = face_size - dist_a;
459 if (dist_a == 1 || dist_b == 1) {
462 else if (dist_a == 2 && dist_b == 2) {
464 removed_corners_num += 4;
467 r_removed.
faces += 1;
468 r_removed.
corners += removed_corners_num;
474 corner_next[corner_a_prev] = corner_b;
475 corner_next[lb_prev] = corner_a;
481 removed_corners_num += 2;
483 else if (dist_b == 2) {
484 removed_corners_num += 2;
493 r_weld_mesh->
weld_faces.increase_size_by_unchecked(1);
512 corner_b = corner_next[corner_b];
513 }
while (lb_prev != corner_end);
515 corner_a_prev = corner_a;
516 if (corner_a == corner_end) {
520 corner_a = corner_next[corner_a];
521 }
while (corner_a != corner_end);
523 r_removed.
corners += removed_corners_num;
526 weld_assert_face_no_vert_repetition(*r_wp, *r_weld_mesh);
950 const int removed_vertex_count,
951 const bool do_mix_data,
955#ifdef USE_WELD_DEBUG_TIME
964 const int src_verts_num =
mesh.verts_num;
965 const int src_edges_num =
mesh.edges_num;
971 mesh, vert_src_to_target, vert_affected, removed_vertex_count, &weld_mesh);
995 vert_src_to_target, vert_survivors, vert_src_to_dst, do_mix_data, mask_memory);
1022 weld_mesh.
edge_src_to_target, edge_survivors, edge_src_to_dst, do_mix_data, mask_memory);
1039 for (const int dst_edge_index : range) {
1040 const int2 src_edge = src_edges[edge_map.dst_to_src[dst_edge_index]];
1041 dst_edges[dst_edge_index] = int2(vert_src_to_dst[src_edge[0]], vert_src_to_dst[src_edge[1]]);
1048 const Span<int> corner_next = weld_mesh.corner_next;
1053 src_faces.index_range(),
1055 [&](
const int face) {
1056 const int face_ctx = weld_mesh.face_to_weld_face[face];
1057 return face_ctx == OUT_OF_CONTEXT || weld_faces[face_ctx].face_dst == OUT_OF_CONTEXT;
1063 [&](
const int weld_face) { return weld_faces[weld_face].face_dst == OUT_OF_CONTEXT; },
1069 [&](
const int src_face,
const int dst_face) {
1070 const int face_ctx = weld_mesh.face_to_weld_face[src_face];
1071 dst_face_offsets[dst_face] = face_ctx ==
OUT_OF_CONTEXT ? src_faces[src_face].size() :
1072 weld_faces[face_ctx].corners_num;
1074 exec_mode::grain_size(4096));
1076 [&](
const int weld_face,
const int pos) {
1077 dst_face_offsets[dst_new_faces[pos]] = weld_faces[weld_face].corners_num;
1079 exec_mode::grain_size(4096));
1080 if (!dst_face_offsets.is_empty()) {
1081 offset_indices::accumulate_counts_to_offsets(dst_face_offsets);
1083 const OffsetIndices dst_faces =
result->faces();
1084 BLI_assert(dst_faces.total_size() == dst_corners_num);
1088 const auto foreach_corner_in_group =
1089 [&](
const IndexRange src_face,
const int corner,
const auto &fn) {
1090 const int vert = vert_src_to_target[src_corner_verts[corner]];
1091 if (!vert_affected[vert]) {
1095 for (
const int group_corner : src_face) {
1096 if (vert_src_to_target[src_corner_verts[group_corner]] == vert) {
1104 Array<int> mixed_corner_offset_data(weld_faces.
size() + 1, 0);
1105 Array<int> mixed_source_offset_data(weld_faces.
size() + 1, 0);
1106 threading::parallel_for(weld_faces.
index_range(), 1024, [&](
const IndexRange range) {
1107 for (const int i : range) {
1108 const WeldFace &weld_face = weld_faces[i];
1109 if (weld_face.face_dst != OUT_OF_CONTEXT) {
1112 const IndexRange src_face = src_faces[weld_face.face_src];
1113 foreach_weld_face_corner(weld_face, corner_next, [&](const int corner) {
1115 foreach_corner_in_group(
1116 src_face, corner, [&](const int ) { group_size++; });
1117 if (group_size > 1) {
1118 mixed_corner_offset_data[i]++;
1119 mixed_source_offset_data[i] += group_size;
1124 const OffsetIndices mixed_corners_by_weld_face = offset_indices::accumulate_counts_to_offsets(
1125 mixed_corner_offset_data);
1126 const OffsetIndices mixed_sources_by_weld_face = offset_indices::accumulate_counts_to_offsets(
1127 mixed_source_offset_data);
1129 MergePropagationMap corner_map;
1130 corner_map.dst_to_src.reinitialize(dst_corners_num);
1131 Array<int> mixed_dst_corners(mixed_corners_by_weld_face.total_size());
1132 corner_map.mixed_offsets.reinitialize(mixed_corners_by_weld_face.total_size() + 1);
1133 corner_map.mixed_indices.reinitialize(mixed_sources_by_weld_face.total_size());
1134 corner_map.mixed_offsets.last() = corner_map.mixed_indices.size();
1136 const auto fill_weld_face = [&](
const int weld_face_index,
const IndexRange dst_face) {
1137 const WeldFace &weld_face = weld_faces[weld_face_index];
1138 const IndexRange src_face = src_faces[weld_face.face_src];
1139 int dst_corner = dst_face.start();
1140 int mixed_corner = mixed_corners_by_weld_face[weld_face_index].start();
1141 int mixed_source = mixed_sources_by_weld_face[weld_face_index].start();
1143 const int vert = vert_src_to_target[src_corner_verts[corner]];
1144 const int edge = weld_mesh.edge_src_to_target[src_corner_edges[corner]];
1145 dst_corner_verts[dst_corner] = vert_src_to_dst[
vert];
1146 dst_corner_edges[dst_corner] = edge_src_to_dst[edge];
1149 foreach_corner_in_group(src_face, corner, [&](
const int group_corner) {
1150 if (group_size++ == 0) {
1151 corner_map.dst_to_src[dst_corner] = group_corner;
1154 if (group_size > 1) {
1155 mixed_dst_corners[mixed_corner] = dst_corner;
1156 corner_map.mixed_offsets[mixed_corner] = mixed_source;
1157 foreach_corner_in_group(src_face, corner, [&](
const int group_corner) {
1158 corner_map.mixed_indices[mixed_source++] = group_corner;
1164 BLI_assert(dst_corner == dst_face.one_after_last());
1168 [&](
const int src_face_index,
const int dst_face_index) {
1169 const IndexRange dst_face = dst_faces[dst_face_index];
1170 const int face_ctx = weld_mesh.face_to_weld_face[src_face_index];
1172 fill_weld_face(face_ctx, dst_face);
1175 const IndexRange src_face = src_faces[src_face_index];
1176 for (
const int i : src_face.index_range()) {
1177 dst_corner_verts[dst_face[i]] = vert_src_to_dst[src_corner_verts[src_face[i]]];
1178 dst_corner_edges[dst_face[i]] = edge_src_to_dst[src_corner_edges[src_face[i]]];
1179 corner_map.dst_to_src[dst_face[i]] = src_face[i];
1182 exec_mode::grain_size(512));
1184 [&](
const int weld_face,
const int pos) {
1185 fill_weld_face(weld_face, dst_faces[dst_new_faces[pos]]);
1187 exec_mode::grain_size(512));
1188 corner_map.mixed = IndexMask::from_indices(mixed_dst_corners.as_span(), mask_memory);
1191 src_attributes.foreach_attribute([&](
const bke::AttributeIter &iter) {
1192 if (iter.domain != bke::AttrDomain::Face) {
1195 if (attribute_filter.allow_skip(iter.name)) {
1198 const bke::GAttributeReader src_attr = iter.get();
1199 const CommonVArrayInfo info = src_attr.varray.common_info();
1200 if (info.type == CommonVArrayInfo::Type::Single) {
1201 const bke::AttributeInitValue
init(GPointer(src_attr.varray.type(), info.data));
1202 if (dst_attributes.add(iter.name, iter.domain, iter.data_type,
init)) {
1206 if (kept_src_faces.
size() == src_faces.size() && dst_new_faces.is_empty() &&
1207 src_attr.sharing_info && src_attr.varray.is_span())
1209 const bke::AttributeInitShared
init(src_attr.varray.get_internal_span().data(),
1210 *src_attr.sharing_info);
1211 if (dst_attributes.add(iter.name, iter.domain, iter.data_type,
init)) {
1215 const CPPType &type = src_attr.varray.type();
1216 bke::GSpanAttributeWriter dst_attr = dst_attributes.lookup_or_add_for_write_only_span(
1217 iter.name, iter.domain, iter.data_type);
1218 array_utils::gather(
1219 src_attr.varray, kept_src_faces, dst_attr.span.take_front(kept_src_faces.
size()));
1220 GMutableSpan default_data = dst_attr.span.slice(dst_new_faces);
1221 type.fill_assign_n(type.default_value(), default_data.data(), default_data.size());
1229 &
result->face_data, CD_ORIGINDEX, CD_CONSTRUCT,
result->faces_num)),
1231 array_utils::gather(
1232 GSpan(src), kept_src_faces, GMutableSpan(dst.take_front(kept_src_faces.
size())));
1238 bke::AttrDomain::Corner,
1239 bke::attribute_filter_with_skip_ref(attribute_filter, {
".corner_vert",
".corner_edge"}),
1242 if (
const auto *src =
static_cast<const float2 *
>(
1246 &
result->corner_data, CD_ORIGSPACE_MLOOP, CD_CONSTRUCT,
result->corners_num));
1247 const Span src_span(src, mesh.corners_num);
1248 const MutableSpan dst_span(dst,
result->corners_num);
1249 array_utils::gather(src_span, corner_map.dst_to_src.as_span(), dst_span);
1250 const GroupedSpan<int> mixed_groups = corner_map.mixed_groups();
1251 bke::attribute_math::mix_groups(GSpan(src_span),
1252 mixed_groups.offsets,
1256 GMutableSpan(dst_span));
1264 for (
const int dst_corner : IndexRange(
result->corners_num)) {
1268 corner_map.dst_to_src[dst_corner],