159 uint newLoops = 0, newPolys = 0, newEdges = 0, newVerts = 0, rimVerts = 0;
163 const short mat_ofs = mat_nr_max ? smd->
mat_ofs : 0;
164 const short mat_ofs_rim = mat_nr_max ? smd->
mat_ofs_rim : 0;
168 uint *new_vert_arr =
nullptr;
171 uint *new_edge_arr =
nullptr;
176 uint *edge_users =
nullptr;
177 int *edge_order =
nullptr;
179 float (*vert_nors)[3] =
nullptr;
188 const float ofs_new = smd->
offset + ofs_orig;
195 const bool do_bevel_convex = bevel_convex != 0.0f;
207 const uint stride = do_shell ? 2 : 1;
220 if (need_face_normals) {
222 face_normals =
mesh->face_normals_true();
233#define INVALID_UNUSED uint(-1)
234#define INVALID_PAIR uint(-2)
247 for (eidx = 0; eidx < edges_num; eidx++) {
255 int corner_i_prev = face.
last();
257 for (j = 0; j < face.
size(); j++) {
258 const int corner_i = face[j];
259 const int vert_i = orig_corner_verts[corner_i];
260 const int prev_vert_i = orig_corner_verts[corner_i_prev];
262 eidx = int(orig_corner_edges[corner_i_prev]);
264 const int2 &edge = orig_edges[eidx];
266 edge_users[eidx] = (prev_vert_i > vert_i) == (edge[0] < edge[1]) ?
uint(i) :
267 (
uint(i) + faces_num);
268 edge_order[eidx] = j;
273 corner_i_prev = corner_i;
277 for (eidx = 0; eidx < edges_num; eidx++) {
287 for (i = 0; i < verts_num; i++) {
298 MEM_delete(orig_mvert_tag);
301 if (do_shell ==
false) {
313#ifdef USE_NONMANIFOLD_WORKAROUND
330 int((verts_num * stride) + newVerts),
331 int((edges_num * stride) + newEdges + rimVerts),
332 int((faces_num * stride) + newPolys),
333 int((loops_num * stride) + newLoops));
348 vert_interp.
copy(0, 0,
int(verts_num));
349 vert_interp.
copy(0,
int(verts_num),
int(verts_num));
351 edge_interp.
copy(0, 0,
int(edges_num));
352 edge_interp.
copy(0,
int(edges_num),
int(edges_num));
354 corner_interp.
copy(0, 0,
int(loops_num));
361 face_interp.
copy(0, 0,
int(faces_num));
362 face_interp.
copy(0,
int(faces_num),
int(faces_num));
365 face_offsets[faces_num + i] = orig_faces[i].start() +
mesh->corners_num;
370 vert_interp.
copy(0, 0,
int(verts_num));
371 for (i = 0, j =
int(verts_num); i < verts_num; i++) {
373 vert_interp.
copy(i, j, 1);
378 edge_interp.
copy(0, 0,
int(edges_num));
380 for (i = 0, j =
int(edges_num); i < edges_num; i++) {
382 int2 *ed_src, *ed_dst;
383 edge_interp.
copy(i, j, 1);
387 (*ed_dst)[0] = old_vert_arr[(*ed_src)[0]] + verts_num;
388 (*ed_dst)[1] = old_vert_arr[(*ed_src)[1]] + verts_num;
394 corner_interp.
copy(0, 0,
int(loops_num));
395 face_interp.
copy(0, 0,
int(faces_num));
399 const VArraySpan orig_vert_bweight = *orig_attributes.
lookup<
float>(
"bevel_weight_vert",
402 if (orig_attributes.
contains(
"bevel_weight_edge") ||
403 (do_bevel_convex || !orig_vert_bweight.
is_empty()))
410#define INIT_VERT_ARRAY_OFFSETS(test) \
411 if (((ofs_new >= ofs_orig) == do_flip) == test) { \
413 do_shell_align = true; \
419 do_shell_align = true; \
423 do_shell_align = false; \
425 vert_index = verts_num; \
437 const int loop_end = face.
size() - 1;
443 const int corner_2 = face.
start() +
mesh->corners_num;
445 for (j = 0; j < face.
size(); j++) {
446 corner_interp.
copy(face.
start() + j, face.
start() + (loop_end - j) +
mesh->corners_num, 1);
452 for (
int j_prev = loop_end; j < face.
size(); j_prev = j++) {
454 face.
start() + j, face.
start() + (loop_end - j_prev) +
mesh->corners_num, 1);
459 dst_material_index.
span[faces_num + i] += mat_ofs;
460 CLAMP(dst_material_index.
span[faces_num + i], 0, mat_nr_max);
463 e = corner_edges[corner_2 + 0];
464 for (j = 0; j < loop_end; j++) {
465 corner_edges[corner_2 + j] = corner_edges[corner_2 + j + 1];
467 corner_edges[corner_2 + loop_end] =
e;
469 for (j = 0; j < face.
size(); j++) {
470 corner_verts[corner_2 + j] += verts_num;
471 corner_edges[corner_2 + j] += edges_num;
475 for (
int2 &edge : edges.
slice(edges_num, edges_num)) {
483 float ofs_new_vgroup;
486 float *vert_lens =
nullptr;
487 float *vert_angs =
nullptr;
489 const float offset_sq = offset * offset;
492 float *edge_angs =
nullptr;
496 std::fill_n(vert_lens,
int(verts_num),
FLT_MAX);
497 for (
uint i = 0; i < edges_num; i++) {
499 vert_positions[edges[i][1]]);
500 vert_lens[edges[i][0]] =
min_ff(vert_lens[edges[i][0]], ed_len_sq);
501 vert_lens[edges[i][1]] =
min_ff(vert_lens[edges[i][1]], ed_len_sq);
505 if (do_angle_clamp || do_bevel_convex) {
507 if (do_angle_clamp) {
509 std::fill_n(vert_angs,
int(verts_num), 0.5f *
M_PI);
511 if (do_bevel_convex) {
519 for (eidx = 0; eidx < edges_num; eidx++) {
525 int prev_corner_i = face.
last();
526 for (
const int corner_i : face) {
527 const int vert_i = orig_corner_verts[corner_i];
528 const int prev_vert_i = orig_corner_verts[prev_corner_i];
530 eidx = orig_corner_edges[prev_corner_i];
531 const int2 &
ed = orig_edges[eidx];
533 char flip = char((prev_vert_i > vert_i) == (
ed[0] <
ed[1]));
535 edge_user_pairs[eidx][flip] =
uint(i);
541 prev_corner_i = corner_i;
545 for (
uint i = 0; i < edges_num; i++) {
546 const int2 &edge = orig_edges[i];
550 const float *n0 = face_normals[edge_user_pairs[i][0]];
551 const float *n1 = face_normals[edge_user_pairs[i][1]];
552 sub_v3_v3v3(
e, orig_vert_positions[edge[0]], orig_vert_positions[edge[1]]);
555 if (do_angle_clamp) {
556 vert_angs[edge[0]] =
max_ff(vert_angs[edge[0]],
angle);
557 vert_angs[edge[1]] =
max_ff(vert_angs[edge[1]],
angle);
559 if (do_bevel_convex) {
560 edge_angs[i] =
angle;
567 MEM_delete(edge_user_pairs);
570 if (ofs_new != 0.0f) {
574 ofs_new_vgroup = ofs_new;
579 for (i_orig = 0; i_orig < i_end; i_orig++, vert_index++) {
580 const uint i = do_shell_align ? i_orig : new_vert_arr[i_orig];
589 ofs_new_vgroup = (offset_fac_vg + (ofs_new_vgroup * offset_fac_vg_inv)) * ofs_new;
593 if (dvert ==
nullptr) {
594 ofs_new_vgroup = ofs_new;
596 if (do_angle_clamp) {
597 float cos_ang =
cosf(((2 *
M_PI) - vert_angs[i]) * 0.5f);
599 float max_off =
sqrtf(vert_lens[i]) * 0.5f / cos_ang;
600 if (max_off < offset * 0.5f) {
601 ofs_new_vgroup *= max_off / offset * 2;
606 if (vert_lens[i] < offset_sq) {
607 float scalar =
sqrtf(vert_lens[i]) / offset;
608 ofs_new_vgroup *= scalar;
613 madd_v3_v3fl(vert_positions[vert_index], vert_nors[i], ofs_new_vgroup);
616 madd_v3_v3fl(vert_positions[vert_index], vert_normals[i], ofs_new_vgroup);
621 if (ofs_orig != 0.0f) {
625 ofs_new_vgroup = ofs_orig;
631 for (i_orig = 0; i_orig < i_end; i_orig++, vert_index++) {
632 const uint i = do_shell_align ? i_orig : new_vert_arr[i_orig];
641 ofs_new_vgroup = (offset_fac_vg + (ofs_new_vgroup * offset_fac_vg_inv)) * ofs_orig;
645 if (dvert ==
nullptr) {
646 ofs_new_vgroup = ofs_orig;
648 if (do_angle_clamp) {
649 float cos_ang =
cosf(vert_angs[i_orig] * 0.5f);
651 float max_off =
sqrtf(vert_lens[i]) * 0.5f / cos_ang;
652 if (max_off < offset * 0.5f) {
653 ofs_new_vgroup *= max_off / offset * 2;
658 if (vert_lens[i] < offset_sq) {
659 float scalar =
sqrtf(vert_lens[i]) / offset;
660 ofs_new_vgroup *= scalar;
665 madd_v3_v3fl(vert_positions[vert_index], vert_nors[i], ofs_new_vgroup);
668 madd_v3_v3fl(vert_positions[vert_index], vert_normals[i], ofs_new_vgroup);
673 if (do_bevel_convex) {
674 for (
uint i = 0; i < edges_num; i++) {
676 float angle = edge_angs[i];
677 result_edge_bweight.span[i] =
clamp_f(
678 result_edge_bweight.span[i] + (
angle <
M_PI ?
clamp_f(bevel_convex, 0.0f, 1.0f) :
679 clamp_f(bevel_convex, -1.0f, 0.0f)),
683 result_edge_bweight.span[i + edges_num] =
clamp_f(
684 result_edge_bweight.span[i + edges_num] + (
angle >
M_PI ?
685 clamp_f(bevel_convex, 0.0f, 1.0f) :
686 clamp_f(bevel_convex, -1.0f, 0.0f)),
693 MEM_delete(edge_users);
695 MEM_delete(edge_angs);
699 MEM_delete(vert_lens);
700 if (do_angle_clamp) {
701 MEM_delete(vert_angs);
706#ifdef USE_NONMANIFOLD_WORKAROUND
710 float *vert_accum = vert_angles + verts_num;
714 if (vert_nors ==
nullptr) {
716 for (i = 0; i < verts_num; i++) {
727 int i_curr = face.
size() - 1;
730 const int *face_verts = &corner_verts[face.
start()];
731 const int *face_edges = &corner_edges[face.
start()];
734 nor_prev, vert_positions[face_verts[i_curr - 1]], vert_positions[face_verts[i_curr]]);
737 while (i_next < face.
size()) {
740 nor_next, vert_positions[face_verts[i_curr]], vert_positions[face_verts[i_next]]);
747 vidx = face_verts[i_curr];
748 vert_accum[vidx] +=
angle;
750#ifdef USE_NONMANIFOLD_WORKAROUND
752 if ((check_non_manifold ==
false) ||
760 vert_angles[vidx] +=
angle;
781 for (i = 0; i < verts_num; i++, dv++) {
783 scalar = offset_fac_vg + (scalar * offset_fac_vg_inv);
784 vert_angles[i] *= scalar;
788 for (i = 0; i < verts_num; i++, dv++) {
790 scalar = offset_fac_vg + (scalar * offset_fac_vg_inv);
791 vert_angles[i] *= scalar;
797 float *vert_angs =
nullptr;
799 float *edge_angs =
nullptr;
801 if (do_angle_clamp || do_bevel_convex) {
803 if (do_angle_clamp) {
805 std::fill_n(vert_angs,
int(verts_num), 0.5f *
M_PI);
807 if (do_bevel_convex) {
815 for (eidx = 0; eidx < edges_num; eidx++) {
821 int prev_corner_i = face.
start() + face.
size() - 1;
822 for (
int j = 0; j < face.
size(); j++) {
823 const int corner_i = face.
start() + j;
824 const int vert_i = orig_corner_verts[corner_i];
825 const int prev_vert_i = orig_corner_verts[prev_corner_i];
828 eidx = orig_corner_edges[prev_corner_i];
829 const int2 &edge = orig_edges[eidx];
831 char flip = char((prev_vert_i > vert_i) == (edge[0] < edge[1]));
833 edge_user_pairs[eidx][flip] =
uint(i);
839 prev_corner_i = corner_i;
843 for (i = 0; i < edges_num; i++) {
844 const int2 &edge = orig_edges[i];
848 const float *n0 = face_normals[edge_user_pairs[i][0]];
849 const float *n1 = face_normals[edge_user_pairs[i][1]];
850 if (do_angle_clamp) {
852 vert_angs[edge[0]] =
max_ff(vert_angs[edge[0]],
angle);
853 vert_angs[edge[1]] =
max_ff(vert_angs[edge[1]],
angle);
855 if (do_bevel_convex) {
856 sub_v3_v3v3(
e, orig_vert_positions[edge[0]], orig_vert_positions[edge[1]]);
865 MEM_delete(edge_user_pairs);
869 const float clamp_fac = 1 + (do_angle_clamp ?
fabsf(smd->
offset_fac) : 0);
873 const float offset_sq = offset * offset;
874 std::fill_n(vert_lens_sq,
int(verts_num),
FLT_MAX);
875 for (i = 0; i < edges_num; i++) {
877 vert_positions[edges[i][1]]);
878 vert_lens_sq[edges[i][0]] =
min_ff(vert_lens_sq[edges[i][0]], ed_len);
879 vert_lens_sq[edges[i][1]] =
min_ff(vert_lens_sq[edges[i][1]], ed_len);
881 if (do_angle_clamp) {
882 for (i = 0; i < verts_num; i++) {
883 float cos_ang =
cosf(vert_angs[i] * 0.5f);
885 float max_off =
sqrtf(vert_lens_sq[i]) * 0.5f / cos_ang;
886 if (max_off < offset * 0.5f) {
887 vert_angles[i] *= max_off / offset * 2;
891 MEM_delete(vert_angs);
894 for (i = 0; i < verts_num; i++) {
895 if (vert_lens_sq[i] < offset_sq) {
896 float scalar =
sqrtf(vert_lens_sq[i]) / offset;
897 vert_angles[i] *= scalar;
901 MEM_delete(vert_lens_sq);
905 if (do_bevel_convex) {
906 for (i = 0; i < edges_num; i++) {
908 float angle = edge_angs[i];
909 result_edge_bweight.span[i] =
clamp_f(
910 result_edge_bweight.span[i] + (
angle <
M_PI ?
clamp_f(bevel_convex, 0.0f, 1.0f) :
911 clamp_f(bevel_convex, -1.0f, 0.0f)),
915 result_edge_bweight.span[i + edges_num] =
clamp_f(
916 result_edge_bweight.span[i + edges_num] +
924 MEM_delete(edge_users);
926 MEM_delete(edge_angs);
932 if (ofs_new != 0.0f) {
939 for (i_orig = 0; i_orig < i_end; i_orig++, vert_index++) {
940 const uint i_other = do_shell_align ? i_orig : new_vert_arr[i_orig];
941 if (vert_accum[i_other]) {
944 ofs_new * (vert_angles[i_other] / vert_accum[i_other]));
949 if (ofs_orig != 0.0f) {
957 for (i_orig = 0; i_orig < i_end; i_orig++, vert_index++) {
958 const uint i_other = do_shell_align ? i_orig : new_vert_arr[i_orig];
959 if (vert_accum[i_other]) {
962 ofs_orig * (vert_angles[i_other] / vert_accum[i_other]));
967 MEM_delete(vert_angles);
970#ifdef USE_NONMANIFOLD_WORKAROUND
971 MEM_SAFE_DELETE(edge_tmp_tag);
975 MEM_delete(vert_nors);
979 if (shell_defgrp_index != -1 || rim_defgrp_index != -1) {
983 if (dst_dvert !=
nullptr) {
985 if (rim_defgrp_index != -1) {
986 for (
uint i = 0; i < rimVerts; i++) {
994 if (shell_defgrp_index != -1) {
995 for (
uint i = verts_num; i <
result->verts_num; i++) {
1008 int *origindex_edge;
1013 if (crease_rim || crease_outer || crease_inner) {
1019 origindex_edge =
static_cast<int *
>(
1021 orig_ed = (origindex_edge) ? &origindex_edge[(edges_num * stride) + newEdges] :
nullptr;
1023 int new_edge_index = int(edges_num * stride + newEdges);
1024 for (i = 0; i < rimVerts; i++) {
1025 edges[new_edge_index][0] = new_vert_arr[i];
1026 edges[new_edge_index][1] = (do_shell ? new_vert_arr[i] : i) + verts_num;
1028 if (result_edge_bweight && !orig_vert_bweight.
is_empty()) {
1029 result_edge_bweight.span[new_edge_index] = orig_vert_bweight[new_vert_arr[i]];
1037 if (result_edge_crease && crease_rim) {
1038 result_edge_crease.
span[new_edge_index] = crease_rim;
1044 int new_face_index = int(faces_num * stride);
1048 for (i = 0; i < newPolys; i++) {
1049 uint eidx = new_edge_arr[i];
1050 uint pidx = edge_users[eidx];
1054 if (pidx >= faces_num) {
1062 const int2 &edge = edges[eidx];
1065 face_interp.
copy(
int(pidx),
int((faces_num * stride) + i), 1);
1067 const int old_face_size = orig_faces[pidx].
size();
1068 face_offsets[new_face_index] = int(j + (loops_num * stride));
1071 k1 = face_offsets[pidx] + (((edge_order[eidx] - 1) + old_face_size) % old_face_size);
1073 k2 = face_offsets[pidx] + (edge_order[eidx]);
1075 corner_interp.
copy(k2,
int((loops_num * stride) + j + 0), 1);
1076 corner_interp.
copy(k1,
int((loops_num * stride) + j + 1), 1);
1077 corner_interp.
copy(k1,
int((loops_num * stride) + j + 2), 1);
1078 corner_interp.
copy(k2,
int((loops_num * stride) + j + 3), 1);
1080 if (flip ==
false) {
1081 new_corner_verts[j] = edge[0];
1082 new_corner_edges[j++] = eidx;
1084 new_corner_verts[j] = edge[1];
1085 new_corner_edges[j++] = (edges_num * stride) + old_vert_arr[edge[1]] + newEdges;
1087 new_corner_verts[j] = (do_shell ? edge[1] : old_vert_arr[edge[1]]) + verts_num;
1088 new_corner_edges[j++] = (do_shell ? eidx : i) + edges_num;
1090 new_corner_verts[j] = (do_shell ? edge[0] : old_vert_arr[edge[0]]) + verts_num;
1091 new_corner_edges[j++] = (edges_num * stride) + old_vert_arr[edge[0]] + newEdges;
1094 new_corner_verts[j] = edge[1];
1095 new_corner_edges[j++] = eidx;
1097 new_corner_verts[j] = edge[0];
1098 new_corner_edges[j++] = (edges_num * stride) + old_vert_arr[edge[0]] + newEdges;
1100 new_corner_verts[j] = (do_shell ? edge[0] : old_vert_arr[edge[0]]) + verts_num;
1101 new_corner_edges[j++] = (do_shell ? eidx : i) + edges_num;
1103 new_corner_verts[j] = (do_shell ? edge[1] : old_vert_arr[edge[1]]) + verts_num;
1104 new_corner_edges[j++] = (edges_num * stride) + old_vert_arr[edge[1]] + newEdges;
1107 if (origindex_edge) {
1114 dst_material_index.
span[new_face_index] += mat_ofs_rim;
1115 CLAMP(dst_material_index.
span[new_face_index], 0, mat_nr_max);
1117 if (result_edge_crease && crease_outer) {
1119 float *cr = &(result_edge_crease.
span[eidx]);
1120 float tcr = *cr + crease_outer;
1121 *cr = tcr > 1.0f ? 1.0f : tcr;
1124 if (result_edge_crease && crease_inner) {
1126 float *cr = &(result_edge_crease.
span[edges_num + (do_shell ? eidx : i)]);
1127 float tcr = *cr + crease_inner;
1128 *cr = tcr > 1.0f ? 1.0f : tcr;
1134 MEM_delete(new_vert_arr);
1135 MEM_delete(new_edge_arr);
1137 MEM_delete(edge_users);
1138 MEM_delete(edge_order);
1140 result_edge_crease.
finish();
1144 MEM_delete(old_vert_arr);
1147 result_edge_bweight.finish();
1148 dst_material_index.
finish();