149 if (faces_num == 0 && verts_num != 0) {
155 const short mat_nr_max = mat_nrs - 1;
156 const short mat_ofs = mat_nrs > 1 ? smd->
mat_ofs : 0;
157 const short mat_ofs_rim = mat_nrs > 1 ? smd->
mat_ofs_rim : 0;
166 const float ofs_front_clamped =
clamp_nonzero(ofs_front, 1e-5f);
167 const float ofs_back_clamped =
clamp_nonzero(ofs_back, 1e-5f);
200 const VArraySpan orig_vert_bweight = *orig_attributes.
lookup<
float>(
"bevel_weight_vert",
202 const VArraySpan orig_edge_bweight = *orig_attributes.
lookup<
float>(
"bevel_weight_edge",
204 const VArraySpan orig_edge_crease = *orig_attributes.
lookup<
float>(
"crease_edge",
207 uint new_verts_num = 0;
208 uint new_edges_num = 0;
209 uint new_loops_num = 0;
210 uint new_faces_num = 0;
212#define MOD_SOLIDIFY_EMPTY_TAG uint(-1)
222 uint largest_ngon = 3;
229 const int2 &edge = orig_edges[orig_corner_edges[face.
start()]];
231 sub_v3_v3v3(edgedir, orig_vert_positions[edge[1]], orig_vert_positions[edge[0]]);
233 face_nors[i][2] = 1.0f;
236 face_nors[i][1] = 1.0f;
239 null_faces[i] =
true;
246 new_face_ref_a.
face = face;
250 face_sides_arr[i * 2] = std::move(new_face_ref_a);
255 new_face_ref_b.
face = face;
259 face_sides_arr[i * 2 + 1] = std::move(new_face_ref_b);
261 if (face.
size() > largest_ngon) {
267 new_loops_num +=
uint(face.
size() * 2);
276 for (
const int64_t edge : orig_corner_edges.
slice(orig_faces[i])) {
277 edge_adj_faces_len[edge]++;
290 for (
uint i = 0; i < verts_num; i++) {
298 bool has_singularities =
false;
305 for (
uint i = 0; i < verts_num; i++) {
306 orig_mvert_co[i][0] = orig_vert_positions[i][0];
307 orig_mvert_co[i][1] = orig_vert_positions[i][1];
308 orig_mvert_co[i][2] = orig_vert_positions[i][2];
318 for (
const int64_t corner : orig_faces[i]) {
319 const int vert = orig_corner_verts[corner];
320 const int edge = orig_corner_edges[corner];
321 const bool reversed = orig_edges[edge][1] != vert;
323 if (old_face_edge_ref ==
nullptr) {
324 const uint len = edge_adj_faces_len[edge];
328 adj_faces[0] =
uint(i);
329 for (
uint k = 1; k <
len; k++) {
332 adj_faces_reversed[0] = reversed;
335 edge_adj_faces[edge] = ref;
350 float edgedir[3] = {0, 0, 0};
360 for (
uint i = 0; i < edges_num; i++) {
361 const int2 &edge = orig_edges[i];
362 if (edge_adj_faces_len[i] > 0) {
363 uint v1 = vm[edge[0]];
375 if (orig_edge_lengths[i] <= merge_tolerance_sqr) {
379 bool can_merge =
true;
380 for (
uint k = 0; k < edges_num && can_merge; k++) {
381 if (k != i && edge_adj_faces_len[k] > 0 &&
382 (
ELEM(vm[orig_edges[k][0]], v1,
v2) !=
ELEM(vm[orig_edges[k][1]], v1,
v2)))
384 for (
uint j = 0; j < edge_adj_faces[k]->
faces_len && can_merge; j++) {
402 bool has_multiple_unique_others =
false;
405 int cur = face.
size() - 1;
406 for (
int next = 0; next < face.
size() && changes <= 2; next++) {
407 uint cur_v = vm[orig_corner_verts[face[cur]]];
408 uint next_v = vm[orig_corner_verts[face[next]]];
409 changes += (
ELEM(cur_v, v1,
v2) !=
ELEM(next_v, v1,
v2));
410 if (!
ELEM(cur_v, v1,
v2)) {
412 unique_other_vert = cur_v;
414 else if (unique_other_vert != cur_v) {
415 has_multiple_unique_others =
true;
420 can_merge = can_merge && changes <= 2 &&
421 !(changes == 2 && has_multiple_unique_others ==
false);
427 orig_edge_lengths[i] = 0.0f;
428 vert_adj_edges_len[v1]++;
429 vert_adj_edges_len[
v2]++;
434 (combined_verts[
v2] + 1) /
435 float(combined_verts[v1] + combined_verts[
v2] + 2));
437 for (
uint j =
v2; j < verts_num; j++) {
442 vert_adj_edges_len[v1] += vert_adj_edges_len[
v2];
443 vert_adj_edges_len[
v2] = 0;
444 combined_verts[v1] += combined_verts[
v2] + 1;
447 new_loops_num -= edge_adj_faces_len[i] * 2;
450 edge_adj_faces_len[i] = 0;
451 MEM_delete(edge_adj_faces[i]->faces);
452 MEM_delete(edge_adj_faces[i]->faces_reversed);
453 MEM_delete(edge_adj_faces[i]);
454 edge_adj_faces[i] =
nullptr;
457 orig_edge_lengths[i] =
sqrtf(orig_edge_lengths[i]);
458 vert_adj_edges_len[v1]++;
459 vert_adj_edges_len[
v2]++;
464 for (
uint i = 0; i < edges_num; i++) {
465 const int2 &edge = orig_edges[i];
466 const uint v1 = vm[edge[0]];
467 const uint v2 = vm[edge[1]];
468 if (v1 ==
v2 && edge_adj_faces[i]) {
471 const uint face = edge_adj_faces[i]->
faces[j];
472 if (!face_singularity[face]) {
473 bool is_singularity =
true;
474 for (
const int vert : orig_corner_verts.
slice(orig_faces[face])) {
475 if (vm[vert] != v1) {
476 is_singularity =
false;
480 if (is_singularity) {
481 face_singularity[face] =
true;
491 new_loops_num -= edge_adj_faces_len[i] * 2;
494 edge_adj_faces_len[i] = 0;
495 MEM_delete(edge_adj_faces[i]->faces);
496 MEM_delete(edge_adj_faces[i]->faces_reversed);
497 MEM_delete(edge_adj_faces[i]);
498 edge_adj_faces[i] =
nullptr;
502 MEM_delete(face_singularity);
503 MEM_delete(combined_verts);
508 for (
uint i = 0; i < edges_num; i++) {
509 const int2 &edge = orig_edges[i];
510 if (edge_adj_faces_len[i] > 0) {
511 const int vs[2] = {int(vm[edge[0]]), int(vm[edge[1]])};
512 uint invalid_edge_index = 0;
513 bool invalid_edge_reversed =
false;
514 for (
uint j = 0; j < 2; j++) {
515 const int vert = vs[j];
516 const uint len = vert_adj_edges_len[vert];
519 if (old_edge_vert_ref ==
nullptr) {
522 for (
uint k = 1; k <
len; k++) {
527 vert_adj_edges[vert] = ref;
531 const uint edge = old_edge_vert_ref->
edges[k];
533 old_edge_vert_ref->
edges[k] = i;
537 if (vm[orig_edges[edge][0]] == vs[1 - j]) {
538 invalid_edge_index = edge + 1;
539 invalid_edge_reversed = (j == 0);
542 if (vm[orig_edges[edge][1]] == vs[1 - j]) {
543 invalid_edge_index = edge + 1;
544 invalid_edge_reversed = (j == 1);
548 if (invalid_edge_index) {
559 if (invalid_edge_index) {
560 const uint tmp = invalid_edge_index - 1;
561 invalid_edge_index = i;
564 OldEdgeFaceRef *invalid_adj_faces = edge_adj_faces[invalid_edge_index];
568 if (i_adj_faces->
faces[k] == invalid_adj_faces->
faces[
l] &&
579 new_faces_num -= 2 * j;
580 new_loops_num -= 4 * j;
589 adj_faces[j] = i_adj_faces->
faces[k];
595 adj_faces[j] = invalid_adj_faces->
faces[k];
596 adj_faces_loops_reversed[j++] = (invalid_edge_reversed !=
601 edge_adj_faces_len[invalid_edge_index] = 0;
602 edge_adj_faces_len[i] =
len;
603 MEM_delete(i_adj_faces->
faces);
606 i_adj_faces->
faces = adj_faces;
608 i_adj_faces->
used += invalid_adj_faces->
used;
609 MEM_delete(invalid_adj_faces->
faces);
611 MEM_delete(invalid_adj_faces);
612 edge_adj_faces[invalid_edge_index] = i_adj_faces;
614 i = invalid_edge_index;
620 MEM_delete(vert_adj_edges_len);
626 for (
uint i = 0; i < edges_num; i++) {
627 if (edge_adj_faces_len[i] > 0) {
634 for (
uint j = 0; j < adj_len; j++) {
636 const int j_loopstart = orig_faces[face].start();
637 const int totloop = orig_faces[face].
size();
638 const uint j_first_v = vm[orig_corner_verts[j_loopstart]];
639 for (
uint k = j + 1; k < adj_len; k++) {
640 if (orig_faces[adj_faces->
faces[k]].
size() != totloop) {
644 const int k_loopstart = orig_faces[adj_faces->
faces[k]].start();
647 const int *corner_vert = &orig_corner_verts[k_loopstart];
648 for (
l = 0;
l < totloop && vm[*corner_vert] != j_first_v;
l++, corner_vert++) {
657 const int count_dir = reversed ? -1 : 1;
658 bool has_diff =
false;
659 for (
int m = 0, n =
l + totloop; m < totloop && !has_diff; m++, n += count_dir) {
660 const int vert = orig_corner_verts[j_loopstart + m];
661 has_diff = has_diff ||
662 vm[vert] != vm[orig_corner_verts[k_loopstart + n % totloop]];
667 for (
uint m = 0; m < totloop; m++) {
668 const int e = orig_corner_edges[j_loopstart + m];
672 uint *e_adj_faces_faces = e_adj_faces->
faces;
675 if (e_adj_faces_faces != adj_faces->
faces) {
678 face_index < faces_len && e_adj_faces_faces[face_index] != face;
684 if (face_index == faces_len) {
692 memmove(e_adj_faces_faces + face_index,
693 e_adj_faces_faces + face_index + 1,
694 (faces_len - face_index - 1) *
sizeof(*e_adj_faces_faces));
695 memmove(e_adj_faces_reversed + face_index,
696 e_adj_faces_reversed + face_index + 1,
697 (faces_len - face_index - 1) *
sizeof(*e_adj_faces_reversed));
699 if (edge_adj_faces_len[
e] > 0) {
700 edge_adj_faces_len[
e]--;
701 if (edge_adj_faces_len[
e] == 0) {
703 edge_adj_faces[
e] =
nullptr;
706 else if (e_adj_faces->
used > 1) {
707 for (
uint n = 0; n < edges_num; n++) {
708 if (edge_adj_faces[n] == e_adj_faces && edge_adj_faces_len[n] > 0) {
709 edge_adj_faces_len[n]--;
710 if (edge_adj_faces_len[n] == 0) {
711 edge_adj_faces[n]->
used--;
712 edge_adj_faces[n] =
nullptr;
723 new_loops_num -= 2 * del_loops;
736 for (
uint i = 0; i < edges_num; i++) {
737 const int2 &edge = orig_edges[i];
738 const uint v1 = vm[edge[0]];
739 const uint v2 = vm[edge[1]];
740 if (edge_adj_faces_len[i] > 0) {
741 if (orig_edge_lengths[i] >
FLT_EPSILON) [[likely]] {
743 mul_v3_fl(edgedir, 1.0f / orig_edge_lengths[i]);
755 for (
int j = 0; j < link1->
edges_len; j++) {
757 if (edge_adj_faces_len[
e] > 0 &&
e != i) {
759 vm[vm[orig_edges[
e][0]] == v1 ? orig_edges[
e][1] : orig_edges[
e][0]];
767 for (
int j = 0; j < link2->
edges_len; j++) {
769 if (edge_adj_faces_len[
e] > 0 &&
e != i) {
771 vm[vm[orig_edges[
e][0]] ==
v2 ? orig_edges[
e][1] : orig_edges[
e][0]];
787 const uint *adj_faces_faces = adj_faces->
faces;
789 uint new_edges_len = 0;
792 new_edges_len = adj_len;
794 float ref_nor[3] = {0, 0, 0};
796 for (
uint j = 0; j < adj_len; j++) {
797 const bool reverse = adj_faces_reversed[j];
798 const uint face_i = adj_faces_faces[j];
806 if (orig_faces[face_i].size() > 3) {
808 if (d != 0) [[likely]] {
815 if (d == 0.0f) [[unlikely]] {
816 sorted_faces[j].
angle = 0.0f;
820 sorted_faces[j].
angle = 0.0f;
826 sorted_faces[j].
face =
827 &face_sides_arr[adj_faces_faces[j] * 2 + (adj_faces_reversed[j] ? 1 : 0)];
835 sorted_faces[0].
face =
836 &face_sides_arr[adj_faces_faces[0] * 2 + (adj_faces_reversed[0] ? 1 : 0)];
847 new_edges[new_edges_len] =
nullptr;
849 for (
uint j = 0; j < new_edges_len; j++) {
852 const uint next_j = j + 1 == adj_len ? 0 : j + 1;
853 faces[0] = sorted_faces[j].
face;
854 faces[1] = sorted_faces[next_j].
face->
reversed ? sorted_faces[next_j].
face - 1 :
855 sorted_faces[next_j].
face + 1;
863 sorted_faces[0].
face + j;
869 if (do_shell || (adj_len == 1 && do_rim)) {
870 edge_data_edge_index = 0;
875 new_edge_ref.
faces[0] = faces[0];
876 new_edge_ref.
faces[1] = faces[1];
880 new_edge_ref.
new_edge = edge_data_edge_index;
881 *edge_data = new_edge_ref;
883 new_edges[j] = edge_data;
884 for (
uint k = 0; k < 2; k++) {
885 if (faces[k] !=
nullptr) {
887 const int edge = orig_corner_edges[faces[k]->
face.
start() +
l];
888 if (edge_adj_faces[edge] == edge_adj_faces[i]) {
889 if (edge != i && orig_edge_data_arr[edge] ==
nullptr) {
890 orig_edge_data_arr[edge] = new_edges;
892 faces[k]->link_edges[
l] = edge_data;
899 MEM_delete(sorted_faces);
900 orig_edge_data_arr[i] = new_edges;
901 if (do_shell || (adj_len == 1 && do_rim)) {
902 new_edges_num += new_edges_len;
908 for (
uint i = 0; i < edges_num; i++) {
909 if (edge_adj_faces[i]) {
910 if (edge_adj_faces[i]->used > 1) {
911 edge_adj_faces[i]->
used--;
914 MEM_delete(edge_adj_faces[i]->faces);
915 MEM_delete(edge_adj_faces[i]->faces_reversed);
916 MEM_delete(edge_adj_faces[i]);
920 MEM_delete(edge_adj_faces);
926 for (
uint i = 0; i < verts_num; i++, adj_edges_ptr++) {
927 if (*adj_edges_ptr !=
nullptr && (*adj_edges_ptr)->
edges_len >= 2) {
931 bool contains_long_groups =
false;
932 uint topo_groups = 0;
936 const uint *adj_edges = (*adj_edges_ptr)->edges;
937 const uint tot_adj_edges = (*adj_edges_ptr)->edges_len;
939 uint unassigned_edges_len = 0;
940 for (
uint j = 0; j < tot_adj_edges; j++) {
941 NewEdgeRef **new_edges = orig_edge_data_arr[adj_edges[j]];
947 unassigned_edges_len++;
953 unassigned_edges_len, __func__);
954 for (
uint j = 0, k = 0; j < tot_adj_edges; j++) {
955 NewEdgeRef **new_edges = orig_edge_data_arr[adj_edges[j]];
958 unassigned_edges[k++] = *new_edges;
966 uint edge_groups_len = unassigned_edges_len / 2;
969 uint assigned_edges_len = 0;
971 uint found_edge_index = 0;
972 bool insert_at_start =
false;
973 uint eg_capacity = 5;
974 NewFaceRef *eg_track_faces[2] = {
nullptr,
nullptr};
977 while (assigned_edges_len < unassigned_edges_len) {
978 found_edge =
nullptr;
979 insert_at_start =
false;
980 if (eg_index >= 0 && edge_groups[eg_index].edges_len == 0) {
986 while (!edge && j < unassigned_edges_len) {
987 edge = unassigned_edges[j++];
988 if (edge && last_open_edge_track &&
989 (edge->
faces[0] != last_open_edge_track || edge->
faces[1] !=
nullptr))
994 if (!edge && last_open_edge_track) {
996 last_open_edge_track =
nullptr;
999 while (!edge && j < unassigned_edges_len) {
1000 edge = unassigned_edges[j++];
1003 else if (!last_open_edge_track && eg_index > 0) {
1008 found_edge_index = j - 1;
1010 if (!last_open_edge_track && vm[orig_edges[edge->
old_edge][0]] == i) {
1011 eg_track_faces[0] = edge->
faces[0];
1012 eg_track_faces[1] = edge->
faces[1];
1013 if (edge->
faces[1] ==
nullptr) {
1019 eg_track_faces[0] = edge->
faces[1];
1020 eg_track_faces[1] = edge->
faces[0];
1023 else if (eg_index >= 0) {
1025 for (found_edge_index = 0; found_edge_index < unassigned_edges_len;
1026 found_edge_index++, edge_ptr++)
1030 if (edge->
faces[0] == eg_track_faces[1]) {
1031 insert_at_start =
false;
1032 eg_track_faces[1] = edge->
faces[1];
1034 if (edge->
faces[1] ==
nullptr) {
1041 if (edge->
faces[0] == eg_track_faces[0]) {
1042 insert_at_start =
true;
1043 eg_track_faces[0] = edge->
faces[1];
1045 if (edge->
faces[1] ==
nullptr) {
1050 if (edge->
faces[1] !=
nullptr) {
1051 if (edge->
faces[1] == eg_track_faces[1]) {
1052 insert_at_start =
false;
1053 eg_track_faces[1] = edge->
faces[0];
1057 if (edge->
faces[1] == eg_track_faces[0]) {
1058 insert_at_start =
true;
1059 eg_track_faces[0] = edge->
faces[0];
1068 unassigned_edges[found_edge_index] =
nullptr;
1069 assigned_edges_len++;
1070 const uint needed_capacity = edge_groups[eg_index].
edges_len + 1;
1071 if (needed_capacity > eg_capacity) {
1072 eg_capacity = needed_capacity + 1;
1074 if (insert_at_start) {
1076 edge_groups[eg_index].edges,
1077 edge_groups[eg_index].edges_len *
sizeof(*new_eg));
1081 edge_groups[eg_index].edges,
1082 edge_groups[eg_index].edges_len *
sizeof(*new_eg));
1084 MEM_delete(edge_groups[eg_index].edges);
1085 edge_groups[eg_index].
edges = new_eg;
1087 else if (insert_at_start) {
1088 memmove(edge_groups[eg_index].edges + 1,
1089 edge_groups[eg_index].edges,
1090 edge_groups[eg_index].edges_len *
sizeof(*edge_groups[eg_index].edges));
1092 edge_groups[eg_index].
edges[insert_at_start ? 0 : edge_groups[eg_index].
edges_len] =
1095 if (edge_groups[eg_index].edges[edge_groups[eg_index].edges_len - 1]->faces[1] !=
1098 last_open_edge_track =
nullptr;
1100 if (edge_groups[eg_index].edges_len > 3) {
1101 contains_long_groups =
true;
1113 edge_group.
valid =
true;
1114 edge_group.
edges = edges;
1119 edge_group.
split = 0;
1125 edge_groups[eg_index] = edge_group;
1127 eg_track_faces[0] =
nullptr;
1128 eg_track_faces[1] =
nullptr;
1136 MEM_delete(unassigned_edges);
1145 if (contains_long_groups) {
1147 for (
uint j = 0; j < eg_index; j++) {
1148 const uint edges_len = edge_groups[j + add_index].
edges_len;
1149 if (edges_len > 3) {
1150 bool has_doubles =
false;
1152 EdgeGroup g = edge_groups[j + add_index];
1153 for (
uint k = 0; k < edges_len; k++) {
1154 for (
uint l = k + 1;
l < edges_len;
l++) {
1163 const uint prior_splits = splits;
1164 const uint prior_index = add_index;
1165 int unique_start = -1;
1166 int first_unique_end = -1;
1167 int last_split = -1;
1168 int first_split = -1;
1169 bool first_even_split =
false;
1171 while (real_k < edges_len ||
1174 (first_unique_end == -1 ? 0 : first_unique_end) +
int(edges_len) ||
1175 first_split != last_split)))
1177 const uint k = real_k % edges_len;
1179 if (first_unique_end != -1 && unique_start == -1) {
1180 unique_start = int(real_k);
1183 else if (first_unique_end == -1) {
1184 first_unique_end = int(k);
1186 else if (unique_start != -1) {
1187 const uint split = ((
uint(unique_start) + real_k + 1) / 2) % edges_len;
1188 const bool is_even_split = ((
uint(unique_start) + real_k) & 1);
1189 if (last_split != -1) {
1191 if (prior_splits != splits) {
1192 memmove(edge_groups + j + add_index + 1,
1193 edge_groups + j + add_index,
1194 (
uint(eg_index) - j) *
sizeof(*edge_groups));
1197 if (last_split >
split) {
1198 const uint edges_len_group = (
split + edges_len) -
uint(last_split);
1200 edges_len_group, __func__);
1202 g.
edges + last_split,
1203 (edges_len -
uint(last_split)) *
sizeof(*edges));
1204 memcpy(edges + (edges_len -
uint(last_split)),
1206 split *
sizeof(*edges));
1209 edge_group.
valid =
true;
1210 edge_group.
edges = edges;
1221 edge_groups[j + add_index] = edge_group;
1226 edges_len_group, __func__);
1227 memcpy(edges, g.
edges + last_split, edges_len_group *
sizeof(*edges));
1230 edge_group.
valid =
true;
1231 edge_group.
edges = edges;
1242 edge_groups[j + add_index] = edge_group;
1246 last_split = int(
split);
1247 if (first_split == -1) {
1248 first_split = int(
split);
1249 first_even_split = is_even_split;
1255 if (first_split != -1) {
1257 if (prior_splits != splits) {
1258 memmove(edge_groups + (j + prior_index + 1),
1259 edge_groups + (j + prior_index),
1260 (
uint(eg_index) + add_index - (j + prior_index)) *
1261 sizeof(*edge_groups));
1262 memmove(edge_groups + (j + add_index + 2),
1263 edge_groups + (j + add_index + 1),
1264 (
uint(eg_index) - j) *
sizeof(*edge_groups));
1268 memmove(edge_groups + (j + add_index + 2),
1269 edge_groups + (j + add_index + 1),
1270 (
uint(eg_index) - j - 1) *
sizeof(*edge_groups));
1273 uint(first_split), __func__);
1274 memcpy(edges, g.
edges,
uint(first_split) *
sizeof(*edges));
1277 edge_group_a.
valid =
true;
1278 edge_group_a.
edges = edges;
1283 edge_group_a.
split = 1;
1289 edge_groups[j + prior_index] = edge_group_a;
1294 edges_len -
uint(last_split), __func__);
1296 g.
edges + last_split,
1297 (edges_len -
uint(last_split)) *
sizeof(*edges));
1300 edge_group_b.
valid =
true;
1301 edge_group_b.
edges = edges;
1306 edge_group_b.
split = add_index - prior_index + 1;
1312 edge_groups[j + add_index] = edge_group_b;
1314 if (prior_splits != splits) {
1315 MEM_delete(g.
edges);
1318 if (first_unique_end != -1 && prior_splits == splits) {
1319 has_singularities =
true;
1323 MEM_delete(doubles);
1329 orig_vert_groups_arr[i] = edge_groups;
1333 bool contains_open_splits =
false;
1334 uint open_edges = 0;
1335 uint contains_splits = 0;
1336 uint last_added = 0;
1337 uint first_added = 0;
1338 bool first_set =
false;
1341 for (
uint j = 0; j < g->edges_len; j++,
e++) {
1342 const uint flip =
uint(vm[orig_edges[(*e)->old_edge][1]] == i);
1343 BLI_assert(flip || vm[orig_edges[(*e)->old_edge][0]] == i);
1344 (*e)->link_edge_groups[flip] = g;
1347 if (do_shell || (do_rim && !g->is_orig_closed)) {
1349 g->new_vert = new_verts_num++;
1350 if (do_rim || (do_shell && g->split)) {
1352 contains_splits += (g->split != 0);
1353 contains_open_splits |= g->split && !g->is_orig_closed;
1357 open_edges +=
uint(added < last_added);
1360 first_added = added;
1363 if (!(g + 1)->valid || g->topo_group != (g + 1)->topo_group) {
1364 if (new_verts > 2) {
1366 new_edges_num += new_verts;
1367 open_edges +=
uint(first_added < last_added);
1368 open_edges -=
uint(open_edges && !contains_open_splits);
1369 if (do_shell && do_rim) {
1370 new_loops_num += new_verts * 2;
1372 else if (do_shell) {
1373 new_loops_num += new_verts * 2 - open_edges;
1376 new_loops_num += new_verts * 2 + open_edges - contains_splits;
1379 else if (new_verts == 2) {
1381 new_loops_num += 2u -
uint(!(do_rim && do_shell) && contains_open_splits);
1384 contains_open_splits =
false;
1385 contains_splits = 0;
1400 for (
OldVertEdgeRef **p = vert_adj_edges; i < verts_num; i++, p++) {
1402 MEM_delete((*p)->edges);
1406 MEM_delete(vert_adj_edges);
1416 float *face_weight =
nullptr;
1418 if (do_flat_faces) {
1422 float scalar_vgroup = 1.0f;
1423 for (
const int vert : orig_corner_verts.
slice(orig_faces[i])) {
1425 if (defgrp_invert) {
1433 scalar_vgroup = offset_fac_vg + (scalar_vgroup * offset_fac_vg_inv);
1434 face_weight[i] = scalar_vgroup;
1438 gs_ptr = orig_vert_groups_arr;
1439 for (
uint i = 0; i < verts_num; i++, gs_ptr++) {
1442 if (!g->is_singularity) {
1448 float move_nor[3] = {0, 0, 0};
1451 (g->is_orig_closed || g->split));
1452 bool approximate_free_direction =
false;
1460 uint queue_index = 0;
1462 float fallback_nor[3];
1463 float fallback_ofs = 0.0f;
1465 const bool cycle = (g->is_orig_closed && !g->split) || g->is_even_split;
1466 for (
uint k = 0; k < g->edges_len; k++, edge_ptr++) {
1467 if (!(k & 1) || (!cycle && k == g->edges_len - 1)) {
1469 for (
uint l = 0;
l < 2;
l++) {
1471 if (face && (first_edge ==
nullptr ||
1472 (first_edge->
faces[0] != face && first_edge->
faces[1] != face)))
1474 float ofs = face->
reversed ? ofs_back_clamped : ofs_front_clamped;
1476 if (do_flat_faces) {
1477 ofs *= face_weight[face->
index];
1480 if (!null_faces[face->
index]) {
1483 face_nors[face->
index],
1485 planes_queue[queue_index++][3] = ofs;
1495 if ((cycle && k == 0) || (!cycle && k + 3 >= g->edges_len)) {
1500 if (queue_index > 2) {
1505 for (
uint k = 0; k < queue_index; k++) {
1506 for (
uint m = k + 1; m < queue_index; m++) {
1507 float p =
dot_v3v3(planes_queue[k], planes_queue[m]);
1517 swap_v4_v4(planes_queue[min_n0], planes_queue[0]);
1518 swap_v4_v4(planes_queue[min_n1], planes_queue[1]);
1521 swap_v4_v4(planes_queue[min_n0], planes_queue[1]);
1526 float max_p = -1.0f;
1527 for (
uint k = 2; k < queue_index; k++) {
1529 dot_v3v3(planes_queue[1], planes_queue[k]));
1530 if (max_p <= min_p) {
1535 swap_v4_v4(planes_queue[min_n1], planes_queue[2]);
1538 while (queue_index > 2) {
1541 float best_p = -1.0f;
1542 float best_ofs_diff = 0.0f;
1543 for (
uint k = 0; k < queue_index; k++) {
1544 for (
uint m = k + 1; m < queue_index; m++) {
1545 float p =
dot_v3v3(planes_queue[m], planes_queue[k]);
1546 float ofs_diff =
fabsf(planes_queue[m][3] - planes_queue[k][3]);
1547 if (p > best_p +
FLT_EPSILON || (p >= best_p && ofs_diff < best_ofs_diff)) {
1549 best_ofs_diff = ofs_diff;
1557 if (best_p < 0.98f) {
1560 add_v3_v3(planes_queue[best_n0], planes_queue[best_n1]);
1562 planes_queue[best_n0][3] = (planes_queue[best_n0][3] + planes_queue[best_n1][3]) *
1565 memmove(planes_queue + best_n1,
1566 planes_queue + best_n1 + 1,
1567 (queue_index - best_n1) *
sizeof(*planes_queue));
1569 const uint size = queue_index;
1577 const float boundary_fix_threshold = 0.7f;
1582 for (
int k = 0; k < 3; k++) {
1583 for (
int m = 0; m < size; m++) {
1584 madd_v3_v3fl(mat[k], planes_queue[m], planes_queue[m][k]);
1594 for (
int k = 0; k < size; k++) {
1595 madd_v3_v3fl(nor, planes_queue[k], planes_queue[k][3]);
1599 if (!disable_boundary_fix) {
1601 float greatest_angle_cos = 1.0f;
1602 for (
uint k = 0; k < 2; k++) {
1603 for (
uint m = 2; m < size; m++) {
1604 float p =
dot_v3v3(planes_queue[m], planes_queue[k]);
1605 greatest_angle_cos = std::min(p, greatest_angle_cos);
1608 if (greatest_angle_cos > boundary_fix_threshold) {
1609 approximate_free_direction =
true;
1612 disable_boundary_fix =
true;
1616 else if (size > 1) {
1619 const float q =
dot_v3v3(planes_queue[0], planes_queue[1]);
1620 float d = 1.0f - q * q;
1625 mul_v3_fl(planes_queue[0], (planes_queue[0][3] - planes_queue[1][3] * q) * d);
1626 mul_v3_fl(planes_queue[1], (planes_queue[1][3] - planes_queue[0][3] * q) * d);
1629 d = 1.0f / (
fabsf(q) + 1.0f);
1630 mul_v3_fl(planes_queue[0], planes_queue[0][3] * d);
1631 mul_v3_fl(planes_queue[1], planes_queue[1][3] * d);
1633 add_v3_v3v3(nor, planes_queue[0], planes_queue[1]);
1635 d =
dot_v3v3(planes_queue[2], move_nor);
1638 if (
fabsf(d) > 0.02f) {
1644 if (
fabsf(d) > 1.0f - boundary_fix_threshold) {
1645 disable_boundary_fix =
true;
1649 approximate_free_direction =
false;
1651 else if (size == 1) {
1653 mul_v3_v3fl(nor, planes_queue[0], planes_queue[0][3]);
1654 if (g->edges_len > 2) {
1655 disable_boundary_fix =
true;
1656 approximate_free_direction =
true;
1662 disable_boundary_fix =
true;
1664 MEM_delete(planes_queue);
1668 float total_angle = 0;
1669 float total_angle_back = 0;
1673 float nor_back[3] = {0, 0, 0};
1674 bool has_back =
false;
1675 bool has_front =
false;
1676 bool cycle = (g->is_orig_closed && !g->split) || g->is_even_split;
1677 for (
uint k = 0; k < g->edges_len; k++, edge_ptr++) {
1678 if (!(k & 1) || (!cycle && k == g->edges_len - 1)) {
1680 for (
uint l = 0;
l < 2;
l++) {
1682 if (face && (first_edge ==
nullptr ||
1683 (first_edge->
faces[0] != face && first_edge->
faces[1] != face)))
1686 float ofs = face->
reversed ? -ofs_back_clamped : ofs_front_clamped;
1688 if (do_flat_faces) {
1689 ofs *= face_weight[face->
index];
1696 int corner = corner_next + (face->
face.
size() - 1);
1697 int corner_prev = corner - 1;
1700 m < face->
face.
size() && vm[orig_corner_verts[corner]] != i;
1703 corner_prev = corner;
1704 corner = corner_next;
1708 orig_mvert_co[vm[orig_corner_verts[corner_next]]]);
1710 total_angle_back +=
angle * ofs * ofs;
1713 total_angle +=
angle * ofs * ofs;
1735 if ((cycle && k == 0) || (!cycle && k + 3 >= g->edges_len)) {
1746 mul_v3_fl(nor, total_angle / length_sq);
1752 mul_v3_fl(nor_back, total_angle_back / length_sq);
1758 if (has_front && has_back) {
1759 float nor_length =
len_v3(nor);
1760 float nor_back_length =
len_v3(nor_back);
1763 q /= nor_length * nor_back_length;
1765 float d = 1.0f - q * q;
1769 mul_v3_fl(nor, (1 - nor_back_length * q / nor_length) * d);
1772 mul_v3_fl(nor_back, (1 - nor_length * q / nor_back_length) * d);
1788 mul_v3_fl(nor_back, 1.0f / total_angle_back);
1796 if (!disable_boundary_fix && g->edges_len > 2) {
1797 approximate_free_direction =
true;
1800 disable_boundary_fix =
true;
1803 if (approximate_free_direction) {
1808 for (k = 1; k + 1 < g->edges_len; k++, edge_ptr++) {
1809 const int2 &edge = orig_edges[(*edge_ptr)->old_edge];
1811 tmp, orig_mvert_co[vm[edge[0]] == i ? edge[1] : edge[0]], orig_mvert_co[i]);
1815 disable_boundary_fix =
true;
1822 if (!disable_boundary_fix) {
1824 float constr_nor[3];
1825 const int2 &e0_edge = orig_edges[g->edges[0]->old_edge];
1826 const int2 &e1_edge = orig_edges[g->edges[g->edges_len - 1]->old_edge];
1830 orig_mvert_co[vm[e0_edge[0]] == i ? e0_edge[1] : e0_edge[0]],
1833 orig_mvert_co[vm[e1_edge[0]] == i ? e1_edge[1] : e1_edge[0]],
1844 if (g->edges[0]->faces[0]->reversed) {
1845 negate_v3_v3(f0, face_nors[g->edges[0]->faces[0]->index]);
1848 copy_v3_v3(f0, face_nors[g->edges[0]->faces[0]->index]);
1850 if (g->edges[g->edges_len - 1]->faces[0]->reversed) {
1851 negate_v3_v3(f1, face_nors[g->edges[g->edges_len - 1]->faces[0]->index]);
1854 copy_v3_v3(f1, face_nors[g->edges[g->edges_len - 1]->faces[0]->index]);
1865 float d =
dot_v3v3(constr_nor, move_nor);
1867 if (
fabsf(d) > 0.1f) {
1872 float scalar_vgroup = 1;
1874 if (dvert && !do_flat_faces) {
1876 if (defgrp_invert) {
1882 scalar_vgroup = offset_fac_vg + (scalar_vgroup * offset_fac_vg_inv);
1886 if (do_angle_clamp) {
1887 if (g->edges_len > 2) {
1888 float min_length = 0;
1891 for (
NewEdgeRef **p = g->edges; k < g->edges_len; k++, p++) {
1892 float length = orig_edge_lengths[(*p)->old_edge];
1893 float e_ang = (*p)->angle;
1895 if (
length < min_length || k == 0) {
1901 float max_off = min_length * 0.5f / cos_ang;
1902 if (max_off < offset * 0.5f) {
1903 scalar_vgroup *= max_off / offset * 2;
1909 float min_length = 0;
1911 for (
NewEdgeRef **p = g->edges; k < g->edges_len; k++, p++) {
1912 float length = orig_edge_lengths[(*p)->old_edge];
1913 if (
length < min_length || k == 0) {
1917 if (min_length < offset) {
1918 scalar_vgroup *= min_length / offset;
1932 if (do_flat_faces) {
1933 MEM_delete(face_weight);
1937 MEM_delete(orig_mvert_co);
1939 MEM_delete(null_faces);
1946 uint(*singularity_edges)[2] =
nullptr;
1947 uint totsingularity = 0;
1948 if (has_singularities) {
1949 has_singularities =
false;
1951 uint singularity_edges_len = 1;
1953 for (
NewEdgeRef ***new_edges = orig_edge_data_arr; i < edges_num; i++, new_edges++) {
1954 if (*new_edges && (do_shell || edge_adj_faces_len[i] == 1) && (**new_edges)->old_edge == i) {
1956 if ((*l)->link_edge_groups[0]->is_singularity &&
1957 (*l)->link_edge_groups[1]->is_singularity)
1959 const uint v1 = (*l)->link_edge_groups[0]->new_vert;
1960 const uint v2 = (*l)->link_edge_groups[1]->new_vert;
1961 bool exists_already =
false;
1963 for (
uint(*p)[2] = singularity_edges; j < totsingularity; p++, j++) {
1964 if (((*p)[0] == v1 && (*p)[1] ==
v2) || ((*p)[0] ==
v2 && (*p)[1] == v1)) {
1965 exists_already =
true;
1969 if (!exists_already) {
1970 has_singularities =
true;
1971 if (singularity_edges_len <= totsingularity) {
1972 singularity_edges_len = totsingularity + 1;
1975 singularity_edges_len *
sizeof(*singularity_edges),
1978 singularity_edges[totsingularity][0] = v1;
1979 singularity_edges[totsingularity][1] =
v2;
1981 if (edge_adj_faces_len[i] == 1 && do_rim) {
1997 mesh,
int(new_verts_num),
int(new_edges_num),
int(new_faces_num),
int(new_loops_num));
2006 const VArraySpan src_material_index = *orig_attributes.
lookup<
int>(
"material_index",
2011 int *origindex_edge =
static_cast<int *
>(
2013 int *origindex_face =
static_cast<int *
>(
2017 if (orig_attributes.
contains(
"bevel_weight_edge") ||
2018 (bevel_convex != 0.0f || !orig_vert_bweight.
is_empty()))
2026 if (shell_defgrp_index != -1 || rim_defgrp_index != -1) {
2027 dst_dvert =
result->deform_verts_for_write().data();
2032 const VArraySpan vertex_crease = *orig_attributes.
lookup<
float>(
"crease_vert",
2036 if (!vertex_crease.
is_empty() || !orig_edge_crease.is_empty()) {
2041 result_attributes.
remove(
"crease_vert");
2052 gs_ptr = orig_vert_groups_arr;
2053 for (
uint i = 0; i < verts_num; i++, gs_ptr++) {
2058 vert_interp.
copy(
int(i),
int(g->new_vert), 1);
2059 copy_v3_v3(vert_positions[g->new_vert], g->co);
2069 edge_index += totsingularity;
2070 for (
NewEdgeRef ***new_edges = orig_edge_data_arr; i < edges_num; i++, new_edges++) {
2071 if (*new_edges && (do_shell || edge_adj_faces_len[i] == 1) && (**new_edges)->old_edge == i) {
2074 const uint v1 = (*l)->link_edge_groups[0]->new_vert;
2075 const uint v2 = (*l)->link_edge_groups[1]->new_vert;
2077 if (has_singularities && ((*l)->link_edge_groups[0]->is_singularity &&
2078 (*l)->link_edge_groups[1]->is_singularity))
2081 for (
uint(*p)[2] = singularity_edges; j < totsingularity; p++, j++) {
2082 if (((*p)[0] == v1 && (*p)[1] ==
v2) || ((*p)[0] ==
v2 && (*p)[1] == v1)) {
2097 if (result_edge_crease) {
2098 result_edge_crease.span[
insert] = !orig_edge_crease.is_empty() ?
2099 orig_edge_crease[(*l)->old_edge] :
2102 if (result_edge_bweight) {
2103 result_edge_bweight.
span[
insert] = !orig_edge_bweight.is_empty() ?
2104 orig_edge_bweight[(*l)->old_edge] :
2106 if (bevel_convex != 0.0f && (*l)->faces[1] !=
nullptr) {
2110 clamp_f(bevel_convex, 0.0f, 1.0f) :
2112 clamp_f(bevel_convex, -1.0f, 0.0f) :
2124 if (singularity_edges) {
2125 MEM_delete(singularity_edges);
2147 gs_ptr = orig_vert_groups_arr;
2148 for (
uint i = 0; i < verts_num; i++, gs_ptr++) {
2155 for (
uint j = 0; j < g->edges_len; j++,
e++) {
2156 printf(
"%u/%d, ", (*e)->old_edge,
int((*e)->new_edge));
2158 printf(
"(tg:%u)(s:%u,c:%d)\n", g->topo_group, g->split, g->is_orig_closed);
2166 gs_ptr = orig_vert_groups_arr;
2167 for (
uint i = 0; i < verts_num; i++, gs_ptr++) {
2174 float mv_crease = !vertex_crease.
is_empty() ? vertex_crease[i] : 0.0f;
2175 float mv_bweight = !orig_vert_bweight.
is_empty() ? orig_vert_bweight[i] : 0.0f;
2178 float last_max_crease = 0.0f;
2179 float first_max_crease = 0.0f;
2181 float last_max_bweight = 0.0f;
2182 float first_max_bweight = 0.0f;
2191 if (result_edge_crease) {
2192 if (!orig_edge_crease.is_empty()) {
2204 if (result_edge_crease) {
2205 if (!orig_edge_crease.is_empty() &&
2206 orig_edge_crease[orig_edge_index] > max_crease)
2208 max_crease = orig_edge_crease[orig_edge_index];
2212 if (result_edge_bweight) {
2214 max_bweight = std::max(bweight, max_bweight);
2220 const float bweight_open_edge =
2221 !orig_edge_bweight.is_empty() ?
2225 if (bweight_open_edge > 0) {
2226 max_bweight =
min_ff(bweight_open_edge, max_bweight);
2229 if (bevel_convex < 0.0f) {
2235 first_max_crease = max_crease;
2236 first_max_bweight = max_bweight;
2241 if (origindex_edge) {
2244 edges[edge_index][0] = last_g->
new_vert;
2245 edges[edge_index][1] = g->
new_vert;
2246 if (result_edge_crease) {
2247 result_edge_crease.span[edge_index] =
max_ff(mv_crease,
2248 min_ff(last_max_crease, max_crease));
2250 if (result_edge_bweight) {
2251 result_edge_bweight.
span[edge_index] =
max_ff(
2252 mv_bweight,
min_ff(last_max_bweight, max_bweight));
2257 last_max_crease = max_crease;
2258 last_max_bweight = max_bweight;
2261 if (!(g + 1)->valid || g->
topo_group != (g + 1)->topo_group) {
2267 if (origindex_edge) {
2271 edges[edge_index][0] = last_g->
new_vert;
2272 edges[edge_index][1] = first_g->
new_vert;
2273 if (result_edge_crease) {
2274 result_edge_crease.span[edge_index] =
max_ff(
2275 mv_crease,
min_ff(last_max_crease, first_max_crease));
2277 if (result_edge_bweight) {
2278 result_edge_bweight.
span[edge_index] =
max_ff(
2279 mv_bweight,
min_ff(last_max_bweight, first_max_bweight));
2286 short most_mat_nr = 0;
2287 uint most_mat_nr_face = 0;
2288 uint most_mat_nr_count = 0;
2289 for (
short l = 0;
l < mat_nrs;
l++) {
2294 if ((do_rim && !g3->is_orig_closed) || (do_shell && g3->split)) {
2296 if ((!src_material_index.
is_empty() ?
2297 src_material_index[g3->edges[0]->faces[0]->index] :
2300 face = g3->edges[0]->faces[0]->index;
2303 NewEdgeRef *le = g3->edges[g3->edges_len - 1];
2321 if (count > most_mat_nr_count) {
2323 most_mat_nr_face = face;
2324 most_mat_nr_count = count;
2327 face_interp.
copy(
int(most_mat_nr_face),
int(face_index), 1);
2328 if (origindex_face) {
2331 face_offsets[face_index] = int(loop_index);
2332 dst_material_index.span[face_index] = most_mat_nr + (g->
is_orig_closed || !do_rim ?
2335 CLAMP(dst_material_index.span[face_index], 0, mat_nr_max);
2338 for (
uint k = 0; g2->
valid && k < j; g2++) {
2341 for (
int l = 0;
l < face.
size();
l++) {
2342 const int vert = orig_corner_verts[face[
l]];
2343 if (vm[vert] == i) {
2344 loops_data[k] = face[
l];
2353 for (
uint k = 0; k < j; k++) {
2354 corner_interp.
copy(loops_data[k],
int(loop_index), 1);
2355 corner_verts[loop_index] = edges[edge_index - j + k][0];
2356 corner_edges[loop_index++] = edge_index - j + k;
2360 for (
uint k = 1; k <= j; k++) {
2361 corner_interp.
copy(loops_data[j - k],
int(loop_index), 1);
2362 corner_verts[loop_index] = edges[edge_index - k][1];
2363 corner_edges[loop_index++] = edge_index - k;
2366 MEM_delete(loops_data);
2372 last_max_crease = 0;
2373 first_max_crease = 0;
2374 last_max_bweight = 0;
2375 first_max_bweight = 0;
2384 for (
uint i = 0; i < edges_num; i++) {
2385 if (edge_adj_faces_len[i] == 1 && orig_edge_data_arr[i] &&
2386 (*orig_edge_data_arr[i])->old_edge == i)
2388 NewEdgeRef **new_edges = orig_edge_data_arr[i];
2396 if (v1_singularity && v2_singularity) {
2400 const uint orig_face_index = (*new_edges)->faces[0]->index;
2401 const IndexRange face = (*new_edges)->faces[0]->face;
2402 face_interp.
copy(
int((*new_edges)->faces[0]->index),
int(face_index), 1);
2403 face_offsets[face_index] = int(loop_index);
2404 dst_material_index.span[face_index] = (!src_material_index.
is_empty() ?
2405 src_material_index[orig_face_index] :
2408 CLAMP(dst_material_index.span[face_index], 0, mat_nr_max);
2413 const uint old_v1 = vm[orig_edges[edge1->
old_edge][0]];
2414 const uint old_v2 = vm[orig_edges[edge1->
old_edge][1]];
2415 for (
uint j = 0; j < face.
size(); j++) {
2416 const int vert = orig_corner_verts[face.
start() + j];
2417 if (vm[vert] == old_v1) {
2418 loop1 = face.
start() + int(j);
2420 else if (vm[vert] == old_v2) {
2421 loop2 = face.
start() + int(j);
2425 int2 open_face_edge;
2426 uint open_face_edge_index;
2428 if (rim_defgrp_index != -1) {
2432 corner_interp.
copy(loop1,
int(loop_index), 1);
2433 corner_verts[loop_index] = edges[edge1->
new_edge][0];
2434 corner_edges[loop_index++] = edge1->
new_edge;
2436 if (!v2_singularity) {
2438 if (rim_defgrp_index != -1) {
2442 corner_interp.
copy(loop2,
int(loop_index), 1);
2443 corner_verts[loop_index] = edges[edge1->
new_edge][1];
2444 open_face_edge = edges[open_face_edge_index];
2445 if (
ELEM(edges[edge2->
new_edge][1], open_face_edge[0], open_face_edge[1])) {
2446 corner_edges[loop_index++] = open_face_edge_index;
2453 if (rim_defgrp_index != -1) {
2457 corner_interp.
copy(loop2,
int(loop_index), 1);
2458 corner_verts[loop_index] = edges[edge2->
new_edge][1];
2459 corner_edges[loop_index++] = edge2->
new_edge;
2461 if (!v1_singularity) {
2463 if (rim_defgrp_index != -1) {
2467 corner_interp.
copy(loop1,
int(loop_index), 1);
2468 corner_verts[loop_index] = edges[edge2->
new_edge][0];
2469 open_face_edge = edges[open_face_edge_index];
2470 if (
ELEM(edges[edge1->
new_edge][0], open_face_edge[0], open_face_edge[1])) {
2471 corner_edges[loop_index++] = open_face_edge_index;
2479 if (!v1_singularity) {
2481 if (rim_defgrp_index != -1) {
2485 corner_interp.
copy(loop1,
int(loop_index), 1);
2486 corner_verts[loop_index] = edges[edge1->
new_edge][0];
2487 open_face_edge = edges[open_face_edge_index];
2488 if (
ELEM(edges[edge2->
new_edge][0], open_face_edge[0], open_face_edge[1])) {
2489 corner_edges[loop_index++] = open_face_edge_index;
2496 if (rim_defgrp_index != -1) {
2500 corner_interp.
copy(loop1,
int(loop_index), 1);
2501 corner_verts[loop_index] = edges[edge2->
new_edge][0];
2502 corner_edges[loop_index++] = edge2->
new_edge;
2504 if (!v2_singularity) {
2506 if (rim_defgrp_index != -1) {
2510 corner_interp.
copy(loop2,
int(loop_index), 1);
2511 corner_verts[loop_index] = edges[edge2->
new_edge][1];
2512 open_face_edge = edges[open_face_edge_index];
2513 if (
ELEM(edges[edge1->
new_edge][1], open_face_edge[0], open_face_edge[1])) {
2514 corner_edges[loop_index++] = open_face_edge_index;
2521 if (rim_defgrp_index != -1) {
2525 corner_interp.
copy(loop2,
int(loop_index), 1);
2526 corner_verts[loop_index] = edges[edge1->
new_edge][1];
2527 corner_edges[loop_index++] = edge1->
new_edge;
2538 for (
uint i = 0; i < faces_num * 2; i++) {
2542 uint valid_edges = 0;
2544 while (totloop > 0 && (!fr.
link_edges[totloop - 1] ||
2552 vm[orig_corner_verts[loopstart + (totloop - 1)]]);
2553 for (
uint j = 0; j < totloop; j++) {
2558 vm[orig_corner_verts[loopstart + j]]);
2560 vm[orig_corner_verts[loopstart + j]]);
2565 if (k == 0 || face_verts[k - 1] != new_v1) {
2566 face_loops[k] = loopstart + j;
2573 BLI_assert(k == 0 || edges[face_edges[k]][1] == face_verts[k - 1] ||
2574 edges[face_edges[k]][0] == face_verts[k - 1]);
2576 edges[face_edges[k]][1] == new_v1 || edges[face_edges[k]][0] == new_v1);
2577 face_verts[k++] = new_v1;
2579 prior_edge = new_edge;
2580 prior_flip = 1 - flip;
2581 if (j < totloop - 1 || face_verts[0] != new_v2) {
2582 face_loops[k] = loopstart + (j + 1) % totloop;
2583 face_edges[k] = new_edge->
new_edge;
2584 face_verts[k++] = new_v2;
2587 face_edges[0] = new_edge->
new_edge;
2591 if (k > 2 && valid_edges > 2) {
2592 face_interp.
copy(
int(i / 2),
int(face_index), 1);
2593 face_offsets[face_index] = int(loop_index);
2594 dst_material_index.span[face_index] = (!src_material_index.
is_empty() ?
2595 src_material_index[fr.
index] :
2597 (fr.
reversed != do_flip ? mat_ofs : 0);
2598 CLAMP(dst_material_index.span[face_index], 0, mat_nr_max);
2600 for (
int l =
int(k) - 1;
l >= 0;
l--) {
2601 if (shell_defgrp_index != -1) {
2605 corner_interp.
copy(
int(face_loops[
l]),
int(loop_index), 1);
2606 corner_verts[loop_index] = face_verts[
l];
2607 corner_edges[loop_index++] = face_edges[
l];
2612 for (
uint next_l = 0; next_l < k; next_l++) {
2613 corner_interp.
copy(
int(face_loops[
l]),
int(loop_index), 1);
2614 corner_verts[loop_index] = face_verts[
l];
2615 corner_edges[loop_index++] = face_edges[next_l];
2623 MEM_delete(face_loops);
2624 MEM_delete(face_verts);
2625 MEM_delete(face_edges);
2627 if (edge_index != new_edges_num) {
2630 "Internal Error: edges array wrong size: %u instead of %u",
2634 if (face_index != new_faces_num) {
2637 "Internal Error: faces array wrong size: %u instead of %u",
2641 if (loop_index != new_loops_num) {
2644 "Internal Error: loops array wrong size: %u instead of %u",
2655 MEM_delete(edge_adj_faces_len);
2657 for (
EdgeGroup **p = orig_vert_groups_arr; i < verts_num; i++, p++) {
2660 MEM_delete(eg->edges);
2665 MEM_delete(orig_vert_groups_arr);
2667 for (
NewEdgeRef ***p = orig_edge_data_arr + (edges_num - 1); i > 0; i--, p--) {
2668 if (*p && (**p)->old_edge == i - 1) {
2675 MEM_delete(orig_edge_data_arr);
2676 MEM_delete(orig_edge_lengths);
2679 MEM_delete(p.link_edges);
2683#undef MOD_SOLIDIFY_EMPTY_TAG
2685 dst_material_index.finish();
2686 result_edge_bweight.
finish();
2687 result_edge_crease.finish();