Blender V5.3
bmesh_operators.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
10
11#include "MEM_guardedalloc.h"
12
13#include "BLI_listbase.hh"
14#include "BLI_math_matrix_c.hh"
15#include "BLI_math_vector_c.hh"
16#include "BLI_memarena.hh"
17#include "BLI_mempool.hh"
18#include "BLI_string.hh"
19#include "BLI_utildefines.hh"
20
21#include "bmesh.hh"
23
24namespace blender {
25
26/* forward declarations */
27static void bmo_flag_layer_alloc(BMesh *bm);
28static void bmo_flag_layer_free(BMesh *bm);
29static void bmo_flag_layer_clear(BMesh *bm);
30static int bmo_name_to_slotcode(const BMOpSlot slot_args[BMO_OP_MAX_SLOTS],
31 const char *identifier);
32static int bmo_name_to_slotcode_check(const BMOpSlot slot_args[BMO_OP_MAX_SLOTS],
33 const char *identifier);
34
36 0, /* 0: #BMO_OP_SLOT_SENTINEL */
37 sizeof(int), /* 1: #BMO_OP_SLOT_BOOL */
38 sizeof(int), /* 2: #BMO_OP_SLOT_INT */
39 sizeof(float), /* 3: #BMO_OP_SLOT_FLT */
40 sizeof(void *), /* 4: #BMO_OP_SLOT_PNT */
41 sizeof(void *), /* 5: #BMO_OP_SLOT_PNT */
42 0, /* 6: unused */
43 0, /* 7: unused */
44 sizeof(float[3]), /* 8: #BMO_OP_SLOT_VEC */
45 sizeof(void *), /* 9: #BMO_OP_SLOT_ELEMENT_BUF */
46 sizeof(void *), /* 10: #BMO_OP_SLOT_MAPPING */
47};
48
49/* Dummy slot so there is something to return when slot name lookup fails */
50// static BMOpSlot BMOpEmptySlot = {0};
51
52void BMO_op_flag_enable(BMesh * /*bm*/, BMOperator *op, const int op_flag)
53{
54 op->flag |= op_flag;
55}
56
57void BMO_op_flag_disable(BMesh * /*bm*/, BMOperator *op, const int op_flag)
58{
59 op->flag &= ~op_flag;
60}
61
62void BMO_push(BMesh *bm, BMOperator * /*op*/)
63{
65
67
68 /* add flag layer, if appropriate */
69 if (bm->toolflag_index > 0) {
71 }
72 else {
74 }
75}
76
78{
79 if (bm->toolflag_index > 0) {
81 }
82
84}
85
86/* use for both slot_types_in and slot_types_out */
87static void bmo_op_slots_init(const BMOSlotType *slot_types, BMOpSlot *slot_args)
88{
89 BMOpSlot *slot;
90 uint i;
91 for (i = 0; slot_types[i].type; i++) {
92 slot = &slot_args[i];
93 slot->slot_name = slot_types[i].name;
94 slot->slot_type = slot_types[i].type;
95 slot->slot_subtype = slot_types[i].subtype;
96 // slot->index = i; // UNUSED
97
98 switch (slot->slot_type) {
100 slot->data.ghash = BLI_ghash_ptr_new("bmesh slot map hash");
101 break;
102 case BMO_OP_SLOT_INT:
103 if (ELEM(slot->slot_subtype.intg,
106 {
107 slot->data.enum_data.flags = slot_types[i].enum_flags;
108 /* Set the first value of the enum as the default value. */
109 slot->data.i = slot->data.enum_data.flags[0].value;
110 }
111 default:
112 break;
113 }
114 }
115}
116
117static void bmo_op_slots_free(const BMOSlotType *slot_types, BMOpSlot *slot_args)
118{
119 BMOpSlot *slot;
120 uint i;
121 for (i = 0; slot_types[i].type; i++) {
122 slot = &slot_args[i];
123 switch (slot->slot_type) {
125 BLI_ghash_free(slot->data.ghash, nullptr, nullptr);
126 break;
127 default:
128 break;
129 }
130 }
131}
132
133void BMO_op_init(BMesh *bm, BMOperator *op, const int flag, const char *opname)
134{
135 int opcode = BMO_opcode_from_opname(opname);
136
137#ifndef NDEBUG
138 BM_ELEM_INDEX_VALIDATE(bm, "pre bmo", opname);
139#else
140 (void)bm;
141#endif
142
143 if (opcode == -1) {
144 opcode = 0; /* error!, already printed, have a better way to handle this? */
145 }
146
147 memset(op, 0, sizeof(BMOperator));
148 op->type = opcode;
149 op->type_flag = bmo_opdefines[opcode]->type_flag;
150 op->flag = flag;
151
152 /* initialize the operator slot types */
153 bmo_op_slots_init(bmo_opdefines[opcode]->slot_types_in, op->slots_in);
154 bmo_op_slots_init(bmo_opdefines[opcode]->slot_types_out, op->slots_out);
155
156 /* callback */
157 op->exec = bmo_opdefines[opcode]->exec;
158
159 /* memarena, used for operator's slot buffers */
162
163 if (bmo_opdefines[opcode]->init) {
164 bmo_opdefines[opcode]->init(op);
165 }
166}
167
169{
170 /* allocate tool flags on demand */
172
173 BMO_push(bm, op);
174
175 if (bm->toolflag_index == 1) {
177 }
178 op->exec(bm, op);
179
180 if (bm->toolflag_index == 1) {
182 }
183
184 BMO_pop(bm);
185}
186
188{
191
193
194#ifndef NDEBUG
196
197 /* avoid accidental re-use */
198 memset(op, 0xff, sizeof(*op));
199#else
200 (void)bm;
201#endif
202}
203
204bool BMO_slot_exists(BMOpSlot slot_args[BMO_OP_MAX_SLOTS], const char *identifier)
205{
206 int slot_code = bmo_name_to_slotcode(slot_args, identifier);
207 return (slot_code >= 0);
208}
209
210BMOpSlot *BMO_slot_get(BMOpSlot slot_args[BMO_OP_MAX_SLOTS], const char *identifier)
211{
212 int slot_code = bmo_name_to_slotcode_check(slot_args, identifier);
213
214 if (slot_code < 0) [[unlikely]] {
215 // return &BMOpEmptySlot;
216 BLI_assert(0);
217 return nullptr; /* better crash */
218 }
219
220 return &slot_args[slot_code];
221}
222
224 const char *slot_name_src,
225 BMOpSlot slot_args_dst[BMO_OP_MAX_SLOTS],
226 const char *slot_name_dst,
227 MemArena *arena_dst)
228{
229 BMOpSlot *slot_src = BMO_slot_get(slot_args_src, slot_name_src);
230 BMOpSlot *slot_dst = BMO_slot_get(slot_args_dst, slot_name_dst);
231
232 if (slot_src == slot_dst) {
233 return;
234 }
235
236 BLI_assert(slot_src->slot_type == slot_dst->slot_type);
237 if (slot_src->slot_type != slot_dst->slot_type) {
238 return;
239 }
240
241 if (slot_dst->slot_type == BMO_OP_SLOT_ELEMENT_BUF) {
242 /* do buffer copy */
243 slot_dst->data.buf = nullptr;
244 slot_dst->len = slot_src->len;
245 if (slot_dst->len) {
246 /* Check destination has all flags enabled that the source has. */
247 const eBMOpSlotSubType_Elem src_elem_flag = eBMOpSlotSubType_Elem(
248 (slot_src->slot_subtype.elem & BM_ALL_NOLOOP));
249 const eBMOpSlotSubType_Elem dst_elem_flag = eBMOpSlotSubType_Elem(
250 (slot_dst->slot_subtype.elem & BM_ALL_NOLOOP));
251
252 if ((src_elem_flag | dst_elem_flag) == dst_elem_flag) {
253 /* pass */
254 }
255 else {
256 /* check types */
257 const uint tot = slot_src->len;
258 uint i;
259 uint out = 0;
260 BMElem **ele_src = reinterpret_cast<BMElem **>(slot_src->data.buf);
261 for (i = 0; i < tot; i++, ele_src++) {
262 if ((*ele_src)->head.htype & dst_elem_flag) {
263 out++;
264 }
265 }
266 if (out != tot) {
267 slot_dst->len = out;
268 }
269 }
270
271 if (slot_dst->len) {
272 const int slot_alloc_size = BMO_OPSLOT_TYPEINFO[slot_dst->slot_type] * slot_dst->len;
273 slot_dst->data.buf = static_cast<void **>(BLI_memarena_alloc(arena_dst, slot_alloc_size));
274 if (slot_src->len == slot_dst->len) {
275 memcpy(slot_dst->data.buf, slot_src->data.buf, slot_alloc_size);
276 }
277 else {
278 /* only copy compatible elements */
279 const uint tot = slot_src->len;
280 uint i;
281 BMElem **ele_src = reinterpret_cast<BMElem **>(slot_src->data.buf);
282 BMElem **ele_dst = reinterpret_cast<BMElem **>(slot_dst->data.buf);
283 for (i = 0; i < tot; i++, ele_src++) {
284 if ((*ele_src)->head.htype & dst_elem_flag) {
285 *ele_dst = *ele_src;
286 ele_dst++;
287 }
288 }
289 }
290 }
291 }
292 }
293 else if (slot_dst->slot_type == BMO_OP_SLOT_MAPPING) {
294 GHashIterator gh_iter;
295 GHASH_ITER (gh_iter, slot_src->data.ghash) {
296 void *key = BLI_ghashIterator_getKey(&gh_iter);
297 void *val = BLI_ghashIterator_getValue(&gh_iter);
298 BLI_ghash_insert(slot_dst->data.ghash, key, val);
299 }
300 }
301 else {
302 slot_dst->data = slot_src->data;
303 }
304}
305
306/*
307 * BMESH OPSTACK SET XXX
308 *
309 * Sets the value of a slot depending on its type
310 */
311
312void BMO_slot_float_set(BMOpSlot slot_args[BMO_OP_MAX_SLOTS], const char *slot_name, const float f)
313{
314 BMOpSlot *slot = BMO_slot_get(slot_args, slot_name);
316 if (!(slot->slot_type == BMO_OP_SLOT_FLT)) {
317 return;
318 }
319
320 slot->data.f = f;
321}
322
323void BMO_slot_int_set(BMOpSlot slot_args[BMO_OP_MAX_SLOTS], const char *slot_name, const int i)
324{
325 BMOpSlot *slot = BMO_slot_get(slot_args, slot_name);
327 if (!(slot->slot_type == BMO_OP_SLOT_INT)) {
328 return;
329 }
330
331 slot->data.i = i;
332}
333
334void BMO_slot_bool_set(BMOpSlot slot_args[BMO_OP_MAX_SLOTS], const char *slot_name, const bool i)
335{
336 BMOpSlot *slot = BMO_slot_get(slot_args, slot_name);
338 if (!(slot->slot_type == BMO_OP_SLOT_BOOL)) {
339 return;
340 }
341
342 slot->data.i = i;
343}
344
346 BMOpSlot slot_args[BMO_OP_MAX_SLOTS],
347 const char *slot_name,
348 const float *mat,
349 int size)
350{
351 BMOpSlot *slot = BMO_slot_get(slot_args, slot_name);
353 if (!(slot->slot_type == BMO_OP_SLOT_MAT)) {
354 return;
355 }
356
357 slot->len = 4;
358 slot->data.p = BLI_memarena_alloc(op->arena, sizeof(float[4][4]));
359
360 if (size == 4) {
361 copy_m4_m4(static_cast<float (*)[4]>(slot->data.p), reinterpret_cast<const float (*)[4]>(mat));
362 }
363 else if (size == 3) {
364 copy_m4_m3(static_cast<float (*)[4]>(slot->data.p), reinterpret_cast<const float (*)[3]>(mat));
365 }
366 else {
367 fprintf(stderr, "%s: invalid size argument %d (bmesh internal error)\n", __func__, size);
368
369 zero_m4(static_cast<float (*)[4]>(slot->data.p));
370 }
371}
372
374 const char *slot_name,
375 float r_mat[4][4])
376{
377 BMOpSlot *slot = BMO_slot_get(slot_args, slot_name);
379 if (!(slot->slot_type == BMO_OP_SLOT_MAT)) {
380 return;
381 }
382
383 if (slot->data.p) {
384 copy_m4_m4(r_mat, BMO_SLOT_AS_MATRIX(slot));
385 }
386 else {
387 unit_m4(r_mat);
388 }
389}
390
392 const char *slot_name,
393 float r_mat[3][3])
394{
395 BMOpSlot *slot = BMO_slot_get(slot_args, slot_name);
397 if (!(slot->slot_type == BMO_OP_SLOT_MAT)) {
398 return;
399 }
400
401 if (slot->data.p) {
402 copy_m3_m4(r_mat, BMO_SLOT_AS_MATRIX(slot));
403 }
404 else {
405 unit_m3(r_mat);
406 }
407}
408
409void BMO_slot_ptr_set(BMOpSlot slot_args[BMO_OP_MAX_SLOTS], const char *slot_name, void *p)
410{
411 BMOpSlot *slot = BMO_slot_get(slot_args, slot_name);
413 if (!(slot->slot_type == BMO_OP_SLOT_PTR)) {
414 return;
415 }
416
417 slot->data.p = p;
418}
419
421 const char *slot_name,
422 const float vec[3])
423{
424 BMOpSlot *slot = BMO_slot_get(slot_args, slot_name);
426 if (!(slot->slot_type == BMO_OP_SLOT_VEC)) {
427 return;
428 }
429
430 copy_v3_v3(slot->data.vec, vec);
431}
432
433float BMO_slot_float_get(BMOpSlot slot_args[BMO_OP_MAX_SLOTS], const char *slot_name)
434{
435 BMOpSlot *slot = BMO_slot_get(slot_args, slot_name);
437 if (!(slot->slot_type == BMO_OP_SLOT_FLT)) {
438 return 0.0f;
439 }
440
441 return slot->data.f;
442}
443
444int BMO_slot_int_get(BMOpSlot slot_args[BMO_OP_MAX_SLOTS], const char *slot_name)
445{
446 BMOpSlot *slot = BMO_slot_get(slot_args, slot_name);
448 if (!(slot->slot_type == BMO_OP_SLOT_INT)) {
449 return 0;
450 }
451
452 return slot->data.i;
453}
454
455bool BMO_slot_bool_get(BMOpSlot slot_args[BMO_OP_MAX_SLOTS], const char *slot_name)
456{
457 BMOpSlot *slot = BMO_slot_get(slot_args, slot_name);
459 if (!(slot->slot_type == BMO_OP_SLOT_BOOL)) {
460 return false;
461 }
462
463 return slot->data.i;
464}
465
466void *BMO_slot_as_arrayN(BMOpSlot slot_args[BMO_OP_MAX_SLOTS], const char *slot_name, int *len)
467{
468 BMOpSlot *slot = BMO_slot_get(slot_args, slot_name);
469 void **ret;
470
471 /* could add support for mapping type */
473
475 memcpy(ret, slot->data.buf, sizeof(void *) * slot->len);
476 *len = slot->len;
477 return ret;
478}
479
480void *BMO_slot_ptr_get(BMOpSlot slot_args[BMO_OP_MAX_SLOTS], const char *slot_name)
481{
482 BMOpSlot *slot = BMO_slot_get(slot_args, slot_name);
484 if (!(slot->slot_type == BMO_OP_SLOT_PTR)) {
485 return nullptr;
486 }
487
488 return slot->data.p;
489}
490
491void BMO_slot_vec_get(BMOpSlot slot_args[BMO_OP_MAX_SLOTS], const char *slot_name, float r_vec[3])
492{
493 BMOpSlot *slot = BMO_slot_get(slot_args, slot_name);
495 if (!(slot->slot_type == BMO_OP_SLOT_VEC)) {
496 return;
497 }
498
499 copy_v3_v3(r_vec, slot->data.vec);
500}
501
502/*
503 * BMO_COUNTFLAG
504 *
505 * Counts the number of elements of a certain type that have a
506 * specific flag enabled (or disabled if test_for_enabled is false).
507 */
508
510 const char htype,
511 const short oflag,
512 const bool test_for_enabled)
513{
514 int count_vert = 0, count_edge = 0, count_face = 0;
515
516 if (htype & BM_VERT) {
517 BMIter iter;
518 BMVert *ele;
519 BM_ITER_MESH (ele, &iter, bm, BM_VERTS_OF_MESH) {
520 if (BMO_vert_flag_test_bool(bm, ele, oflag) == test_for_enabled) {
521 count_vert++;
522 }
523 }
524 }
525 if (htype & BM_EDGE) {
526 BMIter iter;
527 BMEdge *ele;
528 BM_ITER_MESH (ele, &iter, bm, BM_EDGES_OF_MESH) {
529 if (BMO_edge_flag_test_bool(bm, ele, oflag) == test_for_enabled) {
530 count_edge++;
531 }
532 }
533 }
534 if (htype & BM_FACE) {
535 BMIter iter;
536 BMFace *ele;
537 BM_ITER_MESH (ele, &iter, bm, BM_FACES_OF_MESH) {
538 if (BMO_face_flag_test_bool(bm, ele, oflag) == test_for_enabled) {
539 count_face++;
540 }
541 }
542 }
543
544 return (count_vert + count_edge + count_face);
545}
546
547int BMO_mesh_enabled_flag_count(BMesh *bm, const char htype, const short oflag)
548{
549 return bmo_mesh_flag_count(bm, htype, oflag, true);
550}
551
552int BMO_mesh_disabled_flag_count(BMesh *bm, const char htype, const short oflag)
553{
554 return bmo_mesh_flag_count(bm, htype, oflag, false);
555}
556
557void BMO_mesh_flag_disable_all(BMesh *bm, BMOperator * /*op*/, const char htype, const short oflag)
558{
559 if (htype & BM_VERT) {
560 BMIter iter;
561 BMVert *ele;
562 BM_ITER_MESH (ele, &iter, bm, BM_VERTS_OF_MESH) {
564 }
565 }
566 if (htype & BM_EDGE) {
567 BMIter iter;
568 BMEdge *ele;
569 BM_ITER_MESH (ele, &iter, bm, BM_EDGES_OF_MESH) {
571 }
572 }
573 if (htype & BM_FACE) {
574 BMIter iter;
575 BMFace *ele;
576 BM_ITER_MESH (ele, &iter, bm, BM_FACES_OF_MESH) {
578 }
579 }
580}
581
583 BMOpSlot *slot_vert_map,
584 BMOpSlot *slot_edge_map,
585 BMOpSlot *slot_face_map,
586 const bool check_select)
587{
588 if (bm->selected.first()) {
589 BMEditSelection *ese, *ese_next;
590 BMOpSlot *slot_elem_map;
591
592 for (ese = bm->selected.first(); ese; ese = ese_next) {
593 ese_next = ese->next;
594
595 switch (ese->htype) {
596 case BM_VERT:
597 slot_elem_map = slot_vert_map;
598 break;
599 case BM_EDGE:
600 slot_elem_map = slot_edge_map;
601 break;
602 default:
603 slot_elem_map = slot_face_map;
604 break;
605 }
606
607 ese->ele = static_cast<BMElem *>(BMO_slot_map_elem_get(slot_elem_map, ese->ele));
608
609 if ((ese->ele == nullptr) ||
610 (check_select && (BM_elem_flag_test(ese->ele, BM_ELEM_SELECT) == false))) [[unlikely]]
611 {
612 BLI_remlink(&bm->selected, ese);
613 MEM_delete(ese);
614 }
615 }
616 }
617
618 if (bm->act_face) {
619 BMFace *f = static_cast<BMFace *>(BMO_slot_map_elem_get(slot_face_map, bm->act_face));
620 if (f) {
621 bm->act_face = f;
622 }
623 }
624}
625
626int BMO_slot_buffer_len(BMOpSlot slot_args[BMO_OP_MAX_SLOTS], const char *slot_name)
627{
628 BMOpSlot *slot = BMO_slot_get(slot_args, slot_name);
630
631 /* check if its actually a buffer */
632 if (slot->slot_type != BMO_OP_SLOT_ELEMENT_BUF) {
633 return 0;
634 }
635
636 return slot->len;
637}
638
639int BMO_slot_map_len(BMOpSlot slot_args[BMO_OP_MAX_SLOTS], const char *slot_name)
640{
641 BMOpSlot *slot = BMO_slot_get(slot_args, slot_name);
643 return BLI_ghash_len(slot->data.ghash);
644}
645
646void BMO_slot_map_insert(BMOperator *op, BMOpSlot *slot, const void *element, const void *data)
647{
648 (void)op; /* Ignored in release builds. */
649
651 BMO_ASSERT_SLOT_IN_OP(slot, op);
652
653 BLI_ghash_insert(slot->data.ghash, const_cast<void *>(element), const_cast<void *>(data));
654}
655
656#if 0
657void *bmo_slot_buffer_grow(BMesh *bm, BMOperator *op, int slot_code, int totadd)
658{
659 BMOpSlot *slot = &op->slots[slot_code];
660 void *tmp;
661 int64_t allocsize;
662
663 BLI_assert(slot->slottype == BMO_OP_SLOT_ELEMENT_BUF);
664
665 /* check if its actually a buffer */
666 if (slot->slottype != BMO_OP_SLOT_ELEMENT_BUF) {
667 return nullptr;
668 }
669
670 if (slot->flag & BMOS_DYNAMIC_ARRAY) {
671 if (slot->len >= slot->size) {
672 slot->size = (slot->size + 1 + totadd) * 2;
673
674 allocsize = BMO_OPSLOT_TYPEINFO[bmo_opdefines[op->type]->slot_types[slot_code].type] *
675 slot->size;
676 slot->data.buf = MEM_realloc_zeroed_id(slot->data.buf, allocsize, "opslot dynamic array");
677 }
678
679 slot->len += totadd;
680 }
681 else {
682 slot->flag |= BMOS_DYNAMIC_ARRAY;
683 slot->len += totadd;
684 slot->size = slot->len + 2;
685
686 allocsize = BMO_OPSLOT_TYPEINFO[bmo_opdefines[op->type]->slot_types[slot_code].type] *
687 slot->len;
688
689 tmp = slot->data.buf;
690 slot->data.buf = MEM_new_zeroed(allocsize, "opslot dynamic array");
691 memcpy(slot->data.buf, tmp, allocsize);
692 }
693
694 return slot->data.buf;
695}
696#endif
697
699 BMOpSlot slot_args[BMO_OP_MAX_SLOTS],
700 const char *slot_name,
701 const char htype,
702 const short oflag)
703{
704 GHashIterator gh_iter;
705 BMOpSlot *slot = BMO_slot_get(slot_args, slot_name);
706 BMElemF *ele_f;
707
709
710 GHASH_ITER (gh_iter, slot->data.ghash) {
711 ele_f = static_cast<BMElemF *>(BLI_ghashIterator_getKey(&gh_iter));
712 if (ele_f->head.htype & htype) {
714 }
715 }
716}
717
719 BMOpSlot slot_args[BMO_OP_MAX_SLOTS],
720 const char *slot_name,
721 const int len)
722{
723 BMOpSlot *slot = BMO_slot_get(slot_args, slot_name);
724
725 /* check if its actually a buffer */
726 if (slot->slot_type != BMO_OP_SLOT_ELEMENT_BUF) {
727 return nullptr;
728 }
729
730 slot->len = len;
731 if (len) {
732 slot->data.buf = static_cast<void **>(
734 }
735 else {
736 slot->data.buf = nullptr;
737 }
738
739 return slot->data.buf;
740}
741
743 BMOperator *op,
744 BMOpSlot slot_args[BMO_OP_MAX_SLOTS],
745 const char *slot_name,
746 const char htype)
747{
748 BMOpSlot *output = BMO_slot_get(slot_args, slot_name);
749 int totelement = 0, i = 0;
750
752 BLI_assert(((output->slot_subtype.elem & BM_ALL_NOLOOP) & htype) == htype);
753
754 if (htype & BM_VERT) {
755 totelement += bm->totvert;
756 }
757 if (htype & BM_EDGE) {
758 totelement += bm->totedge;
759 }
760 if (htype & BM_FACE) {
761 totelement += bm->totface;
762 }
763
764 if (totelement) {
765 BMIter iter;
766 BMHeader *ele;
767
768 BMO_slot_buffer_alloc(op, slot_args, slot_name, totelement);
769
770 /* TODO: collapse these loops into one. */
771
772 if (htype & BM_VERT) {
773 BM_ITER_MESH (ele, &iter, bm, BM_VERTS_OF_MESH) {
774 output->data.buf[i] = ele;
775 i++;
776 }
777 }
778
779 if (htype & BM_EDGE) {
780 BM_ITER_MESH (ele, &iter, bm, BM_EDGES_OF_MESH) {
781 output->data.buf[i] = ele;
782 i++;
783 }
784 }
785
786 if (htype & BM_FACE) {
787 BM_ITER_MESH (ele, &iter, bm, BM_FACES_OF_MESH) {
788 output->data.buf[i] = ele;
789 i++;
790 }
791 }
792 }
793}
794
802 BMOperator *op,
803 BMOpSlot slot_args[BMO_OP_MAX_SLOTS],
804 const char *slot_name,
805 const char htype,
806 const char hflag,
807 const bool test_for_enabled)
808{
809 BMOpSlot *output = BMO_slot_get(slot_args, slot_name);
810 int totelement = 0, i = 0;
811 const bool respecthide = ((op->flag & BMO_FLAG_RESPECT_HIDE) != 0) &&
812 ((hflag & BM_ELEM_HIDDEN) == 0);
813
815 BLI_assert(((output->slot_subtype.elem & BM_ALL_NOLOOP) & htype) == htype);
816 BLI_assert((output->slot_subtype.elem & BMO_OP_SLOT_SUBTYPE_ELEM_IS_SINGLE) == 0);
817
818 if (test_for_enabled) {
819 totelement = BM_mesh_elem_hflag_count_enabled(bm, htype, hflag, respecthide);
820 }
821 else {
822 totelement = BM_mesh_elem_hflag_count_disabled(bm, htype, hflag, respecthide);
823 }
824
825 if (totelement) {
826 BMIter iter;
827 BMElem *ele;
828
829 BMO_slot_buffer_alloc(op, slot_args, slot_name, totelement);
830
831 /* TODO: collapse these loops into one. */
832
833 if (htype & BM_VERT) {
834 BM_ITER_MESH (ele, &iter, bm, BM_VERTS_OF_MESH) {
835 if ((!respecthide || !BM_elem_flag_test(ele, BM_ELEM_HIDDEN)) &&
836 BM_elem_flag_test_bool(ele, hflag) == test_for_enabled)
837 {
838 output->data.buf[i] = ele;
839 i++;
840 }
841 }
842 }
843
844 if (htype & BM_EDGE) {
845 BM_ITER_MESH (ele, &iter, bm, BM_EDGES_OF_MESH) {
846 if ((!respecthide || !BM_elem_flag_test(ele, BM_ELEM_HIDDEN)) &&
847 BM_elem_flag_test_bool(ele, hflag) == test_for_enabled)
848 {
849 output->data.buf[i] = ele;
850 i++;
851 }
852 }
853 }
854
855 if (htype & BM_FACE) {
856 BM_ITER_MESH (ele, &iter, bm, BM_FACES_OF_MESH) {
857 if ((!respecthide || !BM_elem_flag_test(ele, BM_ELEM_HIDDEN)) &&
858 BM_elem_flag_test_bool(ele, hflag) == test_for_enabled)
859 {
860 output->data.buf[i] = ele;
861 i++;
862 }
863 }
864 }
865 }
866 else {
867 output->len = 0;
868 }
869}
870
872 BMOperator *op,
873 BMOpSlot slot_args[BMO_OP_MAX_SLOTS],
874 const char *slot_name,
875 const char htype,
876 const char hflag)
877{
878 bmo_slot_buffer_from_hflag(bm, op, slot_args, slot_name, htype, hflag, true);
879}
880
882 BMOperator *op,
883 BMOpSlot slot_args[BMO_OP_MAX_SLOTS],
884 const char *slot_name,
885 const char htype,
886 const char hflag)
887{
888 bmo_slot_buffer_from_hflag(bm, op, slot_args, slot_name, htype, hflag, false);
889}
890
892{
893 BMO_ASSERT_SLOT_IN_OP(slot, op);
896 BLI_assert(ELEM(slot->len, 0, 1));
897
898 BLI_assert(slot->slot_subtype.elem & ele->htype);
899
900 slot->data.buf = static_cast<void **>(
901 BLI_memarena_alloc(op->arena, sizeof(void *) * 4)); /* XXX, why 'x4' ? */
902 slot->len = 1;
903 *slot->data.buf = ele;
904}
905
907 BMOpSlot *slot,
908 BMHeader **ele_buffer,
909 int ele_buffer_len)
910{
911 BMO_ASSERT_SLOT_IN_OP(slot, op);
913 BLI_assert(ELEM(slot->len, 0, ele_buffer_len));
914
915 if (slot->data.buf == nullptr) {
916 slot->data.buf = static_cast<void **>(
917 BLI_memarena_alloc(op->arena, sizeof(*slot->data.buf) * ele_buffer_len));
918 }
919
920 slot->len = ele_buffer_len;
921 memcpy(slot->data.buf, ele_buffer, ele_buffer_len * sizeof(*slot->data.buf));
922}
923
925{
928 BLI_assert(ELEM(slot->len, 0, 1));
929
930 return slot->len ? static_cast<BMHeader *>(slot->data.buf[0]) : nullptr;
931}
932
934 const char *slot_name_dst,
935 BMOpSlot slot_args_src[BMO_OP_MAX_SLOTS],
936 const char *slot_name_src,
937 MemArena *arena_dst)
938{
939 BMOpSlot *slot_dst = BMO_slot_get(slot_args_dst, slot_name_dst);
940 BMOpSlot *slot_src = BMO_slot_get(slot_args_src, slot_name_src);
941
944
945 if (slot_dst->len == 0) {
946 /* output slot is empty, copy rather than append */
947 _bmo_slot_copy(slot_args_src, slot_name_src, slot_args_dst, slot_name_dst, arena_dst);
948 }
949 else if (slot_src->len != 0) {
950 int elem_size = BMO_OPSLOT_TYPEINFO[slot_dst->slot_type];
951 int alloc_size = elem_size * (slot_dst->len + slot_src->len);
952 /* allocate new buffer */
953 void *buf = BLI_memarena_alloc(arena_dst, alloc_size);
954
955 /* copy slot data */
956 memcpy(buf, slot_dst->data.buf, elem_size * slot_dst->len);
957 memcpy((static_cast<char *>(buf)) + elem_size * slot_dst->len,
958 slot_src->data.buf,
959 elem_size * slot_src->len);
960
961 slot_dst->data.buf = static_cast<void **>(buf);
962 slot_dst->len += slot_src->len;
963 }
964}
965
973 BMOperator *op,
974 BMOpSlot slot_args[BMO_OP_MAX_SLOTS],
975 const char *slot_name,
976 const char htype,
977 const short oflag,
978 const bool test_for_enabled)
979{
980 BMOpSlot *slot = BMO_slot_get(slot_args, slot_name);
981 int totelement, i = 0;
982
983 BLI_assert(op->slots_in == slot_args || op->slots_out == slot_args);
984
986 BLI_assert(((slot->slot_subtype.elem & BM_ALL_NOLOOP) & htype) == htype);
988
989 if (test_for_enabled) {
990 totelement = BMO_mesh_enabled_flag_count(bm, htype, oflag);
991 }
992 else {
993 totelement = BMO_mesh_disabled_flag_count(bm, htype, oflag);
994 }
995
996 if (totelement) {
997 BMIter iter;
998 BMHeader *ele;
999 BMHeader **ele_array;
1000
1001 BMO_slot_buffer_alloc(op, slot_args, slot_name, totelement);
1002
1003 ele_array = reinterpret_cast<BMHeader **>(slot->data.buf);
1004
1005 /* TODO: collapse these loops into one. */
1006
1007 if (htype & BM_VERT) {
1008 BM_ITER_MESH (ele, &iter, bm, BM_VERTS_OF_MESH) {
1009 if (BMO_vert_flag_test_bool(bm, (BMVert *)ele, oflag) == test_for_enabled) {
1010 ele_array[i] = ele;
1011 i++;
1012 }
1013 }
1014 }
1015
1016 if (htype & BM_EDGE) {
1017 BM_ITER_MESH (ele, &iter, bm, BM_EDGES_OF_MESH) {
1018 if (BMO_edge_flag_test_bool(bm, (BMEdge *)ele, oflag) == test_for_enabled) {
1019 ele_array[i] = ele;
1020 i++;
1021 }
1022 }
1023 }
1024
1025 if (htype & BM_FACE) {
1026 BM_ITER_MESH (ele, &iter, bm, BM_FACES_OF_MESH) {
1027 if (BMO_face_flag_test_bool(bm, (BMFace *)ele, oflag) == test_for_enabled) {
1028 ele_array[i] = ele;
1029 i++;
1030 }
1031 }
1032 }
1033 }
1034 else {
1035 slot->len = 0;
1036 }
1037}
1038
1040 BMOperator *op,
1041 BMOpSlot slot_args[BMO_OP_MAX_SLOTS],
1042 const char *slot_name,
1043 const char htype,
1044 const short oflag)
1045{
1046 bmo_slot_buffer_from_flag(bm, op, slot_args, slot_name, htype, oflag, true);
1047}
1048
1050 BMOperator *op,
1051 BMOpSlot slot_args[BMO_OP_MAX_SLOTS],
1052 const char *slot_name,
1053 const char htype,
1054 const short oflag)
1055{
1056 bmo_slot_buffer_from_flag(bm, op, slot_args, slot_name, htype, oflag, false);
1057}
1058
1060 BMOpSlot slot_args[BMO_OP_MAX_SLOTS],
1061 const char *slot_name,
1062 const char htype,
1063 char hflag,
1064 const bool do_flush)
1065{
1066 /* Mutually exclusive, hidden wins but this points to an error with the caller. */
1067 if ((hflag & BM_ELEM_SELECT) && (hflag & BM_ELEM_HIDDEN)) {
1068 hflag &= ~BM_ELEM_SELECT;
1070 }
1071
1072 BMOpSlot *slot = BMO_slot_get(slot_args, slot_name);
1073 BMElem **data = reinterpret_cast<BMElem **>(slot->data.buf);
1074 int i;
1075 const bool do_flush_select = (do_flush && (hflag & BM_ELEM_SELECT));
1076 const bool do_flush_hide = (do_flush && (hflag & BM_ELEM_HIDDEN));
1077 const bool do_check_select = hflag & BM_ELEM_SELECT;
1078
1080 BLI_assert(((slot->slot_subtype.elem & BM_ALL_NOLOOP) & htype) == htype);
1082
1083 for (i = 0; i < slot->len; i++, data++) {
1084 if (!(htype & (*data)->head.htype)) {
1085 continue;
1086 }
1087
1088 if (do_flush_select) {
1089 BM_elem_select_set(bm, *data, true);
1090 }
1091
1092 if (do_flush_hide) {
1093 BM_elem_hide_set(bm, *data, true);
1094 }
1095
1096 /* Prevent hidden geometry from becoming selected. */
1097 char hflag_final = hflag;
1098 if (do_check_select && BM_elem_flag_test(*data, BM_ELEM_HIDDEN)) {
1099 hflag_final &= ~BM_ELEM_SELECT;
1100 }
1101
1102 BM_elem_flag_enable(*data, hflag_final);
1103 }
1104}
1105
1107 BMOpSlot slot_args[BMO_OP_MAX_SLOTS],
1108 const char *slot_name,
1109 const char htype,
1110 const char hflag,
1111 const bool do_flush)
1112{
1113 BMOpSlot *slot = BMO_slot_get(slot_args, slot_name);
1114 BMElem **data = reinterpret_cast<BMElem **>(slot->data.buf);
1115 int i;
1116 const bool do_flush_select = (do_flush && (hflag & BM_ELEM_SELECT));
1117 const bool do_flush_hide = (do_flush && (hflag & BM_ELEM_HIDDEN));
1118
1120 BLI_assert(((slot->slot_subtype.elem & BM_ALL_NOLOOP) & htype) == htype);
1121
1122 for (i = 0; i < slot->len; i++, data++) {
1123 if (!(htype & (*data)->head.htype)) {
1124 continue;
1125 }
1126
1127 if (do_flush_select) {
1128 BM_elem_select_set(bm, *data, false);
1129 }
1130
1131 if (do_flush_hide) {
1132 BM_elem_hide_set(bm, *data, false);
1133 }
1134
1135 BM_elem_flag_disable(*data, hflag);
1136 }
1137}
1138
1140 BMOpSlot slot_args[BMO_OP_MAX_SLOTS],
1141 const char *slot_name,
1142 const char htype,
1143 const short oflag)
1144{
1145 BMOpSlot *slot = BMO_slot_get(slot_args, slot_name);
1146 BMHeader **data = static_cast<BMHeader **>(slot->data.p);
1147 int i;
1148
1150 BLI_assert(((slot->slot_subtype.elem & BM_ALL_NOLOOP) & htype) == htype);
1151
1152 for (i = 0; i < slot->len; i++) {
1153 if (!(htype & data[i]->htype)) {
1154 continue;
1155 }
1156
1158 }
1159}
1160
1162 BMOpSlot slot_args[BMO_OP_MAX_SLOTS],
1163 const char *slot_name,
1164 const char htype,
1165 const short oflag)
1166{
1167 BMOpSlot *slot = BMO_slot_get(slot_args, slot_name);
1168 BMHeader **data = reinterpret_cast<BMHeader **>(slot->data.buf);
1169 int i;
1170
1172 BLI_assert(((slot->slot_subtype.elem & BM_ALL_NOLOOP) & htype) == htype);
1173
1174 for (i = 0; i < slot->len; i++) {
1175 if (!(htype & data[i]->htype)) {
1176 continue;
1177 }
1178
1180 }
1181}
1182
1197{
1198 /* set the index values since we are looping over all data anyway,
1199 * may save time later on */
1200
1201 BLI_mempool *voldpool = bm->vtoolflagpool; /* old flag pool */
1202 BLI_mempool *eoldpool = bm->etoolflagpool; /* old flag pool */
1203 BLI_mempool *foldpool = bm->ftoolflagpool; /* old flag pool */
1204
1205 /* store memcpy size for reuse */
1206 const size_t old_totflags_size = (bm->totflags * sizeof(BMFlagLayer));
1207
1208 bm->totflags++;
1209
1211 sizeof(BMFlagLayer) * bm->totflags, bm->totvert, 512, BLI_MEMPOOL_NOP);
1213 sizeof(BMFlagLayer) * bm->totflags, bm->totedge, 512, BLI_MEMPOOL_NOP);
1215 sizeof(BMFlagLayer) * bm->totflags, bm->totface, 512, BLI_MEMPOOL_NOP);
1216
1217 /* now go through and memcpy all the flags. Loops don't get a flag layer at this time. */
1218 BMIter iter;
1219 int i;
1220
1221 BMVert_OFlag *v_oflag;
1222 BLI_mempool *newpool = bm->vtoolflagpool;
1223 BM_ITER_MESH_INDEX (v_oflag, &iter, bm, BM_VERTS_OF_MESH, i) {
1224 void *oldflags = v_oflag->oflags;
1225 v_oflag->oflags = static_cast<BMFlagLayer *>(BLI_mempool_calloc(newpool));
1226 memcpy(v_oflag->oflags, oldflags, old_totflags_size);
1227 BM_elem_index_set(&v_oflag->base, i); /* set_inline */
1228 BM_ELEM_API_FLAG_CLEAR((BMElemF *)v_oflag);
1229 }
1230
1231 BMEdge_OFlag *e_oflag;
1232 newpool = bm->etoolflagpool;
1233 BM_ITER_MESH_INDEX (e_oflag, &iter, bm, BM_EDGES_OF_MESH, i) {
1234 void *oldflags = e_oflag->oflags;
1235 e_oflag->oflags = static_cast<BMFlagLayer *>(BLI_mempool_calloc(newpool));
1236 memcpy(e_oflag->oflags, oldflags, old_totflags_size);
1237 BM_elem_index_set(&e_oflag->base, i); /* set_inline */
1238 BM_ELEM_API_FLAG_CLEAR((BMElemF *)e_oflag);
1239 }
1240
1241 BMFace_OFlag *f_oflag;
1242 newpool = bm->ftoolflagpool;
1243 BM_ITER_MESH_INDEX (f_oflag, &iter, bm, BM_FACES_OF_MESH, i) {
1244 void *oldflags = f_oflag->oflags;
1245 f_oflag->oflags = static_cast<BMFlagLayer *>(BLI_mempool_calloc(newpool));
1246 memcpy(f_oflag->oflags, oldflags, old_totflags_size);
1247 BM_elem_index_set(&f_oflag->base, i); /* set_inline */
1248 BM_ELEM_API_FLAG_CLEAR((BMElemF *)f_oflag);
1249 }
1250
1251 BLI_mempool_destroy(voldpool);
1252 BLI_mempool_destroy(eoldpool);
1253 BLI_mempool_destroy(foldpool);
1254
1256}
1257
1259{
1260 /* set the index values since we are looping over all data anyway,
1261 * may save time later on */
1262
1263 BLI_mempool *voldpool = bm->vtoolflagpool;
1264 BLI_mempool *eoldpool = bm->etoolflagpool;
1265 BLI_mempool *foldpool = bm->ftoolflagpool;
1266
1267 /* store memcpy size for reuse */
1268 const size_t new_totflags_size = ((bm->totflags - 1) * sizeof(BMFlagLayer));
1269
1270 /* de-increment the totflags first. */
1271 bm->totflags--;
1272
1273 bm->vtoolflagpool = BLI_mempool_create(new_totflags_size, bm->totvert, 512, BLI_MEMPOOL_NOP);
1274 bm->etoolflagpool = BLI_mempool_create(new_totflags_size, bm->totedge, 512, BLI_MEMPOOL_NOP);
1275 bm->ftoolflagpool = BLI_mempool_create(new_totflags_size, bm->totface, 512, BLI_MEMPOOL_NOP);
1276
1277 /* now go through and memcpy all the flag */
1278 BMIter iter;
1279 int i;
1280
1281 BMVert_OFlag *v_oflag;
1282 BLI_mempool *newpool = bm->vtoolflagpool;
1283 BM_ITER_MESH_INDEX (v_oflag, &iter, bm, BM_VERTS_OF_MESH, i) {
1284 void *oldflags = v_oflag->oflags;
1285 v_oflag->oflags = static_cast<BMFlagLayer *>(BLI_mempool_alloc(newpool));
1286 memcpy(v_oflag->oflags, oldflags, new_totflags_size);
1287 BM_elem_index_set(&v_oflag->base, i); /* set_inline */
1288 BM_ELEM_API_FLAG_CLEAR((BMElemF *)v_oflag);
1289 }
1290
1291 BMEdge_OFlag *e_oflag;
1292 newpool = bm->etoolflagpool;
1293 BM_ITER_MESH_INDEX (e_oflag, &iter, bm, BM_EDGES_OF_MESH, i) {
1294 void *oldflags = e_oflag->oflags;
1295 e_oflag->oflags = static_cast<BMFlagLayer *>(BLI_mempool_alloc(newpool));
1296 memcpy(e_oflag->oflags, oldflags, new_totflags_size);
1297 BM_elem_index_set(&e_oflag->base, i); /* set_inline */
1298 BM_ELEM_API_FLAG_CLEAR((BMElemF *)e_oflag);
1299 }
1300
1301 BMFace_OFlag *f_oflag;
1302 newpool = bm->ftoolflagpool;
1303 BM_ITER_MESH_INDEX (f_oflag, &iter, bm, BM_FACES_OF_MESH, i) {
1304 void *oldflags = f_oflag->oflags;
1305 f_oflag->oflags = static_cast<BMFlagLayer *>(BLI_mempool_alloc(newpool));
1306 memcpy(f_oflag->oflags, oldflags, new_totflags_size);
1307 BM_elem_index_set(&f_oflag->base, i); /* set_inline */
1308 BM_ELEM_API_FLAG_CLEAR((BMElemF *)f_oflag);
1309 }
1310
1311 BLI_mempool_destroy(voldpool);
1312 BLI_mempool_destroy(eoldpool);
1313 BLI_mempool_destroy(foldpool);
1314
1316}
1317
1319{
1320 /* set the index values since we are looping over all data anyway,
1321 * may save time later on */
1322 const BMFlagLayer zero_flag = {0};
1323
1324 const int totflags_offset = bm->totflags - 1;
1325
1326 /* now go through and memcpy all the flag */
1327 {
1328 BMIter iter;
1329 BMVert_OFlag *ele;
1330 int i;
1331 BM_ITER_MESH_INDEX (ele, &iter, bm, BM_VERTS_OF_MESH, i) {
1332 ele->oflags[totflags_offset] = zero_flag;
1333 BM_elem_index_set(&ele->base, i); /* set_inline */
1334 }
1335 }
1336 {
1337 BMIter iter;
1338 BMEdge_OFlag *ele;
1339 int i;
1340 BM_ITER_MESH_INDEX (ele, &iter, bm, BM_EDGES_OF_MESH, i) {
1341 ele->oflags[totflags_offset] = zero_flag;
1342 BM_elem_index_set(&ele->base, i); /* set_inline */
1343 }
1344 }
1345 {
1346 BMIter iter;
1347 BMFace_OFlag *ele;
1348 int i;
1349 BM_ITER_MESH_INDEX (ele, &iter, bm, BM_FACES_OF_MESH, i) {
1350 ele->oflags[totflags_offset] = zero_flag;
1351 BM_elem_index_set(&ele->base, i); /* set_inline */
1352 }
1353 }
1354
1356}
1357
1358void *BMO_slot_buffer_get_first(BMOpSlot slot_args[BMO_OP_MAX_SLOTS], const char *slot_name)
1359{
1360 BMOpSlot *slot = BMO_slot_get(slot_args, slot_name);
1361
1362 if (slot->slot_type != BMO_OP_SLOT_ELEMENT_BUF) {
1363 return nullptr;
1364 }
1365
1366 return slot->data.buf ? *slot->data.buf : nullptr;
1367}
1368
1370 BMOpSlot slot_args[BMO_OP_MAX_SLOTS],
1371 const char *slot_name,
1372 const char restrictmask)
1373{
1374 BMOpSlot *slot = BMO_slot_get(slot_args, slot_name);
1375
1376 memset(iter, 0, sizeof(BMOIter));
1377
1378 iter->slot = slot;
1379 iter->cur = 0;
1380 iter->restrictmask = restrictmask;
1381
1382 if (iter->slot->slot_type == BMO_OP_SLOT_MAPPING) {
1383 BLI_ghashIterator_init(&iter->giter, slot->data.ghash);
1384 }
1385 else if (iter->slot->slot_type == BMO_OP_SLOT_ELEMENT_BUF) {
1386 BLI_assert(restrictmask & slot->slot_subtype.elem);
1387 }
1388 else {
1389 BLI_assert(0);
1390 }
1391
1392 return BMO_iter_step(iter);
1393}
1394
1396{
1397 BMOpSlot *slot = iter->slot;
1398 if (slot->slot_type == BMO_OP_SLOT_ELEMENT_BUF) {
1399 BMHeader *ele;
1400
1401 if (iter->cur >= slot->len) {
1402 return nullptr;
1403 }
1404
1405 ele = static_cast<BMHeader *>(slot->data.buf[iter->cur++]);
1406 while (!(iter->restrictmask & ele->htype)) {
1407 if (iter->cur >= slot->len) {
1408 return nullptr;
1409 }
1410
1411 ele = static_cast<BMHeader *>(slot->data.buf[iter->cur++]);
1412 BLI_assert((ele == nullptr) || (slot->slot_subtype.elem & ele->htype));
1413 }
1414
1415 BLI_assert((ele == nullptr) || (slot->slot_subtype.elem & ele->htype));
1416
1417 return ele;
1418 }
1419 if (slot->slot_type == BMO_OP_SLOT_MAPPING) {
1420 void *ret;
1421
1422 if (BLI_ghashIterator_done(&iter->giter) == false) {
1424 iter->val = BLI_ghashIterator_getValue_p(&iter->giter);
1425
1427 }
1428 else {
1429 ret = nullptr;
1430 iter->val = nullptr;
1431 }
1432
1433 return ret;
1434 }
1435 BLI_assert(0);
1436
1437 return nullptr;
1438}
1439
1440/* used for iterating over mappings */
1441
1443{
1444 return iter->val;
1445}
1446
1448{
1452 return iter->val ? *iter->val : nullptr;
1453}
1454
1456{
1458 return **(reinterpret_cast<float **>(iter->val));
1459}
1460
1462{
1464 return **(reinterpret_cast<int **>(iter->val));
1465}
1466
1468{
1470 return **(reinterpret_cast<bool **>(iter->val));
1471}
1472
1473/* error system */
1480
1482{
1483 while (BMO_error_pop(bm, nullptr, nullptr, nullptr)) {
1484 /* pass */
1485 }
1486}
1487
1488void BMO_error_raise(BMesh *bm, BMOperator *owner, eBMOpErrorLevel level, const char *msg)
1489{
1490 BMOpError *err = MEM_new_zeroed<BMOpError>("bmop_error");
1491
1492 err->msg = msg;
1493 err->op = owner;
1494 err->level = level;
1495
1496 BLI_addhead(&bm->errorstack, err);
1497}
1498
1500{
1501 for (const BMOpError *err = bm->errorstack.first(); err; err = err->next) {
1502 if (err->level == level) {
1503 return true;
1504 }
1505 }
1506 return false;
1507}
1508
1509bool BMO_error_get(BMesh *bm, const char **r_msg, BMOperator **r_op, eBMOpErrorLevel *r_level)
1510{
1511 BMOpError *err = bm->errorstack.first();
1512 if (err == nullptr) {
1513 return false;
1514 }
1515
1516 if (r_msg) {
1517 *r_msg = err->msg;
1518 }
1519 if (r_op) {
1520 *r_op = err->op;
1521 }
1522 if (r_level) {
1523 *r_level = err->level;
1524 }
1525
1526 return true;
1527}
1528
1530 eBMOpErrorLevel level,
1531 const char **r_msg,
1532 BMOperator **r_op)
1533{
1534 for (BMOpError &err : bm->errorstack) {
1535 if (err.level >= level) {
1536 if (r_msg) {
1537 *r_msg = err.msg;
1538 }
1539 if (r_op) {
1540 *r_op = err.op;
1541 }
1542 return true;
1543 }
1544 }
1545
1546 return false;
1547}
1548
1549bool BMO_error_pop(BMesh *bm, const char **r_msg, BMOperator **r_op, eBMOpErrorLevel *r_level)
1550{
1551 bool result = BMO_error_get(bm, r_msg, r_op, r_level);
1552
1553 if (result) {
1554 BMOpError *err = bm->errorstack.first();
1555
1557 MEM_delete(err);
1558 }
1559
1560 return result;
1561}
1562
1563#define NEXT_CHAR(fmt) ((fmt)[0] != 0 ? (fmt)[1] : 0)
1564
1565static int bmo_name_to_slotcode(const BMOpSlot slot_args[BMO_OP_MAX_SLOTS], const char *identifier)
1566{
1567 int i = 0;
1568
1569 while (slot_args->slot_name) {
1570 if (STREQLEN(identifier, slot_args->slot_name, MAX_SLOTNAME)) {
1571 return i;
1572 }
1573 slot_args++;
1574 i++;
1575 }
1576
1577 return -1;
1578}
1579
1581 const char *identifier)
1582{
1583 int i = bmo_name_to_slotcode(slot_args, identifier);
1584 if (i < 0) {
1585 fprintf(stderr,
1586 "%s: ! could not find bmesh slot for name %s! (bmesh internal error)\n",
1587 __func__,
1588 identifier);
1589 }
1590
1591 return i;
1592}
1593
1594int BMO_opcode_from_opname(const char *opname)
1595{
1596
1597 const uint tot = bmo_opdefines_total;
1598 uint i;
1599 for (i = 0; i < tot; i++) {
1600 if (STREQ(bmo_opdefines[i]->opname, opname)) {
1601 return i;
1602 }
1603 }
1604 return -1;
1605}
1606
1607static int BMO_opcode_from_opname_check(const char *opname)
1608{
1609 int i = BMO_opcode_from_opname(opname);
1610 if (i == -1) {
1611 fprintf(stderr,
1612 "%s: could not find bmesh slot for name %s! (bmesh internal error)\n",
1613 __func__,
1614 opname);
1615 }
1616 return i;
1617}
1618
1620 BMOperator *op,
1621 const int flag,
1622 const char *_fmt,
1623 va_list vlist // NOLINT
1624)
1625{
1626 // BMOpDefine *def;
1627 char *opname, *ofmt, *fmt;
1628 char slot_name[64] = {0};
1629 int i, type;
1630 bool noslot, state;
1631
1632 /* basic useful info to help find where bmop formatting strings fail */
1633 const char *err_reason = "Unknown";
1634 int lineno = -1;
1635
1636#define GOTO_ERROR(reason) \
1637 { \
1638 err_reason = reason; \
1639 lineno = __LINE__; \
1640 goto error; \
1641 } \
1642 (void)0
1643
1644 /* we muck around in here, so dup it */
1645 fmt = ofmt = BLI_strdup(_fmt);
1646
1647 /* find operator name */
1648 i = strcspn(fmt, " ");
1649
1650 opname = fmt;
1651 noslot = (opname[i] == '\0');
1652 opname[i] = '\0';
1653
1654 fmt += i + (noslot ? 0 : 1);
1655
1656 i = BMO_opcode_from_opname_check(opname);
1657
1658 if (i == -1) {
1659 MEM_delete(ofmt);
1660 BLI_assert(0);
1661 return false;
1662 }
1663
1664 BMO_op_init(bm, op, flag, opname);
1665 // def = bmo_opdefines[i];
1666
1667 i = 0;
1668 state = true; /* false: not inside slot_code name, true: inside slot_code name */
1669
1670 while (*fmt) {
1671 if (state) {
1672 /* Jump past leading white-space. */
1673 i = strspn(fmt, " ");
1674 fmt += i;
1675
1676 /* Ignore trailing white-space. */
1677 if (!fmt[i]) {
1678 break;
1679 }
1680
1681 /* find end of slot name, only "slot=%f", can be used */
1682 i = strcspn(fmt, "=");
1683 if (!fmt[i]) {
1684 GOTO_ERROR("could not match end of slot name");
1685 }
1686
1687 fmt[i] = 0;
1688
1689 if (bmo_name_to_slotcode_check(op->slots_in, fmt) < 0) {
1690 GOTO_ERROR("name to slot code check failed");
1691 }
1692
1693 STRNCPY(slot_name, fmt);
1694
1695 state = false;
1696 fmt += i;
1697 }
1698 else {
1699 switch (*fmt) {
1700 case ' ':
1701 case '=':
1702 case '%':
1703 break;
1704 case 'm': {
1705 int size;
1706 const char c = NEXT_CHAR(fmt);
1707 fmt++;
1708
1709 if (c == '3') {
1710 size = 3;
1711 }
1712 else if (c == '4') {
1713 size = 4;
1714 }
1715 else {
1716 GOTO_ERROR("matrix size was not 3 or 4");
1717 }
1718
1719 BMO_slot_mat_set(op, op->slots_in, slot_name, va_arg(vlist, float *), size);
1720 state = true;
1721 break;
1722 }
1723 case 'v': {
1724 BMO_slot_vec_set(op->slots_in, slot_name, va_arg(vlist, float *));
1725 state = true;
1726 break;
1727 }
1728 case 'e': {
1729 BMOpSlot *slot = BMO_slot_get(op->slots_in, slot_name);
1730
1731 if (NEXT_CHAR(fmt) == 'b') {
1732 BMHeader **ele_buffer = va_arg(vlist, BMHeader **);
1733 int ele_buffer_len = va_arg(vlist, int);
1734
1735 BMO_slot_buffer_from_array(op, slot, ele_buffer, ele_buffer_len);
1736 fmt++;
1737 }
1738 else {
1739 /* single vert/edge/face */
1740 BMHeader *ele = va_arg(vlist, BMHeader *);
1741
1742 BMO_slot_buffer_from_single(op, slot, ele);
1743 }
1744
1745 state = true;
1746 break;
1747 }
1748 case 's':
1749 case 'S': {
1750 BMOperator *op_other = va_arg(vlist, BMOperator *);
1751 const char *slot_name_other = va_arg(vlist, char *);
1752
1753 if (*fmt == 's') {
1754 BLI_assert(bmo_name_to_slotcode_check(op_other->slots_in, slot_name_other) != -1);
1755 BMO_slot_copy(op_other, slots_in, slot_name_other, op, slots_in, slot_name);
1756 }
1757 else {
1758 BLI_assert(bmo_name_to_slotcode_check(op_other->slots_out, slot_name_other) != -1);
1759 BMO_slot_copy(op_other, slots_out, slot_name_other, op, slots_in, slot_name);
1760 }
1761 state = true;
1762 break;
1763 }
1764 case 'i':
1765 BMO_slot_int_set(op->slots_in, slot_name, va_arg(vlist, int));
1766 state = true;
1767 break;
1768 case 'b':
1769 BMO_slot_bool_set(op->slots_in, slot_name, va_arg(vlist, int));
1770 state = true;
1771 break;
1772 case 'p':
1773 BMO_slot_ptr_set(op->slots_in, slot_name, va_arg(vlist, void *));
1774 state = true;
1775 break;
1776 case 'f':
1777 case 'F':
1778 case 'h':
1779 case 'H':
1780 case 'a':
1781 type = *fmt;
1782
1783 if (NEXT_CHAR(fmt) == ' ' || NEXT_CHAR(fmt) == '\0') {
1784 BMO_slot_float_set(op->slots_in, slot_name, va_arg(vlist, double));
1785 }
1786 else {
1787 char htype = 0;
1788
1789 while (true) {
1790 char htype_set;
1791 const char c = NEXT_CHAR(fmt);
1792 if (c == 'f') {
1793 htype_set = BM_FACE;
1794 }
1795 else if (c == 'e') {
1796 htype_set = BM_EDGE;
1797 }
1798 else if (c == 'v') {
1799 htype_set = BM_VERT;
1800 }
1801 else {
1802 break;
1803 }
1804
1805 if (htype & htype_set) [[unlikely]] {
1806 GOTO_ERROR("htype duplicated");
1807 }
1808
1809 htype |= htype_set;
1810 fmt++;
1811 }
1812
1813 if (type == 'h') {
1815 bm, op, op->slots_in, slot_name, htype, va_arg(vlist, int));
1816 }
1817 else if (type == 'H') {
1819 bm, op, op->slots_in, slot_name, htype, va_arg(vlist, int));
1820 }
1821 else if (type == 'a') {
1822 if ((op->flag & BMO_FLAG_RESPECT_HIDE) == 0) {
1823 BMO_slot_buffer_from_all(bm, op, op->slots_in, slot_name, htype);
1824 }
1825 else {
1827 bm, op, op->slots_in, slot_name, htype, BM_ELEM_HIDDEN);
1828 }
1829 }
1830 else if (type == 'f') {
1832 bm, op, op->slots_in, slot_name, htype, va_arg(vlist, int));
1833 }
1834 else if (type == 'F') {
1836 bm, op, op->slots_in, slot_name, htype, va_arg(vlist, int));
1837 }
1838 }
1839
1840 state = true;
1841 break;
1842 default:
1843 fprintf(stderr,
1844 "%s: unrecognized bmop format char: '%c', %d in '%s'\n",
1845 __func__,
1846 *fmt,
1847 int(fmt - ofmt),
1848 ofmt);
1849 break;
1850 }
1851 }
1852 fmt++;
1853 }
1854
1855 MEM_delete(ofmt);
1856 return true;
1857error:
1858
1859 /* TODO: explain exactly what is failing (not urgent). */
1860 fprintf(stderr, "%s: error parsing formatting string\n", __func__);
1861
1862 fprintf(stderr, "string: '%s', position %d\n", _fmt, int(fmt - ofmt));
1863 fprintf(stderr, " ");
1864 {
1865 int pos = int(fmt - ofmt);
1866 for (i = 0; i < pos; i++) {
1867 fprintf(stderr, " ");
1868 }
1869 fprintf(stderr, "^\n");
1870 }
1871
1872 fprintf(stderr, "source code: %s:%d\n", __FILE__, lineno);
1873
1874 fprintf(stderr, "reason: %s\n", err_reason);
1875
1876 MEM_delete(ofmt);
1877
1878 BMO_op_finish(bm, op);
1879 return false;
1880
1881#undef GOTO_ERROR
1882}
1883
1884bool BMO_op_initf(BMesh *bm, BMOperator *op, const int flag, const char *fmt, ...)
1885{
1886 va_list list;
1887
1888 va_start(list, fmt);
1889 if (!BMO_op_vinitf(bm, op, flag, fmt, list)) {
1890 printf("%s: failed\n", __func__);
1891 va_end(list);
1892 return false;
1893 }
1894 va_end(list);
1895
1896 return true;
1897}
1898
1899bool BMO_op_vcallf(BMesh *bm, const int flag, const char *fmt, va_list list)
1900{
1901 BMOperator op;
1902
1903 if (!BMO_op_vinitf(bm, &op, flag, fmt, list)) {
1904 printf("%s: failed, format is:\n \"%s\"\n", __func__, fmt);
1905 return false;
1906 }
1907
1908 BMO_op_exec(bm, &op);
1909 BMO_op_finish(bm, &op);
1910
1911 return true;
1912}
1913
1914bool BMO_op_callf(BMesh *bm, const int flag, const char *fmt, ...)
1915{
1916 va_list list;
1917 va_start(list, fmt);
1918 const bool result = BMO_op_vcallf(bm, flag, fmt, list);
1919 va_end(list);
1920 return result;
1921}
1922
1923} // namespace blender
#define GHASH_ITER(gh_iter_, ghash_)
Definition BLI_ghash.hh:320
#define BLI_MEMARENA_STD_BUFSIZE
Read Blender memory allocation and freeing.
#define BLI_assert_unreachable()
#define STREQLEN(a, b, n)
#define BLI_assert(a)
#define ELEM(...)
#define STREQ(a, b)
#define BM_ALL_NOLOOP
#define BM_ELEM_INDEX_VALIDATE(_bm, _msg_a, _msg_b)
#define BM_elem_flag_disable(ele, hflag)
#define BM_elem_index_set(ele, index)
#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_MESH_INDEX(ele, iter, bm, itype, indexvar)
#define BM_elem_hide_set(bm, ele, hide)
#define BMO_elem_flag_disable(bm, ele, oflag)
#define BMO_edge_flag_test_bool(bm, e, oflag)
#define BMO_vert_flag_disable(bm, e, oflag)
#define BMO_face_flag_test_bool(bm, e, oflag)
#define MAX_SLOTNAME
#define BMO_ASSERT_SLOT_IN_OP(slot, op)
#define BMO_slot_copy(op_src, slots_src, slot_name_src, op_dst, slots_dst, slot_name_dst)
#define BMO_OP_MAX_SLOTS
#define BMO_SLOT_AS_MATRIX(slot)
#define BMO_elem_flag_enable(bm, ele, oflag)
#define BMO_OP_SLOT_TOTAL_TYPES
#define BMO_vert_flag_test_bool(bm, e, oflag)
#define BMO_face_flag_disable(bm, e, oflag)
#define BMO_edge_flag_disable(bm, e, oflag)
#define GOTO_ERROR(reason)
#define BM_ELEM_API_FLAG_CLEAR(element)
long long int int64_t
#define output
const int state
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)
bool BMO_error_occurred_at_level(BMesh *bm, eBMOpErrorLevel level)
bool BMO_error_get_at_level(BMesh *bm, eBMOpErrorLevel level, const char **r_msg, BMOperator **r_op)
void BMO_slot_ptr_set(BMOpSlot slot_args[BMO_OP_MAX_SLOTS], const char *slot_name, void *p)
void BMO_slot_buffer_from_disabled_hflag(BMesh *bm, BMOperator *op, BMOpSlot slot_args[BMO_OP_MAX_SLOTS], const char *slot_name, char htype, char hflag)
static void bmo_slot_buffer_from_hflag(BMesh *bm, BMOperator *op, BMOpSlot slot_args[BMO_OP_MAX_SLOTS], const char *slot_name, const char htype, const char hflag, const bool test_for_enabled)
BMO_HEADERFLAG_TO_SLOT.
void * BMO_slot_as_arrayN(BMOpSlot slot_args[BMO_OP_MAX_SLOTS], const char *slot_name, int *len)
int BMO_slot_int_get(BMOpSlot slot_args[BMO_OP_MAX_SLOTS], const char *slot_name)
BLI_INLINE void * BLI_ghashIterator_getKey(GHashIterator *ghi) ATTR_WARN_UNUSED_RESULT
Definition BLI_ghash.hh:297
char * STRNCPY(char(&dst)[N], const char *src)
void BM_mesh_elem_toolflags_ensure(BMesh *bm)
Definition bmesh_mesh.cc:78
@ BMO_OP_SLOT_SUBTYPE_MAP_INTERNAL
void BLI_memarena_use_calloc(MemArena *ma) ATTR_NONNULL(1)
int BMO_slot_buffer_len(BMOpSlot slot_args[BMO_OP_MAX_SLOTS], const char *slot_name)
MemArena * BLI_memarena_new(size_t bufsize, const char *name) ATTR_WARN_UNUSED_RESULT ATTR_RETURNS_NONNULL ATTR_NONNULL(2) ATTR_MALLOC
int BMO_iter_map_value_int(BMOIter *iter)
MINLINE void copy_v3_v3(float r[3], const float a[3])
unsigned int uint
Definition BKE_text.h:55
static void bmo_slot_buffer_from_flag(BMesh *bm, BMOperator *op, BMOpSlot slot_args[BMO_OP_MAX_SLOTS], const char *slot_name, const char htype, const short oflag, const bool test_for_enabled)
BMO_FLAG_TO_SLOT.
void * MEM_new_array_uninitialized(size_t len, size_t size, const char *str) ATTR_WARN_UNUSED_RESULT ATTR_ALLOC_SIZE(1
static int bmo_name_to_slotcode(const BMOpSlot slot_args[BMO_OP_MAX_SLOTS], const char *identifier)
void BLI_addhead(ListBase *listbase, void *vlink) ATTR_NONNULL(1)
Definition listbase.cc:98
int BMO_mesh_enabled_flag_count(BMesh *bm, char htype, short oflag)
void copy_m3_m4(float m1[3][3], const float m2[4][4])
void BMO_slot_buffer_hflag_enable(BMesh *bm, BMOpSlot slot_args[BMO_OP_MAX_SLOTS], const char *slot_name, char htype, char hflag, bool do_flush)
BMO_FLAG_BUFFER.
void BMO_slot_buffer_from_array(BMOperator *op, BMOpSlot *slot, BMHeader **ele_buffer, int ele_buffer_len)
static int BMO_opcode_from_opname_check(const char *opname)
BLI_INLINE void ** BLI_ghashIterator_getValue_p(GHashIterator *ghi) ATTR_WARN_UNUSED_RESULT
Definition BLI_ghash.hh:305
void copy_m4_m3(float m1[4][4], const float m2[3][3])
float BMO_slot_float_get(BMOpSlot slot_args[BMO_OP_MAX_SLOTS], const char *slot_name)
void BMO_error_clear(BMesh *bm)
void BMO_slot_buffer_flag_enable(BMesh *bm, BMOpSlot slot_args[BMO_OP_MAX_SLOTS], const char *slot_name, char htype, short oflag)
BMO_FLAG_BUFFER.
static void bmo_flag_layer_clear(BMesh *bm)
bool BMO_op_initf(BMesh *bm, BMOperator *op, int flag, const char *fmt,...)
void * BMO_iter_step(BMOIter *iter)
static void bmo_op_slots_free(const BMOSlotType *slot_types, BMOpSlot *slot_args)
void BMO_slot_map_to_flag(BMesh *bm, BMOpSlot slot_args[BMO_OP_MAX_SLOTS], const char *slot_name, char htype, short oflag)
void BMO_mesh_selected_remap(BMesh *bm, BMOpSlot *slot_vert_map, BMOpSlot *slot_edge_map, BMOpSlot *slot_face_map, bool check_select)
void BMO_slot_float_set(BMOpSlot slot_args[BMO_OP_MAX_SLOTS], const char *slot_name, float f)
void * BMO_iter_map_value_ptr(BMOIter *iter)
const int BMO_OPSLOT_TYPEINFO[BMO_OP_SLOT_TOTAL_TYPES]
void BMO_slot_buffer_from_all(BMesh *bm, BMOperator *op, BMOpSlot slot_args[BMO_OP_MAX_SLOTS], const char *slot_name, char htype)
BMO_ALL_TO_SLOT.
void BMO_op_exec(BMesh *bm, BMOperator *op)
BMESH OPSTACK EXEC OP.
int BM_mesh_elem_hflag_count_enabled(BMesh *bm, const char htype, const char hflag, const bool respecthide)
void BMO_op_flag_enable(BMesh *bm, BMOperator *op, int op_flag)
void BLI_ghash_insert(GHash *gh, void *key, void *val)
Definition BLI_ghash.cc:711
void * BMO_slot_buffer_get_single(BMOpSlot *slot)
void BMO_push(BMesh *bm, BMOperator *op)
BMESH OPSTACK PUSH.
void BMO_op_flag_disable(BMesh *bm, BMOperator *op, int op_flag)
BLI_INLINE void * BLI_ghashIterator_getValue(GHashIterator *ghi) ATTR_WARN_UNUSED_RESULT
Definition BLI_ghash.hh:301
void BMO_slot_map_insert(BMOperator *op, BMOpSlot *slot, const void *element, const void *data)
bool BMO_iter_map_value_bool(BMOIter *iter)
void BLI_mempool_destroy(BLI_mempool *pool) ATTR_NONNULL(1)
void * BMO_slot_ptr_get(BMOpSlot slot_args[BMO_OP_MAX_SLOTS], const char *slot_name)
void BLI_ghashIterator_step(GHashIterator *ghi)
Definition BLI_ghash.cc:917
const int bmo_opdefines_total
void BMO_slot_mat_set(BMOperator *op, BMOpSlot slot_args[BMO_OP_MAX_SLOTS], const char *slot_name, const float *mat, int size)
void * MEM_new_zeroed(size_t len, const char *str) ATTR_WARN_UNUSED_RESULT ATTR_ALLOC_SIZE(1) ATTR_NONNULL(2)
void _bmo_slot_copy(BMOpSlot slot_args_src[BMO_OP_MAX_SLOTS], const char *slot_name_src, BMOpSlot slot_args_dst[BMO_OP_MAX_SLOTS], const char *slot_name_dst, struct MemArena *arena_dst)
BMESH OPSTACK COPY SLOT.
void BLI_ghash_free(GHash *gh, GHashKeyFreeFP keyfreefp, GHashValFreeFP valfreefp)
Definition BLI_ghash.cc:866
void _bmo_slot_buffer_append(BMOpSlot slot_args_dst[BMO_OP_MAX_SLOTS], const char *slot_name_dst, BMOpSlot slot_args_src[BMO_OP_MAX_SLOTS], const char *slot_name_src, struct MemArena *arena_dst)
static void bmo_flag_layer_free(BMesh *bm)
void BLI_remlink(ListBase *listbase, void *vlink) ATTR_NONNULL(1)
Definition listbase.cc:138
BMesh const char void * data
void BMO_slot_vec_get(BMOpSlot slot_args[BMO_OP_MAX_SLOTS], const char *slot_name, float r_vec[3])
void BMO_slot_buffer_from_enabled_flag(BMesh *bm, BMOperator *op, BMOpSlot slot_args[BMO_OP_MAX_SLOTS], const char *slot_name, char htype, short oflag)
BLI_mempool * BLI_mempool_create(unsigned int esize, unsigned int elem_num, unsigned int pchunk, unsigned int flag) ATTR_MALLOC ATTR_WARN_UNUSED_RESULT ATTR_RETURNS_NONNULL
void BM_elem_select_set(BMesh *bm, BMElem *ele, const bool select)
int BM_mesh_elem_hflag_count_disabled(BMesh *bm, const char htype, const char hflag, const bool respecthide)
void BMO_slot_vec_set(BMOpSlot slot_args[BMO_OP_MAX_SLOTS], const char *slot_name, const float vec[3])
void BMO_slot_bool_set(BMOpSlot slot_args[BMO_OP_MAX_SLOTS], const char *slot_name, bool i)
GHash * BLI_ghash_ptr_new(const char *info) ATTR_MALLOC ATTR_WARN_UNUSED_RESULT
void BMO_slot_buffer_from_disabled_flag(BMesh *bm, BMOperator *op, BMOpSlot slot_args[BMO_OP_MAX_SLOTS], const char *slot_name, char htype, short oflag)
void unit_m4(float m[4][4])
bool BMO_op_callf(BMesh *bm, int flag, const char *fmt,...)
@ BMO_OP_SLOT_SUBTYPE_ELEM_IS_SINGLE
unsigned int BLI_ghash_len(const GHash *gh) ATTR_WARN_UNUSED_RESULT
Definition BLI_ghash.cc:706
float BMO_iter_map_value_float(BMOIter *iter)
void BMO_slot_mat4_get(BMOpSlot slot_args[BMO_OP_MAX_SLOTS], const char *slot_name, float r_mat[4][4])
void BMO_slot_int_set(BMOpSlot slot_args[BMO_OP_MAX_SLOTS], const char *slot_name, int i)
static int bmo_name_to_slotcode_check(const BMOpSlot slot_args[BMO_OP_MAX_SLOTS], const char *identifier)
void BLI_ghashIterator_init(GHashIterator *ghi, GHash *gh)
Definition BLI_ghash.cc:901
static int bmo_mesh_flag_count(BMesh *bm, const char htype, const short oflag, const bool test_for_enabled)
static void bmo_op_slots_init(const BMOSlotType *slot_types, BMOpSlot *slot_args)
const BMOpDefine * bmo_opdefines[]
BMOpSlot * BMO_slot_get(BMOpSlot slot_args[BMO_OP_MAX_SLOTS], const char *identifier)
BMESH OPSTACK GET SLOT.
void * BLI_memarena_alloc(MemArena *ma, size_t size) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1) ATTR_MALLOC ATTR_ALLOC_SIZE(2)
bool BMO_slot_bool_get(BMOpSlot slot_args[BMO_OP_MAX_SLOTS], const char *slot_name)
int BMO_opcode_from_opname(const char *opname)
void unit_m3(float m[3][3])
char * BLI_strdup(const char *str) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1) ATTR_MALLOC
bool BMO_op_vinitf(BMesh *bm, BMOperator *op, int flag, const char *fmt, va_list vlist)
@ BLI_MEMPOOL_NOP
void * BMO_slot_buffer_alloc(BMOperator *op, BMOpSlot slot_args[BMO_OP_MAX_SLOTS], const char *slot_name, int len)
void ** BMO_iter_map_value_p(BMOIter *iter)
void * BLI_mempool_calloc(BLI_mempool *pool) ATTR_MALLOC ATTR_WARN_UNUSED_RESULT ATTR_RETURNS_NONNULL ATTR_NONNULL(1)
void bmesh_edit_begin(BMesh *, BMOpTypeFlag)
BMesh Begin Edit.
int BMO_mesh_disabled_flag_count(BMesh *bm, char htype, short oflag)
void BMO_slot_buffer_from_single(BMOperator *op, BMOpSlot *slot, BMHeader *ele)
int BMO_slot_map_len(BMOpSlot slot_args[BMO_OP_MAX_SLOTS], const char *slot_name)
void BMO_slot_mat3_get(BMOpSlot slot_args[BMO_OP_MAX_SLOTS], const char *slot_name, float r_mat[3][3])
void zero_m4(float m[4][4])
void BMO_error_raise(BMesh *bm, BMOperator *owner, eBMOpErrorLevel level, const char *msg) ATTR_NONNULL(1
void * BLI_mempool_alloc(BLI_mempool *pool) ATTR_MALLOC ATTR_WARN_UNUSED_RESULT ATTR_RETURNS_NONNULL ATTR_NONNULL(1)
void BMO_op_init(BMesh *bm, BMOperator *op, int flag, const char *opname)
BMESH OPSTACK INIT OP.
void copy_m4_m4(float m1[4][4], const float m2[4][4])
bool BMO_op_vcallf(BMesh *bm, int flag, const char *fmt, va_list list)
void BMO_op_finish(BMesh *bm, BMOperator *op)
BMESH OPSTACK FINISH OP.
ATTR_WARN_UNUSED_RESULT const void * element
ATTR_WARN_UNUSED_RESULT const BMFlagLayer const short oflag
void bmesh_edit_end(BMesh *bm, BMOpTypeFlag type_flag)
BMesh End Edit.
void BMO_slot_buffer_hflag_disable(BMesh *bm, BMOpSlot slot_args[BMO_OP_MAX_SLOTS], const char *slot_name, char htype, char hflag, bool do_flush)
BMO_FLAG_BUFFER.
bool BMO_error_pop(BMesh *bm, const char **r_msg, BMOperator **r_op, eBMOpErrorLevel *r_level)
void BMO_slot_buffer_flag_disable(BMesh *bm, BMOpSlot slot_args[BMO_OP_MAX_SLOTS], const char *slot_name, char htype, short oflag)
BMO_FLAG_BUFFER.
void BMO_mesh_flag_disable_all(BMesh *bm, BMOperator *op, char htype, short oflag)
void *(*) MEM_realloc_zeroed_id(void *vmemh, size_t len, const char *str) ATTR_WARN_UNUSED_RESULT ATTR_ALLOC_SIZE(2)
void BMO_pop(BMesh *bm)
BMESH OPSTACK POP.
void BMO_slot_buffer_from_enabled_hflag(BMesh *bm, BMOperator *op, BMOpSlot slot_args[BMO_OP_MAX_SLOTS], const char *slot_name, char htype, char hflag)
BLI_INLINE bool BLI_ghashIterator_done(const GHashIterator *ghi) ATTR_WARN_UNUSED_RESULT
Definition BLI_ghash.hh:309
void bool BMO_error_get(BMesh *bm, const char **r_msg, BMOperator **r_op, eBMOpErrorLevel *r_level)
void * BMO_slot_buffer_get_first(BMOpSlot slot_args[BMO_OP_MAX_SLOTS], const char *slot_name)
void BLI_memarena_free(MemArena *ma) ATTR_NONNULL(1)
bool BMO_slot_exists(BMOpSlot slot_args[BMO_OP_MAX_SLOTS], const char *identifier)
BMESH OPSTACK HAS SLOT.
static void bmo_flag_layer_alloc(BMesh *bm)
ALLOC/FREE FLAG LAYER.
void * BMO_iter_new(BMOIter *iter, BMOpSlot slot_args[BMO_OP_MAX_SLOTS], const char *slot_name, char restrictmask)
New Iterator.
KERNEL_FEATURE_LIGHT_PASSES KERNEL_FEATURE_PATH_GUIDING float
struct BMFlagLayer * oflags
struct BMEditSelection * next
struct BMFlagLayer * oflags
char name[MAX_SLOTNAME]
eBMOpSlotSubType_Union subtype
BMOSlotType slot_types_out[BMO_OP_MAX_SLOTS]
void(*) exec(BMesh *bm, BMOperator *op)
BMOSlotType slot_types_in[BMO_OP_MAX_SLOTS]
void(*) init(BMOperator *op)
eBMOpErrorLevel level
eBMOpSlotSubType_Union slot_subtype
union blender::BMOpSlot::@376352321363166111241172004263244043165250166277 data
struct BMOpSlot slots_in[BMO_OP_MAX_SLOTS]
struct BMOpSlot slots_out[BMO_OP_MAX_SLOTS]
struct MemArena * arena
void(*) exec(BMesh *bm, struct BMOperator *op)
struct BMFlagLayer * oflags
ListBaseT< BMOpError > errorstack
ListBaseT< BMEditSelection > selected