59 const int v_edges_num,
63 for (
int i = 0; i < v_edges_num; i++) {
65 if (
e->l !=
nullptr) {
68 if (l_radial_iter->
v ==
v) {
74 v_loops[v_loops_num++] = l_radial_iter;
76 }
while ((l_radial_iter = l_radial_iter->
radial_next) !=
e->l);
83 const int v_loops_all_num)
86 uint edges_from_loop_ear_num = 0;
88 for (
int i = 0; i < v_loops_all_num; i++) {
93 if (e_opposite ==
nullptr) {
103 edges_from_loop_ear[edges_from_loop_ear_num++] = e_opposite;
106 if (edges_from_loop_ear_num >= 3) {
125 const int v_loops_all_num)
127 for (
int i = 0; i < v_loops_all_num; i++) {
154 const int v_loops_all_num)
157 if (v_loops_all_num < 2) {
163 for (
int i = 0; i < v_loops_all_num; i++) {
167 v_loops[v_loops_num++] =
l;
170 if (v_loops_num < 2) {
174 std::ranges::sort(v_loops, v_loops + v_loops_num, {}, [](
const BMLoop *
l) {
return l->
f->
len; });
180 auto verts_canonical_collapsed_fn = [](
const BMLoop *l_vert) -> VertArray {
181 const int verts_num = l_vert->f->len - 1;
185 verts[verts_index++] =
l->
v;
192 for (
int i = 1; i < verts_num; i++) {
193 if (verts[i] < verts[i_min]) {
197 const int i_next = (i_min + 1 == verts_num) ? 0 : i_min + 1;
198 const int i_prev = (i_min == 0) ? verts_num - 1 : i_min - 1;
200 const int step = (verts[i_next] < verts[i_prev]) ? 1 : (verts_num - 1);
203 for (
int i = 0, j = i_min; i < verts_num; i++) {
204 verts_ordered[i] = verts[j];
206 if (j >= verts_num) {
210 return verts_ordered;
215 for (
int group_beg = 0; group_beg < v_loops_num;) {
216 const int group_f_len = v_loops[group_beg]->
f->
len;
217 int group_end = group_beg + 1;
218 while (group_end < v_loops_num && v_loops[group_end]->f->len == group_f_len) {
222 const int group_len = group_end - group_beg;
223 if (group_len >= 2) {
225 for (
int i = 0; i < group_len; i++) {
226 collapsed[i] = verts_canonical_collapsed_fn(v_loops[group_beg + i]);
228 for (
int i = 0; i + 1 < group_len; i++) {
229 for (
int j = i + 1; j < group_len; j++) {
230 if (std::ranges::equal(collapsed[i], collapsed[j])) {
236 group_beg = group_end;
258 const bool check_for_duplicates,
270 uint e_boundary_num = 0;
273 uint tot_edge_boundary = 0;
274 uint tot_edge_manifold = 0;
275 uint tot_edge_wire = 0;
281 if (e_boundary_num <
ARRAY_SIZE(e_boundary)) {
282 e_boundary[e_boundary_num] =
e;
301 v_edges[tot_edge] =
e;
305 if (((tot_edge == 4) && (tot_edge_boundary == 0) && (tot_edge_manifold == 4)) ||
306 ((tot_edge == 3) && (tot_edge_boundary == 0) && (tot_edge_manifold == 3)))
308 if (check_for_duplicates) {
323 *v_loops_num_p = v_loops_num;
327 if ((tot_edge == 3) && (tot_edge_boundary == 2) && (tot_edge_manifold == 1)) {
328 if (check_for_duplicates) {
358 *v_loops_num_p = v_loops_num;
362 if ((tot_edge == 2) && (tot_edge_wire == 2)) {
365 if ((tot_edge == 2) && (tot_edge_manifold == 2)) {
382 v,
true, v_loops, &v_loops_num);
394 for (
int i = 0; i < v_loops_num; i++) {
439 const uint verts_start_num,
440 const int desired_tag,
442 uint &r_verts_tagged_num)
447 r_verts_tagged_num = 0;
449 for (
int i = 0; i < verts_start_num; i++) {
459 r_verts_tagged[r_verts_tagged_num++] = v_other;
475 uint verts_collapse_num = 0;
476 uint verts_ignore_num = 0;
484 if (tag_only ==
false) {
492 for (iter_step = 0; iter_step < iterations; iter_step++) {
494 bool verts_were_marked_for_dissolve =
false;
519 verts_ignore_num = 1;
531 if (verts_collapse_num == 0) {
534 verts_were_marked_for_dissolve =
true;
541 if (verts_ignore_num == 0) {
549 if (!verts_were_marked_for_dissolve) {
564 MEM_delete(verts_collapse);
565 MEM_delete(verts_ignore);
Read Blender memory allocation and freeing.
#define BLI_assert_unreachable()
#define BM_elem_index_get(ele)
#define BM_elem_flag_merge_into(ele, ele_a, ele_b)
#define BM_elem_index_set(ele, index)
#define BM_elem_flag_test(ele, hflag)
#define BM_elem_flag_enable(ele, hflag)
#define BM_ITER_ELEM(ele, iter, data, itype)
#define BM_ITER_MESH(ele, iter, bm, itype)
#define BM_ITER_MESH_MUTABLE(ele, ele_next, iter, bm, itype)
VecBase< float, D > step(VecOp< float, D >, VecOp< float, D >) RET
void BM_mesh_decimate_unsubdivide_ex(BMesh *bm, int iterations, bool tag_only)
BLI_assert(slot->slot_subtype.map==BMO_OP_SLOT_SUBTYPE_MAP_FLT)
BLI_INLINE bool BM_edge_is_wire(const BMEdge *e) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL()
static std::optional< VertDissolveMethod > bm_vert_dissolve_fan_or_chain_test(BMVert *v, const bool check_for_duplicates, BMLoop *v_loops[VERT_DISSOLVE_MAX], int *v_loops_num_p)
static bool bm_vert_dissolve_fan_makes_double_whole_face(BMLoop **v_loops_all, const int v_loops_all_num)
static int bm_vert_loops_from_vert_edges(const BMVert *v, BMEdge **v_edges, const int v_edges_num, BMLoop *v_loops[VERT_DISSOLVE_MAX])
void * MEM_new_array_uninitialized(size_t len, size_t size, const char *str) ATTR_WARN_UNUSED_RESULT ATTR_ALLOC_SIZE(1
constexpr int VERT_DISSOLVE_MAX
ATTR_WARN_UNUSED_RESULT const BMLoop * l
void BM_mesh_decimate_unsubdivide(BMesh *bm, int iterations)
static void bm_tag_untagged_neighbors(BMVert *verts_start[], const uint verts_start_num, const int desired_tag, BMVert *r_verts_tagged[], uint &r_verts_tagged_num)
ATTR_WARN_UNUSED_RESULT const BMVert * v
BLI_INLINE bool BM_edge_is_manifold(const BMEdge *e) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL()
static bool bm_vert_dissolve_fan_makes_double_with_self(BMLoop **v_loops_all, const int v_loops_all_num)
BLI_INLINE BMVert * BM_edge_other_vert(BMEdge *e, const BMVert *v) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL()
bool BM_face_split_check_double_face(BMLoop *l_a, BMLoop *l_b, const int f_len)
static bool bm_vert_dissolve_fan_or_chain(BMesh *bm, BMVert *v)
constexpr size_t ARRAY_SIZE(const T(&arg)[N]) noexcept
BLI_INLINE bool BM_edge_is_boundary(const BMEdge *e) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL()
BMEdge * BM_vert_collapse_edge(BMesh *bm, BMEdge *e_kill, BMVert *v_kill, const bool do_del, const bool kill_degenerate_faces, const bool kill_duplicate_faces)
Vert Collapse Faces.
BMEdge * BM_edge_exists(BMVert *v_a, BMVert *v_b)
bool BM_vert_dissolve(BMesh *bm, BMVert *v)
Dissolve Vert.
static bool bm_vert_dissolve_fan_makes_double_with_existing(BMLoop **v_loops_all, const int v_loops_all_num)
BMFace * BM_face_split(BMesh *bm, BMFace *f, BMLoop *l_a, BMLoop *l_b, BMLoop **r_l, BMEdge *example, const bool no_double)
Face Split.
bool BM_face_exists_multi_edge(BMEdge **earr, int len)
ATTR_WARN_UNUSED_RESULT const BMVert const BMEdge * e
struct BMLoop * radial_next