34 #define VERT_SHARED (1 << 0)
36 #define EDGE_RING (1 << 0)
37 #define EDGE_RIM (1 << 1)
38 #define EDGE_IN_STACK (1 << 2)
40 #define FACE_OUT (1 << 0)
41 #define FACE_SHARED (1 << 1)
42 #define FACE_IN_STACK (1 << 2)
69 float fac = 1.333333f;
74 const float t = 1.0f +
dot;
75 fac = (fac *
t) + (0.75f * (1.0f -
t));
96 return (
len * 0.5f) * fac;
126 }
while ((l_iter = l_iter->
next) != l_first);
154 bool has_overlap =
true;
234 if (el_store_other) {
235 pair_test.
first = el_store;
236 pair_test.
second = el_store_other;
255 eloop_pair_gs =
NULL;
258 return eloop_pair_gs;
277 v_arr[cuts + 1] = v_b;
281 v_arr[cuts + 1] = v_a;
312 bool found_outer =
false, found_inner =
false, found_outer_tag =
false;
314 float no_outer[3] = {0.0f}, no_inner[3] = {0.0f};
339 found_outer_tag =
true;
349 if (found_inner && found_outer_tag) {
357 else if (found_outer) {
376 for (i = 0; i < e_arr_len; i++) {
380 l_iter = l_first =
e->l;
387 }
while ((l_iter = l_iter->
radial_next) != l_first);
398 for (i = 0; i < e_arr_len_iter; i++) {
402 l_iter = l_first =
e->l;
405 }
while ((l_iter = l_iter->
radial_next) != l_first);
430 const int interp_mode)
445 float(*nors_pair[2])[3];
446 GHash *nors_gh_pair[2];
454 nors_pair[0] = lpair->
nors_a;
455 nors_pair[1] = lpair->
nors_b;
474 for (side_index = 0; side_index < 2; side_index++) {
478 GHash *nors_gh_iter = nors_gh_pair[side_index];
479 float(*
nor)[3] = nors_pair[side_index];
483 for (v_iter = lb->
first, i = 0; v_iter; v_iter = v_iter->
next, i++) {
521 const int interp_mode,
524 const float *falloff_cache)
526 const int resolu = cuts + 2;
528 bool is_a_no_valid, is_b_no_valid;
531 float el_store_a_co[3], el_store_b_co[3];
532 float el_store_a_no[3], el_store_b_no[3];
555 if (is_a_no_valid ==
false) {
558 if (is_b_no_valid ==
false) {
561 (
void)is_a_no_valid, (
void)is_b_no_valid;
566 if (
dot_v3v3(el_store_a_no, el_dir) > 0.0f) {
569 if (
dot_v3v3(el_store_b_no, el_dir) < 0.0f) {
577 float handle_a[3], handle_b[3];
581 el_store_a_co, el_store_a_no, el_store_b_co, el_store_b_no) *
590 coord_array_main =
MEM_mallocN(dims * (resolu) *
sizeof(
float), __func__);
592 for (i = 0; i < dims; i++) {
597 ((
float *)coord_array_main) + i,
599 sizeof(
float) * dims);
603 switch (interp_mode) {
606 float(*coord_array)[3] =
MEM_mallocN(dims * (resolu) *
sizeof(
float), __func__);
607 for (i = 0; i < resolu; i++) {
609 coord_array[i], el_store_a_co, el_store_b_co, (
float)i / (
float)(resolu - 1));
612 for (el_store_ring = eloops_ring->
first; el_store_ring;
617 for (v_iter = lb_ring->
first, i = 0; v_iter; v_iter = v_iter->
next, i++) {
618 if (i > 0 && i < resolu - 1) {
636 float(*direction_array)[3] =
MEM_mallocN(dims * (resolu) *
sizeof(
float), __func__);
637 float(*quat_array)[4] =
MEM_mallocN(resolu *
sizeof(*quat_array), __func__);
638 float(*tri_array)[3][3] =
MEM_mallocN(resolu *
sizeof(*tri_array), __func__);
639 float(*tri_sta)[3], (*tri_end)[3], (*tri_tmp)[3];
644 copy_v3_v3(direction_array[0], el_store_a_no);
645 negate_v3_v3(direction_array[resolu - 1], el_store_b_no);
646 for (i = 1; i < resolu - 1; i++) {
648 coord_array_main[i - 1],
650 coord_array_main[i + 1]);
653 vec_to_quat(quat_array[0], direction_array[0], 5, 1);
656 for (i = 1; i < resolu; i++) {
662 cross_v3_v3v3(cross_tmp, direction_array[i - 1], direction_array[i]);
673 for (i = 0; i < resolu; i++) {
676 const float shape_size = falloff_cache ? falloff_cache[i] : 1.0f;
678 tri_tmp = tri_array[i];
681 for (j = 0; j < 3; j++) {
684 tri_tmp[j][0] = shape_size;
687 tri_tmp[j][1] = shape_size;
690 add_v3_v3(tri_tmp[j], coord_array_main[i]);
694 tri_sta = tri_array[0];
695 tri_end = tri_array[resolu - 1];
697 for (el_store_ring = eloops_ring->
first; el_store_ring;
707 v_iter = v_iter->
next, i++) {
708 float co_a[3], co_b[3];
710 tri_tmp = tri_array[i];
725 float(*coord_array)[3] =
MEM_mallocN(dims * (resolu) *
sizeof(
float), __func__);
728 for (el_store_ring = eloops_ring->
first; el_store_ring;
736 float co_a[3], no_a[3], handle_a[3], co_b[3], no_b[3], handle_b[3];
767 for (i = 0; i < dims; i++) {
772 ((
float *)coord_array) + i,
774 sizeof(
float) * dims);
779 v_iter = v_iter->
next, i++) {
780 if (i > 0 && i < resolu - 1) {
800 if (coord_array_main) {
814 for (i = 0; i < cuts; i++) {
840 LinkData *v_iter_a_step = v_iter_a_first;
841 LinkData *v_iter_b_step = v_iter_b_first;
848 v_iter_a_step = v_iter_a_step->
next;
852 v_iter_b_step = v_iter_b_step->
next;
856 v_iter_a_step = v_iter_a_step ? v_iter_a_step->
prev : lb_a->
last;
857 v_iter_b_step = v_iter_b_step ? v_iter_b_step->
prev : lb_b->
last;
902 if (
node->data == v_other) {
1002 while ((f =
STACK_POP(faces_ring_arr))) {
1003 BMLoop *l_iter, *l_first;
1014 }
while ((l_iter = l_iter->
next) != l_first);
1018 for (el_store_ring = eloops_ring->
first; el_store_ring;
1031 const int interp_mode,
1034 const float *falloff_cache)
1040 bm, lpair, el_store_a, el_store_b, &eloops_ring, interp_mode, cuts,
smooth, falloff_cache);
1058 bool changed =
false;
1063 const int resolu = cuts + 2;
1068 float *falloff_cache = (profile_shape_factor != 0.0f) ?
1114 if (falloff_cache) {
1116 for (i = 0; i < resolu; i++) {
1117 float shape_size = 1.0f;
1118 float fac = (
float)i / (
float)(resolu - 1);
1119 fac =
fabsf(1.0f - 2.0f *
fabsf(0.5f - fac));
1121 shape_size += fac * profile_shape_factor;
1123 falloff_cache[i] = shape_size;
1136 else if (
count == 2) {
1152 bm, lpair, el_store_a, el_store_b, interp_mode, cuts,
smooth, falloff_cache);
1168 if (eloop_pairs_gs ==
NULL) {
1188 lpair_arr[i] = lpair;
1201 bm, lpair, el_store_a, el_store_b, interp_mode, cuts,
smooth, falloff_cache);
typedef float(TangentPoint)[2]
void BKE_curve_forward_diff_bezier(float q0, float q1, float q2, float q3, float *p, int it, int stride)
#define BLI_array_alloca(arr, realsize)
#define GSET_ITER_INDEX(gs_iter_, gset_, i_)
bool BLI_ghash_haskey(const GHash *gh, const void *key) ATTR_WARN_UNUSED_RESULT
bool BLI_gset_ensure_p_ex(GSet *gs, const void *key, void ***r_key)
GHashPair * BLI_ghashutil_pairalloc(const void *first, const void *second)
unsigned int BLI_gset_len(const GSet *gs) ATTR_WARN_UNUSED_RESULT
GSet * BLI_gset_pair_new(const char *info) ATTR_MALLOC ATTR_WARN_UNUSED_RESULT
void * BLI_ghash_lookup(const GHash *gh, const void *key) ATTR_WARN_UNUSED_RESULT
void BLI_ghash_insert(GHash *gh, void *key, void *val)
void BLI_ghash_free(GHash *gh, GHashKeyFreeFP keyfreefp, GHashValFreeFP valfreefp)
void BLI_gset_free(GSet *gs, GSetKeyFreeFP keyfreefp)
GHash * BLI_ghash_ptr_new(const char *info) ATTR_MALLOC ATTR_WARN_UNUSED_RESULT
BLI_INLINE void * BLI_gsetIterator_getKey(GSetIterator *gsi)
void BLI_listbase_rotate_first(struct ListBase *lb, void *vlink) ATTR_NONNULL(1
void BLI_addtail(struct ListBase *listbase, void *vlink) ATTR_NONNULL(1)
MINLINE int max_ii(int a, int b)
void transform_point_by_tri_v3(float pt_tar[3], float const pt_src[3], const float tri_tar_p1[3], const float tri_tar_p2[3], const float tri_tar_p3[3], const float tri_src_p1[3], const float tri_src_p2[3], const float tri_src_p3[3])
float closest_to_line_v3(float r_close[3], const float p[3], const float l1[3], const float l2[3])
void axis_angle_to_quat(float r[4], const float axis[3], float angle)
void vec_to_quat(float q[4], const float vec[3], short axis, short upflag)
float normalize_qt(float q[4])
void mul_qt_v3(const float q[4], float r[3])
void mul_qt_qtqt(float q[4], const float a[4], const float b[4])
void copy_qt_qt(float q[4], const float a[4])
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_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 void negate_v3_v3(float r[3], const float a[3])
MINLINE float dot_v3v3(const float a[3], const float b[3]) ATTR_WARN_UNUSED_RESULT
void interp_v3_v3v3(float r[3], const float a[3], const float b[3], float t)
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 float normalize_v3_v3(float r[3], const float a[3])
MINLINE void zero_v3(float r[3])
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
MINLINE void add_v3_v3(float r[3], const float a[3])
void bisect_v3_v3v3v3(float r[3], const float a[3], const float b[3], const float c[3])
#define POINTER_AS_UINT(i)
#define POINTER_FROM_UINT(i)
#define STACK_PUSH(stack, val)
#define STACK_DECLARE(stack)
#define STACK_INIT(stack, stack_num)
_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 GLdouble GLint GLint const GLdouble *points _GL_VOID_RET _GL_VOID GLdouble GLdouble u2 _GL_VOID_RET _GL_VOID GLdouble GLdouble GLint GLdouble GLdouble v2 _GL_VOID_RET _GL_VOID GLenum GLfloat param _GL_VOID_RET _GL_VOID GLenum GLint param _GL_VOID_RET _GL_VOID GLenum mode _GL_VOID_RET _GL_VOID GLdouble GLdouble nz _GL_VOID_RET _GL_VOID GLfloat GLfloat nz _GL_VOID_RET _GL_VOID GLint GLint nz _GL_VOID_RET _GL_VOID GLshort GLshort nz _GL_VOID_RET _GL_VOID GLsizei const void *pointer _GL_VOID_RET _GL_VOID GLsizei const GLfloat *values _GL_VOID_RET _GL_VOID GLsizei const GLushort *values _GL_VOID_RET _GL_VOID GLint param _GL_VOID_RET _GL_VOID const GLuint const GLclampf *priorities _GL_VOID_RET _GL_VOID GLdouble y _GL_VOID_RET _GL_VOID GLfloat y _GL_VOID_RET _GL_VOID GLint y _GL_VOID_RET _GL_VOID GLshort y _GL_VOID_RET _GL_VOID GLdouble GLdouble z _GL_VOID_RET _GL_VOID GLfloat GLfloat z _GL_VOID_RET _GL_VOID GLint GLint z _GL_VOID_RET _GL_VOID GLshort GLshort z _GL_VOID_RET _GL_VOID GLdouble GLdouble GLdouble w _GL_VOID_RET _GL_VOID GLfloat GLfloat GLfloat w _GL_VOID_RET _GL_VOID GLint GLint GLint w _GL_VOID_RET _GL_VOID GLshort GLshort GLshort w _GL_VOID_RET _GL_VOID GLdouble GLdouble GLdouble y2 _GL_VOID_RET _GL_VOID GLfloat GLfloat GLfloat y2 _GL_VOID_RET _GL_VOID GLint GLint GLint y2 _GL_VOID_RET _GL_VOID GLshort GLshort GLshort y2 _GL_VOID_RET _GL_VOID GLdouble GLdouble GLdouble z _GL_VOID_RET _GL_VOID GLdouble GLdouble z _GL_VOID_RET _GL_VOID GLuint *buffer _GL_VOID_RET _GL_VOID GLdouble t _GL_VOID_RET _GL_VOID GLfloat t _GL_VOID_RET _GL_VOID GLint t _GL_VOID_RET _GL_VOID GLshort t _GL_VOID_RET _GL_VOID GLdouble t
Read Guarded memory(de)allocation.
#define BM_FACE_FIRST_LOOP(p)
const float * BM_edgeloop_center_get(struct BMEdgeLoopStore *el_store)
void BM_mesh_edgeloops_free(ListBase *eloops)
BMEdgeLoopStore * BM_edgeloop_from_verts(BMVert **v_arr, const int v_arr_tot, bool is_closed)
int BM_mesh_edgeloops_find(BMesh *bm, ListBase *r_eloops, bool(*test_fn)(BMEdge *, void *user_data), void *user_data)
int BM_edgeloop_length_get(BMEdgeLoopStore *el_store)
bool BM_edgeloop_is_closed(BMEdgeLoopStore *el_store)
void BM_edgeloop_edges_get(struct BMEdgeLoopStore *el_store, BMEdge **e_arr)
ListBase * BM_edgeloop_verts_get(BMEdgeLoopStore *el_store)
bool BM_edgeloop_calc_normal(BMesh *UNUSED(bm), BMEdgeLoopStore *el_store)
bool BM_edgeloop_calc_normal_aligned(BMesh *UNUSED(bm), BMEdgeLoopStore *el_store, const float no_align[3])
const float * BM_edgeloop_normal_get(struct BMEdgeLoopStore *el_store)
void BM_edgeloop_flip(BMesh *UNUSED(bm), BMEdgeLoopStore *el_store)
void BM_edgeloop_calc_center(BMesh *UNUSED(bm), BMEdgeLoopStore *el_store)
#define BM_EDGELOOP_NEXT(el_store)
void BMO_error_raise(BMesh *bm, BMOperator *owner, eBMOpErrorLevel level, const char *msg) ATTR_NONNULL(1
#define BM_elem_flag_set(ele, hflag, val)
#define BM_elem_flag_test(ele, hflag)
#define BM_ITER_ELEM(ele, iter, data, itype)
#define BM_ITER_MESH(ele, iter, bm, itype)
ATTR_WARN_UNUSED_RESULT BMesh * bm
void BM_mesh_elem_hflag_disable_all(BMesh *bm, const char htype, const char hflag, const bool respecthide)
BMVert * BM_edge_split_n(BMesh *bm, BMEdge *e, int numcuts, BMVert **r_varr)
Split an edge multiple times evenly.
BMFace * BM_face_split(BMesh *bm, BMFace *f, BMLoop *l_a, BMLoop *l_b, BMLoop **r_l, BMEdge *example, const bool no_double)
Face Split.
#define BMO_edge_flag_test_bool(bm, e, oflag)
void BMO_slot_buffer_flag_enable(BMesh *bm, BMOpSlot slot_args[BMO_OP_MAX_SLOTS], const char *slot_name, char htype, short oflag)
BMO_FLAG_BUFFER.
#define BMO_edge_flag_test(bm, e, oflag)
#define BMO_edge_flag_enable(bm, e, oflag)
float BMO_slot_float_get(BMOpSlot slot_args[BMO_OP_MAX_SLOTS], const char *slot_name)
#define BMO_vert_flag_set(bm, e, oflag, val)
void BMO_slot_buffer_from_enabled_flag(BMesh *bm, BMOperator *op, BMOpSlot slot_args[BMO_OP_MAX_SLOTS], const char *slot_name, char htype, short oflag)
#define BMO_face_flag_enable(bm, e, oflag)
#define BMO_ITER(ele, iter, slot_args, slot_name, restrict_flag)
#define BMO_vert_flag_test(bm, e, oflag)
int BMO_slot_int_get(BMOpSlot slot_args[BMO_OP_MAX_SLOTS], const char *slot_name)
#define BMO_face_flag_disable(bm, e, oflag)
#define BMO_edge_flag_disable(bm, e, oflag)
#define BMO_face_flag_test(bm, e, oflag)
ATTR_WARN_UNUSED_RESULT const BMFlagLayer const short oflag
@ SUBD_RING_INTERP_LINEAR
BMEdge * BM_edge_exists(BMVert *v_a, BMVert *v_b)
float bmesh_subd_falloff_calc(const int falloff, float val)
void BM_edge_calc_face_tangent(const BMEdge *e, const BMLoop *e_loop, float r_tangent[3])
BMESH EDGE/FACE TANGENT.
BLI_INLINE BMVert * BM_edge_other_vert(BMEdge *e, const BMVert *v) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL()
BLI_INLINE bool BM_edge_is_wire(const BMEdge *e) 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 BMLoop * l
ATTR_WARN_UNUSED_RESULT const BMVert const BMEdge * e
ATTR_WARN_UNUSED_RESULT const BMVert * v
struct LoopPairStore LoopPairStore
static void bm_edgering_pair_order(BMesh *bm, struct BMEdgeLoopStore *el_store_a, struct BMEdgeLoopStore *el_store_b)
void bmo_subdivide_edgering_exec(BMesh *bm, BMOperator *op)
static bool bm_edge_rim_test_cb(BMEdge *e, void *bm_v)
static float bezier_handle_calc_length_v3(const float co_a[3], const float no_a[3], const float co_b[3], const float no_b[3])
static void bm_edge_subdiv_as_loop(BMesh *bm, ListBase *eloops, BMEdge *e, BMVert *v_a, const int cuts)
static void bm_faces_share_tag_flush(BMesh *bm, BMEdge **e_arr, const uint e_arr_len)
static uint bm_verts_tag_count(BMesh *bm)
static bool bmo_face_is_vert_tag_all(BMesh *bm, BMFace *f, short oflag)
static void bm_edgering_pair_ringsubd(BMesh *bm, LoopPairStore *lpair, struct BMEdgeLoopStore *el_store_a, struct BMEdgeLoopStore *el_store_b, const int interp_mode, const int cuts, const float smooth, const float *falloff_cache)
static void bm_faces_share_tag_clear(BMesh *bm, BMEdge **e_arr_iter, const uint e_arr_len_iter)
static void bm_face_slice(BMesh *bm, BMLoop *l, const int cuts)
static bool bm_edgeloop_check_overlap_all(BMesh *bm, struct BMEdgeLoopStore *el_store_a, struct BMEdgeLoopStore *el_store_b)
static void bm_vert_calc_surface_tangent(BMesh *bm, BMVert *v, float r_no[3])
static void bm_edgering_pair_store_free(LoopPairStore *lpair, const int interp_mode)
static void bm_edgering_pair_interpolate(BMesh *bm, LoopPairStore *lpair, struct BMEdgeLoopStore *el_store_a, struct BMEdgeLoopStore *el_store_b, ListBase *eloops_ring, const int interp_mode, const int cuts, const float smooth, const float *falloff_cache)
static void bm_edgeloop_vert_tag(struct BMEdgeLoopStore *el_store, const bool tag)
static bool bm_vert_is_tag_edge_connect(BMesh *bm, BMVert *v)
static bool bm_edgering_pair_order_is_flipped(BMesh *UNUSED(bm), struct BMEdgeLoopStore *el_store_a, struct BMEdgeLoopStore *el_store_b)
static void bm_edgering_pair_subdiv(BMesh *bm, struct BMEdgeLoopStore *el_store_a, struct BMEdgeLoopStore *el_store_b, ListBase *eloops_ring, const int cuts)
static GSet * bm_edgering_pair_calc(BMesh *bm, ListBase *eloops_rim)
static void bmo_edgeloop_vert_tag(BMesh *bm, struct BMEdgeLoopStore *el_store, const short oflag, const bool tag)
static LoopPairStore * bm_edgering_pair_store_create(BMesh *bm, struct BMEdgeLoopStore *el_store_a, struct BMEdgeLoopStore *el_store_b, const int interp_mode)
SIMD_FORCE_INLINE btScalar angle(const btVector3 &v) const
Return the angle between this and another vector.
SyclQueue void void size_t num_bytes void
void(* MEM_freeN)(void *vmemh)
void *(* MEM_mallocN)(size_t len, const char *str)
T dot(const vec_base< T, Size > &a, const vec_base< T, Size > &b)
smooth(Type::FLOAT, "mask_weight")
struct BMLoop * radial_next
struct BMOpSlot slots_out[BMO_OP_MAX_SLOTS]
struct BMOpSlot slots_in[BMO_OP_MAX_SLOTS]