31 const char *identifier);
33 const char *identifier);
91 for (i = 0; slot_types[i].
type; i++) {
109 slot->
data.i = slot->
data.enum_data.flags[0].value;
121 for (i = 0; slot_types[i].
type; i++) {
122 slot = &slot_args[i];
198 memset(op, 0xff,
sizeof(*op));
207 return (slot_code >= 0);
214 if (slot_code < 0) [[unlikely]] {
220 return &slot_args[slot_code];
224 const char *slot_name_src,
226 const char *slot_name_dst,
232 if (slot_src == slot_dst) {
243 slot_dst->
data.buf =
nullptr;
244 slot_dst->
len = slot_src->
len;
252 if ((src_elem_flag | dst_elem_flag) == dst_elem_flag) {
257 const uint tot = slot_src->
len;
261 for (i = 0; i < tot; i++, ele_src++) {
262 if ((*ele_src)->head.htype & dst_elem_flag) {
274 if (slot_src->
len == slot_dst->
len) {
275 memcpy(slot_dst->
data.buf, slot_src->
data.buf, slot_alloc_size);
279 const uint tot = slot_src->
len;
283 for (i = 0; i < tot; i++, ele_src++) {
284 if ((*ele_src)->head.htype & dst_elem_flag) {
347 const char *slot_name,
361 copy_m4_m4(
static_cast<float (*)[4]
>(slot->
data.p),
reinterpret_cast<const float (*)[4]
>(mat));
363 else if (size == 3) {
364 copy_m4_m3(
static_cast<float (*)[4]
>(slot->
data.p),
reinterpret_cast<const float (*)[3]
>(mat));
367 fprintf(stderr,
"%s: invalid size argument %d (bmesh internal error)\n", __func__, size);
374 const char *slot_name,
392 const char *slot_name,
421 const char *slot_name,
475 memcpy(
ret, slot->
data.buf,
sizeof(
void *) * slot->
len);
512 const bool test_for_enabled)
514 int count_vert = 0, count_edge = 0, count_face = 0;
544 return (count_vert + count_edge + count_face);
586 const bool check_select)
592 for (ese =
bm->
selected.first(); ese; ese = ese_next) {
593 ese_next = ese->
next;
595 switch (ese->
htype) {
597 slot_elem_map = slot_vert_map;
600 slot_elem_map = slot_edge_map;
603 slot_elem_map = slot_face_map;
607 ese->
ele =
static_cast<BMElem *
>(BMO_slot_map_elem_get(slot_elem_map, ese->
ele));
609 if ((ese->
ele ==
nullptr) ||
657void *bmo_slot_buffer_grow(BMesh *
bm, BMOperator *op,
int slot_code,
int totadd)
659 BMOpSlot *slot = &op->slots[slot_code];
670 if (slot->flag & BMOS_DYNAMIC_ARRAY) {
671 if (slot->len >= slot->size) {
672 slot->size = (slot->size + 1 + totadd) * 2;
682 slot->flag |= BMOS_DYNAMIC_ARRAY;
684 slot->size = slot->len + 2;
689 tmp = slot->data.buf;
690 slot->data.buf =
MEM_new_zeroed(allocsize,
"opslot dynamic array");
691 memcpy(slot->data.buf, tmp, allocsize);
694 return slot->data.buf;
700 const char *slot_name,
720 const char *slot_name,
732 slot->
data.buf =
static_cast<void **
>(
736 slot->
data.buf =
nullptr;
739 return slot->
data.buf;
745 const char *slot_name,
749 int totelement = 0, i = 0;
774 output->data.buf[i] = ele;
781 output->data.buf[i] = ele;
788 output->data.buf[i] = ele;
804 const char *slot_name,
807 const bool test_for_enabled)
810 int totelement = 0, i = 0;
818 if (test_for_enabled) {
838 output->data.buf[i] = ele;
849 output->data.buf[i] = ele;
860 output->data.buf[i] = ele;
874 const char *slot_name,
884 const char *slot_name,
900 slot->
data.buf =
static_cast<void **
>(
903 *slot->
data.buf = ele;
915 if (slot->
data.buf ==
nullptr) {
916 slot->
data.buf =
static_cast<void **
>(
920 slot->
len = ele_buffer_len;
921 memcpy(slot->
data.buf, ele_buffer, ele_buffer_len *
sizeof(*slot->
data.buf));
930 return slot->
len ?
static_cast<BMHeader *
>(slot->
data.buf[0]) :
nullptr;
934 const char *slot_name_dst,
936 const char *slot_name_src,
945 if (slot_dst->
len == 0) {
947 _bmo_slot_copy(slot_args_src, slot_name_src, slot_args_dst, slot_name_dst, arena_dst);
949 else if (slot_src->
len != 0) {
951 int alloc_size = elem_size * (slot_dst->
len + slot_src->
len);
956 memcpy(buf, slot_dst->
data.buf, elem_size * slot_dst->
len);
957 memcpy((
static_cast<char *
>(buf)) + elem_size * slot_dst->
len,
959 elem_size * slot_src->
len);
961 slot_dst->
data.buf =
static_cast<void **
>(buf);
962 slot_dst->
len += slot_src->
len;
975 const char *slot_name,
978 const bool test_for_enabled)
981 int totelement, i = 0;
989 if (test_for_enabled) {
1003 ele_array =
reinterpret_cast<BMHeader **
>(slot->
data.buf);
1042 const char *slot_name,
1052 const char *slot_name,
1061 const char *slot_name,
1064 const bool do_flush)
1075 const bool do_flush_select = (do_flush && (hflag &
BM_ELEM_SELECT));
1076 const bool do_flush_hide = (do_flush && (hflag &
BM_ELEM_HIDDEN));
1083 for (i = 0; i < slot->
len; i++,
data++) {
1084 if (!(htype & (*data)->head.htype)) {
1088 if (do_flush_select) {
1092 if (do_flush_hide) {
1097 char hflag_final = hflag;
1108 const char *slot_name,
1111 const bool do_flush)
1116 const bool do_flush_select = (do_flush && (hflag &
BM_ELEM_SELECT));
1117 const bool do_flush_hide = (do_flush && (hflag &
BM_ELEM_HIDDEN));
1122 for (i = 0; i < slot->
len; i++,
data++) {
1123 if (!(htype & (*data)->head.htype)) {
1127 if (do_flush_select) {
1131 if (do_flush_hide) {
1141 const char *slot_name,
1152 for (i = 0; i < slot->
len; i++) {
1153 if (!(htype &
data[i]->htype)) {
1163 const char *slot_name,
1174 for (i = 0; i < slot->
len; i++) {
1175 if (!(htype &
data[i]->htype)) {
1224 void *oldflags = v_oflag->
oflags;
1226 memcpy(v_oflag->
oflags, oldflags, old_totflags_size);
1234 void *oldflags = e_oflag->
oflags;
1236 memcpy(e_oflag->
oflags, oldflags, old_totflags_size);
1244 void *oldflags = f_oflag->
oflags;
1246 memcpy(f_oflag->
oflags, oldflags, old_totflags_size);
1284 void *oldflags = v_oflag->
oflags;
1286 memcpy(v_oflag->
oflags, oldflags, new_totflags_size);
1294 void *oldflags = e_oflag->
oflags;
1296 memcpy(e_oflag->
oflags, oldflags, new_totflags_size);
1304 void *oldflags = f_oflag->
oflags;
1306 memcpy(f_oflag->
oflags, oldflags, new_totflags_size);
1324 const int totflags_offset =
bm->
totflags - 1;
1332 ele->
oflags[totflags_offset] = zero_flag;
1341 ele->
oflags[totflags_offset] = zero_flag;
1350 ele->
oflags[totflags_offset] = zero_flag;
1366 return slot->
data.buf ? *slot->
data.buf :
nullptr;
1371 const char *slot_name,
1372 const char restrictmask)
1376 memset(iter, 0,
sizeof(
BMOIter));
1401 if (iter->
cur >= slot->
len) {
1407 if (iter->
cur >= slot->
len) {
1430 iter->
val =
nullptr;
1452 return iter->
val ? *iter->
val :
nullptr;
1458 return **(
reinterpret_cast<float **
>(iter->
val));
1464 return **(
reinterpret_cast<int **
>(iter->
val));
1470 return **(
reinterpret_cast<bool **
>(iter->
val));
1502 if (err->level == level) {
1512 if (err ==
nullptr) {
1523 *r_level = err->
level;
1535 if (err.
level >= level) {
1563#define NEXT_CHAR(fmt) ((fmt)[0] != 0 ? (fmt)[1] : 0)
1569 while (slot_args->slot_name) {
1581 const char *identifier)
1586 "%s: ! could not find bmesh slot for name %s! (bmesh internal error)\n",
1599 for (i = 0; i < tot; i++) {
1612 "%s: could not find bmesh slot for name %s! (bmesh internal error)\n",
1627 char *opname, *ofmt, *fmt;
1628 char slot_name[64] = {0};
1633 const char *err_reason =
"Unknown";
1636#define GOTO_ERROR(reason) \
1638 err_reason = reason; \
1639 lineno = __LINE__; \
1648 i = strcspn(fmt,
" ");
1651 noslot = (opname[i] ==
'\0');
1654 fmt += i + (noslot ? 0 : 1);
1673 i = strspn(fmt,
" ");
1682 i = strcspn(fmt,
"=");
1684 GOTO_ERROR(
"could not match end of slot name");
1690 GOTO_ERROR(
"name to slot code check failed");
1712 else if (c ==
'4') {
1733 int ele_buffer_len = va_arg(vlist,
int);
1751 const char *slot_name_other = va_arg(vlist,
char *);
1755 BMO_slot_copy(op_other, slots_in, slot_name_other, op, slots_in, slot_name);
1759 BMO_slot_copy(op_other, slots_out, slot_name_other, op, slots_in, slot_name);
1795 else if (c ==
'e') {
1798 else if (c ==
'v') {
1805 if (htype & htype_set) [[unlikely]] {
1815 bm, op, op->
slots_in, slot_name, htype, va_arg(vlist,
int));
1817 else if (type ==
'H') {
1819 bm, op, op->
slots_in, slot_name, htype, va_arg(vlist,
int));
1821 else if (type ==
'a') {
1830 else if (type ==
'f') {
1832 bm, op, op->
slots_in, slot_name, htype, va_arg(vlist,
int));
1834 else if (type ==
'F') {
1836 bm, op, op->
slots_in, slot_name, htype, va_arg(vlist,
int));
1844 "%s: unrecognized bmop format char: '%c', %d in '%s'\n",
1860 fprintf(stderr,
"%s: error parsing formatting string\n", __func__);
1862 fprintf(stderr,
"string: '%s', position %d\n", _fmt,
int(fmt - ofmt));
1863 fprintf(stderr,
" ");
1865 int pos = int(fmt - ofmt);
1866 for (i = 0; i < pos; i++) {
1867 fprintf(stderr,
" ");
1869 fprintf(stderr,
"^\n");
1872 fprintf(stderr,
"source code: %s:%d\n", __FILE__, lineno);
1874 fprintf(stderr,
"reason: %s\n", err_reason);
1888 va_start(
list, fmt);
1890 printf(
"%s: failed\n", __func__);
1904 printf(
"%s: failed, format is:\n \"%s\"\n", __func__, fmt);
1917 va_start(
list, fmt);
#define GHASH_ITER(gh_iter_, ghash_)
#define BLI_MEMARENA_STD_BUFSIZE
Read Blender memory allocation and freeing.
#define BLI_assert_unreachable()
#define STREQLEN(a, b, n)
#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 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_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)
ccl_device_inline dual1 len(const ccl_private dual< T > &a)
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
char * STRNCPY(char(&dst)[N], const char *src)
void BM_mesh_elem_toolflags_ensure(BMesh *bm)
@ BMO_OP_SLOT_SUBTYPE_MAP_INTERNAL
@ BMO_OP_SLOT_SUBTYPE_MAP_FLT
@ BMO_OP_SLOT_SUBTYPE_MAP_BOOL
@ BMO_OP_SLOT_SUBTYPE_MAP_INT
@ BMO_OP_SLOT_SUBTYPE_MAP_ELEM
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])
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)
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)
@ BMO_OP_SLOT_SUBTYPE_INT_ENUM
@ BMO_OP_SLOT_SUBTYPE_INT_FLAG
BLI_INLINE void ** BLI_ghashIterator_getValue_p(GHashIterator *ghi) ATTR_WARN_UNUSED_RESULT
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)
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
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)
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)
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)
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
@ BMO_OP_SLOT_ELEMENT_BUF
unsigned int BLI_ghash_len(const GHash *gh) ATTR_WARN_UNUSED_RESULT
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)
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)
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
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
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)
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]
void(*) exec(BMesh *bm, struct BMOperator *op)
struct BMFlagLayer * oflags
BLI_mempool * vtoolflagpool
ListBaseT< BMOpError > errorstack
BLI_mempool * ftoolflagpool
BLI_mempool * etoolflagpool
ListBaseT< BMEditSelection > selected
eBMOpSlotSubType_Int intg
eBMOpSlotSubType_Elem elem