31 #ifdef USE_DEBUG_INDEX_MEMCHECK
32 # define DEBUG_MEMCHECK_INDEX_INVALIDATE(ele) \
35 BM_elem_index_set(ele, undef_idx); \
54 #ifdef USE_DEBUG_INDEX_MEMCHECK
55 DEBUG_MEMCHECK_INDEX_INVALIDATE(
v);
142 #ifdef USE_DEBUG_INDEX_MEMCHECK
143 DEBUG_MEMCHECK_INDEX_INVALIDATE(
e);
161 memset(&
e->v1_disk_link, 0,
sizeof(
BMDiskLink[2]));
218 #ifdef USE_DEBUG_INDEX_MEMCHECK
219 DEBUG_MEMCHECK_INDEX_INVALIDATE(
l);
262 #ifdef USE_BMESH_HOLES
269 #ifdef USE_BMESH_HOLES
270 lst->first = lst->last =
l;
280 BMesh *bm_dst,
BMesh *bm_src,
BMFace *f,
const bool copy_verts,
const bool copy_edges)
290 BLI_assert((bm_dst == bm_src) || (copy_verts && copy_edges));
302 }
while ((l_iter = l_iter->
next) != l_first);
322 edges[i] = l_iter->
e;
325 }
while ((l_iter = l_iter->
next) != l_first);
335 l_copy = l_copy->
next;
336 }
while ((l_iter = l_iter->
next) != l_first);
355 #ifdef USE_DEBUG_INDEX_MEMCHECK
356 DEBUG_MEMCHECK_INDEX_INVALIDATE(f);
370 #ifdef USE_BMESH_HOLES
388 #ifdef USE_BMESH_HOLES
426 for (i = 1; i <
len; i++) {
436 startl->
prev = lastl;
437 lastl->
next = startl;
469 const bool create_edges)
492 IS_WRONG_TYPE = (1 << 1),
494 IS_VERT_WRONG_EDGE_TYPE = (1 << 2),
496 IS_EDGE_NULL_DISK_LINK = (1 << 3),
497 IS_EDGE_WRONG_LOOP_TYPE = (1 << 4),
498 IS_EDGE_WRONG_FACE_TYPE = (1 << 5),
499 IS_EDGE_NULL_RADIAL_LINK = (1 << 6),
500 IS_EDGE_ZERO_FACE_LENGTH = (1 << 7),
502 IS_LOOP_WRONG_FACE_TYPE = (1 << 8),
503 IS_LOOP_WRONG_EDGE_TYPE = (1 << 9),
504 IS_LOOP_WRONG_VERT_TYPE = (1 << 10),
505 IS_LOOP_VERT_NOT_IN_EDGE = (1 << 11),
506 IS_LOOP_NULL_CYCLE_LINK = (1 << 12),
507 IS_LOOP_ZERO_FACE_LENGTH = (1 << 13),
508 IS_LOOP_WRONG_FACE_LENGTH = (1 << 14),
509 IS_LOOP_WRONG_RADIAL_LENGTH = (1 << 15),
511 IS_FACE_NULL_LOOP = (1 << 16),
512 IS_FACE_WRONG_LOOP_FACE = (1 << 17),
513 IS_FACE_NULL_EDGE = (1 << 18),
514 IS_FACE_NULL_VERT = (1 << 19),
515 IS_FACE_LOOP_VERT_NOT_IN_EDGE = (1 << 20),
516 IS_FACE_LOOP_WRONG_RADIAL_LENGTH = (1 << 21),
517 IS_FACE_LOOP_WRONG_DISK_LENGTH = (1 << 22),
518 IS_FACE_LOOP_DUPE_LOOP = (1 << 23),
519 IS_FACE_LOOP_DUPE_VERT = (1 << 24),
520 IS_FACE_LOOP_DUPE_EDGE = (1 << 25),
521 IS_FACE_WRONG_LENGTH = (1 << 26),
528 if (head->
htype != htype) {
529 return IS_WRONG_TYPE;
536 err |= IS_VERT_WRONG_EDGE_TYPE;
542 if (
e->v1_disk_link.prev ==
NULL ||
e->v2_disk_link.prev ==
NULL ||
543 e->v1_disk_link.next ==
NULL ||
e->v2_disk_link.next ==
NULL) {
544 err |= IS_EDGE_NULL_DISK_LINK;
548 err |= IS_EDGE_WRONG_LOOP_TYPE;
551 err |= IS_EDGE_WRONG_FACE_TYPE;
553 if (
e->l && (
e->l->radial_next ==
NULL ||
e->l->radial_prev ==
NULL)) {
554 err |= IS_EDGE_NULL_RADIAL_LINK;
556 if (
e->l &&
e->l->f->len <= 0) {
557 err |= IS_EDGE_ZERO_FACE_LENGTH;
566 err |= IS_LOOP_WRONG_FACE_TYPE;
569 err |= IS_LOOP_WRONG_EDGE_TYPE;
572 err |= IS_LOOP_WRONG_VERT_TYPE;
576 "%s: fatal bmesh error (vert not in edge)! (bmesh internal error)\n",
578 err |= IS_LOOP_VERT_NOT_IN_EDGE;
582 err |= IS_LOOP_NULL_CYCLE_LINK;
584 if (
l->
f->
len <= 0) {
585 err |= IS_LOOP_ZERO_FACE_LENGTH;
598 }
while ((l2 = l2->next) !=
l);
600 if (i !=
l->
f->
len || l2 !=
l) {
601 err |= IS_LOOP_WRONG_FACE_LENGTH;
605 err |= IS_LOOP_WRONG_RADIAL_LENGTH;
616 # ifdef USE_BMESH_HOLES
622 err |= IS_FACE_NULL_LOOP;
626 if (l_iter->
f != f) {
628 "%s: loop inside one face points to another! (bmesh internal error)\n",
630 err |= IS_FACE_WRONG_LOOP_FACE;
634 err |= IS_FACE_NULL_EDGE;
637 err |= IS_FACE_NULL_VERT;
639 if (l_iter->
e && l_iter->
v) {
642 err |= IS_FACE_LOOP_VERT_NOT_IN_EDGE;
646 err |= IS_FACE_LOOP_WRONG_RADIAL_LENGTH;
650 err |= IS_FACE_LOOP_WRONG_DISK_LENGTH;
656 err |= IS_FACE_LOOP_DUPE_LOOP;
661 err |= IS_FACE_LOOP_DUPE_VERT;
667 err |= IS_FACE_LOOP_DUPE_EDGE;
673 }
while ((l_iter = l_iter->
next) != l_first);
685 }
while ((l_iter = l_iter->
next) != l_first);
688 err |= IS_FACE_WRONG_LENGTH;
803 edges[i++] = l_iter->
e;
804 }
while ((l_iter = l_iter->
next) != l_first);
806 for (i = 0; i < f->
len; i++) {
821 }
while ((l_iter = l_iter->
next) != l_first);
823 for (i = 0; i < f->
len; i++) {
830 #ifdef USE_BMESH_HOLES
831 BMLoopList *ls, *ls_next;
841 #ifdef USE_BMESH_HOLES
842 for (ls = f->loops.first; ls; ls = ls_next)
847 BMLoop *l_iter, *l_next, *l_first;
849 #ifdef USE_BMESH_HOLES
851 l_iter = l_first = ls->first;
857 l_next = l_iter->
next;
862 }
while ((l_iter = l_next) != l_first);
864 #ifdef USE_BMESH_HOLES
874 #ifdef USE_BMESH_HOLES
875 BMLoopList *ls, *ls_next;
880 #ifdef USE_BMESH_HOLES
881 for (ls = f->loops.first; ls; ls = ls_next)
886 BMLoop *l_iter, *l_next, *l_first;
888 #ifdef USE_BMESH_HOLES
890 l_iter = l_first = ls->first;
897 l_next = l_iter->
next;
917 }
while ((l_iter = l_next) != l_first);
919 #ifdef USE_BMESH_HOLES
960 }
while ((
l =
l->
next) != l_first);
967 const int cd_loop_mdisp_offset,
968 const bool use_loop_mdisp_flip)
976 bool is_prev_boundary = l_prev_radial_next == l_prev_radial_next->
radial_next;
983 bool is_iter_boundary = l_iter_radial_next == l_iter_radial_next->
radial_next;
990 if (is_prev_boundary) {
1003 if (e_iter->
l == l_iter) {
1004 e_iter->
l = l_iter->
next;
1011 if (cd_loop_mdisp_offset != -1) {
1017 l_prev_radial_next = l_iter_radial_next;
1018 l_prev_radial_prev = l_iter_radial_prev;
1019 is_prev_boundary = is_iter_boundary;
1022 }
while ((l_iter = l_iter->
prev) != l_first);
1027 for (i = 0, l_iter = l_first; i < f->
len; i++, l_iter = l_iter->
next) {
1046 for (i = 0; i < tot; i++) {
1056 for (i = 0; i < tot; i++) {
1126 #ifdef USE_BMESH_HOLES
1153 for (i = 0; i < totface; i++) {
1163 else if (rlen == 1) {
1171 else if (rlen == 2) {
1201 }
while ((l_iter = l_iter->
next) != l_first);
1203 #ifdef USE_BMESH_HOLES
1204 for (lst = f->loops.first; lst; lst = lst->next) {
1205 if (lst == f->loops.first) {
1235 }
while (l2 != l_iter);
1239 if (l2->
v != l_iter->
v) {
1246 }
while ((l_iter = l_iter->
next) != l_first);
1248 #ifdef USE_BMESH_HOLES
1253 for (lst = f_new->loops.first; lst; lst = lst->next) {
1254 l_iter = l_first = lst->first;
1257 }
while ((l_iter = l_iter->
next) != l_first);
1265 if (cd_loop_mdisp_offset != -1) {
1270 for (i = 0; i < totface; i++) {
1276 for (i = 0; i < totface; i++) {
1278 bm, l_iter,
faces[i], f_center, faces_center[i], cd_loop_mdisp_offset);
1280 }
while ((l_iter = l_iter->
next) != l_first);
1295 for (i = 0; i < totface; i++) {
1319 #ifdef USE_BMESH_HOLES
1325 #ifdef USE_BMESH_HOLES
1330 #ifdef USE_BMESH_HOLES
1344 #ifdef USE_BMESH_HOLES
1348 const bool no_double)
1350 #ifdef USE_BMESH_HOLES
1351 BMLoopList *lst, *lst2;
1357 BMLoop *l_iter, *l_first;
1382 #ifdef USE_BMESH_HOLES
1383 lst = f->loops.first;
1384 lst2 = f2->loops.first;
1386 lst2->first = lst2->last = l_f2;
1387 lst->first = lst->last = l_f1;
1390 l_iter = l_first = l_f1;
1396 }
while ((l_iter = l_iter->
next) != l_first);
1398 if (first_loop_f1) {
1437 }
while ((l_iter = l_iter->
next) != l_first);
1449 }
while ((l_iter = l_iter->
next) != l_first);
1457 #ifdef USE_BMESH_HOLES
1464 for (lst = f->loops.last; lst != f->loops.first; lst = lst2) {
1484 int valence1, valence2;
1532 bool is_first =
true;
1585 for (i = 0,
l =
e->l; i < radlen; i++, l = l->radial_next) {
1602 for (i = 0,
l = e_new->
l; i < radlen; i++, l = l->radial_next) {
1635 const bool check_edge_exists,
1636 const bool kill_degenerate_faces,
1637 const bool kill_duplicate_faces)
1640 BMVert *v_old, *v_target;
1655 int valence1, valence2;
1681 if (check_edge_exists) {
1700 if (l_kill->
next->
v == v_kill) {
1701 l_kill->
next->
v = v_target;
1712 if (kill_degenerate_faces && (l_kill->
f->
len < 3)) {
1718 if (kill_duplicate_faces) {
1726 }
while ((l_kill = l_kill_next) != e_kill->
l);
1753 for (i = 0,
l = e_old->
l; i < radlen; i++, l = l->radial_next) {
1766 if (check_edge_exists) {
1773 if (kill_degenerate_faces) {
1780 if (kill_duplicate_faces) {
1802 const bool check_edge_exists,
1803 const bool kill_degenerate_faces)
1811 BMLoop *l_kill, *l_first, *l_kill_next;
1812 l_kill = l_first = e_kill->
l;
1815 if (l_kill->
next->
v == v_kill) {
1816 l_kill->
next->
v = v_target;
1827 if (kill_degenerate_faces) {
1828 if (l_kill->
f->
len < 3) {
1836 }
while ((l_kill = l_kill_next) != l_first);
1845 if (v_target->
e && v_kill->
e) {
1848 while ((
e = v_kill->
e)) {
1851 if (check_edge_exists) {
1858 if (check_edge_exists) {
1866 if (kill_degenerate_faces) {
1884 int newlen = 0, i, f1len = 0, f2len = 0;
1905 if (l_f1->
v == l_f2->v) {
1923 bool is_dupe =
false;
1930 for (i = 0, l_iter =
BM_FACE_FIRST_LOOP(f1); i < f1len; i++, l_iter = l_iter->next) {
1933 for (i = 0, l_iter =
BM_FACE_FIRST_LOOP(f2); i < f2len; i++, l_iter = l_iter->next) {
1934 if (l_iter != l_f2) {
1943 for (i = 0, l_iter =
BM_FACE_FIRST_LOOP(f1); i < f1len; i++, l_iter = l_iter->next) {
1964 f1->
len += (f2->
len - 2);
2005 bool is_double =
false;
2009 if (v_a->
e && v_b->
e) {
2012 #define VERT_VISIT _FLAG_WALK
2015 e = e_first = v_a->
e;
2023 e = e_first = v_b->
e;
2033 e = e_first = v_a->
e;
2051 if (v_src == v_dst) {
2058 while ((
e = v_src->
e)) {
2079 return (
e->l &&
e->l->radial_next !=
e->l);
2085 int v_edges_num = 0;
2102 int edges_found = 0;
2104 #define EDGE_VISIT _FLAG_WALK
2108 BMEdge *e_first, *e_iter;
2109 e_iter = e_first =
v->
e;
2130 BMLoop *l_iter, *l_first;
2131 l_iter = l_first =
e->l;
2139 }
while ((l_iter = l_iter->
radial_next) != l_first);
2147 if (edges_found == v_edges_num) {
2176 if (r_vout_len !=
NULL) {
2177 *r_vout_len = verts_num;
2180 if (r_vout !=
NULL) {
2228 }
while ((n_step = n_step->
next));
2230 }
while ((n_orig = n_orig->
next) && n_orig->
next);
2231 }
while ((edges_separate = edges_separate->
next));
2238 const bool copy_select,
2245 for (i = 0; i < e_in_len; i++) {
2262 if (edges_separate) {
2270 const bool copy_select,
2275 BMEdge *e_iter, *e_first;
2277 e_iter = e_first =
v->
e;
2287 if (edges_separate ==
NULL && edges_orig ==
NULL) {
2301 if (edges_separate) {
2309 bool (*testfn)(
BMEdge *,
void *arg),
2313 BMEdge *e_iter, *e_first;
2315 e_iter = e_first = v_src->
e;
2317 if (testfn(e_iter, arg)) {
2324 e_iter = edges_hflag->
link;
2326 }
while ((edges_hflag = edges_hflag->
next));
2380 if (l_sep ==
e->l) {
2426 while (!
ELEM(e_iter, l_sep->
e, l_sep->
prev->
e)) {
2432 if (e_iter == v_sep->
e) {
2438 v_sep->
e = l_sep->
e;
2442 edges[0] = l_sep->
e;
2443 edges[1] = l_sep->
prev->
e;
2469 bool is_mixed_edge_any =
false;
2471 bool is_mixed_loop_any =
false;
2473 #define LOOP_VISIT _FLAG_WALK
2474 #define EDGE_VISIT _FLAG_WALK
2476 for (i = 0; i < larr_len; i++) {
2491 for (
int j = 0; j <
ARRAY_SIZE(loop_pair); j++) {
2506 BMEdge *e_first, *e_iter;
2507 e_iter = e_first = v_sep->
e;
2510 BMLoop *l_iter, *l_first;
2511 bool is_mixed_loop =
false;
2513 l_iter = l_first = e_iter->
l;
2516 is_mixed_loop =
true;
2519 }
while ((l_iter = l_iter->
radial_next) != l_first);
2521 if (is_mixed_loop) {
2526 is_mixed_loop_any =
true;
2533 is_mixed_edge_any =
true;
2540 if (is_mixed_loop_any ==
false && is_mixed_edge_any ==
false) {
2550 BMLoop *l_iter, *l_first, *l_next;
2561 if (
e->v1 == v_sep) {
2562 e_new_v_pair[0] = v_new;
2563 e_new_v_pair[1] =
e->v2;
2567 e_new_v_pair[0] =
e->v1;
2568 e_new_v_pair[1] = v_new;
2574 l_iter = l_first =
e->l;
2582 }
while ((l_iter = l_next) != l_first);
2593 for (i = 0; i < larr_len; i++) {
2617 BMLoop *l_iter, *l_first;
2622 l_iter = l_first =
e->l;
2624 if (l_iter->
v == v_src) {
2630 else if (l_iter->
next->
v == v_src) {
2631 l_iter->
next->
v = v_dst;
2639 }
while ((l_iter = l_iter->
radial_next) != l_first);
2653 BMLoop *l_iter, *l_first;
2660 }
while ((l_iter = l_iter->
next) != l_first);
2665 }
while ((l_iter = l_iter->
next) != l_first);
typedef float(TangentPoint)[2]
CustomData interface, see also DNA_customdata_types.h.
void CustomData_bmesh_set_default(struct CustomData *data, void **block)
void CustomData_bmesh_copy_data(const struct CustomData *source, struct CustomData *dest, void *src_block, void **dest_block)
void CustomData_bmesh_free_block_data(struct CustomData *data, void *block)
void * CustomData_bmesh_get(const struct CustomData *data, void *block, int type)
int CustomData_get_offset(const struct CustomData *data, int type)
void CustomData_bmesh_free_block(struct CustomData *data, void **block)
void BKE_mesh_mdisp_flip(struct MDisps *md, bool use_loop_mdisp_flip)
#define BLI_array_alloca(arr, realsize)
A (mainly) macro array library.
#define BLI_array_append(arr, item)
#define BLI_array_staticdeclare(arr, maxstatic)
#define BLI_array_len(arr)
#define BLI_array_free(arr)
#define BLI_linklist_prepend_alloca(listp, ptr)
BLI_LINKSTACK_*** wrapper macros for using a LinkNode to store a stack of pointers,...
#define BLI_SMALLSTACK_DECLARE(var, type)
#define BLI_SMALLSTACK_AS_TABLE(var, data)
#define BLI_SMALLSTACK_POP(var)
#define BLI_SMALLSTACK_PUSH(var, data)
BLI_INLINE void BLI_listbase_clear(struct ListBase *lb)
void void void BLI_movelisttolist(struct ListBase *dst, struct ListBase *src) ATTR_NONNULL(1
void BLI_addtail(struct ListBase *listbase, void *vlink) ATTR_NONNULL(1)
void BLI_remlink(struct ListBase *listbase, void *vlink) ATTR_NONNULL(1)
MINLINE void copy_v3_v3(float r[3], const float a[3])
MINLINE void zero_v3(float r[3])
void BLI_mempool_free(BLI_mempool *pool, void *addr) ATTR_NONNULL(1
void * BLI_mempool_alloc(BLI_mempool *pool) ATTR_MALLOC ATTR_WARN_UNUSED_RESULT ATTR_RETURNS_NONNULL ATTR_NONNULL(1)
void * BLI_mempool_calloc(BLI_mempool *pool) ATTR_MALLOC ATTR_WARN_UNUSED_RESULT ATTR_RETURNS_NONNULL ATTR_NONNULL(1)
#define UNUSED_FUNCTION(x)
#define STACK_PUSH(stack, val)
#define STACK_DECLARE(stack)
#define STACK_SIZE(stack)
#define STACK_INIT(stack, stack_num)
_GL_VOID GLfloat value _GL_VOID_RET _GL_VOID const GLuint GLboolean *residences _GL_BOOL_RET _GL_VOID GLsizei GLfloat GLfloat GLfloat GLfloat const GLubyte *bitmap _GL_VOID_RET _GL_VOID GLenum const void *lists _GL_VOID_RET _GL_VOID const GLdouble *equation _GL_VOID_RET _GL_VOID GLdouble GLdouble blue _GL_VOID_RET _GL_VOID GLfloat GLfloat blue _GL_VOID_RET _GL_VOID GLint GLint blue _GL_VOID_RET _GL_VOID GLshort GLshort blue _GL_VOID_RET _GL_VOID GLubyte GLubyte blue _GL_VOID_RET _GL_VOID GLuint GLuint blue _GL_VOID_RET _GL_VOID GLushort GLushort blue _GL_VOID_RET _GL_VOID GLbyte GLbyte GLbyte alpha _GL_VOID_RET _GL_VOID GLdouble GLdouble GLdouble alpha _GL_VOID_RET _GL_VOID GLfloat GLfloat GLfloat alpha _GL_VOID_RET _GL_VOID GLint GLint GLint alpha _GL_VOID_RET _GL_VOID GLshort GLshort GLshort alpha _GL_VOID_RET _GL_VOID GLubyte GLubyte GLubyte alpha _GL_VOID_RET _GL_VOID GLuint GLuint GLuint alpha _GL_VOID_RET _GL_VOID GLushort GLushort GLushort alpha _GL_VOID_RET _GL_VOID GLenum mode _GL_VOID_RET _GL_VOID GLint GLsizei GLsizei GLenum type _GL_VOID_RET _GL_VOID GLsizei GLenum GLenum const void *pixels _GL_VOID_RET _GL_VOID const void *pointer _GL_VOID_RET _GL_VOID GLdouble v _GL_VOID_RET _GL_VOID GLfloat v _GL_VOID_RET _GL_VOID GLint GLint i2 _GL_VOID_RET _GL_VOID GLint j _GL_VOID_RET _GL_VOID GLfloat param _GL_VOID_RET _GL_VOID GLint param _GL_VOID_RET _GL_VOID GLdouble GLdouble GLdouble GLdouble GLdouble zFar _GL_VOID_RET _GL_UINT GLdouble *equation _GL_VOID_RET _GL_VOID GLenum GLint *params _GL_VOID_RET _GL_VOID GLenum GLfloat *v _GL_VOID_RET _GL_VOID GLenum GLfloat *params _GL_VOID_RET _GL_VOID GLfloat *values _GL_VOID_RET _GL_VOID GLushort *values _GL_VOID_RET _GL_VOID GLenum GLfloat *params _GL_VOID_RET _GL_VOID GLenum GLdouble *params _GL_VOID_RET _GL_VOID GLenum GLint *params _GL_VOID_RET _GL_VOID GLsizei const void *pointer _GL_VOID_RET _GL_VOID GLsizei const void *pointer _GL_VOID_RET _GL_BOOL GLfloat param _GL_VOID_RET _GL_VOID GLint param _GL_VOID_RET _GL_VOID GLenum GLfloat param _GL_VOID_RET _GL_VOID GLenum GLint param _GL_VOID_RET _GL_VOID GLushort pattern _GL_VOID_RET _GL_VOID GLdouble GLdouble GLint GLint const GLdouble *points _GL_VOID_RET _GL_VOID GLdouble GLdouble GLint GLint GLdouble v1
Read Guarded memory(de)allocation.
#define BM_DISK_EDGE_NEXT(e, v)
#define BM_DEFAULT_NGON_STACK_SIZE
#define BM_FACE_FIRST_LOOP(p)
#define BM_ELEM_CD_GET_VOID_P(ele, offset)
void BM_elem_select_copy(BMesh *bm_dst, void *ele_dst_v, const void *ele_src_v)
void BM_elem_attrs_copy(BMesh *bm_src, BMesh *bm_dst, const void *ele_src, void *ele_dst)
void BM_edges_from_verts_ensure(BMesh *bm, BMEdge **edge_arr, BMVert **vert_arr, const int len)
BMFace * BM_face_create_ngon(BMesh *bm, BMVert *v1, BMVert *v2, BMEdge **edges, const int len, const BMFace *f_example, const eBMCreateFlag create_flag)
Make NGon.
bool BM_edges_from_verts(BMEdge **edge_arr, BMVert **vert_arr, const int len)
void bmesh_face_swap_data(BMFace *f_a, BMFace *f_b)
BMFace * BM_faces_join(BMesh *bm, BMFace **faces, int totface, const bool do_del)
Join Connected Faces.
static void bmesh_edge_vert_swap__recursive(BMEdge *e, BMVert *v_dst, BMVert *v_src)
void BM_face_verts_kill(BMesh *bm, BMFace *f)
bool BM_edge_splice(BMesh *bm, BMEdge *e_dst, BMEdge *e_src)
Splice Edge.
BMVert * BM_vert_create(BMesh *bm, const float co[3], const BMVert *v_example, const eBMCreateFlag create_flag)
Main function for creating a new vertex.
void BM_vert_separate(BMesh *bm, BMVert *v, BMEdge **e_in, int e_in_len, const bool copy_select, BMVert ***r_vout, int *r_vout_len)
static BMLoop * bm_loop_create(BMesh *bm, BMVert *v, BMEdge *e, BMFace *f, const BMLoop *l_example, const eBMCreateFlag create_flag)
BMFace * BM_face_create_verts(BMesh *bm, BMVert **vert_arr, const int len, const BMFace *f_example, const eBMCreateFlag create_flag, const bool create_edges)
BMVert * bmesh_kernel_unglue_region_make_vert_multi_isolated(BMesh *bm, BMLoop *l_sep)
static void bm_elements_systag_disable(void *veles, int tot, const char api_flag)
static void bm_kill_only_loop(BMesh *bm, BMLoop *l)
void bmesh_kernel_edge_separate(BMesh *bm, BMEdge *e, BMLoop *l_sep, const bool copy_select)
Separate Edge.
bool BM_vert_splice(BMesh *bm, BMVert *v_dst, BMVert *v_src)
Splice Vert.
BMFace * bmesh_kernel_join_face_kill_edge(BMesh *bm, BMFace *f1, BMFace *f2, BMEdge *e)
Join Face Kill Edge (JFKE)
void BM_vert_kill(BMesh *bm, BMVert *v)
static void bmesh_kernel_vert_separate__cleanup(BMesh *bm, LinkNode *edges_separate)
BMFace * bmesh_kernel_split_face_make_edge(BMesh *bm, BMFace *f, BMLoop *l_v1, BMLoop *l_v2, BMLoop **r_l, BMEdge *e_example, const bool no_double)
Split Face Make Edge (SFME)
void BM_face_kill(BMesh *bm, BMFace *f)
BMEdge * bmesh_kernel_join_edge_kill_vert(BMesh *bm, BMEdge *e_kill, BMVert *v_kill, const bool do_del, const bool check_edge_exists, const bool kill_degenerate_faces, const bool kill_duplicate_faces)
Join Edge Kill Vert (JEKV)
void BM_vert_separate_hflag(BMesh *bm, BMVert *v, const char hflag, const bool copy_select, BMVert ***r_vout, int *r_vout_len)
void BM_face_kill_loose(BMesh *bm, BMFace *f)
static void bm_kill_only_vert(BMesh *bm, BMVert *v)
static BMFace * bm_face_create__sfme(BMesh *bm, BMFace *f_example)
BLI_INLINE BMFace * bm_face_create__internal(BMesh *bm)
BMVert * bmesh_kernel_unglue_region_make_vert(BMesh *bm, BMLoop *l_sep)
Un-glue Region Make Vert (URMV)
static void bm_kill_only_edge(BMesh *bm, BMEdge *e)
static int UNUSED_FUNCTION() bm_loop_length(BMLoop *l)
void BM_face_edges_kill(BMesh *bm, BMFace *f)
static int UNUSED_FUNCTION() bm_vert_systag_count_disk(BMVert *v, const char api_flag)
BMVert * bmesh_kernel_unglue_region_make_vert_multi(BMesh *bm, BMLoop **larr, int larr_len)
void BM_vert_separate_tested_edges(BMesh *UNUSED(bm), BMVert *v_dst, BMVert *v_src, bool(*testfn)(BMEdge *, void *arg), void *arg)
static bool bm_vert_is_manifold_flagged(BMVert *v, const char api_flag)
void bmesh_kernel_loop_reverse(BMesh *bm, BMFace *f, const int cd_loop_mdisp_offset, const bool use_loop_mdisp_flip)
Loop Reverse.
void BM_edge_kill(BMesh *bm, BMEdge *e)
BMFace * BM_face_copy(BMesh *bm_dst, BMesh *bm_src, BMFace *f, const bool copy_verts, const bool copy_edges)
int bmesh_elem_check(void *element, const char htype)
static void bm_elements_systag_enable(void *veles, int tot, const char api_flag)
static BMLoop * bm_face_boundary_add(BMesh *bm, BMFace *f, BMVert *startv, BMEdge *starte, const eBMCreateFlag create_flag)
BMFace * BM_face_create(BMesh *bm, BMVert **verts, BMEdge **edges, const int len, const BMFace *f_example, const eBMCreateFlag create_flag)
BMVert * bmesh_kernel_split_edge_make_vert(BMesh *bm, BMVert *tv, BMEdge *e, BMEdge **r_e)
Split Edge Make Vert (SEMV)
static int bm_loop_systag_count_radial(BMLoop *l, const char api_flag)
void bmesh_kernel_vert_separate(BMesh *bm, BMVert *v, BMVert ***r_vout, int *r_vout_len, const bool copy_select)
Separate Vert.
BLI_INLINE bool bm_edge_supports_separate(const BMEdge *e)
static void bm_kill_only_face(BMesh *bm, BMFace *f)
BMVert * bmesh_kernel_join_vert_kill_edge(BMesh *bm, BMEdge *e_kill, BMVert *v_kill, const bool do_del, const bool check_edge_exists, const bool kill_degenerate_faces)
Join Vert Kill Edge (JVKE)
BMEdge * BM_edge_create(BMesh *bm, BMVert *v1, BMVert *v2, const BMEdge *e_example, const eBMCreateFlag create_flag)
Main function for creating a new edge.
bool BM_vert_splice_check_double(BMVert *v_a, BMVert *v_b)
#define BM_elem_flag_disable(ele, hflag)
#define BM_elem_flag_set(ele, hflag, val)
#define BM_elem_index_set(ele, index)
#define BM_elem_flag_test(ele, hflag)
void BM_loop_interp_multires_ex(BMesh *UNUSED(bm), BMLoop *l_dst, const BMFace *f_src, const float f_dst_center[3], const float f_src_center[3], const int cd_loop_mdisp_offset)
ATTR_WARN_UNUSED_RESULT BMesh * bm
#define BM_select_history_remove(bm, ele)
ATTR_WARN_UNUSED_RESULT const void * element
void BM_face_calc_center_median(const BMFace *f, float r_cent[3])
#define BM_ELEM_API_FLAG_DISABLE(element, f)
#define BM_ELEM_API_FLAG_TEST(element, f)
#define BM_CHECK_ELEMENT(el)
int bmesh_radial_length(const BMLoop *l)
int bmesh_disk_count_at_most(const BMVert *v, int count_max)
#define BM_ELEM_API_FLAG_ENABLE(element, f)
int bmesh_disk_count(const BMVert *v)
BMEdge * BM_edge_exists(BMVert *v_a, BMVert *v_b)
bool BM_vert_pair_share_face_check(BMVert *v_a, BMVert *v_b)
bool BM_edge_in_face(const BMEdge *e, const BMFace *f)
BMFace * BM_face_find_double(BMFace *f)
int BM_face_share_edge_count(BMFace *f_a, BMFace *f_b)
BMLoop * BM_face_edge_share_loop(BMFace *f, BMEdge *e)
Return the Loop Shared by Face and Edge.
BMFace * BM_face_exists(BMVert **varr, int len)
BLI_INLINE bool BM_edge_is_manifold(const BMEdge *e) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL()
BLI_INLINE bool BM_edge_is_boundary(const BMEdge *e) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL()
#define BM_edge_face_count_is_over(e, n)
#define BM_vert_edge_count_is_equal(v, n)
BLI_INLINE BMVert * BM_edge_other_vert(BMEdge *e, const BMVert *v) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL()
BLI_INLINE bool BM_verts_in_edge(const BMVert *v1, const BMVert *v2, const BMEdge *e) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL()
BLI_INLINE bool BM_vert_in_edge(const BMEdge *e, const BMVert *v) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL()
ATTR_WARN_UNUSED_RESULT const BMVert * v2
ATTR_WARN_UNUSED_RESULT const BMLoop * l
ATTR_WARN_UNUSED_RESULT const BMVert const BMEdge * e
ATTR_WARN_UNUSED_RESULT const BMVert * v
void bmesh_disk_edge_remove(BMEdge *e, BMVert *v)
bool bmesh_loop_validate(BMFace *f)
void bmesh_disk_edge_append(BMEdge *e, BMVert *v)
void bmesh_edge_vert_swap(BMEdge *e, BMVert *v_dst, BMVert *v_src)
void bmesh_disk_vert_replace(BMEdge *e, BMVert *v_dst, BMVert *v_src)
void bmesh_radial_loop_unlink(BMLoop *l)
void bmesh_radial_loop_append(BMEdge *e, BMLoop *l)
void bmesh_radial_loop_remove(BMEdge *e, BMLoop *l)
BMESH RADIAL REMOVE LOOP.
bool bmesh_disk_validate(int len, BMEdge *e, BMVert *v)
bool bmesh_radial_validate(int radlen, BMLoop *l)
BLI_INLINE BMEdge * bmesh_disk_edge_next(const BMEdge *e, const BMVert *v) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL()
void *(* MEM_mallocN)(size_t len, const char *str)
static void error(const char *str)
struct BMLoop * radial_prev
struct BMLoop * radial_next
struct BLI_mempool * epool
struct BLI_mempool * vtoolflagpool
struct BLI_mempool * etoolflagpool
struct BLI_mempool * ftoolflagpool
struct BLI_mempool * fpool
struct BLI_mempool * vpool
struct BLI_mempool * lpool