23#define BMW_state_remove_r(walker, owalk) \
25 memcpy(owalk, BMW_current_state(walker), sizeof(*(owalk))); \
26 BMW_state_remove(walker); \
126 if (h ==
nullptr) [[unlikely]] {
133 v =
reinterpret_cast<BMVert *
>(h);
142 e =
reinterpret_cast<BMEdge *
>(h);
170 for (i = 0; i < 2; i++) {
171 v = i ?
e->v2 :
e->v1;
183 BMEdge *curedge, *next =
nullptr;
184 BMVert *v_old =
nullptr;
185 bool restrictpass =
true;
188 if (!walker->visit_set->contains(shellWalk.base)) {
189 walker->visit_set->add(shellWalk.base);
195 curedge = shellWalk.curedge;
197 if (!walker->visit_set->contains(curedge)) {
198 if (!walker->visibility_flag ||
199 (walker->visibility_flag &&
208 walker->visit_set->add(curedge);
212 newState->base = v_old;
213 newState->curedge = curedge;
218 return shellWalk.curedge;
255 if (h ==
nullptr) [[unlikely]] {
312 e_edj_pair[0] =
l->
e;
313 e_edj_pair[1] =
l->
prev->
e;
315 for (i = 0; i < 2; i++) {
320 l_iter = l_first =
e->l;
322 BMLoop *l_radial = (l_iter->
v ==
l->
v) ? l_iter : l_iter->
next;
327 }
while ((l_iter = l_iter->
radial_next) != l_first);
419 if (h ==
nullptr) [[unlikely]] {
448 l_iter = l_first =
e->l;
452 }
while ((l_iter = l_iter->
radial_next) != l_first);
551 l_iter = l_first =
e->l;
558 }
while ((l_iter = l_iter->
radial_next) != l_first);
687 if (BM_loop_is_manifold(
l)) {
779 if (only_manifold && (l_iter->
radial_next != l_iter)) {
786 if (face_count == 3) {
790 }
while ((l_radial_iter = l_radial_iter->
radial_next) != l_iter);
792 if (face_count != 2) {
797 l_radial_iter = l_iter;
798 while ((l_radial_iter = l_radial_iter->
radial_next) != l_iter) {
806 if (f == iwalk->
cur) {
819 }
while ((l_iter = l_iter->
next) != l_first);
857 if (edge_mark_check_fn(
e)) {
858 if (!edge_mark_check_fn(
l->
e) &&
869 if (edge_mark_check_fn(e_other) &&
913 const int vert_edge_count[2] = {
917 const int vert_face_count[2] = {
999 ((vert_edge_count[0] == 3 && vert_face_count[0] == 3) ||
1000 (vert_edge_count[1] == 3 && vert_face_count[1] == 3)))
1004 BMFace *f_best =
nullptr;
1007 if (f_best ==
nullptr || f_best->
len < f_iter->
len) {
1015 lwalk->
f_hub = f_best->
len > 4 ? f_best :
nullptr;
1019 lwalk->
f_hub =
nullptr;
1023 lwalk->
f_hub =
nullptr;
1028 owalk = *(owalk_pt);
1068 if (vert_edge_tot == 3) {
1088 else if (
l ==
nullptr) {
1092 for (
int i = 0; i < 2; i++) {
1093 v = i ?
e->v2 :
e->v1;
1121 if (
ELEM(vert_edge_tot, 4, 2)) {
1122 int i_opposite = vert_edge_tot / 2;
1133 }
while (++i != i_opposite);
1165 bool has_corner_delimit =
false;
1167 if (vert_edge_tot > 3) {
1168 has_corner_delimit =
true;
1172 has_corner_delimit ==
false)
1175 has_corner_delimit =
true;
1180 if (has_corner_delimit ==
false) {
1242 if (
l->
f->
len != 4) {
1322 owalk = *(owalk_pt);
1467 owalk = *(owalk_pt);
1475 if (delimit_ngon ? (lwalk->
l->
f->
len != 4) : (lwalk->
l->
f->
len % 2 != 0)) {
1486 if (lwalk->
no_calc || (delimit_ngon ? (lwalk->
l->
f->
len != 4) : (lwalk->
l->
f->
len % 2 != 0))) {
1515#define EDGE_CHECK(e) \
1516 (bmw_mask_check_edge(walker, e) && (BM_edge_is_boundary(e) || BM_edge_is_manifold(e)))
1536 bool step_ok =
false;
1725 for (i = 0; i < 2; i++) {
1727 BMLoop *l_pivot, *l_radial;
1729 l_pivot = i ?
l->
next :
l;
1731 BMLoop *l_radial_first = l_radial;
1742 if (l_radial->
v != l_pivot->
v) {
1748 l_other = (l_radial->
v != l_pivot->
v) ? l_radial->
next : l_radial;
1758 lwalk->
l = l_radial;
1760 }
while ((l_radial = l_radial->
radial_next) != l_radial_first);
1771 lwalk->
l = l_boundary;
1824 if (BM_loop_is_manifold(
l)) {
1848 for (
int pass = 0; pass < 2; pass++) {
1855 if (pass == 1) [[unlikely]] {
1864 if (l_cur ==
nullptr) {
1867 else if (l_cur->
e != l_next->
e) {
1876 if (l_cur !=
nullptr) {
1881 if (l_cur !=
nullptr) {
1886 lwalk->
cur = l_cur->
e;
CustomData interface, see also DNA_customdata_types.h.
#define BM_DISK_EDGE_NEXT(e, v)
#define BM_FACE_FIRST_LOOP(p)
#define BM_ELEM_CD_GET_VOID_P(ele, offset)
#define BM_elem_flag_test(ele, hflag)
#define BM_ITER_ELEM(ele, iter, data, itype)
#define BMO_edge_flag_test(bm, e, oflag)
#define BMO_vert_flag_test(bm, e, oflag)
#define BMO_face_flag_test(bm, e, oflag)
#define BM_edge_face_count_is_equal(e, n)
#define BMW_state_remove_r(walker, owalk)
bool contains(const Key &key) const
ccl_device_inline dual1 len(const ccl_private dual< T > &a)
static const BMWalker bmw_UVEdgeWalker_Type
BLI_assert(slot->slot_subtype.map==BMO_OP_SLOT_SUBTYPE_MAP_FLT)
static bool bmw_FaceLoopWalker_delimit_check(BMFace *f_a, BMEdge *e, BMFace *f_b, const BMWDelimitFlag delimit)
static void * bmw_IslandManifoldWalker_step(BMWalker *walker)
static void * bmw_FaceLoopWalker_step(BMWalker *walker)
int BM_edge_face_count(const BMEdge *e)
static void * bmw_EdgeLoopWalker_yield(BMWalker *walker)
BLI_INLINE bool BM_edge_is_wire(const BMEdge *e) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL()
static void * bmw_FaceShellWalker_yield(BMWalker *walker)
static void * bmw_NonManifoldedgeWalker_step(BMWalker *walker)
static const BMWalker bmw_NonManifoldedgeWalker_type
static void bmw_EdgeringWalker_begin(BMWalker *walker, void *data)
static bool bmw_mask_check_vert(BMWalker *walker, BMVert *v)
static void bmw_EdgeLoopWalker_begin(BMWalker *walker, void *data)
void BMW_state_remove(BMWalker *walker)
Remove Current Walker State.
ATTR_WARN_UNUSED_RESULT const BMLoop * l
static void bmw_UVEdgeWalker_begin(BMWalker *walker, void *data)
static bool bmw_EdgeLoopWalker_delimit_mark_check(BMWalker *walker, BMVert *v, BMEdge *e, BMLoop *l)
static const BMWalker bmw_FaceShellWalker_Type
static void * bmw_VertShellWalker_step(BMWalker *walker)
static void * bmw_LoopShellWireWalker_step(BMWalker *walker)
static void bmw_VertShellWalker_visitEdge(BMWalker *walker, BMEdge *e)
static void bmw_NonManifoldedgeWalker_begin(BMWalker *walker, void *data)
static void bmw_EdgeboundaryWalker_begin(BMWalker *walker, void *data)
static const BMWalker bmw_FaceLoopWalker_Type
bool CustomData_data_equals(eCustomDataType type, const void *data1, const void *data2)
static void * bmw_IslandWalker_yield(BMWalker *walker)
void * BMW_state_add(BMWalker *walker)
Add a new Walker State.
static void * bmw_ConnectedVertexWalker_step(BMWalker *walker)
static void bmw_ConnectedVertexWalker_begin(BMWalker *walker, void *data)
static bool bmw_EdgeringWalker_delimit_check(BMEdge *e, const BMWDelimitFlag delimit)
BMLoop * BM_face_other_vert_loop(BMFace *f, BMVert *v_prev, BMVert *v)
Other Loop in Face Sharing a Vertex.
ATTR_WARN_UNUSED_RESULT const BMVert * v
static void bmw_LoopShellWalker_step_impl(BMWalker *walker, BMLoop *l)
static void * bmw_IslandWalker_step(BMWalker *walker)
static void bmw_LoopShellWireWalker_visitVert(BMWalker *walker, BMVert *v, const BMEdge *e_from)
BLI_INLINE bool BM_edge_is_manifold(const BMEdge *e) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL()
static void * bmw_LoopShellWireWalker_yield(BMWalker *walker)
static void bmw_LoopShellWireWalker_begin(BMWalker *walker, void *data)
static void bmw_IslandboundWalker_begin(BMWalker *walker, void *data)
static const BMWalker bmw_ConnectedVertexWalker_Type
BLI_INLINE BMVert * BM_edge_other_vert(BMEdge *e, const BMVert *v) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL()
static void * bmw_VertShellWalker_yield(BMWalker *walker)
static const BMWalker bmw_IslandWalker_Type
static void bmw_FaceLoopWalker_begin(BMWalker *walker, void *data)
static void * bmw_EdgeLoopWalker_step(BMWalker *walker)
static void * bmw_UVEdgeWalker_step(BMWalker *walker)
static BMLoop * bmw_NonManifoldLoop_find_next_around_vertex(BMLoop *l, BMVert *v, int face_count)
static bool bmw_FaceLoopWalker_include_face(BMWalker *walker, BMLoop *l)
static void * bmw_EdgeboundaryWalker_yield(BMWalker *walker)
void * BMW_current_state(BMWalker *walker)
Current Walker State.
int BM_vert_face_count(const BMVert *v)
static void bmw_FaceShellWalker_visitEdge(BMWalker *walker, BMEdge *e)
static const BMWalker bmw_IslandboundWalker_Type
BMesh const char void * data
static bool bmw_mask_check_edge(BMWalker *walker, BMEdge *e)
static bool bmw_mask_check_face(BMWalker *walker, BMFace *f)
static void * bmw_EdgeringWalker_step(BMWalker *walker)
static bool bmw_EdgeLoopWalker_delimit_by_mark(BMWalker *walker, BMVert *v, BMEdge *e, BMLoop *l, bool(*edge_mark_check_fn)(const BMEdge *))
static void * bmw_LoopShellWalker_step(BMWalker *walker)
static void bmw_FaceShellWalker_begin(BMWalker *walker, void *data)
int BM_vert_edge_count_nonwire(const BMVert *v)
static void * bmw_EdgeringWalker_yield(BMWalker *walker)
static const BMWalker bmw_EdgeboundaryWalker_Type
static void * bmw_ConnectedVertexWalker_yield(BMWalker *walker)
constexpr size_t ARRAY_SIZE(const T(&arg)[N]) noexcept
BLI_INLINE bool BM_edge_is_boundary(const BMEdge *e) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL()
static const BMWalker bmw_IslandManifoldWalker_Type
static const BMWalker bmw_VertShellWalker_Type
static void * bmw_IslandboundWalker_step(BMWalker *walker)
static void bmw_LoopShellWalker_begin(BMWalker *walker, void *data)
static const BMWalker bmw_LoopShellWalker_Type
static void * bmw_FaceShellWalker_step(BMWalker *walker)
static void * bmw_UVEdgeWalker_yield(BMWalker *walker)
BMEdge * BM_edge_exists(BMVert *v_a, BMVert *v_b)
static void bmw_LoopShellWalker_visitEdgeWire(BMWalker *walker, BMEdge *e)
static bool bm_edge_is_single(BMEdge *e)
bool BM_edge_is_all_face_flag_test(const BMEdge *e, const char hflag, const bool respect_hide)
ATTR_WARN_UNUSED_RESULT const BMVert * v2
const BMWalker * bm_walker_types[]
static void * bmw_NonManifoldedgeWalker_yield(BMWalker *walker)
static void * bmw_IslandWalker_step_ex(BMWalker *walker, bool only_manifold)
BLI_INLINE BMEdge * bmesh_disk_edge_next(const BMEdge *e, const BMVert *v) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL()
static void * bmw_EdgeboundaryWalker_step(BMWalker *walker)
static void bmw_IslandWalker_begin(BMWalker *walker, void *data)
static void bmw_LoopShellWalker_visitLoop(BMWalker *walker, BMLoop *l)
static const BMWalker bmw_LoopShellWireWalker_Type
static bool bmw_edge_is_wire(const BMWalker *walker, const BMEdge *e)
static bool bmw_FaceLoopWalker_edge_begins_loop(BMWalker *walker, BMEdge *e)
static void bmw_VertShellWalker_begin(BMWalker *walker, void *data)
static void * bmw_IslandboundWalker_yield(BMWalker *walker)
static const BMWalker bmw_EdgeringWalker_Type
static void * bmw_FaceLoopWalker_yield(BMWalker *walker)
static void bmw_ConnectedVertexWalker_visitVertex(BMWalker *walker, BMVert *v)
ATTR_WARN_UNUSED_RESULT const BMVert const BMEdge * e
@ BMW_DELIMIT_EDGE_LOOP_OUTER_CORNERS
@ BMW_DELIMIT_EDGE_MARK_SHARP
@ BMW_DELIMIT_EDGE_LOOP_INNER_CORNERS
@ BMW_DELIMIT_EDGE_LOOP_NGONS
@ BMW_DELIMIT_FACE_MARK_MATERIAL
@ BMW_DELIMIT_EDGE_MARK_SEAM
@ BMW_DELIMIT_EDGE_RING_NGONS
static const BMWalker bmw_EdgeLoopWalker_Type
static void * bmw_LoopShellWalker_yield(BMWalker *walker)
BMLoop * BM_loop_other_edge_loop(BMLoop *l, BMVert *v)
void * BMW_walk(BMWalker *walker)
Main Walking Function.
struct BMLoop * radial_next
Set< const void * > * visit_set
Set< const void * > * visit_set_alt
struct BMLoop * radial_next