46 if (l_iter->
prev->
v == v_prev) {
49 if (l_iter->
next->
v == v_prev) {
69 if (
l->
prev->
v == v_prev) {
102 if (v_a->
e && v_b->
e) {
121 if (v_a->
e && v_b->
e) {
139 const bool allow_adjacent,
145 if (v_a->
e && v_b->
e) {
171 if (v_a->
e && v_b->
e) {
176 if ((f_cur ==
NULL) || (l_a->
f->
len < f_cur->
len)) {
199 if (e_a->
l && e_b->
l) {
204 if ((f_cur ==
NULL) || (l_a->
f->
len < f_cur->
len)) {
234 const float *axis =
l->
f->
no;
240 const float *axis =
l->
f->
no;
257 if (v_a->
e && v_b->
e) {
260 float dot_best = -1.0f;
274 if (dot_best == -1.0f) {
279 if (
dot > dot_best) {
310 #ifdef USE_BMESH_HOLES
312 for (lst = f->loops.first; lst; lst = lst->next)
315 #ifdef USE_BMESH_HOLES
316 l_iter = l_first = lst->first;
321 if (l_iter->
v ==
v) {
324 }
while ((l_iter = l_iter->
next) != l_first);
334 #ifdef USE_BMESH_HOLES
340 for (i = 0; i <
len; i++) {
344 #ifdef USE_BMESH_HOLES
345 for (lst = f->loops.first; lst; lst = lst->next)
349 #ifdef USE_BMESH_HOLES
350 l_iter = l_first = lst->first;
360 }
while ((l_iter = l_iter->
next) != l_first);
363 for (i = 0; i <
len; i++) {
374 #ifdef USE_BMESH_HOLES
386 for (i = 0; i <
len; i++) {
390 #ifdef USE_BMESH_HOLES
391 for (lst = f->loops.first; lst; lst = lst->next)
395 #ifdef USE_BMESH_HOLES
396 l_iter = l_first = lst->first;
410 }
while ((l_iter = l_iter->
next) != l_first);
413 for (i = 0; i <
len; i++) {
423 const BMLoop *l_iter, *l_first;
425 l_iter = l_first =
e->l;
427 if (l_iter->
f == f) {
430 }
while ((l_iter = l_iter->
radial_next) != l_first);
448 if (l_other->
v ==
l->
v) {
451 else if (l_other->
next->
v ==
l->
v) {
452 l_other = l_other->
next;
465 if (
l->
e == e_prev) {
468 else if (
l->
prev->
e == e_prev) {
502 }
while (l_a != e_first->
l);
523 }
while (l_a != e_first->
l);
636 l_iter = l_first =
e->l;
639 }
while ((l_iter = l_iter->
radial_next) != l_first);
652 l_iter = l_first =
e->l;
655 if (
count == count_max) {
658 }
while ((l_iter = l_iter->
radial_next) != l_first);
677 const BMEdge *e_iter, *e_first;
678 e_first = e_iter =
v->
e;
680 if (e_iter->
l !=
NULL) {
693 e_first = e_iter =
v->
e;
707 BMEdge *e_iter, *e_first, *e_prev;
709 int loop_num = 0, loop_num_region = 0, boundary_num = 0;
717 e_first = e_iter =
v->
e;
729 if (e_iter->
l->
v ==
v) {
744 if (boundary_num == 3) {
750 e_first = l_first->
e;
751 l_first = (l_first->
v ==
v) ? l_first : l_first->
next;
758 loop_num_region += 1;
761 return (loop_num == loop_num_region);
764 #define LOOP_VISIT _FLAG_WALK
765 #define EDGE_VISIT _FLAG_WALK
775 l_iter = l_first =
e->l;
777 if (l_iter->
v ==
v) {
787 else if (l_iter->
next->
v ==
v) {
800 }
while ((l_iter = l_iter->
radial_next) != l_first);
811 e_iter = e_first =
l->
e;
816 l_iter = l_first = e_iter->
l;
818 if (l_iter->
v ==
l->
v) {
822 }
while ((l_iter = l_iter->
radial_next) != l_first);
834 *r_loop_total = count_total;
851 int count, count_total;
853 return (
count == count_total);
862 BMLoop *l2 =
e->l->radial_next;
876 const int cd_loop_type,
877 const int cd_loop_offset)
881 if (
e->l &&
e->l->radial_next !=
e->l) {
882 const BMLoop *l_base_v1 =
e->l;
883 const BMLoop *l_base_v2 =
e->l->next;
886 const BMLoop *l_iter =
e->l->radial_next;
890 const void *l_iter_cd_v1;
891 const void *l_iter_cd_v2;
893 if (l_iter->
v == l_base_v1->
v) {
895 l_iter_v2 = l_iter->
next;
898 l_iter_v1 = l_iter->
next;
901 BLI_assert((l_iter_v1->
v == l_base_v1->
v) && (l_iter_v2->
v == l_base_v2->
v));
921 e_first = e_iter =
v->
e;
979 }
while ((l_iter = l_iter->
next) != l_first);
994 }
while ((l_iter = l_iter->
next) != l_first);
1010 }
while ((l_iter = l_iter->
next) != l_first);
1025 }
while ((l_iter = l_iter->
next) != l_first);
1041 if (e1->
l && e2->
l) {
1049 }
while (
l != e1->
l);
1059 if (e1->
l && e2->
l) {
1069 }
while (
l != e1->
l);
1076 return (e1->
v1 == e2->
v1 || e1->
v1 == e2->
v2 || e1->
v2 == e2->
v1 || e1->
v2 == e2->
v2);
1107 if (l_iter->
v ==
v) {
1110 }
while ((l_iter = l_iter->
next) != l_first);
1120 l_iter = l_first =
e->l;
1122 if (l_iter->
f == f) {
1125 }
while ((l_iter = l_iter->
radial_next) != l_first);
1137 *r_v1 = edge_loop->
v;
1138 *r_v2 = edge_loop->
next->
v;
1153 l_step = l_step->
prev;
1170 l_step = l_step->
next;
1182 float e_dir_prev[3];
1183 float e_dir_next[3];
1206 float v1[3],
v2[3], v_tmp[3];
1210 const float fac = ((
v2[0] == 0.0f) ?
1211 ((
v2[1] == 0.0f) ? ((
v2[2] == 0.0f) ? 0.0f :
v1[2] /
v2[2]) :
1227 const float normal_fallback[3],
1228 float const (*vertexCos)[3],
1229 const float epsilon_sq,
1236 float v1[3],
v2[3], v_tmp[3];
1240 const float fac = ((
v2[0] == 0.0f) ?
1241 ((
v2[1] == 0.0f) ? ((
v2[2] == 0.0f) ? 0.0f :
v1[2] /
v2[2]) :
1262 const float normal_fallback[3],
1263 float const (*vertexCos)[3],
1312 if (
compare_v3v3(v_prev, v_next, FLT_EPSILON * 10.0f) ==
false) {
1333 const BMLoop *l2 =
e->l->radial_next;
1344 const float imat3[3][3],
1345 const float fallback)
1349 const BMLoop *l2 =
e->l->radial_next;
1350 float no1[3], no2[3];
1373 BMLoop *l2 =
e->l->radial_next;
1424 float accum_shell = 0.0f;
1425 float accum_angle = 0.0f;
1430 accum_angle += face_angle;
1433 if (accum_angle != 0.0f) {
1434 return accum_shell / accum_angle;
1442 float accum_shell = 0.0f;
1443 float accum_angle = 0.0f;
1444 int tot_sel = 0, tot = 0;
1450 accum_angle += face_angle;
1456 if (accum_angle != 0.0f) {
1457 return accum_shell / accum_angle;
1460 if (tot != 0 && tot_sel == 0) {
1490 float shortest_len = FLT_MAX;
1499 if (len_sq <= shortest_len) {
1500 shortest_loop = l_iter;
1501 shortest_len = len_sq;
1503 }
while ((l_iter = l_iter->
next) != l_first);
1505 return shortest_loop;
1511 float len_max_sq = 0.0f;
1520 if (len_sq >= len_max_sq) {
1521 longest_loop = l_iter;
1522 len_max_sq = len_sq;
1524 }
while ((l_iter = l_iter->
next) != l_first);
1526 return longest_loop;
1545 if (
e->v1 == v_b ||
e->v2 == v_b) {
1563 if ((e_a = v_a->
e) && (e_b = v_b->
e)) {
1564 BMEdge *e_a_iter = e_a, *e_b_iter = e_b;
1601 BMLoop *l_iter, *l_first;
1602 l_iter = l_first =
e->l;
1607 }
while ((l_iter = l_iter->
radial_next) != l_first);
1615 BMEdge *e_iter, *e_first;
1616 e_iter = e_first = varr[0]->
e;
1622 BMLoop *l_iter_radial, *l_first_radial;
1623 l_iter_radial = l_first_radial = e_iter->
l;
1626 if ((l_iter_radial->
v == varr[0]) && (l_iter_radial->
f->
len ==
len)) {
1631 if (l_iter_radial->
next->
v == varr[1]) {
1634 if (l_walk->
v != varr[i_walk]) {
1637 }
while ((
void)(l_walk = l_walk->
next), ++i_walk !=
len);
1639 else if (l_iter_radial->
prev->
v == varr[1]) {
1642 if (l_walk->
v != varr[i_walk]) {
1645 }
while ((
void)(l_walk = l_walk->
prev), ++i_walk !=
len);
1648 if (i_walk ==
len) {
1649 return l_iter_radial->
f;
1652 }
while ((l_iter_radial = l_iter_radial->
radial_next) != l_first_radial);
1664 if (l_iter->f->len == l_first->
f->
len) {
1665 if (l_iter->v == l_first->
v) {
1666 BMLoop *l_a = l_first, *
l_b = l_iter, *l_b_init = l_iter;
1668 if (l_a->
e !=
l_b->
e) {
1671 }
while (((
void)(l_a = l_a->
next), (
l_b =
l_b->
next)) != l_b_init);
1672 if (
l_b == l_b_init) {
1677 BMLoop *l_a = l_first, *
l_b = l_iter, *l_b_init = l_iter;
1679 if (l_a->
e !=
l_b->
e) {
1682 }
while (((
void)(l_a = l_a->
prev), (
l_b =
l_b->
next)) != l_b_init);
1683 if (
l_b == l_b_init) {
1705 for (i = 0; i <
len; i++) {
1723 for (i = 0; i <
len; i++) {
1732 for (i = 0; i <
len; i++) {
1764 for (i = 0; i <
len; i++) {
1772 int tot_face_tag = 0;
1779 if (tot_face_tag != 2) {
1793 for (i = 0; i <
len; i++) {
1823 for (i = 0; i <
len; i++) {
1830 for (i = 0; i <
len; i++) {
1844 for (; f_lnk; f_lnk = f_lnk->
next) {
1855 bool is_init =
false;
1856 bool is_overlap =
false;
1861 for (
int i = 0; i <
len; i++) {
1869 for (
int i = 0; i <
len; i++) {
1873 BMLoop *l_iter, *l_first;
1875 if (is_init ==
false) {
1877 for (
int j = 0; j <
len; j++) {
1889 }
while ((l_iter = l_iter->
next) != l_first);
1901 if (is_init ==
true) {
1902 for (
int i = 0; i <
len; i++) {
1907 for (; f_lnk; f_lnk = f_lnk->
next) {
1953 BMLoop *l_iter, *l_first;
1955 l_iter = l_first =
e->l;
1962 }
while ((l_iter = l_iter->
radial_next) != l_first);
1971 BMLoop *l_iter, *l_first;
1973 l_iter = l_first =
e->l;
1978 }
while ((l_iter = l_iter->
radial_next) != l_first);
1999 }
while ((l_iter = l_iter->
next) != l_first);
2013 }
while ((l_iter = l_iter->
next) != l_first);
2020 BMLoop *l_iter, *l_first;
2022 l_iter = l_first =
e->l;
2027 }
while ((l_iter = l_iter->
radial_next) != l_first);
2035 const float eps = 0.0001f;
2049 const int tottri = f->
len - 2;
2056 for (
int j = 0; j < tottri; j++) {
2057 const float *p1 = loops[index[j][0]]->
v->
co;
2058 const float *p2 = loops[index[j][1]]->
v->
co;
2059 const float *p3 = loops[index[j][2]]->
v->
co;
2074 return (1.0 / 6.0) * vol;
2087 if (is_signed ==
false) {
2095 int *r_groups_array,
2096 int (**r_group_index)[2],
2100 const char hflag_test,
2101 const char htype_step)
2106 int group_index_len = 1;
2108 int group_index_len = 32;
2111 int(*group_index)[2] =
MEM_mallocN(
sizeof(*group_index) * group_index_len, __func__);
2113 int *group_array = r_groups_array;
2148 stack =
MEM_mallocN(
sizeof(*stack) * tot_faces, __func__);
2152 while (tot_touch != tot_faces) {
2160 for (; f_next; f_next = BM_iter_step(&iter)) {
2173 if (group_index_len == group_curr) {
2174 group_index_len *= 2;
2175 group_index =
MEM_reallocN(group_index,
sizeof(*group_index) * group_index_len);
2178 group_item = group_index[group_curr];
2183 BMLoop *l_iter, *l_first;
2196 if ((l_radial_iter != l_iter) && ((filter_fn ==
NULL) || filter_fn(l_iter,
user_data))) {
2198 if ((filter_pair_fn ==
NULL) || filter_pair_fn(l_iter, l_radial_iter,
user_data)) {
2199 BMFace *f_other = l_radial_iter->
f;
2205 }
while ((l_radial_iter = l_radial_iter->
radial_next) != l_iter);
2207 }
while ((l_iter = l_iter->
next) != l_first);
2218 if ((filter_pair_fn ==
NULL) || filter_pair_fn(l_iter, l_other,
user_data)) {
2227 }
while ((l_iter = l_iter->
next) != l_first);
2237 if (group_index_len != group_curr) {
2238 group_index =
MEM_reallocN(group_index,
sizeof(*group_index) * group_curr);
2240 *r_group_index = group_index;
2246 int *r_groups_array,
2247 int (**r_group_index)[2],
2250 const char hflag_test)
2255 int group_index_len = 1;
2257 int group_index_len = 32;
2260 int(*group_index)[2] =
MEM_mallocN(
sizeof(*group_index) * group_index_len, __func__);
2262 int *group_array = r_groups_array;
2294 stack =
MEM_mallocN(
sizeof(*stack) * tot_edges, __func__);
2298 while (tot_touch != tot_edges) {
2306 for (; e_next; e_next = BM_iter_step(&iter)) {
2319 if (group_index_len == group_curr) {
2320 group_index_len *= 2;
2321 group_index =
MEM_reallocN(group_index,
sizeof(*group_index) * group_index_len);
2324 group_item = group_index[group_curr];
2359 if (group_index_len != group_curr) {
2360 group_index =
MEM_reallocN(group_index,
sizeof(*group_index) * group_curr);
2362 *r_group_index = group_index;
2405 if (v_stack_init->
e !=
NULL) {
2406 BMVert *v_iter = v_stack_init;
2408 BMEdge *e_iter, *e_first;
2409 e_iter = e_first = v_iter->
e;
2415 if (e_iter->
l !=
NULL) {
2416 BMLoop *l_iter, *l_first;
2417 l_iter = l_first = e_iter->
l;
2423 }
while ((l_iter = l_iter->
radial_next) != l_first);
2456 val = 3.0f * val * val - 2.0f * val * val * val;
2459 val =
sqrtf(2.0f * val - val * val);
2470 val = val * (2.0f - val);
typedef float(TangentPoint)[2]
CustomData interface, see also DNA_customdata_types.h.
bool CustomData_data_equals(int type, const void *data1, const void *data2)
#define BLI_array_alloca(arr, realsize)
#define BLI_linklist_prepend_alloca(listp, ptr)
MINLINE float shell_v3v3_normalized_to_dist(const float a[3], const float b[3])
float dist_signed_squared_to_plane_v3(const float p[3], const float plane[4])
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])
void mul_transposed_m3_v3(const float M[3][3], float r[3])
MINLINE bool compare_v3v3(const float a[3], const float b[3], float limit) ATTR_WARN_UNUSED_RESULT
MINLINE float len_squared_v3(const float v[3]) ATTR_WARN_UNUSED_RESULT
MINLINE float len_v3v3(const float a[3], const float b[3]) ATTR_WARN_UNUSED_RESULT
MINLINE float normalize_v3(float r[3])
MINLINE void sub_v3_v3(float r[3], const float a[3])
MINLINE float len_squared_v3v3(const float a[3], const float b[3]) ATTR_WARN_UNUSED_RESULT
MINLINE void sub_v3_v3v3(float r[3], const float a[3], const float b[3])
MINLINE void copy_v3_v3(float r[3], const float a[3])
MINLINE double dot_v3v3_db(const double a[3], const double b[3]) ATTR_WARN_UNUSED_RESULT
MINLINE bool is_zero_v3(const float a[3]) ATTR_WARN_UNUSED_RESULT
MINLINE float dot_v3v3(const float a[3], const float b[3]) ATTR_WARN_UNUSED_RESULT
MINLINE void add_v3_v3v3(float r[3], const float a[3], const float b[3])
MINLINE void cross_v3_v3v3(float r[3], const float a[3], const float b[3])
MINLINE void negate_v3(float r[3])
MINLINE void copy_v3db_v3fl(double r[3], const float a[3])
MINLINE void cross_v3_v3v3_db(double r[3], const double a[3], const double b[3])
MINLINE bool equals_v3v3(const float a[3], const float b[3]) ATTR_WARN_UNUSED_RESULT
float angle_v3v3v3(const float a[3], const float b[3], const float c[3]) ATTR_WARN_UNUSED_RESULT
MINLINE void mul_v3_v3fl(float r[3], const float a[3], float f)
float angle_normalized_v3v3(const float v1[3], const float v2[3]) ATTR_WARN_UNUSED_RESULT
#define UNUSED_VARS_NDEBUG(...)
#define STACK_PUSH(stack, val)
#define STACK_DECLARE(stack)
#define STACK_SIZE(stack)
#define STACK_INIT(stack, stack_num)
#define STACK_PUSH_RET(stack)
_GL_VOID GLfloat value _GL_VOID_RET _GL_VOID const GLuint GLboolean *residences _GL_BOOL_RET _GL_VOID GLsizei GLfloat GLfloat GLfloat GLfloat const GLubyte *bitmap _GL_VOID_RET _GL_VOID GLenum const void *lists _GL_VOID_RET _GL_VOID const GLdouble *equation _GL_VOID_RET _GL_VOID GLdouble GLdouble blue _GL_VOID_RET _GL_VOID GLfloat GLfloat blue _GL_VOID_RET _GL_VOID GLint GLint blue _GL_VOID_RET _GL_VOID GLshort GLshort blue _GL_VOID_RET _GL_VOID GLubyte GLubyte blue _GL_VOID_RET _GL_VOID GLuint GLuint blue _GL_VOID_RET _GL_VOID GLushort GLushort blue _GL_VOID_RET _GL_VOID GLbyte GLbyte GLbyte alpha _GL_VOID_RET _GL_VOID GLdouble GLdouble GLdouble alpha _GL_VOID_RET _GL_VOID GLfloat GLfloat GLfloat alpha _GL_VOID_RET _GL_VOID GLint GLint GLint alpha _GL_VOID_RET _GL_VOID GLshort GLshort GLshort alpha _GL_VOID_RET _GL_VOID GLubyte GLubyte GLubyte alpha _GL_VOID_RET _GL_VOID GLuint GLuint GLuint alpha _GL_VOID_RET _GL_VOID GLushort GLushort GLushort alpha _GL_VOID_RET _GL_VOID GLenum mode _GL_VOID_RET _GL_VOID GLint GLsizei GLsizei GLenum type _GL_VOID_RET _GL_VOID GLsizei GLenum GLenum const void *pixels _GL_VOID_RET _GL_VOID const void *pointer _GL_VOID_RET _GL_VOID GLdouble v _GL_VOID_RET _GL_VOID GLfloat v _GL_VOID_RET _GL_VOID GLint GLint i2 _GL_VOID_RET _GL_VOID GLint j _GL_VOID_RET _GL_VOID GLfloat param _GL_VOID_RET _GL_VOID GLint param _GL_VOID_RET _GL_VOID GLdouble GLdouble GLdouble GLdouble GLdouble zFar _GL_VOID_RET _GL_UINT GLdouble *equation _GL_VOID_RET _GL_VOID GLenum GLint *params _GL_VOID_RET _GL_VOID GLenum GLfloat *v _GL_VOID_RET _GL_VOID GLenum GLfloat *params _GL_VOID_RET _GL_VOID GLfloat *values _GL_VOID_RET _GL_VOID GLushort *values _GL_VOID_RET _GL_VOID GLenum GLfloat *params _GL_VOID_RET _GL_VOID GLenum GLdouble *params _GL_VOID_RET _GL_VOID GLenum GLint *params _GL_VOID_RET _GL_VOID GLsizei const void *pointer _GL_VOID_RET _GL_VOID GLsizei const void *pointer _GL_VOID_RET _GL_BOOL GLfloat param _GL_VOID_RET _GL_VOID GLint param _GL_VOID_RET _GL_VOID GLenum GLfloat param _GL_VOID_RET _GL_VOID GLenum GLint param _GL_VOID_RET _GL_VOID GLushort pattern _GL_VOID_RET _GL_VOID GLdouble GLdouble GLint GLint const GLdouble *points _GL_VOID_RET _GL_VOID GLdouble GLdouble GLint GLint GLdouble v1
Read Guarded memory(de)allocation.
#define MEM_reallocN(vmemh, len)
bool(* BMVertFilterFunc)(const BMVert *, void *user_data)
#define BM_DISK_EDGE_NEXT(e, v)
bool(* BMLoopFilterFunc)(const BMLoop *, void *user_data)
#define BM_FACE_FIRST_LOOP(p)
bool(* BMLoopPairFilterFunc)(const BMLoop *, const BMLoop *, void *user_data)
#define BM_ELEM_CD_GET_VOID_P(ele, offset)
bool BM_verts_from_edges(BMVert **vert_arr, BMEdge **edge_arr, const int len)
#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)
ATTR_WARN_UNUSED_RESULT BMesh * bm
void BM_mesh_elem_hflag_disable_all(BMesh *bm, const char htype, const char hflag, const bool respecthide)
float BM_face_calc_normal_subset(const BMLoop *l_first, const BMLoop *l_last, float r_no[3])
float BM_face_calc_normal(const BMFace *f, float r_no[3])
BMESH UPDATE FACE NORMAL.
void BM_face_calc_tessellation(const BMFace *f, const bool use_fixed_quad, BMLoop **r_loops, uint(*r_index)[3])
#define BM_ELEM_API_FLAG_DISABLE(element, f)
#define BM_ELEM_API_FLAG_TEST(element, f)
int bmesh_disk_count_at_most(const BMVert *v, int count_max)
#define BM_ELEM_API_FLAG_ENABLE(element, f)
int bmesh_disk_count(const BMVert *v)
BMLoop * BM_face_other_edge_loop(BMFace *f, BMEdge *e, BMVert *v)
Other Loop in Face Sharing an Edge.
bool BM_face_share_face_check(BMFace *f_a, BMFace *f_b)
float BM_vert_calc_edge_angle(const BMVert *v)
int BM_mesh_calc_edge_groups_as_arrays(BMesh *bm, BMVert **verts, BMEdge **edges, BMFace **faces, int(**r_groups)[3])
BMEdge * BM_edge_exists(BMVert *v_a, BMVert *v_b)
float BM_loop_calc_face_normal_safe(const BMLoop *l, float r_normal[3])
int BM_edge_face_count_at_most(const BMEdge *e, const int count_max)
float BM_loop_point_side_of_loop_test(const BMLoop *l, const float co[3])
void BM_edge_ordered_verts_ex(const BMEdge *edge, BMVert **r_v1, BMVert **r_v2, const BMLoop *edge_loop)
BMLoop * BM_vert_find_first_loop_visible(BMVert *v)
bool BM_vert_is_wire(const BMVert *v)
bool BM_edge_is_contiguous_loop_cd(const BMEdge *e, const int cd_loop_type, const int cd_loop_offset)
bool BM_edge_is_all_face_flag_test(const BMEdge *e, const char hflag, const bool respect_hide)
BMLoop * BM_loop_find_next_nodouble(BMLoop *l, BMLoop *l_stop, const float eps_sq)
void BM_edge_ordered_verts(const BMEdge *edge, BMVert **r_v1, BMVert **r_v2)
bool BM_edge_share_quad_check(BMEdge *e1, BMEdge *e2)
int BM_vert_edge_count_at_most(const BMVert *v, const int count_max)
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)
BMLoop * BM_face_other_vert_loop(BMFace *f, BMVert *v_prev, BMVert *v)
Other Loop in Face Sharing a Vertex.
BMEdge * BM_edge_find_double(BMEdge *e)
float BM_edge_calc_face_angle(const BMEdge *e)
bool BM_face_exists_multi(BMVert **varr, BMEdge **earr, int len)
bool BM_vert_pair_share_face_check(BMVert *v_a, BMVert *v_b)
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)
float BM_vert_calc_shell_factor_ex(const BMVert *v, const float no[3], const char hflag)
bool BM_edge_in_face(const BMEdge *e, const BMFace *f)
BMEdge * BM_vert_other_disk_edge(BMVert *v, BMEdge *e_first)
bool BM_face_is_any_edge_flag_test(const BMFace *f, const char hflag)
float BM_loop_calc_face_normal_safe_vcos(const BMLoop *l, const float normal_fallback[3], float const (*vertexCos)[3], float r_normal[3])
BMLoop * BM_vert_find_first_loop(BMVert *v)
bool BM_edge_is_any_face_len_test(const BMEdge *e, const int len)
bool BM_face_exists_multi_edge(BMEdge **earr, int len)
bool BM_loop_share_edge_check(BMLoop *l_a, BMLoop *l_b)
bool BM_face_is_any_vert_flag_test(const BMFace *f, const char hflag)
float BM_vert_calc_median_tagged_edge_length(const BMVert *v)
bool BM_face_share_edge_check(BMFace *f1, BMFace *f2)
static int bm_loop_region_count__recursive(BMEdge *e, BMVert *v)
bool BM_vert_is_manifold_region(const BMVert *v)
void BM_loop_calc_face_tangent(const BMLoop *l, float r_tangent[3])
BM_loop_calc_face_tangent.
BMFace * BM_face_find_double(BMFace *f)
bool BM_edge_loop_pair(BMEdge *e, BMLoop **r_la, BMLoop **r_lb)
bool BM_vert_is_all_edge_flag_test(const BMVert *v, const char hflag, const bool respect_hide)
bool BM_vert_is_manifold(const BMVert *v)
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])
int BM_face_share_vert_count(BMFace *f_a, BMFace *f_b)
int BM_face_share_edge_count(BMFace *f_a, BMFace *f_b)
bool BM_face_share_vert_check(BMFace *f_a, BMFace *f_b)
float BM_edge_calc_face_angle_with_imat3_ex(const BMEdge *e, const float imat3[3][3], const float fallback)
BMESH EDGE/FACE ANGLE.
float BM_edge_calc_length_squared(const BMEdge *e)
bool BM_edge_face_pair(BMEdge *e, BMFace **r_fa, BMFace **r_fb)
float BM_edge_calc_face_angle_signed(const BMEdge *e)
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_loop_find_prev_nodouble(BMLoop *l, BMLoop *l_stop, const float eps_sq)
float bmesh_subd_falloff_calc(const int falloff, float val)
bool BM_edge_share_vert_check(BMEdge *e1, BMEdge *e2)
float BM_vert_calc_shell_factor(const BMVert *v)
BMLoop * BM_face_edge_share_loop(BMFace *f, BMEdge *e)
Return the Loop Shared by Face and Edge.
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)
bool BM_face_is_normal_valid(const BMFace *f)
bool BM_vert_edge_pair(BMVert *v, BMEdge **r_e_a, BMEdge **r_e_b)
int BM_vert_face_count(const BMVert *v)
int BM_edge_face_count(const BMEdge *e)
float BM_vert_calc_edge_angle_ex(const BMVert *v, const float fallback)
BMESH VERT/EDGE ANGLE.
bool BM_verts_in_face(BMVert **varr, int len, BMFace *f)
BMVert * BM_edge_share_vert(BMEdge *e1, BMEdge *e2)
static float bm_face_calc_split_dot(BMLoop *l_a, BMLoop *l_b)
void BM_loop_calc_face_direction(const BMLoop *l, float r_dir[3])
BM_loop_calc_face_direction.
BMFace * BM_face_exists(BMVert **varr, int len)
bool BM_edge_share_face_check(BMEdge *e1, BMEdge *e2)
int BM_loop_region_loops_count(BMLoop *l)
BMLoop * BM_loop_other_vert_loop(BMLoop *l, BMVert *v)
Other Loop in Face Sharing a Vert.
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_loop_region_loops_count_at_most(BMLoop *l, int *r_loop_total)
BMLoop * BM_edge_vert_share_loop(BMLoop *l, BMVert *v)
Return the Loop Shared by Edge and Vert.
bool BM_vert_in_face(BMVert *v, BMFace *f)
bool BM_edge_is_any_vert_flag_test(const BMEdge *e, const char hflag)
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)
BMLoop * BM_loop_other_vert_loop_by_edge(BMLoop *l, BMEdge *e)
float BM_edge_calc_length(const BMEdge *e)
BMFace * BM_face_exists_overlap(BMVert **varr, const int len)
float BM_edge_calc_face_angle_ex(const BMEdge *e, const float fallback)
BMESH EDGE/FACE ANGLE.
int BM_vert_edge_count(const BMVert *v)
BMLoop * BM_face_find_shortest_loop(BMFace *f)
bool BM_loop_is_convex(const BMLoop *l)
BMLoop * BM_edge_other_loop(BMEdge *e, BMLoop *l)
double BM_mesh_calc_volume(BMesh *bm, bool is_signed)
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)
static int bm_loop_region_count__clear(BMLoop *l)
BMLoop * BM_edge_find_first_loop_visible(BMEdge *e)
float BM_edge_calc_face_angle_with_imat3(const BMEdge *e, const float imat3[3][3])
float BM_loop_calc_face_angle(const BMLoop *l)
BMLoop * BM_vert_step_fan_loop(BMLoop *l, BMEdge **e_step)
bool BM_vert_face_check(const BMVert *v)
static double bm_mesh_calc_volume_face(const BMFace *f)
bool BM_vert_is_edge_pair(const BMVert *v)
int BM_vert_face_count_at_most(const BMVert *v, int count_max)
float BM_edge_calc_face_angle_signed_ex(const BMEdge *e, const float fallback)
BMESH EDGE/FACE ANGLE.
bool BM_vert_is_edge_pair_manifold(const BMVert *v)
int BM_face_share_face_count(BMFace *f_a, BMFace *f_b)
BMLoop * BM_loop_other_edge_loop(BMLoop *l, BMVert *v)
void BM_edge_calc_face_tangent(const BMEdge *e, const BMLoop *e_loop, float r_tangent[3])
BMESH EDGE/FACE TANGENT.
float BM_loop_calc_face_normal(const BMLoop *l, float r_normal[3])
BM_loop_calc_face_normal.
bool BM_vert_is_boundary(const BMVert *v)
int BM_vert_edge_count_nonwire(const BMVert *v)
bool BM_edge_is_convex(const BMEdge *e)
bool BM_vert_is_all_face_flag_test(const BMVert *v, const char hflag, const bool respect_hide)
int BM_verts_in_face_count(BMVert **varr, int len, BMFace *f)
BMLoop * BM_face_find_longest_loop(BMFace *f)
bool BM_edge_is_any_face_flag_test(const BMEdge *e, const char hflag)
BMLoop * BM_face_vert_share_loop(BMFace *f, BMVert *v)
Return the Loop Shared by Face and Vertex.
bool BM_face_exists_overlap_subset(BMVert **varr, const int len)
float BM_loop_point_side_of_edge_test(const BMLoop *l, const float co[3])
bool BM_vert_pair_share_face_check_cb(BMVert *v_a, BMVert *v_b, bool(*test_fn)(BMFace *, void *user_data), void *user_data)
BLI_INLINE bool BM_edge_is_manifold(const BMEdge *e) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL()
BLI_INLINE bool BM_edge_is_boundary(const BMEdge *e) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL()
BLI_INLINE bool BM_loop_is_adjacent(const BMLoop *l_a, const BMLoop *l_b) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL()
BLI_INLINE BMVert * BM_edge_other_vert(BMEdge *e, const BMVert *v) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL()
BLI_INLINE bool BM_vert_in_edge(const BMEdge *e, const BMVert *v) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL()
ATTR_WARN_UNUSED_RESULT const BMVert * v2
ATTR_WARN_UNUSED_RESULT const BMLoop * l
ATTR_WARN_UNUSED_RESULT const BMVert const BMEdge * e
ATTR_WARN_UNUSED_RESULT const BMLoop * l_b
ATTR_WARN_UNUSED_RESULT const BMVert * v
BMLoop * bmesh_disk_faceloop_find_first_visible(const BMEdge *e, const BMVert *v)
BMLoop * bmesh_disk_faceloop_find_first(const BMEdge *e, const BMVert *v)
int bmesh_disk_facevert_count(const BMVert *v)
DISK COUNT FACE VERT.
int bmesh_disk_facevert_count_at_most(const BMVert *v, const int count_max)
BLI_INLINE BMEdge * bmesh_disk_edge_next(const BMEdge *e, const BMVert *v) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL()
SIMD_FORCE_INLINE btScalar angle(const btVector3 &v) const
Return the angle between this and another vector.
DEGForeachIDComponentCallback callback
SyclQueue void void size_t num_bytes void
void(* MEM_freeN)(void *vmemh)
void *(* MEM_mallocN)(size_t len, const char *str)
ccl_device_inline float2 fabs(const float2 &a)
T dot(const vec_base< T, Size > &a, const vec_base< T, Size > &b)
vec_base< T, 3 > cross(const vec_base< T, 3 > &a, const vec_base< T, 3 > &b)
T length(const vec_base< T, Size > &a)
static const pxr::TfToken g("g", pxr::TfToken::Immortal)
struct BMLoop * radial_next