40 const float *v_prev = l_first->
prev->
v->
co;
41 const float *v_curr = l_first->
v->
co;
49 l_iter = l_iter->
next;
51 v_curr = l_iter->
v->
co;
53 }
while (l_iter != l_first);
66 float const (*vertexCos)[3])
79 l_iter = l_iter->
next;
82 }
while (l_iter != l_first);
92 float const (*vertexCos)[3])
94 const BMLoop *l_first, *l_iter;
102 }
while ((l_iter = l_iter->
next) != l_first);
107 const bool use_fixed_quad,
115 *r_loops++ = (l_iter = l_first);
116 *r_loops++ = (l_iter = l_iter->
next);
117 *r_loops++ = (l_iter->
next);
123 else if (f->
len == 4 && use_fixed_quad) {
124 *r_loops++ = (l_iter = l_first);
125 *r_loops++ = (l_iter = l_iter->
next);
126 *r_loops++ = (l_iter = l_iter->
next);
127 *r_loops++ = (l_iter->
next);
138 float axis_mat[3][3];
150 }
while ((l_iter = l_iter->
next) != l_first);
168 const int tottri = f->
len - 2;
173 float area_best = -1.0f;
177 for (j = 0; j < tottri; j++) {
178 const float *p1 = loops[index[j][0]]->
v->
co;
179 const float *p2 = loops[index[j][1]]->
v->
co;
180 const float *p3 = loops[index[j][2]]->
v->
co;
182 if (
area > area_best) {
189 l_tri, loops[index[j_best][0]], loops[index[j_best][1]], loops[index[j_best][2]]);
198 const BMLoop *l_iter, *l_first;
205 }
while ((l_iter = l_iter->
next) != l_first);
212 const BMLoop *l_iter, *l_first;
224 }
while ((l_iter = l_iter->
next) != l_first);
231 const BMLoop *l_iter, *l_first;
239 cross += (luv_next->
uv[0] - luv->
uv[0]) * (luv_next->
uv[1] + luv->
uv[1]);
240 }
while ((l_iter = l_iter->
next) != l_first);
246 const BMLoop *l_iter, *l_first;
247 float perimeter = 0.0f;
252 }
while ((l_iter = l_iter->
next) != l_first);
259 const BMLoop *l_iter, *l_first;
261 float perimeter = 0.0f;
270 }
while ((l_iter = l_iter->
next) != l_first);
286 for (
int i_prev = 1, i_curr = 2, i_next = 0; i_next < 3; i_prev = i_curr, i_curr = i_next++) {
287 const float *co =
verts[i_curr]->co;
288 const float *co_other[2] = {
verts[i_prev]->co,
verts[i_next]->co};
293 float proj_pair[2][3];
299 const float lens[3] = {
304 const float difs[3] = {
305 fabsf(lens[1] - lens[2]),
306 fabsf(lens[2] - lens[0]),
307 fabsf(lens[0] - lens[1]),
311 int order[3] = {0, 1, 2};
330 const float *v_a =
verts[index]->co;
331 const float *v_b =
verts[(index + 1) % 3]->co;
332 const float *v_other =
verts[(index + 2) % 3]->co;
358 else if (f->
len == 4) {
361 float vec[3], vec_a[3], vec_b[3];
382 float len_max_sq = 0.0f;
383 float vec_a[3], vec_b[3];
390 if (len_sq >= len_max_sq) {
391 l_long_other = l_iter;
394 }
while ((l_iter = l_iter->
prev) != l_last);
419 float dist_max_sq = 0.0f;
425 float co_other[3], vec[3];
427 co_other, l_iter->
v->
co, l_iter_other->
v->
co, l_iter_other->
next->
v->
co);
431 if (dist_sq > dist_max_sq) {
432 dist_max_sq = dist_sq;
435 }
while ((l_iter_other = l_iter_other->
next) != l_iter_last);
436 }
while ((l_iter = l_iter->
next) != l_first);
451 float dist_max_sq = 0.0f;
459 if (dist_sq > dist_max_sq) {
460 dist_max_sq = dist_sq;
463 }
while ((l_iter_other = l_iter_other->
next) != l_iter);
464 }
while ((l_iter = l_iter->
next) != l_first);
477 else if (f->
len == 4) {
489 const BMLoop *l_iter, *l_first;
493 }
while ((l_iter = l_iter->
next) != l_first);
498 const BMLoop *l_iter, *l_first;
506 }
while ((l_iter = l_iter->
next) != l_first);
514 float const (*vertexCos)[3])
520 const BMLoop *l_iter, *l_first;
528 }
while ((l_iter = l_iter->
next) != l_first);
535 const BMLoop *l_iter, *l_first;
542 }
while ((l_iter = l_iter->
next) != l_first);
559 const float w = (w_curr + w_prev);
563 }
while ((l_iter = l_iter->
next) != l_first);
579 for (i = 0; i < nverts; i++) {
600 float vec1[3], vec2[3], fac;
711 const float *co2 = (
l =
l->
next)->v->co;
713 const float *co4 = (
l->
next)->v->co;
719 const float *co2 = (
l =
l->
next)->v->co;
720 const float *co3 = (
l->
next)->
v->
co;
737 float const (*vertexCos)[3])
769 BMVert **varr,
int varr_len,
float r_normal[3],
float r_center[3],
int *r_index_tangent)
771 const float varr_len_inv = 1.0f / (
float)varr_len;
774 float center[3] = {0.0f, 0.0f, 0.0f};
775 for (
int i = 0; i < varr_len; i++) {
781 const float *co_a =
NULL;
783 float dist_sq_max = -1.0f;
784 for (
int i = 0; i < varr_len; i++) {
786 if (!(dist_sq_test <= dist_sq_max)) {
789 dist_sq_max = dist_sq_test;
798 const float *co_b =
NULL;
799 float dir_b[3] = {0.0f, 0.0f, 0.0f};
801 float dist_sq_max = -1.0f;
802 for (
int i = 0; i < varr_len; i++) {
803 if (varr[i]->co == co_a) {
810 if (!(dist_sq_test <= dist_sq_max)) {
812 dist_sq_max = dist_sq_test;
825 const float *co_a_opposite =
NULL;
826 const float *co_b_opposite =
NULL;
829 float dot_a_min = FLT_MAX;
830 float dot_b_min = FLT_MAX;
831 for (
int i = 0; i < varr_len; i++) {
832 const float *co_test = varr[i]->
co;
835 if (co_test != co_a) {
836 dot_test =
dot_v3v3(dir_a, co_test);
837 if (dot_test < dot_a_min) {
838 dot_a_min = dot_test;
839 co_a_opposite = co_test;
843 if (co_test != co_b) {
844 dot_test =
dot_v3v3(dir_b, co_test);
845 if (dot_test < dot_b_min) {
846 dot_b_min = dot_test;
847 co_b_opposite = co_test;
853 normal_quad_v3(r_normal, co_a, co_b, co_a_opposite, co_b_opposite);
856 if (r_center !=
NULL) {
859 if (r_index_tangent !=
NULL) {
860 *r_index_tangent = co_a_index;
871 const float *v_prev, *v_curr;
874 const BMLoop *l_iter = l_first;
879 v_prev = l_last->
v->
co;
881 v_curr = l_iter->
v->
co;
884 }
while ((l_iter = l_iter->
next) != l_term);
892 float const (*vertexCos)[3])
903 const int cd_loop_mdisp_offset,
904 const bool use_loop_mdisp_flip)
918 float axis_mat[3][3];
941 int *r_faces_new_tot,
943 int *r_edges_new_tot,
945 const int quad_method,
946 const int ngon_method,
952 struct Heap *pf_heap)
971 const int totfilltri = f->
len - 2;
972 const int last_tri = f->
len - 3;
984 switch (quad_method) {
991 l_v1 = l_first->
next;
992 l_v2 = l_first->
prev;
1002 l_v1 = l_first->
next;
1004 l_v3 = l_first->
prev;
1011 split_24 = ((d2 - d1) > 0.0f);
1017 split_24 = ((d2 - d1) < 0.0f);
1023 if (
UNLIKELY(flip_flag & (1 << 0))) {
1026 else if (
UNLIKELY(flip_flag & (1 << 1))) {
1049 loops[1] = l_v1->
next;
1051 loops[3] = l_v2->
next;
1058 float axis_mat[3][3];
1077 if (cd_loop_mdisp_offset != -1) {
1082 for (i = 0; i < totfilltri; i++) {
1083 BMLoop *l_tri[3] = {loops[tris[i][0]], loops[tris[i][1]], loops[tris[i][2]]};
1085 BMVert *v_tri[3] = {l_tri[0]->
v, l_tri[1]->
v, l_tri[2]->
v};
1101 }
while ((l_iter = l_iter->
radial_next) != l_new);
1110 if (i != last_tri) {
1115 r_faces_new[nf_i++] = f_new;
1119 if (use_tag || r_edges_new) {
1123 l_iter = l_first = l_new;
1128 bool is_new_edge = (l_iter == l_iter->
radial_next);
1135 r_edges_new[ne_i++] =
e;
1139 }
while ((l_iter = l_iter->
next) != l_first);
1142 if (cd_loop_mdisp_offset != -1) {
1143 float f_new_center[3];
1158 if (r_faces_new_tot) {
1159 *r_faces_new_tot = nf_i;
1162 if (r_edges_new_tot) {
1163 *r_edges_new_tot = ne_i;
1169 float out[2] = {-FLT_MAX, -FLT_MAX};
1170 float center[2] = {0.0f, 0.0f};
1171 float axis_mat[3][3];
1207 for (i = 0; i <
len; i++) {
1213 for (i = 0; i <
len; i++) {
1215 mid_v2_v2v2(mid, edgeverts[i][0], edgeverts[i][1]);
1219 for (j = 0, j_prev = f->
len - 1; j < f->
len; j_prev = j++) {
1220 const float *f_edge[2] = {projverts[j_prev], projverts[j]};
1226 if (isect % 2 == 0) {
1231 #define EDGE_SHARE_VERT(e1, e2) \
1232 ((ELEM((e1)[0], (e2)[0], (e2)[1])) || (ELEM((e1)[1], (e2)[0], (e2)[1])))
1235 for (i = 0, i_prev = f->
len - 1; i < f->
len; i_prev = i++) {
1236 const float *f_edge[2] = {projverts[i_prev], projverts[i]};
1237 for (j = 0; j <
len; j++) {
1247 for (i = 0; i <
len; i++) {
1249 for (j = i + 1; j <
len; j++) {
1261 #undef EDGE_SHARE_VERT
1268 for (i = 0; i <
len; i++) {
1269 BMLoop *l_a_dummy, *l_b_dummy;
1271 loops[i][0]->
v, loops[i][1]->
v, &l_a_dummy, &l_b_dummy,
false)) {
typedef float(TangentPoint)[2]
CustomData interface, see also DNA_customdata_types.h.
int CustomData_get_offset(const struct CustomData *data, int type)
#define BLI_array_alloca(arr, realsize)
A min-heap / priority queue ADT.
void void BLI_linklist_prepend(LinkNode **listp, void *ptr) ATTR_NONNULL(1)
MINLINE float saacos(float fac)
MINLINE float max_ff(float a, float b)
int isect_seg_seg_v2(const float v1[2], const float v2[2], const float v3[2], const float v4[2])
float normal_quad_v3(float n[3], const float v1[3], const float v2[3], const float v3[3], const float v4[3])
int is_quad_flip_v3(const float v1[3], const float v2[3], const float v3[3], const float v4[3])
float closest_to_line_segment_v3(float r_close[3], const float p[3], const float l1[3], const float l2[3])
void axis_dominant_v3_to_m3_negate(float r_mat[3][3], const float normal[3])
void axis_dominant_v3_to_m3(float r_mat[3][3], const float normal[3])
Normal to x,y matrix.
float area_squared_tri_v3(const float v1[3], const float v2[3], const float v3[3])
bool is_poly_convex_v2(const float verts[][2], unsigned int nr)
float normal_tri_v3(float n[3], const float v1[3], const float v2[3], const float v3[3])
bool isect_point_poly_v2(const float pt[2], const float verts[][2], unsigned int nr, bool use_holes)
#define ISECT_LINE_LINE_CROSS
void mul_v2_m3v3(float r[2], const float M[3][3], const float a[3])
void mul_v3_m3v3(float r[3], const float M[3][3], const float a[3])
void axis_sort_v3(const float axis_values[3], int r_axis_order[3])
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
void minmax_v3v3_v3(float min[3], float max[3], const float vec[3])
MINLINE void madd_v3_v3fl(float r[3], const float a[3], float f)
MINLINE void sub_v2_v2(float r[2], const float a[2])
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 add_newell_cross_v3_v3v3(float n[3], const float v_prev[3], const float v_curr[3])
MINLINE void sub_v3_v3v3(float r[3], const float a[3], const float b[3])
MINLINE void mul_v2_fl(float r[2], float f)
MINLINE void mul_v3_fl(float r[3], float f)
MINLINE void copy_v3_v3(float r[3], const float a[3])
void project_v3_v3v3(float out[3], const float p[3], const float v_proj[3])
MINLINE void add_v2_v2(float r[2], const float a[2])
void project_plane_normalized_v3_v3v3(float out[3], const float p[3], const float v_plane[3])
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 add_v2_fl(float r[2], float f)
MINLINE void negate_v3(float r[3])
void mid_v2_v2v2(float r[2], const float a[2], const float b[2])
MINLINE float normalize_v3_v3(float r[3], const float a[3])
void mid_v3_v3v3(float r[3], const float a[3], const float b[3])
MINLINE void zero_v3(float r[3])
MINLINE void add_v3_v3(float r[3], const float a[3])
void mid_v3_v3v3v3(float v[3], const float v1[3], const float v2[3], const float v3[3])
MINLINE float len_v3(const float a[3]) ATTR_WARN_UNUSED_RESULT
void void BLI_memarena_clear(MemArena *ma) ATTR_NONNULL(1)
void BLI_polyfill_calc(const float(*coords)[2], unsigned int coords_num, int coords_sign, unsigned int(*r_tris)[3])
void BLI_polyfill_calc_arena(const float(*coords)[2], unsigned int coords_num, int coords_sign, unsigned int(*r_tris)[3], struct MemArena *arena)
void BLI_polyfill_beautify(const float(*coords)[2], unsigned int coords_num, unsigned int(*tris)[3], struct MemArena *arena, struct Heap *eheap)
#define INIT_MINMAX(min, max)
#define ARRAY_SET_ITEMS(...)
These structs are the foundation for all linked lists in the library system.
@ MOD_TRIANGULATE_NGON_BEAUTY
@ MOD_TRIANGULATE_QUAD_SHORTEDGE
@ MOD_TRIANGULATE_QUAD_FIXED
@ MOD_TRIANGULATE_QUAD_LONGEDGE
@ MOD_TRIANGULATE_QUAD_BEAUTY
@ MOD_TRIANGULATE_QUAD_ALTERNATE
NSNotificationCenter * center
_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 order
Read Guarded memory(de)allocation.
float BM_verts_calc_rotate_beauty(const BMVert *v1, const BMVert *v2, const BMVert *v3, const BMVert *v4, const short flag, const short method)
#define BM_FACE_FIRST_LOOP(p)
#define BM_ELEM_CD_GET_VOID_P(ele, offset)
void BM_elem_attrs_copy(BMesh *bm_src, BMesh *bm_dst, const void *ele_src, void *ele_dst)
void bmesh_face_swap_data(BMFace *f_a, BMFace *f_b)
BMFace * BM_face_create_verts(BMesh *bm, BMVert **vert_arr, const int len, const BMFace *f_example, const eBMCreateFlag create_flag, const bool create_edges)
void BM_face_kill(BMesh *bm, BMFace *f)
void bmesh_kernel_loop_reverse(BMesh *bm, BMFace *f, const int cd_loop_mdisp_offset, const bool use_loop_mdisp_flip)
Loop Reverse.
#define BM_elem_index_get(ele)
#define BM_elem_index_set(ele, index)
#define BM_elem_flag_test(ele, hflag)
#define BM_elem_flag_enable(ele, hflag)
void BM_face_interp_multires_ex(BMesh *bm, BMFace *f_dst, const BMFace *f_src, const float f_dst_center[3], const float f_src_center[3], const int cd_loop_mdisp_offset)
#define BM_ITER_ELEM(ele, iter, data, itype)
ATTR_WARN_UNUSED_RESULT BMesh * bm
void BM_face_calc_tangent_edge_pair(const BMFace *f, float r_tangent[3])
void BM_face_as_array_loop_tri(BMFace *f, BMLoop *r_loops[3])
float BM_face_calc_area_uv(const BMFace *f, int cd_loop_uv_offset)
void poly_rotate_plane(const float normal[3], float(*verts)[3], const uint nverts)
POLY ROTATE PLANE.
void BM_face_splits_check_optimal(BMFace *f, BMLoop *(*loops)[2], int len)
void BM_face_calc_center_bounds(const BMFace *f, float r_cent[3])
void BM_vert_normal_update(BMVert *v)
void BM_face_splits_check_legal(BMesh *bm, BMFace *f, BMLoop *(*loops)[2], int len)
void BM_face_calc_tangent_vert_diagonal(const BMFace *f, float r_tangent[3])
void BM_face_as_array_vert_quad(BMFace *f, BMVert *r_verts[4])
void BM_face_triangulate(BMesh *bm, BMFace *f, BMFace **r_faces_new, int *r_faces_new_tot, BMEdge **r_edges_new, int *r_edges_new_tot, LinkNode **r_faces_double, const int quad_method, const int ngon_method, const bool use_tag, MemArena *pf_arena, struct Heap *pf_heap)
static int bm_vert_tri_find_unique_edge(BMVert *verts[3])
float BM_face_calc_area_with_mat3(const BMFace *f, const float mat3[3][3])
void BM_face_calc_point_in_face(const BMFace *f, float r_co[3])
void BM_verts_calc_normal_from_cloud(BMVert **varr, int varr_len, float r_normal[3])
bool BM_face_point_inside_test(const BMFace *f, const float co[3])
bool BM_vert_calc_normal(const BMVert *v, float r_no[3])
void BM_face_calc_tangent_edge_diagonal(const BMFace *f, float r_tangent[3])
static float bm_face_calc_poly_normal_vertex_cos(const BMFace *f, float r_no[3], float const (*vertexCos)[3])
COMPUTE POLY NORMAL (BMFace)
void BM_face_normal_flip_ex(BMesh *bm, BMFace *f, const int cd_loop_mdisp_offset, const bool use_loop_mdisp_flip)
Face Flip Normal.
void BM_vert_tri_calc_tangent_edge(BMVert *verts[3], float r_tangent[3])
void BM_face_normal_update(BMFace *f)
void BM_face_as_array_vert_tri(BMFace *f, BMVert *r_verts[3])
bool BM_vert_calc_normal_ex(const BMVert *v, const char hflag, float r_no[3])
void BM_face_as_array_loop_quad(BMFace *f, BMLoop *r_loops[4])
static void bm_face_calc_poly_center_median_vertex_cos(const BMFace *f, float r_cent[3], float const (*vertexCos)[3])
COMPUTE POLY CENTER (BMFace)
void BM_face_normal_flip(BMesh *bm, BMFace *f)
void BM_face_calc_tangent_edge(const BMFace *f, float r_tangent[3])
void BM_verts_calc_normal_from_cloud_ex(BMVert **varr, int varr_len, float r_normal[3], float r_center[3], int *r_index_tangent)
void BM_face_calc_bounds_expand(const BMFace *f, float min[3], float max[3])
float BM_face_calc_area(const BMFace *f)
#define EDGE_SHARE_VERT(e1, e2)
float BM_face_calc_normal_subset(const BMLoop *l_first, const BMLoop *l_last, float r_no[3])
void BM_face_calc_center_median_vcos(const BMesh *bm, const BMFace *f, float r_cent[3], float const (*vertexCos)[3])
float BM_face_calc_normal(const BMFace *f, float r_no[3])
BMESH UPDATE FACE NORMAL.
float BM_face_calc_perimeter_with_mat3(const BMFace *f, const float mat3[3][3])
void BM_face_calc_center_bounds_vcos(const BMesh *bm, const BMFace *f, float r_cent[3], float const (*vertexCos)[3])
static void bm_loop_normal_accum(const BMLoop *l, float no[3])
void BM_vert_tri_calc_tangent_edge_pair(BMVert *verts[3], float r_tangent[3])
void BM_face_calc_tessellation(const BMFace *f, const bool use_fixed_quad, BMLoop **r_loops, uint(*r_index)[3])
void BM_face_calc_center_median(const BMFace *f, float r_cent[3])
void BM_face_calc_tangent_auto(const BMFace *f, float r_tangent[3])
static float bm_face_calc_poly_normal(const BMFace *f, float n[3])
COMPUTE POLY NORMAL (BMFace)
void BM_face_calc_center_median_weighted(const BMFace *f, float r_cent[3])
void BM_vert_normal_update_all(BMVert *v)
float BM_face_calc_perimeter(const BMFace *f)
float BM_face_calc_normal_vcos(const BMesh *bm, const BMFace *f, float r_no[3], float const (*vertexCos)[3])
void BM_edge_normals_update(BMEdge *e)
bool BM_face_is_normal_valid(const BMFace *f)
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)
float BM_edge_calc_length(const BMEdge *e)
BMLoop * BM_face_find_longest_loop(BMFace *f)
ATTR_WARN_UNUSED_RESULT const BMLoop * l
ATTR_WARN_UNUSED_RESULT const BMVert const BMEdge * e
ATTR_WARN_UNUSED_RESULT const BMVert * v
BLI_INLINE BMEdge * bmesh_disk_edge_next(const BMEdge *e, const BMVert *v) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL()
SIMD_FORCE_INLINE const btScalar & w() const
Return the w value.
SyclQueue void void size_t num_bytes void
IconTextureDrawCall normal
static void area(int d1, int d2, int e1, int e2, float weights[2])
vec_base< T, 3 > cross(const vec_base< T, 3 > &a, const vec_base< T, 3 > &b)
static const pxr::TfToken out("out", pxr::TfToken::Immortal)
struct BMLoop * radial_next