sandey/blender
1
0
Fork 0
forked from bartvdbraak/blender
Code Pull Requests Activity

BMesh: BM_mesh_edgesplit

Browse Source 
Did quite a few checks not to tag bad splits (which wasn't working perfectly)

Instead rely on BM_vert_separate not to create invalid geometry.
This commit is contained in:
Campbell Barton 2015-05-02 16:05:32 +10:00
parent f283b959e7
commit 53d08ec506
6 changed files with 13 additions and 114 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
source/blender/bmesh/operators/bmo_split_edges.c
View File

@ -48,7 +48,7 @@ void bmo_split_edges_exec(BMesh *bm, BMOperator *op)
}
/* this is where everything happens */
BM_mesh_edgesplit(bm, use_verts, true, true, false);
BM_mesh_edgesplit(bm, use_verts, true, false);
BMO_slot_buffer_from_enabled_hflag(bm, op, op->slots_out, "edges.out", BM_EDGE, BM_ELEM_INTERNAL_TAG);
}

117
source/blender/bmesh/tools/bmesh_edgesplit.c
View File

@ -35,74 +35,6 @@
#include "bmesh_edgesplit.h" /* own include */
/**
* Remove the BM_ELEM_TAG flag for edges we cant split
*
* un-tag edges not connected to other tagged edges,
* unless they are on a boundary
*/
static void bm_edgesplit_validate_seams(BMesh *bm, const bool use_non_manifold)
{
BMIter iter;
BMEdge *e;
unsigned char *vtouch;
BM_mesh_elem_index_ensure(bm, BM_VERT);
vtouch = MEM_callocN(sizeof(char) * bm->totvert, __func__);
/* tag all boundary verts so as not to untag an edge which is inbetween only 2 faces [] */
BM_ITER_MESH (e, &iter, bm, BM_EDGES_OF_MESH) {
/* unrelated to flag assignment in this function - since this is the
* only place we loop over all edges, disable tag */
BM_elem_flag_disable(e, BM_ELEM_INTERNAL_TAG);
if (e->l == NULL) {
BM_elem_flag_disable(e, BM_ELEM_TAG);
}
else if (BM_edge_is_boundary(e)) {
unsigned char *vt;
vt = &vtouch[BM_elem_index_get(e->v1)]; if (*vt < 2) (*vt)++;
vt = &vtouch[BM_elem_index_get(e->v2)]; if (*vt < 2) (*vt)++;
/* while the boundary verts need to be tagged,
* the edge its self can't be split */
BM_elem_flag_disable(e, BM_ELEM_TAG);
}
else if ((use_non_manifold == false) &&
(BM_edge_is_manifold(e) == false))
{
BM_elem_flag_disable(e, BM_ELEM_TAG);
}
}
/* single marked edges unconnected to any other marked edges
* are illegal, go through and unmark them */
BM_ITER_MESH (e, &iter, bm, BM_EDGES_OF_MESH) {
if (BM_elem_flag_test(e, BM_ELEM_TAG)) {
/* lame, but we don't want the count to exceed 255,
* so just count to 2, its all we need */
unsigned char *vt;
vt = &vtouch[BM_elem_index_get(e->v1)]; if (*vt < 2) (*vt)++;
vt = &vtouch[BM_elem_index_get(e->v2)]; if (*vt < 2) (*vt)++;
}
}
BM_ITER_MESH (e, &iter, bm, BM_EDGES_OF_MESH) {
if (BM_elem_flag_test(e, BM_ELEM_TAG)) {
if (vtouch[BM_elem_index_get(e->v1)] == 1 &&
vtouch[BM_elem_index_get(e->v2)] == 1)
{
BM_elem_flag_disable(e, BM_ELEM_TAG);
}
}
}
MEM_freeN(vtouch);
}
/**
* \param use_verts Use flagged verts instead of edges.
* \param use_non_manifold Split non-manifold edges (a little slower, must check for doubles).
@ -111,7 +43,7 @@ static void bm_edgesplit_validate_seams(BMesh *bm, const bool use_non_manifold)
*/
void BM_mesh_edgesplit(
BMesh *bm,
const bool use_verts, const bool use_non_manifold,
const bool use_verts,
const bool tag_only, const bool copy_select)
{
BMIter iter;
@ -156,27 +88,8 @@ void BM_mesh_edgesplit(
}
}
bm_edgesplit_validate_seams(bm, use_non_manifold);
BM_ITER_MESH (e, &iter, bm, BM_EDGES_OF_MESH) {
if (BM_elem_flag_test(e, BM_ELEM_TAG)) {
/* this flag gets copied so we can be sure duplicate edges get it too (important) */
BM_elem_flag_enable(e, BM_ELEM_INTERNAL_TAG);
/* keep splitting until each loop has its own edge */
while (!BM_edge_is_boundary(e)) {
BMLoop *l_sep = e->l;
bmesh_edge_separate(bm, e, l_sep, copy_select);
BLI_assert(l_sep->e != e);
if (use_ese) {
BMEditSelection *ese = BLI_ghash_lookup(ese_gh, e);
if (UNLIKELY(ese)) {
BM_select_history_store_after_notest(bm, ese, l_sep->e);
}
}
}
BM_elem_flag_enable(e->v1, BM_ELEM_TAG);
BM_elem_flag_enable(e->v2, BM_ELEM_TAG);
}
@ -194,7 +107,7 @@ void BM_mesh_edgesplit(
BMVert **vtar;
int vtar_len;
bmesh_vert_separate(bm, v, &vtar, &vtar_len, copy_select);
BM_vert_separate_hflag(bm, v, BM_ELEM_TAG, copy_select, &vtar, &vtar_len);
/* first value is always in 'v' */
if (vtar_len > 1) {
@ -211,35 +124,21 @@ void BM_mesh_edgesplit(
MEM_freeN(vtar);
}
else {
bmesh_vert_separate(bm, v, NULL, NULL, copy_select);
BM_vert_separate_hflag(bm, v, BM_ELEM_TAG, copy_select, NULL, NULL);
}
}
}
}
}
if (use_non_manifold) {
/* if we split non-manifold, double edge may remain */
BMEdge *e_next;
BM_ITER_MESH_MUTABLE (e, e_next, &iter, bm, BM_EDGES_OF_MESH) {
if (BM_elem_flag_test(e, BM_ELEM_TAG)) {
BMEdge *e_other;
if ((e_other = BM_edge_find_double(e))) {
BM_edge_splice(bm, e_other, e);
}
}
}
}
else {
#ifndef NDEBUG
/* ensure we don't have any double edges! */
BM_ITER_MESH (e, &iter, bm, BM_EDGES_OF_MESH) {
if (BM_elem_flag_test(e, BM_ELEM_TAG)) {
BLI_assert(BM_edge_find_double(e) == NULL);
}
/* ensure we don't have any double edges! */
BM_ITER_MESH (e, &iter, bm, BM_EDGES_OF_MESH) {
if (BM_elem_flag_test(e, BM_ELEM_TAG)) {
BLI_assert(BM_edge_find_double(e) == NULL);
}
#endif
}
#endif
if (use_ese) {
BLI_ghash_free(ese_gh, NULL, NULL);

2
source/blender/bmesh/tools/bmesh_edgesplit.h
View File

@ -29,7 +29,7 @@
void BM_mesh_edgesplit(
BMesh *bm,
const bool use_verts, const bool use_non_manifold,
const bool use_verts,
const bool tag_only, const bool copy_select);
#endif /* __BMESH_EDGESPLIT_H__ */

2
source/blender/bmesh/tools/bmesh_intersect.c
View File

@ -1281,7 +1281,7 @@ bool BM_mesh_intersect(
BM_elem_flag_enable(e, BM_ELEM_TAG);
}
BM_mesh_edgesplit(bm, false, false, true, false);
BM_mesh_edgesplit(bm, false, true, false);
}
#else
(void)use_separate;

2
source/blender/editors/mesh/editmesh_rip.c
View File

@ -941,7 +941,7 @@ static int edbm_rip_invoke__edge(bContext *C, wmOperator *op, const wmEvent *eve
fill_uloop_pairs = edbm_tagged_loop_pairs_to_fill(bm);
}
BM_mesh_edgesplit(em->bm, true, true, true, true);
BM_mesh_edgesplit(em->bm, true, true, true);
/* note: the output of the bmesh operator is ignored, since we built
* the contiguous loop pairs to split already, its possible that some

2
source/blender/modifiers/intern/MOD_edgesplit.c
View File

@ -91,7 +91,7 @@ static DerivedMesh *doEdgeSplit(DerivedMesh *dm, EdgeSplitModifierData *emd)
}
}
BM_mesh_edgesplit(bm, false, false, true, false);
BM_mesh_edgesplit(bm, false, true, false);
/* BM_mesh_validate(bm); */ /* for troubleshooting */