Blender V5.3
bmesh_marking.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
15
16#include <cstddef>
17
18#include "MEM_guardedalloc.h"
19
20#include "DNA_scene_types.h"
21
22#include "BLI_listbase.hh"
23#include "BLI_math_vector_c.hh"
24#include "BLI_task_c.hh"
25
26#include "bmesh.hh"
28#include "bmesh_query_uv.hh"
29#include "bmesh_structure.hh"
30
31/* For '_FLAG_OVERLAP'. */
32#include "bmesh_private.hh"
33
34namespace blender {
35
36/* -------------------------------------------------------------------- */
39
43
44static void recount_totsels_range_vert_func(void * /*userdata*/,
45 MempoolIterData *iter,
46 const TaskParallelTLS *__restrict tls)
47{
48 SelectionCountChunkData *count = static_cast<SelectionCountChunkData *>(tls->userdata_chunk);
49 const BMVert *eve = reinterpret_cast<const BMVert *>(iter);
51 count->selection_len += 1;
52 }
53}
54
55static void recount_totsels_range_edge_func(void * /*userdata*/,
56 MempoolIterData *iter,
57 const TaskParallelTLS *__restrict tls)
58{
59 SelectionCountChunkData *count = static_cast<SelectionCountChunkData *>(tls->userdata_chunk);
60 const BMEdge *eed = reinterpret_cast<const BMEdge *>(iter);
62 count->selection_len += 1;
63 }
64}
65
66static void recount_totsels_range_face_func(void * /*userdata*/,
67 MempoolIterData *iter,
68 const TaskParallelTLS *__restrict tls)
69{
70 SelectionCountChunkData *count = static_cast<SelectionCountChunkData *>(tls->userdata_chunk);
71 const BMFace *efa = reinterpret_cast<const BMFace *>(iter);
73 count->selection_len += 1;
74 }
75}
76
77static void recount_totsels_reduce(const void *__restrict /*userdata*/,
78 void *__restrict chunk_join,
79 void *__restrict chunk)
80{
81 SelectionCountChunkData *dst = static_cast<SelectionCountChunkData *>(chunk_join);
82 const SelectionCountChunkData *src = static_cast<const SelectionCountChunkData *>(chunk);
83 dst->selection_len += src->selection_len;
84}
85
87{
89
90 TaskParallelMempoolFunc range_func = nullptr;
91 if (iter_type == BM_VERTS_OF_MESH) {
93 }
94 else if (iter_type == BM_EDGES_OF_MESH) {
96 }
97 else if (iter_type == BM_FACES_OF_MESH) {
99 }
100 return range_func;
101}
102
103static int recount_totsel(BMesh *bm, BMIterType iter_type)
104{
105 const int MIN_ITER_SIZE = 1024;
106
107 TaskParallelSettings settings;
110 settings.min_iter_per_thread = MIN_ITER_SIZE;
111
112 SelectionCountChunkData count = {0};
113 settings.userdata_chunk = &count;
114 settings.userdata_chunk_size = sizeof(count);
115
117 BM_iter_parallel(bm, iter_type, range_func, nullptr, &settings);
118 return count.selection_len;
119}
120
125
130
135
142
143#ifndef NDEBUG
150#endif
151
153
154/* -------------------------------------------------------------------- */
157
158static bool bm_vert_is_edge_select_any_other(const BMVert *v, const BMEdge *e_first)
159{
160 const BMEdge *e_iter = e_first;
161
162 /* start by stepping over the current edge */
163 while ((e_iter = bmesh_disk_edge_next(e_iter, v)) != e_first) {
164 if (BM_elem_flag_test(e_iter, BM_ELEM_SELECT)) {
165 return true;
166 }
167 }
168 return false;
169}
170
171#if 0
172static bool bm_vert_is_edge_select_any(const BMVert *v)
173{
174 if (v->e) {
175 const BMEdge *e_iter, *e_first;
176 e_iter = e_first = v->e;
177 do {
178 if (BM_elem_flag_test(e_iter, BM_ELEM_SELECT)) {
179 return true;
180 }
181 } while ((e_iter = bmesh_disk_edge_next(e_iter, v)) != e_first);
182 }
183 return false;
184}
185#endif
186
188{
189 if (v->e) {
190 const BMEdge *e_iter, *e_first;
191 e_iter = e_first = v->e;
192 do {
193 if (!BM_elem_flag_test(e_iter, BM_ELEM_HIDDEN)) {
194 return true;
195 }
196 } while ((e_iter = bmesh_disk_edge_next(e_iter, v)) != e_first);
197 }
198 return false;
199}
200
202{
203 const BMLoop *l_iter = l_first;
204
205 /* start by stepping over the current face */
206 while ((l_iter = l_iter->radial_next) != l_first) {
207 if (BM_elem_flag_test(l_iter->f, BM_ELEM_SELECT)) {
208 return true;
209 }
210 }
211 return false;
212}
213
214#if 0
215static bool bm_edge_is_face_select_any(const BMEdge *e)
216{
217 if (e->l) {
218 const BMLoop *l_iter, *l_first;
219 l_iter = l_first = e->l;
220 do {
221 if (BM_elem_flag_test(l_iter->f, BM_ELEM_SELECT)) {
222 return true;
223 }
224 } while ((l_iter = l_iter->radial_next) != l_first);
225 }
226 return false;
227}
228#endif
229
231{
232 if (e->l) {
233 const BMLoop *l_iter, *l_first;
234 l_iter = l_first = e->l;
235 do {
236 if (!BM_elem_flag_test(l_iter->f, BM_ELEM_HIDDEN)) {
237 return true;
238 }
239 } while ((l_iter = l_iter->radial_next) != l_first);
240 }
241 return false;
242}
243
245
247{
249 return !ELEM(bm->totvertsel, 0, bm->totvert);
250 }
252 return !ELEM(bm->totedgesel, 0, bm->totedge);
253 }
254 return !ELEM(bm->totfacesel, 0, bm->totface);
255}
256
257void BM_mesh_select_mode_clean_ex(BMesh *bm, const short selectmode)
258{
259 if (selectmode & SCE_SELECT_VERTEX) {
260 /* pass */
261 }
262 else if (selectmode & SCE_SELECT_EDGE) {
263 BMIter iter;
264
265 if (bm->totvertsel) {
266 BMVert *v;
267 BM_ITER_MESH (v, &iter, bm, BM_VERTS_OF_MESH) {
269 }
270 bm->totvertsel = 0;
271 }
272
273 if (bm->totedgesel) {
274 BMEdge *e;
275 BM_ITER_MESH (e, &iter, bm, BM_EDGES_OF_MESH) {
277 BM_vert_select_set(bm, e->v1, true);
278 BM_vert_select_set(bm, e->v2, true);
279 }
280 }
281 }
282 }
283 else if (selectmode & SCE_SELECT_FACE) {
284 BMIter iter;
285
286 if (bm->totvertsel) {
287 BMVert *v;
288 BM_ITER_MESH (v, &iter, bm, BM_VERTS_OF_MESH) {
290 }
291 bm->totvertsel = 0;
292 }
293
294 if (bm->totedgesel) {
295 BMEdge *e;
296 BM_ITER_MESH (e, &iter, bm, BM_EDGES_OF_MESH) {
298 }
299 bm->totedgesel = 0;
300 }
301
302 if (bm->totfacesel) {
303 BMFace *f;
304 BM_ITER_MESH (f, &iter, bm, BM_FACES_OF_MESH) {
306 BMLoop *l_iter, *l_first;
307 l_iter = l_first = BM_FACE_FIRST_LOOP(f);
308 do {
309 BM_edge_select_set(bm, l_iter->e, true);
310 } while ((l_iter = l_iter->next) != l_first);
311 }
312 }
313 }
314 }
315}
316
321
322/* -------------------------------------------------------------------- */
325
329
331 MempoolIterData *iter,
332 const TaskParallelTLS *__restrict tls)
333{
334 SelectionFlushChunkData *chunk_data = static_cast<SelectionFlushChunkData *>(
335 tls->userdata_chunk);
336 BMEdge *e = reinterpret_cast<BMEdge *>(iter);
337 const bool is_selected = BM_elem_flag_test(e, BM_ELEM_SELECT);
338 const bool is_hidden = BM_elem_flag_test(e, BM_ELEM_HIDDEN);
339 if (!is_hidden &&
341 {
343 chunk_data->delta_selection_len += is_selected ? 0 : 1;
344 }
345 else {
347 chunk_data->delta_selection_len += is_selected ? -1 : 0;
348 }
349}
350
352 MempoolIterData *iter,
353 const TaskParallelTLS *__restrict tls)
354{
355 SelectionFlushChunkData *chunk_data = static_cast<SelectionFlushChunkData *>(
356 tls->userdata_chunk);
357 BMFace *f = reinterpret_cast<BMFace *>(iter);
358 BMLoop *l_iter;
359 BMLoop *l_first;
360 const bool is_selected = BM_elem_flag_test(f, BM_ELEM_SELECT);
361 bool ok = true;
363 l_iter = l_first = BM_FACE_FIRST_LOOP(f);
364 do {
365 if (!BM_elem_flag_test(l_iter->e, BM_ELEM_SELECT)) {
366 ok = false;
367 break;
368 }
369 } while ((l_iter = l_iter->next) != l_first);
370 }
371 else {
372 ok = false;
373 }
374
376 if (is_selected && !ok) {
377 chunk_data->delta_selection_len -= 1;
378 }
379 else if (ok && !is_selected) {
380 chunk_data->delta_selection_len += 1;
381 }
382}
383
384static void bm_mesh_select_mode_flush_reduce_fn(const void *__restrict /*userdata*/,
385 void *__restrict chunk_join,
386 void *__restrict chunk)
387{
388 SelectionFlushChunkData *dst = static_cast<SelectionFlushChunkData *>(chunk_join);
389 const SelectionFlushChunkData *src = static_cast<const SelectionFlushChunkData *>(chunk);
391}
392
394{
395 SelectionFlushChunkData chunk_data = {0};
396
397 TaskParallelSettings settings;
400 settings.userdata_chunk = &chunk_data;
401 settings.userdata_chunk_size = sizeof(chunk_data);
403
406 bm->totedgesel += chunk_data.delta_selection_len;
407}
408
410{
411 SelectionFlushChunkData chunk_data = {0};
412
413 TaskParallelSettings settings;
416 settings.userdata_chunk = &chunk_data;
417 settings.userdata_chunk_size = sizeof(chunk_data);
419
422 bm->totfacesel += chunk_data.delta_selection_len;
423}
424
431{
432 BMIter iter;
433 BMEdge *e;
434 bool any_select = false;
435 BM_ITER_MESH (e, &iter, bm, BM_EDGES_OF_MESH) {
437 continue;
438 }
440 any_select = true;
441 }
442 else {
443 BM_vert_select_set(bm, e->v1, false);
444 BM_vert_select_set(bm, e->v2, false);
445 }
446 }
447 if (any_select) {
448 BM_ITER_MESH (e, &iter, bm, BM_EDGES_OF_MESH) {
450 continue;
451 }
453 BM_vert_select_set(bm, e->v1, true);
454 BM_vert_select_set(bm, e->v2, true);
455 }
456 }
457 }
458}
459
466{
467 BMIter iter;
468 BMFace *f;
469 bool any_select = false;
470 BM_ITER_MESH (f, &iter, bm, BM_FACES_OF_MESH) {
472 continue;
473 }
475 any_select = true;
476 }
477 else {
478 BMLoop *l_first = BM_FACE_FIRST_LOOP(f);
479 BMLoop *l_iter = l_first;
480 do {
481 BM_vert_select_set(bm, l_iter->v, false);
482 BM_edge_select_set_noflush(bm, l_iter->e, false);
483 } while ((l_iter = l_iter->next) != l_first);
484 }
485 }
486 if (any_select) {
487 BM_ITER_MESH (f, &iter, bm, BM_FACES_OF_MESH) {
489 continue;
490 }
492 BMLoop *l_first = BM_FACE_FIRST_LOOP(f);
493 BMLoop *l_iter = l_first;
494 do {
495 BM_vert_select_set(bm, l_iter->v, true);
496 BM_edge_select_set_noflush(bm, l_iter->e, true);
497 } while ((l_iter = l_iter->next) != l_first);
498 }
499 }
500 }
501}
502
503void BM_mesh_select_mode_flush_ex(BMesh *bm, const short selectmode, BMSelectFlushFlag flag)
504{
505 const bool flush_down = flag_is_set(flag, BMSelectFlushFlag::Down);
506 if (flush_down) {
507 if (selectmode & SCE_SELECT_VERTEX) {
508 /* Pass. */
509 }
510 else if (selectmode & SCE_SELECT_EDGE) {
512 }
513 else if (selectmode & SCE_SELECT_FACE) {
515 }
516 }
517
518 /* Always flush up. */
519 {
520 if (selectmode & SCE_SELECT_VERTEX) {
522 }
523
524 if (selectmode & (SCE_SELECT_VERTEX | SCE_SELECT_EDGE)) {
526 }
527 }
528
529 /* Remove any deselected elements from the BMEditSelection */
531
532 if (flag_is_set(flag, BMSelectFlushFlag::RecalcLenVert)) {
534 }
535 if (flag_is_set(flag, BMSelectFlushFlag::RecalcLenEdge)) {
537 }
538 if (flag_is_set(flag, BMSelectFlushFlag::RecalcLenFace)) {
540 }
542}
543
548
550
552{
553 if (select) {
554 BMEdge *e;
555 BMLoop *l_iter;
556 BMLoop *l_first;
557 BMFace *f;
558
559 BMIter eiter;
560 BMIter fiter;
561
562 bool ok;
563
564 BM_ITER_MESH (e, &eiter, bm, BM_EDGES_OF_MESH) {
567 {
569 }
570 }
571 BM_ITER_MESH (f, &fiter, bm, BM_FACES_OF_MESH) {
572 ok = true;
574 l_iter = l_first = BM_FACE_FIRST_LOOP(f);
575 do {
576 if (!BM_elem_flag_test(l_iter->v, BM_ELEM_SELECT)) {
577 ok = false;
578 break;
579 }
580 } while ((l_iter = l_iter->next) != l_first);
581 }
582 else {
583 ok = false;
584 }
585
586 if (ok) {
588 }
589 }
590 }
591 else {
592 BMIter eiter;
593 BMEdge *e;
594
595 BM_ITER_MESH (e, &eiter, bm, BM_EDGES_OF_MESH) {
600 {
602 }
603 }
604
605 if (e->l && !BM_elem_flag_test(e, BM_ELEM_SELECT)) {
606 BMLoop *l_iter;
607 BMLoop *l_first;
608
609 l_iter = l_first = e->l;
610 do {
612 } while ((l_iter = l_iter->radial_next) != l_first);
613 }
614 }
615 }
616 /* Remove any deselected elements from the #BMEditSelection. */
618 }
619
621}
622
624{
626
628 return;
629 }
630
631 if (select) {
634 bm->totvertsel += 1;
635 }
636 }
637 else {
639 bm->totvertsel -= 1;
641 }
642 }
643}
644
646{
648
650 return;
651 }
652
653 if (select) {
656 bm->totedgesel += 1;
657 }
658 BM_vert_select_set(bm, e->v1, true);
659 BM_vert_select_set(bm, e->v2, true);
660 }
661 else {
664 bm->totedgesel -= 1;
665 }
666
667 if ((bm->selectmode & SCE_SELECT_VERTEX) == 0) {
668 int i;
669
670 /* check if the vert is used by a selected edge */
671 for (i = 0; i < 2; i++) {
672 BMVert *v = *((&e->v1) + i);
673 if (bm_vert_is_edge_select_any_other(v, e) == false) {
674 BM_vert_select_set(bm, v, false);
675 }
676 }
677 }
678 else {
679 BM_vert_select_set(bm, e->v1, false);
680 BM_vert_select_set(bm, e->v2, false);
681 }
682 }
683}
684
686{
687 BMLoop *l_iter;
688 BMLoop *l_first;
689
691
693 return;
694 }
695
696 if (select) {
699 bm->totfacesel += 1;
700 }
701
702 l_iter = l_first = BM_FACE_FIRST_LOOP(f);
703 do {
704 BM_vert_select_set(bm, l_iter->v, true);
705 BM_edge_select_set(bm, l_iter->e, true);
706 } while ((l_iter = l_iter->next) != l_first);
707 }
708 else {
709
712 bm->totfacesel -= 1;
713 }
723 l_iter = l_first = BM_FACE_FIRST_LOOP(f);
724 do {
725 BM_vert_select_set(bm, l_iter->v, false);
726 BM_edge_select_set_noflush(bm, l_iter->e, false);
727 } while ((l_iter = l_iter->next) != l_first);
728 }
729 else {
735 l_iter = l_first = BM_FACE_FIRST_LOOP(f);
736 do {
737 BM_edge_select_set_noflush(bm, l_iter->e, false);
738 } while ((l_iter = l_iter->next) != l_first);
739 }
740 else {
741 l_iter = l_first = BM_FACE_FIRST_LOOP(f);
742 do {
743 if (bm_edge_is_face_select_any_other(l_iter) == false) {
744 BM_edge_select_set_noflush(bm, l_iter->e, false);
745 }
746 } while ((l_iter = l_iter->next) != l_first);
747 }
748
749 /* flush down to verts */
750 l_iter = l_first = BM_FACE_FIRST_LOOP(f);
751 do {
752 if (bm_vert_is_edge_select_any_other(l_iter->v, l_iter->e) == false) {
753 BM_vert_select_set(bm, l_iter->v, false);
754 }
755 } while ((l_iter = l_iter->next) != l_first);
756 }
757 }
758}
759
760/* -------------------------------------------------------------------- */
763
765{
767
769 return;
770 }
771
772 if (select) {
775 bm->totedgesel += 1;
776 }
777 }
778 else {
781 bm->totedgesel -= 1;
782 }
783 }
784}
785
787{
789
791 return;
792 }
793
794 if (select) {
797 bm->totfacesel += 1;
798 }
799 }
800 else {
803 bm->totfacesel -= 1;
804 }
805 }
806}
807
809
810void BM_mesh_select_mode_set(BMesh *bm, int selectmode)
811{
812 BMIter iter;
813 BMElem *ele;
814
815 bm->selectmode = selectmode;
816
818/* disabled because selection flushing handles these */
819#if 0
820 BM_ITER_MESH (ele, &iter, bm, BM_EDGES_OF_MESH) {
822 }
823 BM_ITER_MESH (ele, &iter, bm, BM_FACES_OF_MESH) {
825 }
826#endif
828 }
829 else if (bm->selectmode & SCE_SELECT_EDGE) {
830/* disabled because selection flushing handles these */
831#if 0
832 BM_ITER_MESH (ele, &iter, bm, BM_VERTS_OF_MESH) {
834 }
835#endif
836
837 BM_ITER_MESH (ele, &iter, bm, BM_EDGES_OF_MESH) {
839 BM_edge_select_set(bm, reinterpret_cast<BMEdge *>(ele), true);
840 }
841 }
843 }
844 else if (bm->selectmode & SCE_SELECT_FACE) {
845/* disabled because selection flushing handles these */
846#if 0
847 BM_ITER_MESH (ele, &iter, bm, BM_EDGES_OF_MESH) {
849 }
850#endif
851 BM_ITER_MESH (ele, &iter, bm, BM_FACES_OF_MESH) {
853 BM_face_select_set(bm, reinterpret_cast<BMFace *>(ele), true);
854 }
855 }
857 }
858}
859
864 const char htype,
865 const char hflag,
866 const bool respecthide,
867 const bool test_for_enabled)
868{
869 BMElem *ele;
870 BMIter iter;
871 int tot = 0;
872
873 BLI_assert((htype & ~BM_ALL_NOLOOP) == 0);
874
875 if (htype & BM_VERT) {
876 BM_ITER_MESH (ele, &iter, bm, BM_VERTS_OF_MESH) {
877 if (respecthide && BM_elem_flag_test(ele, BM_ELEM_HIDDEN)) {
878 continue;
879 }
880 if (BM_elem_flag_test_bool(ele, hflag) == test_for_enabled) {
881 tot++;
882 }
883 }
884 }
885 if (htype & BM_EDGE) {
886 BM_ITER_MESH (ele, &iter, bm, BM_EDGES_OF_MESH) {
887 if (respecthide && BM_elem_flag_test(ele, BM_ELEM_HIDDEN)) {
888 continue;
889 }
890 if (BM_elem_flag_test_bool(ele, hflag) == test_for_enabled) {
891 tot++;
892 }
893 }
894 }
895 if (htype & BM_FACE) {
896 BM_ITER_MESH (ele, &iter, bm, BM_FACES_OF_MESH) {
897 if (respecthide && BM_elem_flag_test(ele, BM_ELEM_HIDDEN)) {
898 continue;
899 }
900 if (BM_elem_flag_test_bool(ele, hflag) == test_for_enabled) {
901 tot++;
902 }
903 }
904 }
905
906 return tot;
907}
908
910 const char htype,
911 const char hflag,
912 const bool respecthide)
913{
914 return bm_mesh_flag_count(bm, htype, hflag, respecthide, true);
915}
916
918 const char htype,
919 const char hflag,
920 const bool respecthide)
921{
922 return bm_mesh_flag_count(bm, htype, hflag, respecthide, false);
923}
924
925void BM_elem_select_set(BMesh *bm, BMElem *ele, const bool select)
926{
927 switch (ele->head.htype) {
928 case BM_VERT:
929 BM_vert_select_set(bm, reinterpret_cast<BMVert *>(ele), select);
930 break;
931 case BM_EDGE:
932 BM_edge_select_set(bm, reinterpret_cast<BMEdge *>(ele), select);
933 break;
934 case BM_FACE:
935 BM_face_select_set(bm, reinterpret_cast<BMFace *>(ele), select);
936 break;
937 default:
938 BLI_assert(0);
939 break;
940 }
941}
942
944{
945 bm->act_face = f;
946}
947
948int BM_mesh_active_face_index_get(BMesh *bm, bool is_sloppy, bool is_selected)
949{
950 const BMFace *f = BM_mesh_active_face_get(bm, is_sloppy, is_selected);
951 return f ? BM_elem_index_get(f) : -1;
952}
953
955{
957 return e ? BM_elem_index_get(e) : -1;
958}
959
961{
963 return v ? BM_elem_index_get(v) : -1;
964}
965
966BMFace *BM_mesh_active_face_get(BMesh *bm, const bool is_sloppy, const bool is_selected)
967{
968 if (bm->act_face && (!is_selected || BM_elem_flag_test(bm->act_face, BM_ELEM_SELECT))) {
969 return bm->act_face;
970 }
971 if (is_sloppy) {
972 BMIter iter;
973 BMFace *f = nullptr;
974 BMEditSelection *ese;
975
976 /* Find the latest non-hidden face from the BMEditSelection */
977 ese = bm->selected.last();
978 for (; ese; ese = ese->prev) {
979 if (ese->htype == BM_FACE) {
980 f = reinterpret_cast<BMFace *>(ese->ele);
981
983 f = nullptr;
984 }
985 else if (is_selected && !BM_elem_flag_test(f, BM_ELEM_SELECT)) {
986 f = nullptr;
987 }
988 else {
989 break;
990 }
991 }
992 }
993 /* Last attempt: try to find any selected face */
994 if (f == nullptr) {
995 BM_ITER_MESH (f, &iter, bm, BM_FACES_OF_MESH) {
997 break;
998 }
999 }
1000 }
1001 return f; /* can still be null */
1002 }
1003 return nullptr;
1004}
1005
1007{
1008 if (bm->selected.last()) {
1009 BMEditSelection *ese = bm->selected.last();
1010
1011 if (ese && ese->htype == BM_EDGE) {
1012 return reinterpret_cast<BMEdge *>(ese->ele);
1013 }
1014 }
1015
1016 return nullptr;
1017}
1018
1020{
1021 if (bm->selected.last()) {
1022 BMEditSelection *ese = bm->selected.last();
1023
1024 if (ese && ese->htype == BM_VERT) {
1025 return reinterpret_cast<BMVert *>(ese->ele);
1026 }
1027 }
1028
1029 return nullptr;
1030}
1031
1033{
1034 if (bm->selected.last()) {
1035 BMEditSelection *ese = bm->selected.last();
1036
1037 if (ese) {
1038 return ese->ele;
1039 }
1040 }
1041
1042 return nullptr;
1043}
1044
1045void BM_editselection_center(BMEditSelection *ese, float r_center[3])
1046{
1047 if (ese->htype == BM_VERT) {
1048 BMVert *eve = reinterpret_cast<BMVert *>(ese->ele);
1049 copy_v3_v3(r_center, eve->co);
1050 }
1051 else if (ese->htype == BM_EDGE) {
1052 BMEdge *eed = reinterpret_cast<BMEdge *>(ese->ele);
1053 mid_v3_v3v3(r_center, eed->v1->co, eed->v2->co);
1054 }
1055 else if (ese->htype == BM_FACE) {
1056 BMFace *efa = reinterpret_cast<BMFace *>(ese->ele);
1057 BM_face_calc_center_median(efa, r_center);
1058 }
1059}
1060
1061void BM_editselection_normal(BMEditSelection *ese, float r_normal[3])
1062{
1063 if (ese->htype == BM_VERT) {
1064 BMVert *eve = reinterpret_cast<BMVert *>(ese->ele);
1065 copy_v3_v3(r_normal, eve->no);
1066 }
1067 else if (ese->htype == BM_EDGE) {
1068 BMEdge *eed = reinterpret_cast<BMEdge *>(ese->ele);
1069 float plane[3]; /* need a plane to correct the normal */
1070 float vec[3]; /* temp vec storage */
1071
1072 add_v3_v3v3(r_normal, eed->v1->no, eed->v2->no);
1073 sub_v3_v3v3(plane, eed->v2->co, eed->v1->co);
1074
1075 /* the 2 vertex normals will be close but not at right angles to the edge
1076 * for rotate about edge we want them to be at right angles, so we need to
1077 * do some extra calculation to correct the vert normals,
1078 * we need the plane for this */
1079 cross_v3_v3v3(vec, r_normal, plane);
1080 cross_v3_v3v3(r_normal, plane, vec);
1081 normalize_v3(r_normal);
1082 }
1083 else if (ese->htype == BM_FACE) {
1084 BMFace *efa = reinterpret_cast<BMFace *>(ese->ele);
1085 copy_v3_v3(r_normal, efa->no);
1086 }
1087}
1088
1089void BM_editselection_plane(BMEditSelection *ese, float r_plane[3])
1090{
1091 if (ese->htype == BM_VERT) {
1092 BMVert *eve = reinterpret_cast<BMVert *>(ese->ele);
1093 float vec[3] = {0.0f, 0.0f, 0.0f};
1094
1095 if (ese->prev) { /* use previously selected data to make a useful vertex plane */
1096 BM_editselection_center(ese->prev, vec);
1097 sub_v3_v3v3(r_plane, vec, eve->co);
1098 }
1099 else {
1100 /* make a fake plane that's at right-angles to the normal
1101 * we can't make a cross-vector from a vec that's the same as the vec
1102 * unlikely but possible, so make sure if the normal is (0, 0, 1)
1103 * that vec isn't the same or in the same direction even. */
1104 if (eve->no[0] < 0.5f) {
1105 vec[0] = 1.0f;
1106 }
1107 else if (eve->no[1] < 0.5f) {
1108 vec[1] = 1.0f;
1109 }
1110 else {
1111 vec[2] = 1.0f;
1112 }
1113 cross_v3_v3v3(r_plane, eve->no, vec);
1114 }
1115 normalize_v3(r_plane);
1116 }
1117 else if (ese->htype == BM_EDGE) {
1118 BMEdge *eed = reinterpret_cast<BMEdge *>(ese->ele);
1119
1120 if (BM_edge_is_boundary(eed)) {
1121 sub_v3_v3v3(r_plane, eed->l->v->co, eed->l->next->v->co);
1122 }
1123 else {
1124 /* the plane is simple, it runs along the edge
1125 * however selecting different edges can swap the direction of the y axis.
1126 * this makes it less likely for the y axis of the gizmo
1127 * (running along the edge).. to flip less often.
1128 * at least its more predictable */
1129 if (eed->v2->co[1] > eed->v1->co[1]) { /* check which to do first */
1130 sub_v3_v3v3(r_plane, eed->v2->co, eed->v1->co);
1131 }
1132 else {
1133 sub_v3_v3v3(r_plane, eed->v1->co, eed->v2->co);
1134 }
1135 }
1136
1137 normalize_v3(r_plane);
1138 }
1139 else if (ese->htype == BM_FACE) {
1140 BMFace *efa = reinterpret_cast<BMFace *>(ese->ele);
1141 BM_face_calc_tangent_auto(efa, r_plane);
1142 }
1143}
1144
1146{
1147 BMEditSelection *ese = MEM_new_zeroed<BMEditSelection>("BMEdit Selection");
1148 ese->htype = ele->htype;
1149 ese->ele = reinterpret_cast<BMElem *>(ele);
1150 return ese;
1151}
1152
1153/* --- Macro wrapped functions. --- */
1154
1156{
1157 return (BLI_findptr(&bm->selected, ele, offsetof(BMEditSelection, ele)) != nullptr);
1158}
1159
1161{
1162 BMEditSelection *ese = static_cast<BMEditSelection *>(
1164 if (ese) {
1165 BLI_freelinkN(&bm->selected, ese);
1166 return true;
1167 }
1168 return false;
1169}
1170
1176
1182
1184{
1185 if (!BM_select_history_check(bm, (BMElem *)ele)) {
1187 }
1188}
1189
1196
1202
1204{
1205 if (!BM_select_history_check(bm, (BMElem *)ele)) {
1207 }
1208}
1209/* --- End macro wrapped functions --- */
1210
1212{
1213 bm->selected.free_no_destruct();
1214}
1215
1217{
1218 BMEditSelection *ese, *ese_next;
1219
1220 for (ese = bm->selected.first(); ese; ese = ese_next) {
1221 ese_next = ese->next;
1222 if (!BM_elem_flag_test(ese->ele, BM_ELEM_SELECT)) {
1223 BLI_freelinkN(&(bm->selected), ese);
1224 }
1225 }
1226}
1227
1229{
1230 char htype_selected = 0;
1231 for (const BMEditSelection &ese : bm->selected) {
1232 htype_selected |= ese.htype;
1233 /* Early exit if all types found. */
1234 if (htype_selected == (BM_VERT | BM_EDGE | BM_FACE)) {
1235 break;
1236 }
1237 }
1238 return htype_selected;
1239}
1240
1242{
1243 BMEditSelection *ese_last = bm->selected.last();
1244 BMFace *efa = BM_mesh_active_face_get(bm, false, true);
1245
1246 ese->next = ese->prev = nullptr;
1247
1248 if (ese_last) {
1249 /* If there is an active face, use it over the last selected face. */
1250 if (ese_last->htype == BM_FACE) {
1251 if (efa) {
1252 ese->ele = reinterpret_cast<BMElem *>(efa);
1253 }
1254 else {
1255 ese->ele = ese_last->ele;
1256 }
1257 ese->htype = BM_FACE;
1258 }
1259 else {
1260 ese->ele = ese_last->ele;
1261 ese->htype = ese_last->htype;
1262 }
1263 }
1264 else if (efa) {
1265 /* no edit-selection, fall back to active face */
1266 ese->ele = reinterpret_cast<BMElem *>(efa);
1267 ese->htype = BM_FACE;
1268 }
1269 else {
1270 ese->ele = nullptr;
1271 return false;
1272 }
1273
1274 return true;
1275}
1276
1278{
1279 if (bm->selected.is_empty()) {
1280 return nullptr;
1281 }
1282
1283 GHash *map = BLI_ghash_ptr_new(__func__);
1284
1285 for (BMEditSelection &ese : bm->selected) {
1286 BLI_ghash_insert(map, ese.ele, &ese);
1287 }
1288
1289 return map;
1290}
1291
1293 Map<void *, void *> *vert_map,
1294 Map<void *, void *> *edge_map,
1295 Map<void *, void *> *face_map,
1296 const bool use_chain)
1297{
1298
1299#ifndef NDEBUG
1300 for (BMEditSelection &ese : bm->selected) {
1302 }
1303#endif
1304
1305 for (BMEditSelection &ese : bm->selected) {
1307
1308 /* Only loop when (use_chain == true). */
1309 Map<void *, void *> *map = nullptr;
1310 switch (ese.ele->head.htype) {
1311 case BM_VERT:
1312 map = vert_map;
1313 break;
1314 case BM_EDGE:
1315 map = edge_map;
1316 break;
1317 case BM_FACE:
1318 map = face_map;
1319 break;
1320 default:
1321 BMESH_ASSERT(0);
1322 break;
1323 }
1324 if (map != nullptr) {
1325 BMElem *ele_dst = ese.ele;
1326 while (true) {
1327 BMElem *ele_dst_next = static_cast<BMElem *>(map->lookup_default(ele_dst, nullptr));
1328 BLI_assert(ele_dst != ele_dst_next);
1329 if (ele_dst_next == nullptr) {
1330 break;
1331 }
1332 ele_dst = ele_dst_next;
1333 /* Break loop on circular reference (should never happen). */
1334 if (ele_dst == ese.ele) [[unlikely]] {
1335 BLI_assert(0);
1336 break;
1337 }
1338 if (use_chain == false) {
1339 break;
1340 }
1341 }
1342 ese.ele = ele_dst;
1343 }
1344 }
1345
1346 /* Remove overlapping duplicates. */
1347 for (BMEditSelection *ese = bm->selected.first(), *ese_next; ese; ese = ese_next) {
1348 ese_next = ese->next;
1351 }
1352 else {
1353 BLI_freelinkN(&bm->selected, ese);
1354 }
1355 }
1356}
1357
1359 const char htype,
1360 const char hflag,
1361 const bool respecthide,
1362 const bool overwrite,
1363 const char hflag_test)
1364{
1365 const char iter_types[3] = {BM_VERTS_OF_MESH, BM_EDGES_OF_MESH, BM_FACES_OF_MESH};
1366
1367 const char flag_types[3] = {BM_VERT, BM_EDGE, BM_FACE};
1368
1369 const char hflag_nosel = hflag & ~BM_ELEM_SELECT;
1370
1371 int i;
1372
1373 BLI_assert((htype & ~BM_ALL_NOLOOP) == 0);
1374
1375 if (hflag & BM_ELEM_SELECT) {
1377 }
1378
1379 if ((htype == (BM_VERT | BM_EDGE | BM_FACE)) && (hflag == BM_ELEM_SELECT) &&
1380 (respecthide == false) && (hflag_test == 0))
1381 {
1382 /* fast path for deselect all, avoid topology loops
1383 * since we know all will be de-selected anyway. */
1384 for (i = 0; i < 3; i++) {
1385 BMIter iter;
1386 BMElem *ele;
1387
1388 ele = static_cast<BMElem *>(BM_iter_new(&iter, bm, iter_types[i], nullptr));
1389 for (; ele; ele = static_cast<BMElem *>(BM_iter_step(&iter))) {
1391 }
1392 }
1393
1395 }
1396 else {
1397 for (i = 0; i < 3; i++) {
1398 BMIter iter;
1399 BMElem *ele;
1400
1401 if (htype & flag_types[i]) {
1402 ele = static_cast<BMElem *>(BM_iter_new(&iter, bm, iter_types[i], nullptr));
1403 for (; ele; ele = static_cast<BMElem *>(BM_iter_step(&iter))) {
1404
1405 if (respecthide && BM_elem_flag_test(ele, BM_ELEM_HIDDEN)) [[unlikely]] {
1406 /* pass */
1407 }
1408 else if (!hflag_test || BM_elem_flag_test(ele, hflag_test)) {
1409 if (hflag & BM_ELEM_SELECT) {
1410 BM_elem_select_set(bm, ele, false);
1411 }
1412 BM_elem_flag_disable(ele, hflag);
1413 }
1414 else if (overwrite) {
1415 /* no match! */
1416 if (hflag & BM_ELEM_SELECT) {
1417 BM_elem_select_set(bm, ele, true);
1418 }
1419 BM_elem_flag_enable(ele, hflag_nosel);
1420 }
1421 }
1422 }
1423 }
1424 }
1425}
1426
1428 const char htype,
1429 const char hflag,
1430 const bool respecthide,
1431 const bool overwrite,
1432 const char hflag_test)
1433{
1434 const char iter_types[3] = {BM_VERTS_OF_MESH, BM_EDGES_OF_MESH, BM_FACES_OF_MESH};
1435
1436 const char flag_types[3] = {BM_VERT, BM_EDGE, BM_FACE};
1437
1438 /* use the nosel version when setting so under no
1439 * condition may a hidden face become selected.
1440 * Applying other flags to hidden faces is OK. */
1441 const char hflag_nosel = hflag & ~BM_ELEM_SELECT;
1442
1443 BMIter iter;
1444 BMElem *ele;
1445 int i;
1446
1447 BLI_assert((htype & ~BM_ALL_NOLOOP) == 0);
1448
1449 /* NOTE: better not attempt a fast path for selection as done with de-select
1450 * because hidden geometry and different selection modes can give different results,
1451 * we could of course check for no hidden faces and then use
1452 * quicker method but its not worth it. */
1453
1454 for (i = 0; i < 3; i++) {
1455 if (htype & flag_types[i]) {
1456 ele = static_cast<BMElem *>(BM_iter_new(&iter, bm, iter_types[i], nullptr));
1457 for (; ele; ele = static_cast<BMElem *>(BM_iter_step(&iter))) {
1458
1459 if (respecthide && BM_elem_flag_test(ele, BM_ELEM_HIDDEN)) [[unlikely]] {
1460 /* pass */
1461 }
1462 else if (!hflag_test || BM_elem_flag_test(ele, hflag_test)) {
1463 /* match! */
1464 if (hflag & BM_ELEM_SELECT) {
1465 BM_elem_select_set(bm, ele, true);
1466 }
1467 BM_elem_flag_enable(ele, hflag_nosel);
1468 }
1469 else if (overwrite) {
1470 /* no match! */
1471 if (hflag & BM_ELEM_SELECT) {
1472 BM_elem_select_set(bm, ele, false);
1473 }
1474 BM_elem_flag_disable(ele, hflag);
1475 }
1476 }
1477 }
1478 }
1479}
1480
1482 const char htype,
1483 const char hflag,
1484 const bool respecthide)
1485{
1486 /* call with 0 hflag_test */
1487 BM_mesh_elem_hflag_disable_test(bm, htype, hflag, respecthide, false, 0);
1488}
1489
1491 const char htype,
1492 const char hflag,
1493 const bool respecthide)
1494{
1495 /* call with 0 hflag_test */
1496 BM_mesh_elem_hflag_enable_test(bm, htype, hflag, respecthide, false, 0);
1497}
1498
1499/***************** Mesh Hiding stuff *********** */
1500
1509
1518
1519void BM_vert_hide_set(BMVert *v, const bool hide)
1520{
1521 /* vert hiding: vert + surrounding edges and faces */
1523 if (hide) {
1525 }
1526
1528
1529 if (v->e) {
1530 BMEdge *e_iter, *e_first;
1531 e_iter = e_first = v->e;
1532 do {
1534 if (e_iter->l) {
1535 const BMLoop *l_radial_iter, *l_radial_first;
1536 l_radial_iter = l_radial_first = e_iter->l;
1537 do {
1538 BM_elem_flag_set(l_radial_iter->f, BM_ELEM_HIDDEN, hide);
1539 } while ((l_radial_iter = l_radial_iter->radial_next) != l_radial_first);
1540 }
1541 } while ((e_iter = bmesh_disk_edge_next(e_iter, v)) != e_first);
1542 }
1543}
1544
1545void BM_edge_hide_set(BMEdge *e, const bool hide)
1546{
1548 if (hide) {
1550 }
1551
1552 /* edge hiding: faces around the edge */
1553 if (e->l) {
1554 const BMLoop *l_iter, *l_first;
1555 l_iter = l_first = e->l;
1556 do {
1558 } while ((l_iter = l_iter->radial_next) != l_first);
1559 }
1560
1562
1563 /* hide vertices if necessary */
1564 if (hide) {
1567 }
1568 else {
1571 }
1572}
1573
1574void BM_face_hide_set(BMFace *f, const bool hide)
1575{
1577 if (hide) {
1579 }
1580
1582
1583 if (hide) {
1584 BMLoop *l_first = BM_FACE_FIRST_LOOP(f);
1585 BMLoop *l_iter;
1586
1587 l_iter = l_first;
1588 do {
1589 edge_flush_hide_set(l_iter->e);
1590 } while ((l_iter = l_iter->next) != l_first);
1591
1592 l_iter = l_first;
1593 do {
1594 vert_flush_hide_set(l_iter->v);
1595 } while ((l_iter = l_iter->next) != l_first);
1596 }
1597 else {
1598 BMLoop *l_first = BM_FACE_FIRST_LOOP(f);
1599 BMLoop *l_iter;
1600
1601 l_iter = l_first;
1602 do {
1605 } while ((l_iter = l_iter->next) != l_first);
1606 }
1607}
1608
1609void _bm_elem_hide_set(BMesh *bm, BMHeader *head, const bool hide)
1610{
1611 /* Follow convention of always deselecting before
1612 * hiding an element */
1613 switch (head->htype) {
1614 case BM_VERT:
1615 if (hide) {
1616 BM_vert_select_set(bm, reinterpret_cast<BMVert *>(head), false);
1617 }
1618 BM_vert_hide_set(reinterpret_cast<BMVert *>(head), hide);
1619 break;
1620 case BM_EDGE:
1621 if (hide) {
1622 BM_edge_select_set(bm, reinterpret_cast<BMEdge *>(head), false);
1623 }
1624 BM_edge_hide_set(reinterpret_cast<BMEdge *>(head), hide);
1625 break;
1626 case BM_FACE:
1627 if (hide) {
1628 BM_face_select_set(bm, reinterpret_cast<BMFace *>(head), false);
1629 }
1630 BM_face_hide_set(reinterpret_cast<BMFace *>(head), hide);
1631 break;
1632 default:
1633 BMESH_ASSERT(0);
1634 break;
1635 }
1636}
1637
1638} // namespace blender
Read Blender memory allocation and freeing.
#define ELEM(...)
#define BM_ALL_NOLOOP
#define BM_FACE_FIRST_LOOP(p)
#define BM_THREAD_LIMIT
#define BMESH_ASSERT(a)
#define BM_elem_index_get(ele)
#define BM_elem_flag_disable(ele, hflag)
#define BM_elem_flag_set(ele, hflag, val)
#define BM_elem_flag_test(ele, hflag)
#define BM_elem_flag_test_bool(ele, hflag)
#define BM_elem_flag_enable(ele, hflag)
#define BM_ITER_MESH(ele, iter, bm, itype)
#define BM_iter_new(iter, bm, itype, data)
#define BM_select_history_store_notest(bm, ele)
#define BM_select_history_store_head_notest(bm, ele)
#define BMSelectFlushFlag_Default
#define BM_select_history_store_after_notest(bm, ese_ref, ele)
#define BM_select_history_check(bm, ele)
#define BM_ELEM_API_FLAG_DISABLE(element, f)
#define BM_ELEM_API_FLAG_TEST(element, f)
#define BM_ELEM_API_FLAG_ENABLE(element, f)
Value lookup_default(const Key &key, const Value &default_value) const
Definition BLI_map.hh:570
#define offsetof(t, d)
BMesh Iterators.
void * BLI_findptr(const ListBase *listbase, const void *ptr, int offset) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1)
Definition listbase.cc:710
void BM_face_calc_center_median(const BMFace *f, float r_cent[3])
BLI_assert(slot->slot_subtype.map==BMO_OP_SLOT_SUBTYPE_MAP_FLT)
static void recount_totsels(BMesh *bm)
void BM_mesh_elem_hflag_enable_all(BMesh *bm, const char htype, const char hflag, const bool respecthide)
static int recount_totsel(BMesh *bm, BMIterType iter_type)
static TaskParallelMempoolFunc recount_totsels_get_range_func(BMIterType iter_type)
BLI_INLINE void BLI_parallel_range_settings_defaults(TaskParallelSettings *settings)
MINLINE void copy_v3_v3(float r[3], const float a[3])
void BM_editselection_center(BMEditSelection *ese, float r_center[3])
void BLI_addhead(ListBase *listbase, void *vlink) ATTR_NONNULL(1)
Definition listbase.cc:98
char BM_select_history_htype_all(const BMesh *bm)
MINLINE void add_v3_v3v3(float r[3], const float a[3], const float b[3])
static void bm_mesh_select_mode_flush_edge_to_face(BMesh *bm)
static bool bm_vert_is_edge_visible_any(const BMVert *v)
void BM_face_calc_tangent_auto(const BMFace *f, float r_tangent[3])
static int bm_mesh_flag_count(BMesh *bm, const char htype, const char hflag, const bool respecthide, const bool test_for_enabled)
static BMEditSelection * bm_select_history_create(BMHeader *ele)
void BM_mesh_elem_hflag_disable_all(BMesh *bm, const char htype, const char hflag, const bool respecthide)
static void bm_mesh_select_mode_flush_face_to_vert_and_edge(BMesh *bm)
ATTR_WARN_UNUSED_RESULT const BMVert * v
void BM_mesh_select_mode_clean(BMesh *bm)
int BM_mesh_active_edge_index_get(BMesh *bm)
void BM_mesh_select_mode_flush(BMesh *bm)
int BM_mesh_elem_hflag_count_enabled(BMesh *bm, const char htype, const char hflag, const bool respecthide)
void BLI_ghash_insert(GHash *gh, void *key, void *val)
Definition BLI_ghash.cc:711
BMEdge * BM_mesh_active_edge_get(BMesh *bm)
void BM_mesh_select_mode_clean_ex(BMesh *bm, const short selectmode)
Select Mode Clean.
GHash * BM_select_history_map_create(BMesh *bm)
void _bm_select_history_store_after_notest(BMesh *bm, BMEditSelection *ese_ref, BMHeader *ele)
static void bm_mesh_select_mode_flush_edge_to_vert(BMesh *bm)
static void recount_totfacesel(BMesh *bm)
void BM_face_select_set_noflush(BMesh *bm, BMFace *f, const bool select)
void * MEM_new_zeroed(size_t len, const char *str) ATTR_WARN_UNUSED_RESULT ATTR_ALLOC_SIZE(1) ATTR_NONNULL(2)
MINLINE void cross_v3_v3v3(float r[3], const float a[3], const float b[3])
static bool recount_totsels_are_ok(BMesh *bm)
void BM_mesh_active_face_set(BMesh *bm, BMFace *f)
void BM_vert_hide_set(BMVert *v, const bool hide)
void BLI_insertlinkafter(ListBase *listbase, void *vprevlink, void *vnewlink) ATTR_NONNULL(1)
Definition listbase.cc:339
void BM_mesh_elem_hflag_enable_test(BMesh *bm, const char htype, const char hflag, const bool respecthide, const bool overwrite, const char hflag_test)
static void bm_mesh_select_mode_flush_vert_to_edge_iter_fn(void *, MempoolIterData *iter, const TaskParallelTLS *__restrict tls)
void BM_elem_select_set(BMesh *bm, BMElem *ele, const bool select)
void BM_face_select_set(BMesh *bm, BMFace *f, const bool select)
Select Face.
bool _bm_select_history_remove(BMesh *bm, BMHeader *ele)
static void recount_totedgesel(BMesh *bm)
int BM_mesh_elem_hflag_count_disabled(BMesh *bm, const char htype, const char hflag, const bool respecthide)
void BLI_freelinkN(ListBase *listbase, void *vlink) ATTR_NONNULL(1)
Definition listbase.cc:277
static void recount_totsels_reduce(const void *__restrict, void *__restrict chunk_join, void *__restrict chunk)
static void recount_totsels_range_edge_func(void *, MempoolIterData *iter, const TaskParallelTLS *__restrict tls)
GHash * BLI_ghash_ptr_new(const char *info) ATTR_MALLOC ATTR_WARN_UNUSED_RESULT
BLI_INLINE bool BM_edge_is_boundary(const BMEdge *e) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL()
static void recount_totsels_range_face_func(void *, MempoolIterData *iter, const TaskParallelTLS *__restrict tls)
void _bm_select_history_store_head(BMesh *bm, BMHeader *ele)
void BM_editselection_plane(BMEditSelection *ese, float r_plane[3])
static void recount_totvertsel(BMesh *bm)
void BM_mesh_select_mode_set(BMesh *bm, int selectmode)
static void bm_mesh_select_mode_flush_edge_to_face_iter_fn(void *, MempoolIterData *iter, const TaskParallelTLS *__restrict tls)
static void edge_flush_hide_set(BMEdge *e)
int BM_mesh_active_face_index_get(BMesh *bm, bool is_sloppy, bool is_selected)
void BM_vert_select_set(BMesh *bm, BMVert *v, const bool select)
Select Vert.
static bool bm_edge_is_face_select_any_other(BMLoop *l_first)
static bool bm_vert_is_edge_select_any_other(const BMVert *v, const BMEdge *e_first)
void BM_select_history_validate(BMesh *bm)
MINLINE float normalize_v3(float n[3])
MINLINE void sub_v3_v3v3(float r[3], const float a[3], const float b[3])
void mid_v3_v3v3(float r[3], const float a[3], const float b[3])
void _bm_elem_hide_set(BMesh *bm, BMHeader *head, const bool hide)
void BLI_addtail(ListBase *listbase, void *vlink) ATTR_NONNULL(1)
Definition listbase.cc:118
BMFace * BM_mesh_active_face_get(BMesh *bm, const bool is_sloppy, const bool is_selected)
void BM_mesh_elem_hflag_disable_test(BMesh *bm, const char htype, const char hflag, const bool respecthide, const bool overwrite, const char hflag_test)
BMElem * BM_mesh_active_elem_get(BMesh *bm)
void BM_face_hide_set(BMFace *f, const bool hide)
bool _bm_select_history_check(BMesh *bm, const BMHeader *ele)
static void bm_mesh_select_mode_flush_reduce_fn(const void *__restrict, void *__restrict chunk_join, void *__restrict chunk)
void BM_select_history_merge_from_targetmap(BMesh *bm, Map< void *, void * > *vert_map, Map< void *, void * > *edge_map, Map< void *, void * > *face_map, const bool use_chain)
void BM_select_history_clear(BMesh *bm)
BLI_INLINE BMEdge * bmesh_disk_edge_next(const BMEdge *e, const BMVert *v) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL()
static void vert_flush_hide_set(BMVert *v)
void _bm_select_history_store_head_notest(BMesh *bm, BMHeader *ele)
void BM_mesh_select_flush_from_verts(BMesh *bm, const bool select)
static bool bm_edge_is_face_visible_any(const BMEdge *e)
void _bm_select_history_store(BMesh *bm, BMHeader *ele)
bool BM_select_history_active_get(BMesh *bm, BMEditSelection *ese)
static void bm_mesh_select_mode_flush_vert_to_edge(BMesh *bm)
int BM_mesh_active_vert_index_get(BMesh *bm)
static void recount_totsels_range_vert_func(void *, MempoolIterData *iter, const TaskParallelTLS *__restrict tls)
void BM_editselection_normal(BMEditSelection *ese, float r_normal[3])
void BM_edge_select_set_noflush(BMesh *bm, BMEdge *e, const bool select)
void(*) TaskParallelMempoolFunc(void *userdata, MempoolIterData *iter, const TaskParallelTLS *__restrict tls)
BMVert * BM_mesh_active_vert_get(BMesh *bm)
void _bm_select_history_store_after(BMesh *bm, BMEditSelection *ese_ref, BMHeader *ele)
ATTR_WARN_UNUSED_RESULT const BMVert const BMEdge * e
void _bm_select_history_store_notest(BMesh *bm, BMHeader *ele)
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 BM_edge_hide_set(BMEdge *e, const bool hide)
bool BM_mesh_select_is_mixed(const BMesh *bm)
void BM_mesh_select_mode_flush_ex(BMesh *bm, const short selectmode, BMSelectFlushFlag flag)
Select Mode Flush.
void BM_edge_select_set(BMesh *bm, BMEdge *e, const bool select)
Select Edge.
struct BMLoop * l
struct BMEditSelection * next
struct BMEditSelection * prev
struct BMLoop * next
struct BMEdge * e
struct BMVert * v
struct BMLoop * radial_next
struct BMFace * f
TaskParallelReduceFunc func_reduce
ListBaseT< BMEditSelection > selected