56 if (l_iter->
prev->
v == v_prev) {
59 if (l_iter->
next->
v == v_prev) {
79 if (
l->
prev->
v == v_prev) {
112 if (v_a->
e && v_b->
e) {
128 bool (*test_fn)(
BMFace *,
void *user_data),
131 if (v_a->
e && v_b->
e) {
136 if (test_fn(f, user_data)) {
149 const bool allow_adjacent,
155 if (v_a->
e && v_b->
e) {
163 callback(f, l_a,
l_b, user_data))
179 BMLoop *l_cur_a =
nullptr, *l_cur_b =
nullptr;
182 if (v_a->
e && v_b->
e) {
187 if ((f_cur ==
nullptr) || (l_a->
f->
len < f_cur->
len)) {
207 BMLoop *l_cur_a =
nullptr, *l_cur_b =
nullptr;
210 if (e_a->
l && e_b->
l) {
215 if ((f_cur ==
nullptr) || (l_a->
f->
len < f_cur->
len)) {
246 const float *axis =
l->
f->
no;
252 const float *axis =
l->
f->
no;
266 BMLoop *l_cur_a =
nullptr, *l_cur_b =
nullptr;
269 if (v_a->
e && v_b->
e) {
272 float dot_best = -1.0f;
278 if (f_cur ==
nullptr) {
286 if (dot_best == -1.0f) {
291 if (
dot > dot_best) {
322#ifdef USE_BMESH_HOLES
324 for (lst = f->loops.first; lst; lst = lst->next)
327#ifdef USE_BMESH_HOLES
328 l_iter = l_first = lst->first;
333 if (l_iter->
v ==
v) {
336 }
while ((l_iter = l_iter->
next) != l_first);
346#ifdef USE_BMESH_HOLES
352 for (i = 0; i <
len; i++) {
356#ifdef USE_BMESH_HOLES
357 for (lst = f->loops.first; lst; lst = lst->next)
361#ifdef USE_BMESH_HOLES
362 l_iter = l_first = lst->first;
372 }
while ((l_iter = l_iter->
next) != l_first);
375 for (i = 0; i <
len; i++) {
386#ifdef USE_BMESH_HOLES
398 for (i = 0; i <
len; i++) {
402#ifdef USE_BMESH_HOLES
403 for (lst = f->loops.first; lst; lst = lst->next)
407#ifdef USE_BMESH_HOLES
408 l_iter = l_first = lst->first;
422 }
while ((l_iter = l_iter->
next) != l_first);
425 for (i = 0; i <
len; i++) {
435 const BMLoop *l_iter, *l_first;
437 l_iter = l_first =
e->l;
439 if (l_iter->
f == f) {
442 }
while ((l_iter = l_iter->
radial_next) != l_first);
460 if (l_other->
v ==
l->
v) {
463 else if (l_other->
next->
v ==
l->
v) {
464 l_other = l_other->
next;
477 if (
l->
e == e_prev) {
480 else if (
l->
prev->
e == e_prev) {
514 }
while (l_a != e_first->
l);
535 }
while (l_a != e_first->
l);
648 l_iter = l_first =
e->l;
651 }
while ((l_iter = l_iter->
radial_next) != l_first);
664 l_iter = l_first =
e->l;
667 if (count == count_max) {
670 }
while ((l_iter = l_iter->
radial_next) != l_first);
688 if (
v->
e !=
nullptr) {
689 const BMEdge *e_iter, *e_first;
690 e_first = e_iter =
v->
e;
692 if (e_iter->
l !=
nullptr) {
705 e_first = e_iter =
v->
e;
719 BMEdge *e_iter, *e_first, *e_prev;
721 int loop_num = 0, loop_num_region = 0, boundary_num = 0;
723 if (
v->
e ==
nullptr) {
729 e_first = e_iter =
v->
e;
741 if (e_iter->
l->
v ==
v) {
756 if (boundary_num == 3) {
762 e_first = l_first->
e;
763 l_first = (l_first->
v ==
v) ? l_first : l_first->
next;
770 loop_num_region += 1;
773 return (loop_num == loop_num_region);
776#define LOOP_VISIT _FLAG_WALK
777#define EDGE_VISIT _FLAG_WALK
787 l_iter = l_first =
e->l;
789 if (l_iter->
v ==
v) {
799 else if (l_iter->
next->
v ==
v) {
812 }
while ((l_iter = l_iter->
radial_next) != l_first);
823 e_iter = e_first =
l->
e;
828 l_iter = l_first = e_iter->
l;
830 if (l_iter->
v ==
l->
v) {
834 }
while ((l_iter = l_iter->
radial_next) != l_first);
846 *r_loop_total = count_total;
863 int count, count_total;
865 return (count == count_total);
874 BMLoop *l2 =
e->l->radial_next;
888 const int cd_loop_type,
889 const int cd_loop_offset)
893 if (
e->l &&
e->l->radial_next !=
e->l) {
894 const BMLoop *l_base_v1 =
e->l;
895 const BMLoop *l_base_v2 =
e->l->next;
898 const BMLoop *l_iter =
e->l->radial_next;
902 const void *l_iter_cd_v1;
903 const void *l_iter_cd_v2;
905 if (l_iter->
v == l_base_v1->
v) {
907 l_iter_v2 = l_iter->
next;
910 l_iter_v1 = l_iter->
next;
913 BLI_assert((l_iter_v1->
v == l_base_v1->
v) && (l_iter_v2->
v == l_base_v2->
v));
935 e_first = e_iter =
v->
e;
993 }
while ((l_iter = l_iter->
next) != l_first);
1008 }
while ((l_iter = l_iter->
next) != l_first);
1024 }
while ((l_iter = l_iter->
next) != l_first);
1039 }
while ((l_iter = l_iter->
next) != l_first);
1055 if (e1->
l && e2->
l) {
1063 }
while (
l != e1->
l);
1073 if (e1->
l && e2->
l) {
1083 }
while (
l != e1->
l);
1090 return (e1->
v1 == e2->
v1 || e1->
v1 == e2->
v2 || e1->
v2 == e2->
v1 || e1->
v2 == e2->
v2);
1121 if (l_iter->
v ==
v) {
1124 }
while ((l_iter = l_iter->
next) != l_first);
1134 l_iter = l_first =
e->l;
1136 if (l_iter->
f == f) {
1139 }
while ((l_iter = l_iter->
radial_next) != l_first);
1151 *r_v1 = edge_loop->
v;
1152 *r_v2 = edge_loop->
next->
v;
1167 l_step = l_step->
prev;
1169 if (l_step == l_stop) [[unlikely]] {
1184 l_step = l_step->
next;
1186 if (l_step == l_stop) [[unlikely]] {
1196 float e_dir_prev[3];
1197 float e_dir_next[3];
1220 float v1[3],
v2[3], v_tmp[3];
1224 const float fac = ((
v2[0] == 0.0f) ?
1225 ((
v2[1] == 0.0f) ? ((
v2[2] == 0.0f) ? 0.0f : v1[2] /
v2[2]) :
1241 const float normal_fallback[3],
1242 float const (*vertexCos)[3],
1243 const float epsilon_sq,
1250 float v1[3],
v2[3], v_tmp[3];
1254 const float fac = ((
v2[0] == 0.0f) ?
1255 ((
v2[1] == 0.0f) ? ((
v2[2] == 0.0f) ? 0.0f : v1[2] /
v2[2]) :
1276 const float normal_fallback[3],
1277 float const (*vertexCos)[3],
1292 if (
len == 0.0f) [[unlikely]] {
1347 const BMLoop *l2 =
e->l->radial_next;
1358 const float imat3[3][3],
1359 const float fallback)
1363 const BMLoop *l2 =
e->l->radial_next;
1364 float no1[3], no2[3];
1387 BMLoop *l2 =
e->l->radial_next;
1439 float accum_shell = 0.0f;
1440 float accum_angle = 0.0f;
1445 accum_angle += face_angle;
1448 if (accum_angle != 0.0f) {
1449 return accum_shell / accum_angle;
1457 float accum_shell = 0.0f;
1458 float accum_angle = 0.0f;
1459 int tot_sel = 0, tot = 0;
1465 accum_angle += face_angle;
1471 if (accum_angle != 0.0f) {
1472 return accum_shell / accum_angle;
1475 if (tot != 0 && tot_sel == 0) {
1510 BMLoop *shortest_loop = l_first;
1514 if (len_sq <= shortest_len) {
1515 shortest_loop = l_iter;
1516 shortest_len = len_sq;
1518 }
while ((l_iter = l_iter->
next) != l_first);
1520 return shortest_loop;
1525 float len_max_sq = 0.0f;
1531 BMLoop *longest_loop = l_first;
1535 if (len_sq >= len_max_sq) {
1536 longest_loop = l_iter;
1537 len_max_sq = len_sq;
1539 }
while ((l_iter = l_iter->
next) != l_first);
1541 return longest_loop;
1560 if (
e->v1 == v_b ||
e->v2 == v_b) {
1578 if ((e_a = v_a->
e) && (e_b = v_b->
e)) {
1579 BMEdge *e_a_iter = e_a, *e_b_iter = e_b;
1615 if (
e->l !=
nullptr) {
1616 BMLoop *l_iter, *l_first;
1617 l_iter = l_first =
e->l;
1622 }
while ((l_iter = l_iter->
radial_next) != l_first);
1630 BMEdge *e_iter, *e_first;
1631 e_iter = e_first = varr[0]->
e;
1637 BMLoop *l_iter_radial, *l_first_radial;
1638 l_iter_radial = l_first_radial = e_iter->
l;
1641 if ((l_iter_radial->
v == varr[0]) && (l_iter_radial->
f->
len ==
len)) {
1646 if (l_iter_radial->
next->
v == varr[1]) {
1649 if (l_walk->
v != varr[i_walk]) {
1652 }
while ((
void)(l_walk = l_walk->
next), ++i_walk !=
len);
1654 else if (l_iter_radial->
prev->
v == varr[1]) {
1657 if (l_walk->
v != varr[i_walk]) {
1660 }
while ((
void)(l_walk = l_walk->
prev), ++i_walk !=
len);
1663 if (i_walk ==
len) {
1664 return l_iter_radial->
f;
1667 }
while ((l_iter_radial = l_iter_radial->
radial_next) != l_first_radial);
1682 for (
int i = 1; i < f_len; i++) {
1683 l_test = l_test->
next;
1690 if (e_exists ==
nullptr || e_exists->
l ==
nullptr) {
1694 BMLoop *l_radial_iter = e_exists->
l;
1696 if (l_radial_iter->
f->
len != f_len) {
1700 const bool swap_winding = (l_radial_iter->
v == l_a->
v);
1701 BMLoop *l_other_beg, *l_other_end;
1703 l_other_beg = l_radial_iter;
1704 l_other_end = l_radial_iter->
next;
1707 l_other_beg = l_radial_iter->
next;
1708 l_other_end = l_radial_iter;
1717 return l_radial_iter->
f;
1724 return l_radial_iter->
f;
1727 }
while ((l_radial_iter = l_radial_iter->
radial_next) != e_exists->
l);
1736 if (l_iter->f->len == l_first->
f->
len) {
1737 if (l_iter->v == l_first->
v) {
1738 BMLoop *l_a = l_first, *
l_b = l_iter, *l_b_init = l_iter;
1740 if (l_a->
e !=
l_b->
e) {
1743 }
while (((
void)(l_a = l_a->
next), (
l_b =
l_b->
next)) != l_b_init);
1744 if (
l_b == l_b_init) {
1749 BMLoop *l_a = l_first, *
l_b = l_iter, *l_b_init = l_iter;
1751 if (l_a->
e !=
l_b->
e) {
1754 }
while (((
void)(l_a = l_a->
prev), (
l_b =
l_b->
next)) != l_b_init);
1755 if (
l_b == l_b_init) {
1777 for (i = 0; i <
len; i++) {
1795 for (i = 0; i <
len; i++) {
1804 for (i = 0; i <
len; i++) {
1836 for (i = 0; i <
len; i++) {
1845 int tot_face_tag = 0;
1852 if (tot_face_tag != 2) {
1866 for (i = 0; i <
len; i++) {
1878 for (
int i = 0; i <
len; i++) {
1884 for (
int i = 0; i <
len; i++) {
1886 for (
int j = 0; j < 2; j++) {
1892 if (varr_len <
len) {
1901 if (varr_len !=
len) {
1914 BMFace *f_overlap =
nullptr;
1919 for (i = 0; i <
len; i++) {
1926 for (i = 0; i <
len; i++) {
1940 for (; f_lnk; f_lnk = f_lnk->
next) {
1951 bool is_init =
false;
1952 bool is_overlap =
false;
1957 for (
int i = 0; i <
len; i++) {
1965 for (
int i = 0; i <
len; i++) {
1969 BMLoop *l_iter, *l_first;
1971 if (is_init ==
false) {
1973 for (
int j = 0; j <
len; j++) {
1985 }
while ((l_iter = l_iter->
next) != l_first);
1997 if (is_init ==
true) {
1998 for (
int i = 0; i <
len; i++) {
2003 for (; f_lnk; f_lnk = f_lnk->
next) {
2049 BMLoop *l_iter, *l_first;
2051 l_iter = l_first =
e->l;
2058 }
while ((l_iter = l_iter->
radial_next) != l_first);
2067 BMLoop *l_iter, *l_first;
2069 l_iter = l_first =
e->l;
2074 }
while ((l_iter = l_iter->
radial_next) != l_first);
2095 }
while ((l_iter = l_iter->
next) != l_first);
2109 }
while ((l_iter = l_iter->
next) != l_first);
2116 BMLoop *l_iter, *l_first;
2118 l_iter = l_first =
e->l;
2123 }
while ((l_iter = l_iter->
radial_next) != l_first);
2131 const float eps = 0.0001f;
2146 const int tottri = f->
len - 2;
2153 for (
int j = 0; j < tottri; j++) {
2154 const float *p1 = loops[
index[j][0]]->v->co;
2155 const float *p2 = loops[
index[j][1]]->v->co;
2156 const float *p3 = loops[
index[j][2]]->v->co;
2171 return (1.0 / 6.0) * vol;
2184 if (is_signed ==
false) {
2192 int *r_groups_array,
2193 int (**r_group_index)[2],
2197 const char hflag_test,
2198 const char htype_step)
2203 int group_index_len = 1;
2205 int group_index_len = 32;
2210 int *group_array = r_groups_array;
2249 while (tot_touch != tot_faces) {
2257 for (; f_next; f_next =
static_cast<BMFace *
>(BM_iter_step(&iter))) {
2270 if (group_index_len == group_curr) {
2271 group_index_len *= 2;
2272 group_index =
static_cast<int (*)[2]
>(
2276 group_item = group_index[group_curr];
2281 BMLoop *l_iter, *l_first;
2294 if ((l_radial_iter != l_iter) &&
2295 ((filter_fn ==
nullptr) || filter_fn(l_iter, user_data)))
2298 if ((filter_pair_fn ==
nullptr) || filter_pair_fn(l_iter, l_radial_iter, user_data))
2300 BMFace *f_other = l_radial_iter->
f;
2306 }
while ((l_radial_iter = l_radial_iter->
radial_next) != l_iter);
2308 }
while ((l_iter = l_iter->
next) != l_first);
2316 if ((filter_fn ==
nullptr) || filter_fn(l_iter, user_data)) {
2319 if ((filter_pair_fn ==
nullptr) || filter_pair_fn(l_iter, l_other, user_data)) {
2328 }
while ((l_iter = l_iter->
next) != l_first);
2338 if (group_index_len != group_curr) {
2339 group_index =
static_cast<int (*)[2]
>(
2342 *r_group_index = group_index;
2348 int *r_groups_array,
2349 int (**r_group_index)[2],
2352 const char hflag_test)
2357 int group_index_len = 1;
2359 int group_index_len = 32;
2364 int *group_array = r_groups_array;
2400 while (tot_touch != tot_edges) {
2408 for (; e_next; e_next =
static_cast<BMEdge *
>(BM_iter_step(&iter))) {
2421 if (group_index_len == group_curr) {
2422 group_index_len *= 2;
2423 group_index =
static_cast<int (*)[2]
>(
2427 group_item = group_index[group_curr];
2444 if ((filter_fn ==
nullptr) || filter_fn(
v, user_data)) {
2462 if (group_index_len != group_curr) {
2463 group_index =
static_cast<int (*)[2]
>(
2466 *r_group_index = group_index;
2509 if (v_stack_init->
e !=
nullptr) {
2510 BMVert *v_iter = v_stack_init;
2512 BMEdge *e_iter, *e_first;
2513 e_iter = e_first = v_iter->
e;
2519 if (e_iter->
l !=
nullptr) {
2520 BMLoop *l_iter, *l_first;
2521 l_iter = l_first = e_iter->
l;
2527 }
while ((l_iter = l_iter->
radial_next) != l_first);
2551 groups =
static_cast<int (*)[3]
>(
2561 val = 3.0f * val * val - 2.0f * val * val * val;
2564 val =
sqrtf(2.0f * val - val * val);
2575 val = val * (2.0f - val);
CustomData interface, see also DNA_customdata_types.h.
#define BLI_linklist_prepend_alloca(listp, ptr)
#define STACK_PUSH(stack, val)
#define STACK_DECLARE(stack)
#define STACK_SIZE(stack)
#define STACK_INIT(stack, stack_num)
#define STACK_PUSH_RET(stack)
Read Blender memory allocation and freeing.
#define UNUSED_VARS_NDEBUG(...)
#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)
#define BM_elem_index_get(ele)
#define BM_elem_flag_disable(ele, hflag)
#define BM_elem_index_set(ele, index)
#define BM_elem_flag_test(ele, hflag)
#define BM_elem_flag_enable(ele, hflag)
#define BM_ITER_ELEM(ele, iter, data, itype)
#define BM_ITER_MESH(ele, iter, bm, itype)
#define BM_ITER_MESH_INDEX(ele, iter, bm, itype, indexvar)
#define BM_ITER_ELEM_INDEX(ele, iter, data, itype, indexvar)
#define BM_iter_new(iter, bm, itype, data)
#define MEM_realloc_uninitialized(vmemh, len)
#define BM_ELEM_API_FLAG_DISABLE(element, f)
#define BM_ELEM_API_FLAG_TEST(element, f)
#define BM_ELEM_API_FLAG_ENABLE(element, f)
SIMD_FORCE_INLINE btScalar angle(const btVector3 &v) const
Return the angle between this and another vector.
float dot(VecOp< float, D >, VecOp< float, D >) RET
VecBase< float, 3 > cross(VecOp< float, 3 >, VecOp< float, 3 >) RET
float length(VecOp< float, D >) RET
ccl_device_inline dual1 len(const ccl_private dual< T > &a)
ccl_device_inline dual3 fabs(const ccl_private dual3 &a)
bool BM_loop_share_edge_check(BMLoop *l_a, BMLoop *l_b)
float BM_loop_calc_face_normal_safe_vcos(const BMLoop *l, const float normal_fallback[3], float const (*vertexCos)[3], float r_normal[3])
void BM_face_calc_tessellation(const BMFace *f, const bool use_fixed_quad, BMLoop **r_loops, uint(*r_index)[3])
void BM_loop_calc_face_direction(const BMLoop *l, float r_dir[3])
BM_loop_calc_face_direction.
BLI_assert(slot->slot_subtype.map==BMO_OP_SLOT_SUBTYPE_MAP_FLT)
void BM_edge_calc_face_tangent(const BMEdge *e, const BMLoop *e_loop, float r_tangent[3])
BMESH EDGE/FACE TANGENT.
MINLINE float len_squared_v3v3(const float a[3], const float b[3]) ATTR_WARN_UNUSED_RESULT
MINLINE float shell_v3v3_normalized_to_dist(const float a[3], const float b[3])
float angle_normalized_v3v3(const float v1[3], const float v2[3]) ATTR_WARN_UNUSED_RESULT
bool BM_face_pair_overlap_check_subset_same_winding(const BMLoop *l_a, const BMLoop *l_a_end, const BMLoop *l_b, const BMLoop *l_b_end)
int BM_loop_region_loops_count(BMLoop *l)
int BM_edge_face_count(const BMEdge *e)
bool BM_verts_in_face(BMVert **varr, int len, BMFace *f)
bool BM_face_is_any_vert_flag_test(const BMFace *f, const char hflag)
BMFace * BM_vert_pair_shared_face_cb(BMVert *v_a, BMVert *v_b, const bool allow_adjacent, bool(*callback)(BMFace *, BMLoop *, BMLoop *, void *userdata), void *user_data, BMLoop **r_l_a, BMLoop **r_l_b)
float BM_face_calc_normal_subset(const BMLoop *l_first, const BMLoop *l_last, float r_no[3])
bool BM_edge_in_face(const BMEdge *e, const BMFace *f)
bool BM_edge_is_any_face_len_test(const BMEdge *e, const int len)
bool BM_face_exists_overlap_subset(BMVert **varr, const int len)
MINLINE double dot_v3v3_db(const double a[3], const double b[3]) ATTR_WARN_UNUSED_RESULT
BMFace * BM_face_exists_overlap(BMVert **varr, const int len)
float BM_edge_calc_face_angle(const BMEdge *e)
BLI_INLINE bool BM_loop_is_adjacent(const BMLoop *l_a, const BMLoop *l_b) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL()
MINLINE void copy_v3_v3(float r[3], const float a[3])
void * MEM_new_array_uninitialized(size_t len, size_t size, const char *str) ATTR_WARN_UNUSED_RESULT ATTR_ALLOC_SIZE(1
float BM_vert_calc_median_tagged_edge_length(const BMVert *v)
bool BM_edge_share_face_check(BMEdge *e1, BMEdge *e2)
ATTR_WARN_UNUSED_RESULT const BMLoop * l
MINLINE void copy_v3db_v3fl(double r[3], const float a[3])
MINLINE void add_v3_v3v3(float r[3], const float a[3], const float b[3])
float BM_edge_calc_face_angle_signed_ex(const BMEdge *e, const float fallback)
BMESH EDGE/FACE ANGLE.
float dist_signed_squared_to_plane_v3(const float p[3], const float plane[4])
bool BM_vert_is_wire(const BMVert *v)
float angle_v3v3v3(const float a[3], const float b[3], const float c[3]) ATTR_WARN_UNUSED_RESULT
BMVert * BM_edge_share_vert(BMEdge *e1, BMEdge *e2)
bool BM_edge_is_convex(const BMEdge *e)
float BM_edge_calc_face_angle_with_imat3_ex(const BMEdge *e, const float imat3[3][3], const float fallback)
BMESH EDGE/FACE ANGLE.
bool BM_edge_is_any_face_flag_test(const BMEdge *e, const char hflag)
BMLoop * BM_edge_vert_share_loop(BMLoop *l, BMVert *v)
Return the Loop Shared by Edge and Vert.
BMLoop * BM_vert_step_fan_loop(BMLoop *l, BMEdge **e_step)
BMLoop * BM_face_edge_share_loop(BMFace *f, BMEdge *e)
Return the Loop Shared by Face and Edge.
bool CustomData_data_equals(eCustomDataType type, const void *data1, const void *data2)
int bmesh_disk_facevert_count(const BMVert *v)
DISK COUNT FACE VERT.
bool BM_face_is_any_edge_flag_test(const BMFace *f, const char hflag)
int BM_face_share_face_count(BMFace *f_a, BMFace *f_b)
int BM_edge_face_count_at_most(const BMEdge *e, const int count_max)
BMFace * BM_vert_pair_share_face_by_len(BMVert *v_a, BMVert *v_b, BMLoop **r_l_a, BMLoop **r_l_b, const bool allow_adjacent)
float BM_loop_calc_face_normal_safe_ex(const BMLoop *l, const float epsilon_sq, float r_normal[3])
BM_loop_calc_face_normal.
BMLoop * BM_face_find_shortest_loop(BMFace *f)
void BM_mesh_elem_hflag_disable_all(BMesh *bm, const char htype, const char hflag, const bool respecthide)
float BM_vert_calc_shell_factor(const BMVert *v)
bool BM_vert_is_all_face_flag_test(const BMVert *v, const char hflag, const bool respect_hide)
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 int bm_loop_region_count__recursive(BMEdge *e, BMVert *v)
float BM_vert_calc_edge_angle(const BMVert *v)
BLI_INLINE bool BM_edge_is_manifold(const BMEdge *e) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL()
float BM_edge_calc_length(const BMEdge *e)
int BM_mesh_calc_edge_groups(BMesh *bm, int *r_groups_array, int(**r_group_index)[2], BMVertFilterFunc filter_fn, void *user_data, const char hflag_test)
int BM_vert_edge_count_at_most(const BMVert *v, const int count_max)
bool BM_vert_is_boundary(const BMVert *v)
BLI_INLINE bool BM_vert_in_edge(const BMEdge *e, const BMVert *v) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL()
BLI_INLINE BMVert * BM_edge_other_vert(BMEdge *e, const BMVert *v) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL()
void BM_edge_ordered_verts_ex(const BMEdge *edge, BMVert **r_v1, BMVert **r_v2, const BMLoop *edge_loop)
BMLoop * BM_face_find_longest_loop(BMFace *f)
void BM_loop_calc_face_tangent(const BMLoop *l, float r_tangent[3])
BM_loop_calc_face_tangent.
BMLoop * bmesh_disk_faceloop_find_first(const BMEdge *e, const BMVert *v)
int BM_face_share_edge_count(BMFace *f_a, BMFace *f_b)
BMFace * BM_vert_pair_share_face_by_angle(BMVert *v_a, BMVert *v_b, BMLoop **r_l_a, BMLoop **r_l_b, const bool allow_adjacent)
MINLINE void sub_v3_v3(float r[3], const float a[3])
bool BM_face_share_edge_check(BMFace *f_a, BMFace *f_b)
bool BM_vert_is_edge_pair_manifold(const BMVert *v)
void mul_transposed_m3_v3(const float M[3][3], float r[3])
bool BM_face_share_face_check(BMFace *f_a, BMFace *f_b)
MINLINE bool equals_v3v3(const float v1[3], const float v2[3]) ATTR_WARN_UNUSED_RESULT
float BM_loop_calc_face_normal(const BMLoop *l, float r_normal[3])
BM_loop_calc_face_normal.
double BM_mesh_calc_volume(BMesh *bm, bool is_signed)
int bmesh_disk_count_at_most(const BMVert *v, int count_max)
int BM_vert_face_count(const BMVert *v)
int BM_loop_region_loops_count_at_most(BMLoop *l, int *r_loop_total)
static float bm_face_calc_split_dot(BMLoop *l_a, BMLoop *l_b)
bool BM_face_share_vert_check(BMFace *f_a, BMFace *f_b)
MINLINE void cross_v3_v3v3(float r[3], const float a[3], const float b[3])
float BM_vert_calc_shell_factor_ex(const BMVert *v, const float no[3], const char hflag)
float BM_edge_calc_face_angle_ex(const BMEdge *e, const float fallback)
BMESH EDGE/FACE ANGLE.
ATTR_WARN_UNUSED_RESULT const BMLoop * l_b
bool BM_vert_is_all_edge_flag_test(const BMVert *v, const char hflag, const bool respect_hide)
BMLoop * BM_loop_other_vert_loop_by_edge(BMLoop *l, BMEdge *e)
int bmesh_disk_count(const BMVert *v)
BMLoop * BM_vert_find_first_loop(BMVert *v)
static int bm_loop_region_count__clear(BMLoop *l)
int BM_vert_edge_count_nonwire(const BMVert *v)
MINLINE void cross_v3_v3v3_db(double r[3], const double a[3], const double b[3])
bool BM_vert_in_face(BMVert *v, BMFace *f)
bool BM_vert_pair_share_face_check(BMVert *v_a, BMVert *v_b)
MINLINE void negate_v3(float r[3])
BMLoop * BM_edge_find_first_loop_visible(BMEdge *e)
BLI_INLINE bool BM_edge_is_boundary(const BMEdge *e) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL()
void BM_edge_ordered_verts(const BMEdge *edge, BMVert **r_v1, BMVert **r_v2)
bool BM_edge_face_pair(BMEdge *e, BMFace **r_fa, BMFace **r_fb)
BMLoop * BM_loop_find_next_nodouble(BMLoop *l, BMLoop *l_stop, const float eps_sq)
BMLoop * BM_edge_other_loop(BMEdge *e, BMLoop *l)
BMLoop * BM_loop_other_vert_loop(BMLoop *l, BMVert *v)
Other Loop in Face Sharing a Vert.
bool(*)(const BMVert *, void *user_data) BMVertFilterFunc
float BM_vert_calc_edge_angle_ex(const BMVert *v, const float fallback)
BMESH VERT/EDGE ANGLE.
int BM_vert_face_count_at_most(const BMVert *v, int count_max)
float BM_loop_calc_face_normal_safe(const BMLoop *l, float r_normal[3])
float bmesh_subd_falloff_calc(const int falloff, float val)
BMFace * BM_edge_pair_share_face_by_len(BMEdge *e_a, BMEdge *e_b, BMLoop **r_l_a, BMLoop **r_l_b, const bool allow_adjacent)
float BM_loop_calc_face_angle(const BMLoop *l)
BMFace * BM_face_exists(BMVert *const *varr, int len)
MINLINE void mul_v3_v3fl(float r[3], const float a[3], float f)
BMEdge * BM_edge_exists(BMVert *v_a, BMVert *v_b)
MINLINE float normalize_v3(float n[3])
bool BM_edge_loop_pair(BMEdge *e, BMLoop **r_la, BMLoop **r_lb)
MINLINE void sub_v3_v3v3(float r[3], const float a[3], const float b[3])
float BM_edge_calc_length_squared(const BMEdge *e)
bool BM_edge_share_quad_check(BMEdge *e1, BMEdge *e2)
MINLINE bool compare_v3v3(const float v1[3], const float v2[3], float limit) ATTR_WARN_UNUSED_RESULT
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
bool BM_vert_is_manifold_region(const BMVert *v)
int BM_mesh_calc_face_groups(BMesh *bm, int *r_groups_array, int(**r_group_index)[2], BMLoopFilterFunc filter_fn, BMLoopPairFilterFunc filter_pair_fn, void *user_data, const char hflag_test, const char htype_step)
BMEdge * BM_vert_other_disk_edge(BMVert *v, BMEdge *e_first)
BMLoop * BM_vert_find_first_loop_visible(BMVert *v)
float BM_face_calc_normal(const BMFace *f, float r_no[3])
BMESH UPDATE FACE NORMAL.
BMFace * BM_face_exists_subset_from_face(BMLoop *l_a, BMLoop *l_b, const int f_len)
MINLINE float len_squared_v3(const float v[3]) ATTR_WARN_UNUSED_RESULT
bool BM_vert_is_edge_pair(const BMVert *v)
BMLoop * BM_loop_find_prev_nodouble(BMLoop *l, BMLoop *l_stop, const float eps_sq)
bool BM_face_exists_multi_edge(BMEdge **earr, int len)
int BM_face_share_vert_count(BMFace *f_a, BMFace *f_b)
bool BM_vert_edge_pair(const BMVert *v, BMEdge **r_e_a, BMEdge **r_e_b)
BMEdge * BM_edge_find_double(BMEdge *e)
float BM_edge_calc_face_angle_with_imat3(const BMEdge *e, const float imat3[3][3])
BLI_INLINE BMEdge * bmesh_disk_edge_next(const BMEdge *e, const BMVert *v) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL()
int BM_verts_in_face_count(BMVert **varr, int len, BMFace *f)
int bmesh_disk_facevert_count_at_most(const BMVert *v, const int count_max)
BMLoop * BM_face_vert_share_loop(BMFace *f, BMVert *v)
Return the Loop Shared by Face and Vertex.
BMFace * BM_face_find_double(BMFace *f)
float BM_loop_point_side_of_edge_test(const BMLoop *l, const float co[3])
bool BM_vert_is_manifold(const BMVert *v)
bool(*)(const BMLoop *, void *user_data) BMLoopFilterFunc
MINLINE float len_v3v3(const float a[3], const float b[3]) ATTR_WARN_UNUSED_RESULT
bool BM_face_is_normal_valid(const BMFace *f)
BMLoop * BM_face_other_edge_loop(BMFace *f, BMEdge *e, BMVert *v)
Other Loop in Face Sharing an Edge.
bool BM_edge_share_vert_check(BMEdge *e1, BMEdge *e2)
static double bm_mesh_calc_volume_face(const BMFace *f)
MINLINE float dot_v3v3(const float a[3], const float b[3]) ATTR_WARN_UNUSED_RESULT
BMLoop * bmesh_disk_faceloop_find_first_visible(const BMEdge *e, const BMVert *v)
float dist_signed_squared_to_corner_v3v3v3(const float p[3], const float v1[3], const float v2[3], const float v3[3], const float axis_ref[3])
MINLINE bool is_zero_v3(const float v[3]) ATTR_WARN_UNUSED_RESULT
bool BM_vert_pair_share_face_check_cb(BMVert *v_a, BMVert *v_b, bool(*test_fn)(BMFace *, void *user_data), void *user_data)
bool BM_edge_is_any_vert_flag_test(const BMEdge *e, const char hflag)
ATTR_WARN_UNUSED_RESULT const BMVert const BMEdge * e
float BM_edge_calc_face_angle_signed(const BMEdge *e)
bool BM_vert_face_check(const BMVert *v)
int BM_mesh_calc_edge_groups_as_arrays(BMesh *bm, BMVert **verts, BMEdge **edges, BMFace **faces, int(**r_groups)[3])
bool BM_face_exists_multi(BMVert **varr, BMEdge **earr, int len)
bool BM_edge_is_contiguous_loop_cd(const BMEdge *e, const int cd_loop_type, const int cd_loop_offset)
int BM_vert_edge_count(const BMVert *v)
BMLoop * BM_loop_other_edge_loop(BMLoop *l, BMVert *v)
bool BM_face_pair_overlap_check_subset_swap_winding(const BMLoop *l_a, const BMLoop *l_a_end, const BMLoop *l_b, const BMLoop *l_b_end)
bool(*)(const BMLoop *, const BMLoop *, void *user_data) BMLoopPairFilterFunc
float BM_loop_point_side_of_loop_test(const BMLoop *l, const float co[3])
bool BM_loop_is_convex(const BMLoop *l)
float BM_loop_calc_face_normal_safe_vcos_ex(const BMLoop *l, const float normal_fallback[3], float const (*vertexCos)[3], const float epsilon_sq, float r_normal[3])
KERNEL_FEATURE_LIGHT_PASSES KERNEL_FEATURE_PATH_GUIDING float
struct BMLoop * radial_next
struct BMLoop * radial_next