Blender V5.3
bmesh_iterators.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
12
13#include "MEM_guardedalloc.h"
14
15#include "bmesh.hh"
18
19namespace blender {
20
22 '\0',
23 BM_VERT, /* BM_VERTS_OF_MESH */
24 BM_EDGE, /* BM_EDGES_OF_MESH */
25 BM_FACE, /* BM_FACES_OF_MESH */
26 BM_EDGE, /* BM_EDGES_OF_VERT */
27 BM_FACE, /* BM_FACES_OF_VERT */
28 BM_LOOP, /* BM_LOOPS_OF_VERT */
29 BM_VERT, /* BM_VERTS_OF_EDGE */
30 BM_FACE, /* BM_FACES_OF_EDGE */
31 BM_VERT, /* BM_VERTS_OF_FACE */
32 BM_EDGE, /* BM_EDGES_OF_FACE */
33 BM_LOOP, /* BM_LOOPS_OF_FACE */
34 BM_LOOP, /* BM_LOOPS_OF_LOOP */
35 BM_LOOP, /* BM_LOOPS_OF_EDGE */
36};
37
39{
40 int count;
41
42 switch (itype) {
44 count = bm->totvert;
45 break;
47 count = bm->totedge;
48 break;
50 count = bm->totface;
51 break;
52 default:
53 count = 0;
54 BLI_assert(0);
55 break;
56 }
57
58 return count;
59}
60
61void *BM_iter_at_index(BMesh *bm, const char itype, void *data, int index)
62{
63 BMIter iter;
64 void *val;
65 int i;
66
67 /* sanity check */
68 if (index < 0) {
69 return nullptr;
70 }
71
72 val = BM_iter_new(&iter, bm, itype, data);
73
74 i = 0;
75 while (i < index) {
76 val = BM_iter_step(&iter);
77 i++;
78 }
79
80 return val;
81}
82
83int BM_iter_as_array(BMesh *bm, const char itype, void *data, void **array, const int len)
84{
85 int i = 0;
86
87 /* sanity check */
88 if (len > 0) {
89 BMIter iter;
90 void *ele;
91
92 for (ele = BM_iter_new(&iter, bm, itype, data); ele; ele = BM_iter_step(&iter)) {
93 array[i] = ele;
94 i++;
95 if (i == len) {
96 return len;
97 }
98 }
99 }
100
101 return i;
102}
104 const char *slot_name,
105 const char restrictmask,
106 void **array,
107 const int len)
108{
109 int i = 0;
110
111 /* sanity check */
112 if (len > 0) {
113 BMOIter oiter;
114 void *ele;
115
116 for (ele = BMO_iter_new(&oiter, slot_args, slot_name, restrictmask); ele;
117 ele = BMO_iter_step(&oiter))
118 {
119 array[i] = ele;
120 i++;
121 if (i == len) {
122 return len;
123 }
124 }
125 }
126
127 return i;
128}
129
131 const char itype,
132 void *data,
133 int *r_len,
134 /* Optional args to avoid an allocation (normally stack array). */
135 void **stack_array,
136 int stack_array_size)
137{
138 BMIter iter;
139
140 BLI_assert(stack_array_size == 0 || (stack_array_size && stack_array));
141
142 /* We can't rely on #BMIter.count being set. */
143 switch (itype) {
144 case BM_VERTS_OF_MESH:
145 iter.count = bm->totvert;
146 break;
147 case BM_EDGES_OF_MESH:
148 iter.count = bm->totedge;
149 break;
150 case BM_FACES_OF_MESH:
151 iter.count = bm->totface;
152 break;
153 default:
154 break;
155 }
156
157 if (BM_iter_init(&iter, bm, itype, data) && iter.count > 0) {
158 BMElem *ele;
159 BMElem **array = iter.count > stack_array_size ?
161 reinterpret_cast<BMElem **>(stack_array);
162 int i = 0;
163
164 *r_len = iter.count; /* set before iterating */
165
166 while ((ele = static_cast<BMElem *>(BM_iter_step(&iter)))) {
167 array[i++] = ele;
168 }
169 return array;
170 }
171
172 *r_len = 0;
173 return nullptr;
174}
175
177 const char *slot_name,
178 const char restrictmask,
179 int *r_len,
180 /* Optional args to avoid an allocation (normally stack array). */
181 void **stack_array,
182 int stack_array_size)
183{
184 BMOIter iter;
185 BMElem *ele;
186 const int slot_len = BMO_slot_buffer_len(slot_args, slot_name);
187
188 BLI_assert(stack_array_size == 0 || (stack_array_size && stack_array));
189
190 if ((ele = static_cast<BMElem *>(BMO_iter_new(&iter, slot_args, slot_name, restrictmask))) &&
191 slot_len > 0)
192 {
193 BMElem **array = slot_len > stack_array_size ?
194 MEM_new_array_uninitialized<BMElem *>(slot_len, __func__) :
195 reinterpret_cast<BMElem **>(stack_array);
196 int i = 0;
197
198 do {
199 array[i++] = ele;
200 } while ((ele = static_cast<BMElem *>(BMO_iter_step(&iter))));
201 BLI_assert(i <= slot_len);
202
203 if (i != slot_len) {
204 if (reinterpret_cast<void **>(array) != stack_array) {
205 array = static_cast<BMElem **>(MEM_realloc_uninitialized(array, sizeof(ele) * i));
206 }
207 }
208 *r_len = i;
209 return array;
210 }
211
212 *r_len = 0;
213 return nullptr;
214}
215
217 BMesh *bm,
218 MutableBitSpan bitmap,
219 bool (*test_fn)(BMElem *, void *user_data),
220 void *user_data)
221{
222 BMIter iter;
223 BMElem *ele;
224 int i;
225 int bitmap_enabled = 0;
226
227 BM_ITER_MESH_INDEX (ele, &iter, bm, itype, i) {
228 if (test_fn(ele, user_data)) {
229 bitmap[i].set();
230 bitmap_enabled++;
231 }
232 else {
233 bitmap[i].reset();
234 }
235 }
236
237 return bitmap_enabled;
238}
239
241 MutableBitSpan bitmap,
242 bool (*test_fn)(BMFace *, void *user_data),
243 void *user_data)
244{
245 BMIter iter;
246 BMFace *f;
247 int i;
248 int j = 0;
249 int bitmap_enabled = 0;
250
251 BM_ITER_MESH_INDEX (f, &iter, bm, BM_FACES_OF_MESH, i) {
252 if (test_fn(f, user_data)) {
253 for (int tri = 2; tri < f->len; tri++) {
254 bitmap[j].set();
255 bitmap_enabled++;
256 j++;
257 }
258 }
259 else {
260 for (int tri = 2; tri < f->len; tri++) {
261 bitmap[j].reset();
262 j++;
263 }
264 }
265 }
266
267 return bitmap_enabled;
268}
269
270int BM_iter_elem_count_flag(const char itype, void *data, const char hflag, const bool value)
271{
272 BMIter iter;
273 BMElem *ele;
274 int count = 0;
275
276 BM_ITER_ELEM (ele, &iter, data, itype) {
277 if (BM_elem_flag_test_bool(ele, hflag) == value) {
278 count++;
279 }
280 }
281
282 return count;
283}
284
286 BMesh *bm, const char itype, void *data, const short oflag, const bool value)
287{
288 BMIter iter;
289 int count = 0;
290
291 /* loops have no header flags */
293
295 case BM_VERT: {
296 BMVert *ele;
297 BM_ITER_ELEM (ele, &iter, data, itype) {
298 if (BMO_vert_flag_test_bool(bm, ele, oflag) == value) {
299 count++;
300 }
301 }
302 break;
303 }
304 case BM_EDGE: {
305 BMEdge *ele;
306 BM_ITER_ELEM (ele, &iter, data, itype) {
307 if (BMO_edge_flag_test_bool(bm, ele, oflag) == value) {
308 count++;
309 }
310 }
311 break;
312 }
313 case BM_FACE: {
314 BMFace *ele;
315 BM_ITER_ELEM (ele, &iter, data, itype) {
316 if (BMO_face_flag_test_bool(bm, ele, oflag) == value) {
317 count++;
318 }
319 }
320 break;
321 }
322 }
323 return count;
324}
325
326int BM_iter_mesh_count_flag(const char itype, BMesh *bm, const char hflag, const bool value)
327{
328 BMIter iter;
329 BMElem *ele;
330 int count = 0;
331
332 BM_ITER_MESH (ele, &iter, bm, itype) {
333 if (BM_elem_flag_test_bool(ele, hflag) == value) {
334 count++;
335 }
336 }
337
338 return count;
339}
340
354
355/*
356 * VERT OF MESH CALLBACKS
357 */
358
359/* see bug #36923 for why we need this,
360 * allow adding but not removing, this isn't _totally_ safe since
361 * you could add/remove within the same loop, but catches common cases
362 */
363#ifndef NDEBUG
364# define USE_IMMUTABLE_ASSERT
365#endif
366
368{
369#ifdef USE_IMMUTABLE_ASSERT
370 (reinterpret_cast<BMIter *>(iter))->count = BLI_mempool_len(iter->pooliter.pool);
371#endif
373}
374
376{
377#ifdef USE_IMMUTABLE_ASSERT
378 BLI_assert(((BMIter *)iter)->count <= BLI_mempool_len(iter->pooliter.pool));
379#endif
380 return BLI_mempool_iterstep(&iter->pooliter);
381}
382
383#ifdef USE_IMMUTABLE_ASSERT
384# undef USE_IMMUTABLE_ASSERT
385#endif
386
387/*
388 * EDGE OF VERT CALLBACKS
389 */
390
392{
393 if (iter->vdata->e) {
394 iter->e_first = iter->vdata->e;
395 iter->e_next = iter->vdata->e;
396 }
397 else {
398 iter->e_first = nullptr;
399 iter->e_next = nullptr;
400 }
401}
402
404{
405 BMEdge *e_curr = iter->e_next;
406
407 if (iter->e_next) {
408 iter->e_next = bmesh_disk_edge_next(iter->e_next, iter->vdata);
409 if (iter->e_next == iter->e_first) {
410 iter->e_next = nullptr;
411 }
412 }
413
414 return e_curr;
415}
416
417/*
418 * FACE OF VERT CALLBACKS
419 */
420
422{
423 (reinterpret_cast<BMIter *>(iter))->count = bmesh_disk_facevert_count(iter->vdata);
424 if ((reinterpret_cast<BMIter *>(iter))->count) {
425 iter->l_first = bmesh_disk_faceloop_find_first(iter->vdata->e, iter->vdata);
426 iter->e_first = iter->l_first->e;
427 iter->e_next = iter->e_first;
428 iter->l_next = iter->l_first;
429 }
430 else {
431 iter->l_first = iter->l_next = nullptr;
432 iter->e_first = iter->e_next = nullptr;
433 }
434}
436{
437 BMLoop *l_curr = iter->l_next;
438
439 if ((reinterpret_cast<BMIter *>(iter))->count && iter->l_next) {
440 (reinterpret_cast<BMIter *>(iter))->count--;
442 if (iter->l_next == iter->l_first) {
443 iter->e_next = bmesh_disk_faceedge_find_next(iter->e_next, iter->vdata);
445 iter->l_next = iter->l_first;
446 }
447 }
448
449 if (!(reinterpret_cast<BMIter *>(iter))->count) {
450 iter->l_next = nullptr;
451 }
452
453 return l_curr ? l_curr->f : nullptr;
454}
455
456/*
457 * LOOP OF VERT CALLBACKS
458 */
459
461{
462 (reinterpret_cast<BMIter *>(iter))->count = bmesh_disk_facevert_count(iter->vdata);
463 if ((reinterpret_cast<BMIter *>(iter))->count) {
464 iter->l_first = bmesh_disk_faceloop_find_first(iter->vdata->e, iter->vdata);
465 iter->e_first = iter->l_first->e;
466 iter->e_next = iter->e_first;
467 iter->l_next = iter->l_first;
468 }
469 else {
470 iter->l_first = iter->l_next = nullptr;
471 iter->e_first = iter->e_next = nullptr;
472 }
473}
475{
476 BMLoop *l_curr = iter->l_next;
477
478 if ((reinterpret_cast<BMIter *>(iter))->count) {
479 (reinterpret_cast<BMIter *>(iter))->count--;
481 if (iter->l_next == iter->l_first) {
482 iter->e_next = bmesh_disk_faceedge_find_next(iter->e_next, iter->vdata);
484 iter->l_next = iter->l_first;
485 }
486 }
487
488 if (!(reinterpret_cast<BMIter *>(iter))->count) {
489 iter->l_next = nullptr;
490 }
491
492 /* nullptr on finish */
493 return l_curr;
494}
495
496/*
497 * LOOP OF EDGE CALLBACKS
498 */
499
501{
502 iter->l_first = iter->l_next = iter->edata->l;
503}
504
506{
507 BMLoop *l_curr = iter->l_next;
508
509 if (iter->l_next) {
510 iter->l_next = iter->l_next->radial_next;
511 if (iter->l_next == iter->l_first) {
512 iter->l_next = nullptr;
513 }
514 }
515
516 /* nullptr on finish */
517 return l_curr;
518}
519
520/*
521 * LOOP OF LOOP CALLBACKS
522 */
523
525{
526 iter->l_first = iter->ldata;
527 iter->l_next = iter->l_first->radial_next;
528
529 if (iter->l_next == iter->l_first) {
530 iter->l_next = nullptr;
531 }
532}
533
535{
536 BMLoop *l_curr = iter->l_next;
537
538 if (iter->l_next) {
539 iter->l_next = iter->l_next->radial_next;
540 if (iter->l_next == iter->l_first) {
541 iter->l_next = nullptr;
542 }
543 }
544
545 /* nullptr on finish */
546 return l_curr;
547}
548
549/*
550 * FACE OF EDGE CALLBACKS
551 */
552
554{
555 iter->l_first = iter->l_next = iter->edata->l;
556}
557
559{
560 BMLoop *current = iter->l_next;
561
562 if (iter->l_next) {
563 iter->l_next = iter->l_next->radial_next;
564 if (iter->l_next == iter->l_first) {
565 iter->l_next = nullptr;
566 }
567 }
568
569 return current ? current->f : nullptr;
570}
571
572/*
573 * VERTS OF EDGE CALLBACKS
574 */
575
577{
578 (reinterpret_cast<BMIter *>(iter))->count = 0;
579}
580
582{
583 switch ((reinterpret_cast<BMIter *>(iter))->count++) {
584 case 0:
585 return iter->edata->v1;
586 case 1:
587 return iter->edata->v2;
588 default:
589 return nullptr;
590 }
591}
592
593/*
594 * VERT OF FACE CALLBACKS
595 */
596
601
603{
604 BMLoop *l_curr = iter->l_next;
605
606 if (iter->l_next) {
607 iter->l_next = iter->l_next->next;
608 if (iter->l_next == iter->l_first) {
609 iter->l_next = nullptr;
610 }
611 }
612
613 return l_curr ? l_curr->v : nullptr;
614}
615
616/*
617 * EDGE OF FACE CALLBACKS
618 */
619
624
626{
627 BMLoop *l_curr = iter->l_next;
628
629 if (iter->l_next) {
630 iter->l_next = iter->l_next->next;
631 if (iter->l_next == iter->l_first) {
632 iter->l_next = nullptr;
633 }
634 }
635
636 return l_curr ? l_curr->e : nullptr;
637}
638
639/*
640 * LOOP OF FACE CALLBACKS
641 */
642
647
649{
650 BMLoop *l_curr = iter->l_next;
651
652 if (iter->l_next) {
653 iter->l_next = iter->l_next->next;
654 if (iter->l_next == iter->l_first) {
655 iter->l_next = nullptr;
656 }
657 }
658
659 return l_curr;
660}
661
663 const char itype,
665 void *userdata,
666 const TaskParallelSettings *settings)
667{
668 switch (BMIterType(itype)) {
669 case BM_VERTS_OF_MESH:
670 BLI_task_parallel_mempool(bm->vpool, userdata, func, settings);
671 break;
672 case BM_EDGES_OF_MESH:
673 BLI_task_parallel_mempool(bm->epool, userdata, func, settings);
674 break;
675 case BM_FACES_OF_MESH:
676 BLI_task_parallel_mempool(bm->fpool, userdata, func, settings);
677 break;
678 default:
679 /* Should never happen. */
681 break;
682 }
683}
684
685} // namespace blender
Read Blender memory allocation and freeing.
#define BLI_assert_unreachable()
#define BM_FACE_FIRST_LOOP(p)
#define BM_elem_flag_test_bool(ele, hflag)
#define BM_ITER_ELEM(ele, iter, data, itype)
#define BM_ITER_MESH(ele, iter, bm, itype)
#define BM_ITER_MESH_INDEX(ele, iter, bm, itype, indexvar)
#define BM_iter_init(iter, bm, itype, data)
#define BM_iter_new(iter, bm, itype, data)
#define BM_ITYPE_MAX
#define BMO_edge_flag_test_bool(bm, e, oflag)
#define BMO_face_flag_test_bool(bm, e, oflag)
#define BMO_OP_MAX_SLOTS
#define BMO_vert_flag_test_bool(bm, e, oflag)
#define MEM_realloc_uninitialized(vmemh, len)
ccl_device_inline dual1 len(const ccl_private dual< T > &a)
Definition math_dual.h:263
BMesh Iterators.
BLI_assert(slot->slot_subtype.map==BMO_OP_SLOT_SUBTYPE_MAP_FLT)
void bmiter__loop_of_loop_begin(BMIter__loop_of_loop *iter)
int BMO_slot_buffer_len(BMOpSlot slot_args[BMO_OP_MAX_SLOTS], const char *slot_name)
void * bmiter__edge_of_face_step(BMIter__edge_of_face *iter)
void bmiter__loop_of_edge_begin(BMIter__loop_of_edge *iter)
int BM_iter_elem_count_flag(const char itype, void *data, const char hflag, const bool value)
Elem Iter Flag Count.
void * MEM_new_array_uninitialized(size_t len, size_t size, const char *str) ATTR_WARN_UNUSED_RESULT ATTR_ALLOC_SIZE(1
void bmiter__edge_of_face_begin(BMIter__edge_of_face *iter)
const char bm_iter_itype_htype_map[BM_ITYPE_MAX]
void * bmiter__loop_of_vert_step(BMIter__loop_of_vert *iter)
void * bmiter__loop_of_edge_step(BMIter__loop_of_edge *iter)
void * bmiter__elem_of_mesh_step(BMIter__elem_of_mesh *iter)
void * BMO_iter_step(BMOIter *iter)
int bmesh_disk_facevert_count(const BMVert *v)
DISK COUNT FACE VERT.
void * bmiter__loop_of_face_step(BMIter__loop_of_face *iter)
void * bmiter__vert_of_face_step(BMIter__vert_of_face *iter)
void * bmiter__face_of_edge_step(BMIter__face_of_edge *iter)
int BM_iter_mesh_count(const char itype, BMesh *bm)
void bmiter__loop_of_vert_begin(BMIter__loop_of_vert *iter)
BMLoop * bmesh_disk_faceloop_find_first(const BMEdge *e, const BMVert *v)
void bmiter__face_of_vert_begin(BMIter__face_of_vert *iter)
void * BM_iter_at_index(BMesh *bm, const char itype, void *data, int index)
void bmiter__elem_of_mesh_begin(BMIter__elem_of_mesh *iter)
BMesh const char itype
void BLI_task_parallel_mempool(struct BLI_mempool *mempool, void *userdata, TaskParallelMempoolFunc func, const TaskParallelSettings *settings)
int BMO_iter_elem_count_flag(BMesh *bm, const char itype, void *data, const short oflag, const bool value)
Elem Iter Tool Flag Count.
BMesh const char void * data
void bmiter__loop_of_face_begin(BMIter__loop_of_face *iter)
void * bmiter__vert_of_edge_step(BMIter__vert_of_edge *iter)
void bmiter__face_of_edge_begin(BMIter__face_of_edge *iter)
void bmiter__vert_of_face_begin(BMIter__vert_of_face *iter)
void BLI_mempool_iternew(BLI_mempool *pool, BLI_mempool_iter *iter) ATTR_NONNULL()
void * BLI_mempool_iterstep(BLI_mempool_iter *iter) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL()
void * BM_iter_as_arrayN(BMesh *bm, const char itype, void *data, int *r_len, void **stack_array, int stack_array_size)
Iterator as Array.
BMEdge * bmesh_disk_faceedge_find_next(const BMEdge *e, const BMVert *v)
BMLoop * bmesh_radial_faceloop_find_first(const BMLoop *l, const BMVert *v)
BME RADIAL FIND FIRST FACE VERT.
int BMO_iter_as_array(BMOpSlot slot_args[BMO_OP_MAX_SLOTS], const char *slot_name, const char restrictmask, void **array, const int len)
Operator Iterator as Array.
void * bmiter__face_of_vert_step(BMIter__face_of_vert *iter)
void * bmiter__loop_of_loop_step(BMIter__loop_of_loop *iter)
int BM_iter_mesh_bitmap_from_filter(const char itype, BMesh *bm, MutableBitSpan bitmap, bool(*test_fn)(BMElem *, void *user_data), void *user_data)
void * bmiter__edge_of_vert_step(BMIter__edge_of_vert *iter)
void bmiter__vert_of_edge_begin(BMIter__vert_of_edge *iter)
void bmiter__edge_of_vert_begin(BMIter__edge_of_vert *iter)
BMLoop * bmesh_radial_faceloop_find_next(const BMLoop *l, const BMVert *v)
void * BMO_iter_as_arrayN(BMOpSlot slot_args[BMO_OP_MAX_SLOTS], const char *slot_name, const char restrictmask, int *r_len, void **stack_array, int stack_array_size)
BLI_INLINE BMEdge * bmesh_disk_edge_next(const BMEdge *e, const BMVert *v) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL()
int BM_iter_mesh_count_flag(const char itype, BMesh *bm, const char hflag, const bool value)
Mesh Iter Flag Count.
int BLI_mempool_len(const BLI_mempool *pool) ATTR_NONNULL(1)
ATTR_WARN_UNUSED_RESULT const BMFlagLayer const short oflag
void(*) TaskParallelMempoolFunc(void *userdata, MempoolIterData *iter, const TaskParallelTLS *__restrict tls)
int BM_iter_mesh_bitmap_from_filter_tessface(BMesh *bm, MutableBitSpan bitmap, bool(*test_fn)(BMFace *, void *user_data), void *user_data)
int BM_iter_as_array(BMesh *bm, const char itype, void *data, void **array, const int len)
Iterator as Array.
void BM_iter_parallel(BMesh *bm, const char itype, TaskParallelMempoolFunc func, void *userdata, const TaskParallelSettings *settings)
Parallel (threaded) iterator, only available for most basic iteration-types (verts/edges/faces of mes...
void * BMO_iter_new(BMOIter *iter, BMOpSlot slot_args[BMO_OP_MAX_SLOTS], const char *slot_name, char restrictmask)
New Iterator.
struct BMEdge * e
struct BMVert * v
struct BMFace * f
struct BMLoop * radial_next