Page MenuHome
Differential D10497 Diff 34835 source/blender/bmesh/intern/bmesh_walkers_impl.c

Changeset View

Standalone View

View Options

source/blender/bmesh/intern/bmesh_walkers_impl.c

Show First 20 Lines • Show All 992 Lines • ▼ Show 20 Lines
} }
} }
return l; return l;
} }
/** \} */ /** \} */
/* -------------------------------------------------------------------- */
/** \name Non-manifold Edge Walker
* \{ */
static void bmw_NonManifoldedgeWalker_begin(BMWalker *walker, void *data)
{
BMwEdgeLoopWalker *lwalk , owalk , *owalk_pt;
BMEdge *e = data;
if (BLI_gset_haskey(walker->visit_set, e)) {
return;
}
lwalk = BMW_state_add(walker);
lwalk->cur = e;
lwalk->start = e;
lwalk->lastv = e->v1;
lwalk->startv = e->v2;
lwalk->is_boundary = BM_edge_is_boundary(e);
lwalk->is_single = (lwalk->is_boundary && bm_edge_is_single(e));
campbellbartonUnsubmitted
Done
Inline Actions

This doesn't make sense to set, it can be removed from a new struct.

Instead, the face_count should be stored, currently this is counted on every edge step which isn't needed.

campbellbarton: This doesn't make sense to set, it can be removed from a new struct. Instead, the face_count…
BLI_gset_insert(walker->visit_set, e);
}
static void *bmw_NonManifoldedgeWalker_yield(BMWalker *walker)
{
BMwEdgeboundaryWalker *lwalk = BMW_current_state(walker);
if (!lwalk) {
return NULL;
}
return lwalk->e;
}
BMLoop* bmw_NonManifoldLoop_edgeloop(BMLoop *l, BMVert *v , int face_count)
{
BLI_assert(!BM_loop_is_manifold(l));
do {
l = BM_loop_other_edge_loop(l, v);
if (BM_loop_is_manifold(l)) {
l = l->radial_next;
}
else if (BM_edge_face_count_is_equal(l->e , face_count)) {
break;
}
} while (true);
return l;
}
campbellbartonUnsubmitted
Done
Inline Actions

Walkers shouldn't depend on selection (notice none of the other walkers here do).

campbellbarton: Walkers shouldn't depend on selection (notice none of the other walkers here do).
campbellbartonUnsubmitted
Done
Inline Actions

This isn't used.

