BMesh: rename cryptic functions
Use expanded names for bmesh primitive operations (urmv jvke semv jfke). Use 'bmesh_kernel_' prefix, these functions aren't intended for wide use so favor readability. Remove BM_face_vert_separate, it wasn't used and only skipped step of finding correct loop of face.
This commit is contained in:
Campbell Barton
parent
f28376d8d9
commit
6521307dcd
@ -192,9 +192,10 @@
|
||||
*
|
||||
* These conventions should be used throughout the bmesh module.
|
||||
*
|
||||
* - ``BM_***()`` - High level BMesh API function for use anywhere.
|
||||
* - ``bmesh_***()`` - Low level API function.
|
||||
* - ``bmesh_kernel_*()`` - Low level API, for primitive functions that others are built ontop of.
|
||||
* - ``bmesh_***()`` - Low level API function.
|
||||
* - ``bm_***()`` - 'static' functions, not apart of the API at all, but use prefix since they operate on BMesh data.
|
||||
* - ``BM_***()`` - High level BMesh API function for use anywhere.
|
||||
* - ``BMO_***()`` - High level operator API function for use anywhere.
|
||||
* - ``bmo_***()`` - Low level / internal operator API functions.
|
||||
* - ``_bm_***()`` - Functions which are called via macros only.
|
||||
|
||||
@ -1021,7 +1021,7 @@ static int UNUSED_FUNCTION(bm_loop_length)(BMLoop *l)
|
||||
* \param use_loop_mdisp_flip: When set, flip the Z-depth of the mdisp,
|
||||
* (use when flipping normals, disable when mirroring, eg: symmetrize).
|
||||
*/
|
||||
void bmesh_loop_reverse(
|
||||
void bmesh_kernel_loop_reverse(
|
||||
BMesh *bm, BMFace *f,
|
||||
const int cd_loop_mdisp_offset, const bool use_loop_mdisp_flip)
|
||||
{
|
||||
@ -1438,7 +1438,7 @@ static BMFace *bm_face_create__sfme(BMesh *bm, BMFace *f_example)
|
||||
*
|
||||
* \return A BMFace pointer
|
||||
*/
|
||||
BMFace *bmesh_sfme(
|
||||
BMFace *bmesh_kernel_split_face_make_edge(
|
||||
BMesh *bm, BMFace *f, BMLoop *l_v1, BMLoop *l_v2,
|
||||
BMLoop **r_l,
|
||||
#ifdef USE_BMESH_HOLES
|
||||
@ -1584,7 +1584,7 @@ BMFace *bmesh_sfme(
|
||||
*
|
||||
* \return The newly created BMVert pointer.
|
||||
*/
|
||||
BMVert *bmesh_semv(BMesh *bm, BMVert *tv, BMEdge *e, BMEdge **r_e)
|
||||
BMVert *bmesh_kernel_split_edge_make_vert(BMesh *bm, BMVert *tv, BMEdge *e, BMEdge **r_e)
|
||||
{
|
||||
BMLoop *l_next;
|
||||
BMEdge *e_new;
|
||||
@ -1766,7 +1766,7 @@ BMVert *bmesh_semv(BMesh *bm, BMVert *tv, BMEdge *e, BMEdge **r_e)
|
||||
* faces with just 2 edges. It is up to the caller to decide what to do with
|
||||
* these faces.
|
||||
*/
|
||||
BMEdge *bmesh_jekv(
|
||||
BMEdge *bmesh_kernel_join_edge_kill_vert(
|
||||
BMesh *bm, BMEdge *e_kill, BMVert *v_kill,
|
||||
const bool do_del, const bool check_edge_double,
|
||||
const bool kill_degenerate_faces)
|
||||
@ -1920,7 +1920,7 @@ BMEdge *bmesh_jekv(
|
||||
*
|
||||
* Collapse an edge, merging surrounding data.
|
||||
*
|
||||
* Unlike #BM_vert_collapse_edge & #bmesh_jekv which only handle 2 valence verts,
|
||||
* Unlike #BM_vert_collapse_edge & #bmesh_kernel_join_edge_kill_vert which only handle 2 valence verts,
|
||||
* this can handle any number of connected edges/faces.
|
||||
*
|
||||
* <pre>
|
||||
@ -1932,7 +1932,7 @@ BMEdge *bmesh_jekv(
|
||||
* +-+-+-+ +-+-+-+
|
||||
* </pre>
|
||||
*/
|
||||
BMVert *bmesh_jvke(
|
||||
BMVert *bmesh_kernel_join_vert_kill_edge(
|
||||
BMesh *bm, BMEdge *e_kill, BMVert *v_kill,
|
||||
const bool do_del, const bool check_edge_double,
|
||||
const bool kill_degenerate_faces)
|
||||
@ -2035,7 +2035,7 @@ BMVert *bmesh_jvke(
|
||||
* In the example A, faces \a f1 and \a f2 are joined by a single edge,
|
||||
* and the euler can safely be used.
|
||||
* In example B however, \a f1 and \a f2 are joined by multiple edges and will produce an error.
|
||||
* The caller in this case should call #bmesh_jekv on the extra edges
|
||||
* The caller in this case should call #bmesh_kernel_join_edge_kill_vert on the extra edges
|
||||
* before attempting to fuse \a f1 and \a f2.
|
||||
*
|
||||
* \note The order of arguments decides whether or not certain per-face attributes are present
|
||||
@ -2044,7 +2044,7 @@ BMVert *bmesh_jvke(
|
||||
*
|
||||
* \return A BMFace pointer
|
||||
*/
|
||||
BMFace *bmesh_jfke(BMesh *bm, BMFace *f1, BMFace *f2, BMEdge *e)
|
||||
BMFace *bmesh_kernel_join_face_kill_edge(BMesh *bm, BMFace *f1, BMFace *f2, BMEdge *e)
|
||||
{
|
||||
BMLoop *l_iter, *l_f1 = NULL, *l_f2 = NULL;
|
||||
int newlen = 0, i, f1len = 0, f2len = 0;
|
||||
@ -2249,7 +2249,7 @@ bool BM_vert_splice(BMesh *bm, BMVert *v_dst, BMVert *v_src)
|
||||
}
|
||||
|
||||
|
||||
/** \name BM_vert_separate, bmesh_vert_separate and friends
|
||||
/** \name BM_vert_separate, bmesh_kernel_vert_separate and friends
|
||||
* \{ */
|
||||
|
||||
/* BM_edge_face_count(e) >= 1 */
|
||||
@ -2269,7 +2269,7 @@ BLI_INLINE bool bm_edge_supports_separate(const BMEdge *e)
|
||||
*
|
||||
* \return Success
|
||||
*/
|
||||
void bmesh_vert_separate(
|
||||
void bmesh_kernel_vert_separate(
|
||||
BMesh *bm, BMVert *v, BMVert ***r_vout, int *r_vout_len,
|
||||
const bool copy_select)
|
||||
{
|
||||
@ -2385,7 +2385,7 @@ void bmesh_vert_separate(
|
||||
*
|
||||
* Takes a list of edges, which have been split from their original.
|
||||
*
|
||||
* Any edges which failed to split off in #bmesh_vert_separate will be merged back into the original edge.
|
||||
* Any edges which failed to split off in #bmesh_kernel_vert_separate will be merged back into the original edge.
|
||||
*
|
||||
* \param edges_separate
|
||||
* A list-of-lists, each list is from a single original edge (the first edge is the original),
|
||||
@ -2398,7 +2398,7 @@ void bmesh_vert_separate(
|
||||
* \note this function looks like it could become slow,
|
||||
* but in common cases its only going to iterate a few times.
|
||||
*/
|
||||
static void bmesh_vert_separate__cleanup(BMesh *bm, LinkNode *edges_separate)
|
||||
static void bmesh_kernel_vert_separate__cleanup(BMesh *bm, LinkNode *edges_separate)
|
||||
{
|
||||
do {
|
||||
LinkNode *n_orig = edges_separate->link;
|
||||
@ -2418,7 +2418,7 @@ static void bmesh_vert_separate__cleanup(BMesh *bm, LinkNode *edges_separate)
|
||||
}
|
||||
|
||||
/**
|
||||
* High level function which wraps both #bmesh_vert_separate and #bmesh_edge_separate
|
||||
* High level function which wraps both #bmesh_kernel_vert_separate and #bmesh_kernel_edge_separate
|
||||
*/
|
||||
void BM_vert_separate(
|
||||
BMesh *bm, BMVert *v,
|
||||
@ -2435,7 +2435,7 @@ void BM_vert_separate(
|
||||
LinkNode *edges_orig = NULL;
|
||||
do {
|
||||
BMLoop *l_sep = e->l;
|
||||
bmesh_edge_separate(bm, e, l_sep, copy_select);
|
||||
bmesh_kernel_edge_separate(bm, e, l_sep, copy_select);
|
||||
BLI_linklist_prepend_alloca(&edges_orig, l_sep->e);
|
||||
BLI_assert(e != l_sep->e);
|
||||
} while (bm_edge_supports_separate(e));
|
||||
@ -2444,10 +2444,10 @@ void BM_vert_separate(
|
||||
}
|
||||
}
|
||||
|
||||
bmesh_vert_separate(bm, v, r_vout, r_vout_len, copy_select);
|
||||
bmesh_kernel_vert_separate(bm, v, r_vout, r_vout_len, copy_select);
|
||||
|
||||
if (edges_separate) {
|
||||
bmesh_vert_separate__cleanup(bm, edges_separate);
|
||||
bmesh_kernel_vert_separate__cleanup(bm, edges_separate);
|
||||
}
|
||||
}
|
||||
|
||||
@ -2472,7 +2472,7 @@ void BM_vert_separate_hflag(
|
||||
LinkNode *edges_orig = NULL;
|
||||
do {
|
||||
BMLoop *l_sep = e->l;
|
||||
bmesh_edge_separate(bm, e, l_sep, copy_select);
|
||||
bmesh_kernel_edge_separate(bm, e, l_sep, copy_select);
|
||||
/* trick to avoid looping over separated edges */
|
||||
if (edges_separate == NULL && edges_orig == NULL) {
|
||||
e_first = l_sep->e;
|
||||
@ -2486,10 +2486,10 @@ void BM_vert_separate_hflag(
|
||||
}
|
||||
} while ((e_iter = BM_DISK_EDGE_NEXT(e_iter, v)) != e_first);
|
||||
|
||||
bmesh_vert_separate(bm, v, r_vout, r_vout_len, copy_select);
|
||||
bmesh_kernel_vert_separate(bm, v, r_vout, r_vout_len, copy_select);
|
||||
|
||||
if (edges_separate) {
|
||||
bmesh_vert_separate__cleanup(bm, edges_separate);
|
||||
bmesh_kernel_vert_separate__cleanup(bm, edges_separate);
|
||||
}
|
||||
}
|
||||
|
||||
@ -2574,7 +2574,7 @@ bool BM_edge_splice(BMesh *bm, BMEdge *e_dst, BMEdge *e_src)
|
||||
* \note Does nothing if \a l_sep is already the only loop in the
|
||||
* edge radial.
|
||||
*/
|
||||
void bmesh_edge_separate(
|
||||
void bmesh_kernel_edge_separate(
|
||||
BMesh *bm, BMEdge *e, BMLoop *l_sep,
|
||||
const bool copy_select)
|
||||
{
|
||||
@ -2620,7 +2620,7 @@ void bmesh_edge_separate(
|
||||
*
|
||||
* \note Will be a no-op and return original vertex if only two edges at that vertex.
|
||||
*/
|
||||
BMVert *bmesh_urmv_loop(BMesh *bm, BMLoop *l_sep)
|
||||
BMVert *bmesh_kernel_unglue_region_make_vert(BMesh *bm, BMLoop *l_sep)
|
||||
{
|
||||
BMVert *v_new = NULL;
|
||||
BMVert *v_sep = l_sep->v;
|
||||
@ -2630,10 +2630,12 @@ BMVert *bmesh_urmv_loop(BMesh *bm, BMLoop *l_sep)
|
||||
|
||||
/* peel the face from the edge radials on both sides of the
|
||||
* loop vert, disconnecting the face from its fan */
|
||||
if (!BM_edge_is_boundary(l_sep->e))
|
||||
bmesh_edge_separate(bm, l_sep->e, l_sep, false);
|
||||
if (!BM_edge_is_boundary(l_sep->prev->e))
|
||||
bmesh_edge_separate(bm, l_sep->prev->e, l_sep->prev, false);
|
||||
if (!BM_edge_is_boundary(l_sep->e)) {
|
||||
bmesh_kernel_edge_separate(bm, l_sep->e, l_sep, false);
|
||||
}
|
||||
if (!BM_edge_is_boundary(l_sep->prev->e)) {
|
||||
bmesh_kernel_edge_separate(bm, l_sep->prev->e, l_sep->prev, false);
|
||||
}
|
||||
|
||||
/* do inline, below */
|
||||
#if 0
|
||||
@ -2681,13 +2683,13 @@ BMVert *bmesh_urmv_loop(BMesh *bm, BMLoop *l_sep)
|
||||
}
|
||||
|
||||
/**
|
||||
* A version of #bmesh_urmv_loop that disconnects multiple loops at once.
|
||||
* A version of #bmesh_kernel_unglue_region_make_vert that disconnects multiple loops at once.
|
||||
* The loops must all share the same vertex, can be in any order
|
||||
* and are all moved to use a single new vertex - which is returned.
|
||||
*
|
||||
* This function handles the details of finding fans boundaries.
|
||||
*/
|
||||
BMVert *bmesh_urmv_loop_multi(
|
||||
BMVert *bmesh_kernel_unglue_region_make_vert_multi(
|
||||
BMesh *bm, BMLoop **larr, int larr_len)
|
||||
{
|
||||
BMVert *v_sep = larr[0]->v;
|
||||
@ -2871,9 +2873,9 @@ static void bmesh_edge_vert_swap__recursive(BMEdge *e, BMVert *v_dst, BMVert *v_
|
||||
|
||||
/**
|
||||
* This function assumes l_sep is apart of a larger fan which has already been
|
||||
* isolated by calling bmesh_edge_separate to segregate it radially.
|
||||
* isolated by calling #bmesh_kernel_edge_separate to segregate it radially.
|
||||
*/
|
||||
BMVert *bmesh_urmv_loop_region(BMesh *bm, BMLoop *l_sep)
|
||||
BMVert *bmesh_kernel_unglue_region_make_vert_multi_isolated(BMesh *bm, BMLoop *l_sep)
|
||||
{
|
||||
BMVert *v_new = BM_vert_create(bm, l_sep->v->co, l_sep->v, BM_CREATE_NOP);
|
||||
/* passing either 'l_sep->e', 'l_sep->prev->e' will work */
|
||||
@ -2882,20 +2884,6 @@ BMVert *bmesh_urmv_loop_region(BMesh *bm, BMLoop *l_sep)
|
||||
return v_new;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* \brief Unglue Region Make Vert (URMV)
|
||||
*
|
||||
* Disconnects f_sep from the vertex fan at \a v_sep
|
||||
*
|
||||
* \return The newly created BMVert
|
||||
*/
|
||||
BMVert *bmesh_urmv(BMesh *bm, BMFace *f_sep, BMVert *v_sep)
|
||||
{
|
||||
BMLoop *l = BM_face_vert_share_loop(f_sep, v_sep);
|
||||
return bmesh_urmv_loop(bm, l);
|
||||
}
|
||||
|
||||
/**
|
||||
* Avoid calling this where possible,
|
||||
* low level function so both face pointers remain intact but point to swapped data.
|
||||
|
||||
@ -64,21 +64,16 @@ void BM_face_kill(BMesh *bm, BMFace *f);
|
||||
void BM_edge_kill(BMesh *bm, BMEdge *e);
|
||||
void BM_vert_kill(BMesh *bm, BMVert *v);
|
||||
|
||||
void bmesh_edge_separate(
|
||||
BMesh *bm, BMEdge *e, BMLoop *l_sep,
|
||||
const bool copy_select);
|
||||
bool BM_edge_splice(BMesh *bm, BMEdge *e_dst, BMEdge *e_src);
|
||||
bool BM_vert_splice(BMesh *bm, BMVert *v_dst, BMVert *v_src);
|
||||
bool BM_vert_splice_check_double(BMVert *v_a, BMVert *v_b);
|
||||
|
||||
void bmesh_vert_separate(
|
||||
BMesh *bm, BMVert *v, BMVert ***r_vout, int *r_vout_len,
|
||||
const bool copy_select);
|
||||
|
||||
void bmesh_loop_reverse(
|
||||
void bmesh_kernel_loop_reverse(
|
||||
BMesh *bm, BMFace *f,
|
||||
const int cd_loop_mdisp_offset, const bool use_loop_mdisp_flip);
|
||||
|
||||
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);
|
||||
void BM_vert_separate(
|
||||
BMesh *bm, BMVert *v, BMEdge **e_in, int e_in_len, const bool copy_select,
|
||||
@ -90,34 +85,43 @@ void BM_vert_separate_wire_hflag(
|
||||
BMesh *bm, BMVert *v_dst, BMVert *v_src,
|
||||
const char hflag);
|
||||
|
||||
/* EULER API - For modifying structure */
|
||||
BMFace *bmesh_sfme(
|
||||
/**
|
||||
* BMesh Kernel: For modifying structure.
|
||||
*
|
||||
* Names are on the verbose side but these are only for low-level access.
|
||||
*/
|
||||
void bmesh_kernel_vert_separate(
|
||||
BMesh *bm, BMVert *v, BMVert ***r_vout, int *r_vout_len,
|
||||
const bool copy_select);
|
||||
void bmesh_kernel_edge_separate(
|
||||
BMesh *bm, BMEdge *e, BMLoop *l_sep,
|
||||
const bool copy_select);
|
||||
|
||||
BMFace *bmesh_kernel_split_face_make_edge(
|
||||
BMesh *bm, BMFace *f,
|
||||
BMLoop *l1, BMLoop *l2,
|
||||
BMLoop **r_l,
|
||||
#ifdef USE_BMESH_HOLES
|
||||
ListBase *holes,
|
||||
ListBase *holes,
|
||||
#endif
|
||||
BMEdge *example,
|
||||
const bool no_double
|
||||
);
|
||||
BMEdge *example,
|
||||
const bool no_double
|
||||
);
|
||||
|
||||
BMVert *bmesh_semv(BMesh *bm, BMVert *tv, BMEdge *e, BMEdge **r_e);
|
||||
BMEdge *bmesh_jekv(
|
||||
BMVert *bmesh_kernel_split_edge_make_vert(
|
||||
BMesh *bm, BMVert *tv, BMEdge *e, BMEdge **r_e);
|
||||
BMEdge *bmesh_kernel_join_edge_kill_vert(
|
||||
BMesh *bm, BMEdge *e_kill, BMVert *v_kill,
|
||||
const bool do_del, const bool check_edge_splice,
|
||||
const bool kill_degenerate_faces);
|
||||
BMVert *bmesh_jvke(
|
||||
BMVert *bmesh_kernel_join_vert_kill_edge(
|
||||
BMesh *bm, BMEdge *e_kill, BMVert *v_kill,
|
||||
const bool do_del, const bool check_edge_double,
|
||||
const bool kill_degenerate_faces);
|
||||
BMFace *bmesh_jfke(BMesh *bm, BMFace *f1, BMFace *f2, BMEdge *e);
|
||||
BMVert *bmesh_urmv(BMesh *bm, BMFace *f_sep, BMVert *v_sep);
|
||||
BMVert *bmesh_urmv_loop(BMesh *bm, BMLoop *l_sep);
|
||||
BMVert *bmesh_urmv_loop_multi(
|
||||
BMesh *bm, BMLoop **larr, int larr_len);
|
||||
BMVert *bmesh_urmv_loop_region(BMesh *bm, BMLoop *l_sep);
|
||||
BMFace *bmesh_kernel_join_face_kill_edge(BMesh *bm, BMFace *f1, BMFace *f2, BMEdge *e);
|
||||
|
||||
void bmesh_face_swap_data(BMFace *f_a, BMFace *f_b);
|
||||
BMVert *bmesh_kernel_unglue_region_make_vert(BMesh *bm, BMLoop *l_sep);
|
||||
BMVert *bmesh_kernel_unglue_region_make_vert_multi(BMesh *bm, BMLoop **larr, int larr_len);
|
||||
BMVert *bmesh_kernel_unglue_region_make_vert_multi_isolated(BMesh *bm, BMLoop *l_sep);
|
||||
|
||||
#endif /* __BMESH_CORE_H__ */
|
||||
|
||||
@ -234,7 +234,7 @@ BMFace *BM_faces_join_pair(BMesh *bm, BMLoop *l_a, BMLoop *l_b, const bool do_de
|
||||
|
||||
if (l_a->v == l_b->v) {
|
||||
const int cd_loop_mdisp_offset = CustomData_get_offset(&bm->ldata, CD_MDISPS);
|
||||
bmesh_loop_reverse(bm, l_b->f, cd_loop_mdisp_offset, true);
|
||||
bmesh_kernel_loop_reverse(bm, l_b->f, cd_loop_mdisp_offset, true);
|
||||
}
|
||||
|
||||
BMFace *faces[2] = {l_a->f, l_b->f};
|
||||
@ -288,9 +288,9 @@ BMFace *BM_face_split(
|
||||
}
|
||||
|
||||
#ifdef USE_BMESH_HOLES
|
||||
f_new = bmesh_sfme(bm, f, l_a, l_b, r_l, NULL, example, no_double);
|
||||
f_new = bmesh_kernel_split_face_make_edge(bm, f, l_a, l_b, r_l, NULL, example, no_double);
|
||||
#else
|
||||
f_new = bmesh_sfme(bm, f, l_a, l_b, r_l, example, no_double);
|
||||
f_new = bmesh_kernel_split_face_make_edge(bm, f, l_a, l_b, r_l, example, no_double);
|
||||
#endif
|
||||
|
||||
if (f_new) {
|
||||
@ -370,19 +370,19 @@ BMFace *BM_face_split_n(
|
||||
f_tmp = BM_face_copy(bm, bm, f, true, true);
|
||||
|
||||
#ifdef USE_BMESH_HOLES
|
||||
f_new = bmesh_sfme(bm, f, l_a, l_b, &l_new, NULL, example, false);
|
||||
f_new = bmesh_kernel_split_face_make_edge(bm, f, l_a, l_b, &l_new, NULL, example, false);
|
||||
#else
|
||||
f_new = bmesh_sfme(bm, f, l_a, l_b, &l_new, example, false);
|
||||
f_new = bmesh_kernel_split_face_make_edge(bm, f, l_a, l_b, &l_new, example, false);
|
||||
#endif
|
||||
/* bmesh_sfme returns in 'l_new' a Loop for f_new going from 'v_a' to 'v_b'.
|
||||
/* bmesh_kernel_split_face_make_edge returns in 'l_new' a Loop for f_new going from 'v_a' to 'v_b'.
|
||||
* The radial_next is for 'f' and goes from 'v_b' to 'v_a' */
|
||||
|
||||
if (f_new) {
|
||||
e = l_new->e;
|
||||
for (i = 0; i < n; i++) {
|
||||
v_new = bmesh_semv(bm, v_b, e, &e_new);
|
||||
v_new = bmesh_kernel_split_edge_make_vert(bm, v_b, e, &e_new);
|
||||
BLI_assert(v_new != NULL);
|
||||
/* bmesh_semv returns in 'e_new' the edge going from 'v_new' to 'v_b' */
|
||||
/* bmesh_kernel_split_edge_make_vert returns in 'e_new' the edge going from 'v_new' to 'v_b' */
|
||||
copy_v3_v3(v_new->co, cos[i]);
|
||||
|
||||
/* interpolate the loop data for the loops with (v == v_new), using orig face */
|
||||
@ -507,7 +507,7 @@ BMEdge *BM_vert_collapse_faces(
|
||||
/* single face or no faces */
|
||||
/* same as BM_vert_collapse_edge() however we already
|
||||
* have vars to perform this operation so don't call. */
|
||||
e_new = bmesh_jekv(bm, e_kill, v_kill, do_del, true, kill_degenerate_faces);
|
||||
e_new = bmesh_kernel_join_edge_kill_vert(bm, e_kill, v_kill, do_del, true, kill_degenerate_faces);
|
||||
/* e_new = BM_edge_exists(tv, tv2); */ /* same as return above */
|
||||
}
|
||||
|
||||
@ -542,7 +542,7 @@ BMEdge *BM_vert_collapse_edge(
|
||||
BMVert *tv2 = BM_edge_other_vert(e2, v_kill);
|
||||
if (tv2) {
|
||||
/* only action, other calls here only get the edge to return */
|
||||
e_new = bmesh_jekv(bm, e_kill, v_kill, do_del, true, kill_degenerate_faces);
|
||||
e_new = bmesh_kernel_join_edge_kill_vert(bm, e_kill, v_kill, do_del, true, kill_degenerate_faces);
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -564,7 +564,7 @@ BMVert *BM_edge_collapse(
|
||||
BMesh *bm, BMEdge *e_kill, BMVert *v_kill,
|
||||
const bool do_del, const bool kill_degenerate_faces)
|
||||
{
|
||||
return bmesh_jvke(bm, e_kill, v_kill, do_del, true, kill_degenerate_faces);
|
||||
return bmesh_kernel_join_vert_kill_edge(bm, e_kill, v_kill, do_del, true, kill_degenerate_faces);
|
||||
}
|
||||
|
||||
/**
|
||||
@ -616,7 +616,7 @@ BMVert *BM_edge_split(BMesh *bm, BMEdge *e, BMVert *v, BMEdge **r_e, float fac)
|
||||
}
|
||||
|
||||
v_other = BM_edge_other_vert(e, v);
|
||||
v_new = bmesh_semv(bm, v, e, &e_new);
|
||||
v_new = bmesh_kernel_split_edge_make_vert(bm, v, e, &e_new);
|
||||
if (r_e != NULL) {
|
||||
*r_e = e_new;
|
||||
}
|
||||
@ -1090,23 +1090,18 @@ BMEdge *BM_edge_rotate(BMesh *bm, BMEdge *e, const bool ccw, const short check_f
|
||||
/**
|
||||
* \brief Rip a single face from a vertex fan
|
||||
*/
|
||||
BMVert *BM_face_vert_separate(BMesh *bm, BMFace *sf, BMVert *sv)
|
||||
BMVert *BM_face_loop_separate(BMesh *bm, BMLoop *l_sep)
|
||||
{
|
||||
return bmesh_urmv(bm, sf, sv);
|
||||
return bmesh_kernel_unglue_region_make_vert(bm, l_sep);
|
||||
}
|
||||
|
||||
/**
|
||||
* \brief Rip a single face from a vertex fan
|
||||
*
|
||||
* \note same as #BM_face_vert_separate but faster (avoids a loop lookup)
|
||||
*/
|
||||
BMVert *BM_face_loop_separate(BMesh *bm, BMLoop *sl)
|
||||
BMVert *BM_face_loop_separate_multi_isolated(BMesh *bm, BMLoop *l_sep)
|
||||
{
|
||||
return bmesh_urmv_loop(bm, sl);
|
||||
return bmesh_kernel_unglue_region_make_vert_multi_isolated(bm, l_sep);
|
||||
}
|
||||
|
||||
BMVert *BM_face_loop_separate_multi(
|
||||
BMesh *bm, BMLoop **larr, int larr_len)
|
||||
BMVert *BM_face_loop_separate_multi(BMesh *bm, BMLoop **larr, int larr_len)
|
||||
{
|
||||
return bmesh_urmv_loop_multi(bm, larr, larr_len);
|
||||
return bmesh_kernel_unglue_region_make_vert_multi(bm, larr, larr_len);
|
||||
}
|
||||
|
||||
|
||||
@ -86,9 +86,8 @@ enum {
|
||||
};
|
||||
|
||||
|
||||
BMVert *BM_face_vert_separate(BMesh *bm, BMFace *sf, BMVert *sv);
|
||||
BMVert *BM_face_loop_separate(BMesh *bm, BMLoop *sl);
|
||||
BMVert *BM_face_loop_separate_multi(
|
||||
BMesh *bm, BMLoop **larr, int larr_len);
|
||||
BMVert *BM_face_loop_separate(BMesh *bm, BMLoop *l_sep);
|
||||
BMVert *BM_face_loop_separate_multi_isolated(BMesh *bm, BMLoop *l_sep);
|
||||
BMVert *BM_face_loop_separate_multi(BMesh *bm, BMLoop **larr, int larr_len);
|
||||
|
||||
#endif /* __BMESH_MODS_H__ */
|
||||
|
||||
@ -844,7 +844,7 @@ void BM_face_normal_flip_ex(
|
||||
BMesh *bm, BMFace *f,
|
||||
const int cd_loop_mdisp_offset, const bool use_loop_mdisp_flip)
|
||||
{
|
||||
bmesh_loop_reverse(bm, f, cd_loop_mdisp_offset, use_loop_mdisp_flip);
|
||||
bmesh_kernel_loop_reverse(bm, f, cd_loop_mdisp_offset, use_loop_mdisp_flip);
|
||||
negate_v3(f->no);
|
||||
}
|
||||
|
||||
|
||||
@ -663,7 +663,7 @@ void bmo_inset_region_exec(BMesh *bm, BMOperator *op)
|
||||
|
||||
/* run the separate arg */
|
||||
if (!BM_edge_is_boundary(es->e_old)) {
|
||||
bmesh_edge_separate(bm, es->e_old, es->l, false);
|
||||
bmesh_kernel_edge_separate(bm, es->e_old, es->l, false);
|
||||
}
|
||||
|
||||
/* calc edge-split info */
|
||||
@ -742,7 +742,7 @@ void bmo_inset_region_exec(BMesh *bm, BMOperator *op)
|
||||
/* disable touching twice, this _will_ happen if the flags not disabled */
|
||||
BM_elem_flag_disable(v, BM_ELEM_TAG);
|
||||
|
||||
bmesh_vert_separate(bm, v, &vout, &r_vout_len, false);
|
||||
bmesh_kernel_vert_separate(bm, v, &vout, &r_vout_len, false);
|
||||
v = NULL; /* don't use again */
|
||||
|
||||
/* in some cases the edge doesn't split off */
|
||||
|
||||
@ -270,7 +270,7 @@ void bmo_offset_edgeloops_exec(BMesh *bm, BMOperator *op)
|
||||
v_other = BM_edge_other_vert(e, v);
|
||||
if (BM_elem_index_get(v_other) == -1) {
|
||||
if (BM_vert_is_edge_pair(v_other)) {
|
||||
/* defer bmesh_jekv to avoid looping over data we're removing */
|
||||
/* defer bmesh_kernel_join_edge_kill_vert to avoid looping over data we're removing */
|
||||
v_other->e = e;
|
||||
STACK_PUSH(varr, v_other);
|
||||
}
|
||||
@ -278,7 +278,7 @@ void bmo_offset_edgeloops_exec(BMesh *bm, BMOperator *op)
|
||||
}
|
||||
|
||||
while ((v = STACK_POP(varr))) {
|
||||
bmesh_jekv(bm, v->e, v, true, false, false);
|
||||
bmesh_kernel_join_edge_kill_vert(bm, v->e, v, true, false, false);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@ -120,7 +120,7 @@ void BM_mesh_separate_faces(
|
||||
}
|
||||
|
||||
/* Perform the split */
|
||||
bmesh_urmv_loop_multi(bm, loop_split.data, loop_split.count);
|
||||
BM_face_loop_separate_multi(bm, loop_split.data, loop_split.count);
|
||||
|
||||
BLI_buffer_empty(&loop_split);
|
||||
}
|
||||
|
||||
@ -596,7 +596,7 @@ static int edbm_rip_invoke__vert(bContext *C, wmOperator *op, const wmEvent *eve
|
||||
BMVert *v_new;
|
||||
|
||||
BLI_assert(l_sep->v == v);
|
||||
v_new = bmesh_urmv_loop_region(bm, l_sep);
|
||||
v_new = BM_face_loop_separate_multi_isolated(bm, l_sep);
|
||||
BLI_assert(BM_vert_find_first_loop(v));
|
||||
|
||||
BM_vert_select_set(bm, v, false);
|
||||
@ -665,7 +665,7 @@ static int edbm_rip_invoke__vert(bContext *C, wmOperator *op, const wmEvent *eve
|
||||
|
||||
BM_vert_select_set(bm, v, false);
|
||||
|
||||
bmesh_vert_separate(bm, v, &vout, &vout_len, true);
|
||||
bmesh_kernel_vert_separate(bm, v, &vout, &vout_len, true);
|
||||
|
||||
if (vout_len < 2) {
|
||||
MEM_freeN(vout);
|
||||
|
||||
Loading…
Reference in New Issue
Block a user