campbellbarton: This isn't used.
static void *bmw_NonManifoldedgeWalker_step(BMWalker *walker)
{
campbellbartonUnsubmitted
Done
Inline Actions

This assumes loop is part of an edge with two face users. That should be checked for with BM_loop_is_manifold, if that fails. bail out of the loopl.

campbellbarton: This assumes loop is part of an edge with two face users. That should be checked for with…
BMwEdgeLoopWalker *lwalk, owalk;
BMW_state_remove_r(walker, &owalk);
campbellbartonUnsubmitted
Done
Inline Actions

This can be extracted into a function, since it's called again below.

campbellbarton: This can be extracted into a function, since it's called again below.
lwalk = &owalk;
BMEdge *e = lwalk->cur;
BMVert *v = BM_edge_other_vert(e, lwalk->lastv);
BMLoop *l, *l_init;
int face_count = BM_edge_face_count(e);
l = l_init = e->l;
campbellbartonUnsubmitted
Done
Inline Actions

This is starting out from one of the loops only, it could start out from any of 3+ loops. Shouldn't all of them be considered as candidates for stepping over?

campbellbarton: This is starting out from one of the loops only, it could start out from any of 3+ loops.
/* `for loop` introduced to avoid separate loop code for reverse traversing */
for (int i = 0; i < 2; i++) {
campbellbartonUnsubmitted
Done
Inline Actions

This still seems to be

campbellbarton: This still seems to be
do {
l = bmw_NonManifoldLoop_edgeloop(l, v , face_count);
campbellbartonUnsubmitted
Done
Inline Actions

For a predictable outcome this should check all radial loops connect to the same edge (or can't find an edge that matches).

This way there can never be a branch in the path which follows only one of the edges.

campbellbarton: For a predictable outcome this should check all radial loops connect to the same edge (or can't…
campbellbartonUnsubmitted
Done
Inline Actions

bmw_NonManifoldLoop_edgeloop will never return an BM_edge_is_boundary(l->e) edge, this check is redundant.

campbellbarton: `bmw_NonManifoldLoop_edgeloop` will never return an `BM_edge_is_boundary(l->e)` edge, this…
if (!BM_edge_is_boundary(l->e) && !BLI_gset_haskey(walker->visit_set, l->e)) {
break;
}
l = l->radial_next;
} while (l != l_init);
/*If edge not found , start traversing opposite direction */
if ((l == l_init)) {
e = lwalk->start;
v = BM_edge_other_vert(e, lwalk->startv);
l = l_init = e->l;
}
}
if (l != NULL) {
if (!BLI_gset_haskey(walker->visit_set, l->e)) {
lwalk = BMW_state_add(walker);
lwalk->lastv = v;
lwalk->cur = l->e;
BLI_gset_insert(walker->visit_set, l->e);
}
}
return owalk.cur;
}
/** \} */
static BMWalker bmw_VertShellWalker_Type = { static BMWalker bmw_VertShellWalker_Type = {
BM_VERT | BM_EDGE, BM_VERT | BM_EDGE,
bmw_VertShellWalker_begin, bmw_VertShellWalker_begin,
bmw_VertShellWalker_step, bmw_VertShellWalker_step,
bmw_VertShellWalker_yield, bmw_VertShellWalker_yield,
sizeof(BMwShellWalker), sizeof(BMwShellWalker),
BMW_BREADTH_FIRST, BMW_BREADTH_FIRST,
BM_EDGE, /* Valid restrict masks. */ BM_EDGE, /* Valid restrict masks. */
▲ Show 20 Lines • Show All 96 Lines • ▼ Show 20 Lines
bmw_EdgeboundaryWalker_begin, bmw_EdgeboundaryWalker_begin,
bmw_EdgeboundaryWalker_step, bmw_EdgeboundaryWalker_step,
bmw_EdgeboundaryWalker_yield, bmw_EdgeboundaryWalker_yield,
sizeof(BMwEdgeboundaryWalker), sizeof(BMwEdgeboundaryWalker),
BMW_DEPTH_FIRST, BMW_DEPTH_FIRST,
0, 0,
}; };
static BMWalker bmw_NonManifoldedgeWalker_type = {
BM_EDGE,
bmw_NonManifoldedgeWalker_begin,
bmw_NonManifoldedgeWalker_step,
bmw_NonManifoldedgeWalker_yield,
sizeof(BMwEdgeLoopWalker),
BMW_DEPTH_FIRST,
0,
};
static BMWalker bmw_UVEdgeWalker_Type = { static BMWalker bmw_UVEdgeWalker_Type = {
BM_LOOP, BM_LOOP,
bmw_UVEdgeWalker_begin, bmw_UVEdgeWalker_begin,
bmw_UVEdgeWalker_step, bmw_UVEdgeWalker_step,
bmw_UVEdgeWalker_yield, bmw_UVEdgeWalker_yield,
sizeof(BMwUVEdgeWalker), sizeof(BMwUVEdgeWalker),
BMW_DEPTH_FIRST, BMW_DEPTH_FIRST,
BM_EDGE, /* Valid restrict masks. */ BM_EDGE, /* Valid restrict masks. */
Show All 13 Lines
&bmw_VertShellWalker_Type, /* #BMW_VERT_SHELL */ &bmw_VertShellWalker_Type, /* #BMW_VERT_SHELL */
&bmw_LoopShellWalker_Type, /* #BMW_LOOP_SHELL */ &bmw_LoopShellWalker_Type, /* #BMW_LOOP_SHELL */
&bmw_LoopShellWireWalker_Type, /* #BMW_LOOP_SHELL_WIRE */ &bmw_LoopShellWireWalker_Type, /* #BMW_LOOP_SHELL_WIRE */
&bmw_FaceShellWalker_Type, /* #BMW_FACE_SHELL */ &bmw_FaceShellWalker_Type, /* #BMW_FACE_SHELL */
&bmw_EdgeLoopWalker_Type, /* #BMW_EDGELOOP */ &bmw_EdgeLoopWalker_Type, /* #BMW_EDGELOOP */
&bmw_FaceLoopWalker_Type, /* #BMW_FACELOOP */ &bmw_FaceLoopWalker_Type, /* #BMW_FACELOOP */
&bmw_EdgeringWalker_Type, /* #BMW_EDGERING */ &bmw_EdgeringWalker_Type, /* #BMW_EDGERING */
&bmw_EdgeboundaryWalker_Type, /* #BMW_EDGEBOUNDARY */ &bmw_EdgeboundaryWalker_Type, /* #BMW_EDGEBOUNDARY */
&bmw_NonManifoldedgeWalker_type, /* #BMW_EDGELOOP_NONMANIFOLD*/
&bmw_UVEdgeWalker_Type, /* #BMW_LOOPDATA_ISLAND */ &bmw_UVEdgeWalker_Type, /* #BMW_LOOPDATA_ISLAND */
&bmw_IslandboundWalker_Type, /* #BMW_ISLANDBOUND */ &bmw_IslandboundWalker_Type, /* #BMW_ISLANDBOUND */
&bmw_IslandWalker_Type, /* #BMW_ISLAND */ &bmw_IslandWalker_Type, /* #BMW_ISLAND */
&bmw_IslandManifoldWalker_Type, /* #BMW_ISLAND_MANIFOLD */ &bmw_IslandManifoldWalker_Type, /* #BMW_ISLAND_MANIFOLD */
&bmw_ConnectedVertexWalker_Type, /* #BMW_CONNECTED_VERTEX */ &bmw_ConnectedVertexWalker_Type, /* #BMW_CONNECTED_VERTEX */
}; };
const int bm_totwalkers = ARRAY_SIZE(bm_walker_types); const int bm_totwalkers = ARRAY_SIZE(bm_walker_types);
Context not available.