30 #define EDGE_TAG_FROM_SPLIT_ANGLE_BYPASS -FLT_MAX
34 const float split_angle_cos);
37 const float split_angle_cos);
49 #define BM_LNORSPACE_UPDATE _FLAG_MF
61 const float e1diff[3],
62 const float e2diff[3],
69 float dotprod =
dot_v3v3(e1diff, e2diff);
70 if ((l_iter->
prev->
e->
v1 == l_iter->
prev->
v) ^ (l_iter->
e->
v1 == l_iter->
v)) {
73 const float fac =
saacos(-dotprod);
112 if (e_first !=
NULL) {
113 float e1diff[3], e2diff[3];
117 if (l_first !=
NULL) {
123 if (l_iter->
v ==
v) {
130 }
while ((l_iter = l_iter->
radial_next) != l_first);
158 if (e_first !=
NULL) {
159 float e1diff[3], e2diff[3];
163 if (l_first !=
NULL) {
171 if (l_iter->
v ==
v) {
181 }
while ((l_iter = l_iter->
radial_next) != l_first);
203 const float (*fnos)[3],
204 const float (*vcos)[3],
238 if (
params->face_normals) {
255 .face_normals =
true,
291 const int verts_len = bmpinfo->
verts_len;
292 const int faces_len = bmpinfo->
faces_len;
298 if (
params->face_normals) {
313 .face_normals =
true,
324 const float (*fnos)[3],
325 const float (*vcos)[3],
361 int index_face, index_loop = 0;
368 }
while ((l_curr = l_curr->
next) != l_first);
377 const float (*fnos)[3],
378 float split_angle_cos,
379 const bool do_sharp_edges_tag)
389 if (do_sharp_edges_tag) {
411 if (split_angle >= (
float)
M_PI) {
427 BMLoop *lfan_pivot_next = l_curr;
443 if (lfan_pivot_next == l_curr) {
470 const float (*vcos)[3],
471 const float (*fnos)[3],
472 const short (*clnors_data)[2],
473 const int cd_loop_clnors_offset,
474 const bool has_clnors,
519 if (r_lnors_spacearr) {
520 float vec_curr[3], vec_prev[3];
524 const BMVert *v_pivot = l_curr->
v;
546 const short(*clnor)[2] = clnors_data ? &clnors_data[l_curr_index] :
548 l_curr, cd_loop_clnors_offset);
574 const BMEdge *e_org = l_curr->
e;
575 BMLoop *lfan_pivot, *lfan_pivot_next;
576 int lfan_pivot_index;
577 float lnor[3] = {0.0f, 0.0f, 0.0f};
578 float vec_curr[3], vec_next[3], vec_org[3];
581 int clnors_avg[2] = {0, 0};
582 const short(*clnor_ref)[2] =
NULL;
583 int clnors_count = 0;
584 bool clnors_invalid =
false;
594 e_next = lfan_pivot->
e;
608 if (r_lnors_spacearr) {
616 if (lfan_pivot_next) {
621 e_next = (lfan_pivot->
e == e_next) ? lfan_pivot->
prev->
e : lfan_pivot->
e;
641 const BMFace *f = lfan_pivot->
f;
649 const short(*clnor)[2] = clnors_data ? &clnors_data[lfan_pivot_index] :
651 lfan_pivot, cd_loop_clnors_offset);
653 clnors_invalid |= ((*clnor_ref)[0] != (*clnor)[0] || (*clnor_ref)[1] != (*clnor)[1]);
658 clnors_avg[0] += (*clnor)[0];
659 clnors_avg[1] += (*clnor)[1];
669 if (r_lnors_spacearr) {
672 if (e_next != e_org) {
688 lfan_pivot = lfan_pivot_next;
696 if (r_lnors_spacearr) {
706 if (clnors_invalid) {
709 clnors_avg[0] /= clnors_count;
710 clnors_avg[1] /= clnors_count;
718 clnor[0] = (short)clnors_avg[0];
719 clnor[1] = (short)clnors_avg[1];
734 if (
LIKELY(lnor_len != 0.0f)) {
752 if (r_lnors_spacearr) {
785 (l_a->
v !=
l_b->
v) &&
796 bool is_smooth =
false;
798 if (split_angle_cos != -1.0f) {
802 if (
dot >= split_angle_cos) {
833 const float split_angle_cos)
837 bool is_smooth =
false;
839 if (split_angle_cos != -1.0f) {
843 if (
dot >= split_angle_cos) {
867 const float (*vcos)[3],
868 const float (*fnos)[3],
870 const short (*clnors_data)[2],
871 const int cd_loop_clnors_offset,
872 const bool do_rebuild,
873 const float split_angle_cos,
889 const bool has_clnors =
true;
891 int loops_of_vert_count = 0;
901 BMLoop *l_curr = e_curr_iter->
l;
902 if (l_curr ==
NULL) {
911 if (l_curr->
v !=
v) {
920 loops_of_vert_count += 1;
923 if (index_best > index_test) {
924 index_best = index_test;
925 link_best = loops_of_vert;
927 }
while ((l_curr = l_curr->
radial_next) != e_curr_iter->
l);
937 if (link_best != loops_of_vert) {
942 bool loops_of_vert_is_sorted =
false;
945 int loops_of_vert_handled = 0;
947 while (loops_of_vert !=
NULL) {
949 loops_of_vert = loops_of_vert->
next;
956 cd_loop_clnors_offset,
966 BLI_assert(loops_of_vert_handled <= loops_of_vert_count);
967 if (loops_of_vert_handled == loops_of_vert_count) {
973 if (!loops_of_vert_is_sorted) {
974 if (loops_of_vert && loops_of_vert->
next) {
976 loops_of_vert_is_sorted =
true;
988 const float (*vcos)[3],
989 const float (*fnos)[3],
991 const bool do_rebuild,
992 const float split_angle_cos,
999 const bool has_clnors =
false;
1000 const short(*clnors_data)[2] =
NULL;
1003 const int cd_loop_clnors_offset = -1;
1010 BMLoop *l_curr = e_curr_iter->
l;
1011 if (l_curr ==
NULL) {
1020 if (l_curr->
v !=
v) {
1024 }
while ((l_curr = l_curr->
radial_next) != e_curr_iter->
l);
1029 BMLoop *l_curr = e_curr_iter->
l;
1030 if (l_curr ==
NULL) {
1034 if (l_curr->
v !=
v) {
1045 cd_loop_clnors_offset,
1051 }
while ((l_curr = l_curr->
radial_next) != e_curr_iter->
l);
1064 const float (*vcos)[3],
1065 const float (*fnos)[3],
1068 const short (*clnors_data)[2],
1069 const int cd_loop_clnors_offset,
1070 const bool do_rebuild,
1071 const float split_angle_cos)
1075 const bool has_clnors = clnors_data || (cd_loop_clnors_offset != -1);
1092 if (!r_lnors_spacearr && has_clnors) {
1094 r_lnors_spacearr = &_lnors_spacearr;
1096 if (r_lnors_spacearr) {
1102 int index_face, index_loop = 0;
1104 BMLoop *l_curr, *l_first;
1112 }
while ((l_curr = l_curr->
next) != l_first);
1127 BMLoop *l_curr, *l_first;
1139 cd_loop_clnors_offset,
1145 }
while ((l_curr = l_curr->
next) != l_first);
1148 if (r_lnors_spacearr) {
1150 if (r_lnors_spacearr == &_lnors_spacearr) {
1180 void *__restrict chunk)
1184 if (
data->r_lnors_spacearr) {
1195 void *__restrict
UNUSED(chunk_join),
1196 void *__restrict chunk)
1201 if (
data->r_lnors_spacearr) {
1207 void *__restrict chunk)
1212 if (
data->r_lnors_spacearr) {
1232 data->cd_loop_clnors_offset,
1234 data->split_angle_cos,
1257 data->split_angle_cos,
1266 const float (*vcos)[3],
1267 const float (*fnos)[3],
1270 const short (*clnors_data)[2],
1271 const int cd_loop_clnors_offset,
1272 const bool do_rebuild,
1273 const float split_angle_cos)
1275 const bool has_clnors = clnors_data || (cd_loop_clnors_offset != -1);
1290 if (!r_lnors_spacearr && has_clnors) {
1292 r_lnors_spacearr = &_lnors_spacearr;
1294 if (r_lnors_spacearr) {
1320 .r_lnors_spacearr = r_lnors_spacearr,
1321 .clnors_data = clnors_data,
1322 .cd_loop_clnors_offset = cd_loop_clnors_offset,
1323 .do_rebuild = do_rebuild,
1324 .split_angle_cos = split_angle_cos,
1327 BM_iter_parallel(
bm,
1334 if (r_lnors_spacearr) {
1335 if (r_lnors_spacearr == &_lnors_spacearr) {
1342 const float (*vcos)[3],
1343 const float (*fnos)[3],
1346 const short (*clnors_data)[2],
1347 const int cd_loop_clnors_offset,
1348 const bool do_rebuild,
1349 const float split_angle_cos)
1358 cd_loop_clnors_offset,
1369 cd_loop_clnors_offset,
1376 #define LNOR_SPACE_TRIGO_THRESHOLD (1.0f - 1e-4f)
1384 const float (*new_lnors)[3])
1387 bool changed =
false;
1399 printf(
"WARNING! Getting invalid NULL loop space for loop %d!\n", i);
1421 const float *org_nor =
NULL;
1426 const float *
nor = new_lnors[lidx];
1446 loops = loops->
next;
1455 if (loops && org_nor) {
1458 const float *
nor = new_lnors[lidx];
1480 short (*r_clnors_data)[2],
1481 const int cd_loop_clnors_offset,
1482 const float (*new_lnors)[3])
1494 printf(
"WARNING! Still getting invalid NULL loop space in second loop for loop %d!\n", i);
1512 const float *
nor = new_lnors[lidx];
1513 short *clnor = r_clnors_data ? &r_clnors_data[lidx] :
1520 int avg_nor_count = 0;
1522 short clnor_data_tmp[2], *clnor_data;
1529 const float *
nor = new_lnors[lidx];
1530 short *clnor = r_clnors_data ? &r_clnors_data[lidx] :
1537 loops = loops->
next;
1541 mul_v3_fl(avg_nor, 1.0f / (
float)avg_nor_count);
1543 lnors_spacearr->
lspacearr[i], avg_nor, clnor_data_tmp);
1546 clnor_data[0] = clnor_data_tmp[0];
1547 clnor_data[1] = clnor_data_tmp[1];
1564 const float (*vcos)[3],
1565 const float (*fnos)[3],
1567 short (*r_clnors_data)[2],
1568 const int cd_loop_clnors_offset,
1569 float (*new_lnors)[3],
1570 const int cd_new_lnors_offset,
1592 cd_loop_clnors_offset,
1597 float(*custom_lnors)[3] = new_lnors;
1599 if (new_lnors ==
NULL) {
1633 cd_loop_clnors_offset,
1641 bm, r_lnors_spacearr, r_clnors_data, cd_loop_clnors_offset, custom_lnors);
1645 if (custom_lnors != new_lnors) {
1651 const float (*vnos)[3],
1652 const float (*fnos)[3],
1670 BMLoop *l_curr, *l_first;
1679 }
while ((l_curr = l_curr->
next) != l_first);
1684 const float (*vcos)[3],
1685 const float (*vnos)[3],
1686 const float (*fnos)[3],
1687 const bool use_split_normals,
1688 const float split_angle,
1691 short (*clnors_data)[2],
1692 const int cd_loop_clnors_offset,
1693 const bool do_rebuild)
1695 const bool has_clnors = clnors_data || (cd_loop_clnors_offset != -1);
1697 if (use_split_normals) {
1704 cd_loop_clnors_offset,
1706 has_clnors ? -1.0f :
cosf(split_angle));
1739 cd_loop_clnors_offset,
1744 #define CLEAR_SPACEARRAY_THRESHOLD(x) ((x) / 2)
1833 if (preserve_clnor) {
1862 cd_loop_clnors_offset,
1870 if (preserve_clnor) {
1933 bm,
NULL,
NULL,
NULL,
true,
M_PI, lnors, temp,
NULL, cd_loop_clnors_offset,
true);
1966 const bool do_all_loops_of_vert)
1976 if (do_all_loops_of_vert) {
2015 const bool use_sel_face_history = sel_faces && (sel_edges || sel_verts);
2022 if (use_sel_face_history) {
2032 for (ese_prev = ese->
prev; ese_prev; ese_prev = ese_prev->
prev) {
2039 do_all_loops_of_vert);
2047 do_all_loops_of_vert);
2053 do_all_loops_of_vert);
2130 float custom_normal[3];
2142 const bool do_all_loops_of_vert)
2170 sizeof(*lnor_ed) * totloopsel, __func__);
2181 lnors_ed_arr->
totloop = totloopsel;
2186 return lnors_ed_arr;
2258 cd_custom_normal_offset,
typedef float(TangentPoint)[2]
CustomData interface, see also DNA_customdata_types.h.
bool CustomData_has_layer(const struct CustomData *data, int type)
void CustomData_set_layer_flag(struct CustomData *data, int type, int flag)
int CustomData_get_offset(const struct CustomData *data, int type)
MLoopNorSpace * BKE_lnor_space_create(MLoopNorSpaceArray *lnors_spacearr)
@ MLNOR_SPACEARR_BMLOOP_PTR
void BKE_lnor_space_define(MLoopNorSpace *lnor_space, const float lnor[3], float vec_ref[3], float vec_other[3], struct BLI_Stack *edge_vectors)
void BKE_lnor_spacearr_clear(MLoopNorSpaceArray *lnors_spacearr)
void BKE_lnor_spacearr_init(MLoopNorSpaceArray *lnors_spacearr, int numLoops, char data_type)
void BKE_lnor_space_add_loop(MLoopNorSpaceArray *lnors_spacearr, MLoopNorSpace *lnor_space, int ml_index, void *bm_loop, bool is_single)
void BKE_lnor_spacearr_free(MLoopNorSpaceArray *lnors_spacearr)
void BKE_lnor_space_custom_data_to_normal(MLoopNorSpace *lnor_space, const short clnor_data[2], float r_custom_lnor[3])
void BKE_lnor_spacearr_tls_join(MLoopNorSpaceArray *lnors_spacearr, MLoopNorSpaceArray *lnors_spacearr_tls)
void BKE_lnor_spacearr_tls_init(MLoopNorSpaceArray *lnors_spacearr, MLoopNorSpaceArray *lnors_spacearr_tls)
void BKE_lnor_space_custom_normal_to_data(MLoopNorSpace *lnor_space, const float custom_lnor[3], short r_clnor_data[2])
#define BLI_BITMAP_NEW(_num, _alloc_string)
#define BLI_BITMAP_TEST(_bitmap, _index)
#define BLI_BITMAP_ENABLE(_bitmap, _index)
LinkNode * BLI_linklist_sort(LinkNode *list, int(*cmp)(const void *, const void *)) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(2)
#define BLI_linklist_prepend_alloca(listp, ptr)
BLI_LINKSTACK_*** wrapper macros for using a LinkNode to store a stack of pointers,...
#define BLI_SMALLSTACK_DECLARE(var, type)
#define BLI_SMALLSTACK_POP(var)
#define BLI_SMALLSTACK_PUSH(var, data)
MINLINE float saacos(float fac)
MINLINE int compare_ff(float a, float b, float max_diff)
MINLINE bool compare_v3v3(const float a[3], const float b[3], float limit) ATTR_WARN_UNUSED_RESULT
MINLINE void madd_v3_v3fl(float r[3], const float a[3], float f)
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 mul_v3_fl(float r[3], float f)
MINLINE void copy_v3_v3(float r[3], const float a[3])
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 float normalize_v3_v3(float r[3], const float a[3])
MINLINE void zero_v3(float r[3])
MINLINE void add_v3_v3(float r[3], const float a[3])
void BLI_stack_push(BLI_Stack *stack, const void *src) ATTR_NONNULL()
bool BLI_stack_is_empty(const BLI_Stack *stack) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL()
void BLI_stack_free(BLI_Stack *stack) ATTR_NONNULL()
#define BLI_stack_new(esize, descr)
struct MempoolIterData MempoolIterData
void BLI_task_parallel_range(int start, int stop, void *userdata, TaskParallelRangeFunc func, const TaskParallelSettings *settings)
BLI_INLINE void BLI_parallel_range_settings_defaults(TaskParallelSettings *settings)
BLI_INLINE void BLI_parallel_mempool_settings_defaults(TaskParallelSettings *settings)
#define UNUSED_VARS_NDEBUG(...)
#define SCE_SELECT_VERTEX
Read Guarded memory(de)allocation.
#define BM_DISK_EDGE_NEXT(e, v)
#define BM_FACE_FIRST_LOOP(p)
#define BM_ELEM_CD_GET_VOID_P(ele, offset)
#define BM_elem_index_get(ele)
#define BM_elem_flag_disable(ele, hflag)
#define BM_elem_flag_set(ele, hflag, val)
#define BM_elem_index_set(ele, index)
#define BM_elem_flag_test(ele, hflag)
#define BM_elem_flag_enable(ele, hflag)
void BM_data_layer_add(BMesh *bm, CustomData *data, int type)
#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)
ATTR_WARN_UNUSED_RESULT BMesh * bm
void BM_mesh_elem_index_ensure(BMesh *bm, const char htype)
static void bm_mesh_loops_assign_normal_data(BMesh *bm, MLoopNorSpaceArray *lnors_spacearr, short(*r_clnors_data)[2], const int cd_loop_clnors_offset, const float(*new_lnors)[3])
void BM_mesh_normals_update_with_partial(BMesh *bm, const BMPartialUpdate *bmpinfo)
void BM_mesh_normals_update_with_partial_ex(BMesh *UNUSED(bm), const BMPartialUpdate *bmpinfo, const struct BMeshNormalsUpdate_Params *params)
static int bm_loop_index_cmp(const void *a, const void *b)
void BM_lnorspacearr_store(BMesh *bm, float(*r_lnors)[3])
static void bm_mesh_verts_calc_normals(BMesh *bm, const float(*fnos)[3], const float(*vcos)[3], float(*vnos)[3])
void BM_mesh_normals_update_ex(BMesh *bm, const struct BMeshNormalsUpdate_Params *params)
BMesh Compute Normals.
#define CLEAR_SPACEARRAY_THRESHOLD(x)
static void bm_vert_calc_normals_with_coords(BMVert *v, BMVertsCalcNormalsWithCoordsData *data)
static void bm_face_calc_normals_cb(void *UNUSED(userdata), MempoolIterData *mp_f, const TaskParallelTLS *__restrict UNUSED(tls))
static void bm_mesh_loops_calc_normals_for_vert_without_clnors(BMesh *bm, const float(*vcos)[3], const float(*fnos)[3], float(*r_lnos)[3], const bool do_rebuild, const float split_angle_cos, MLoopNorSpaceArray *r_lnors_spacearr, BLI_Stack *edge_vectors, BMVert *v)
void BM_lnorspace_update(BMesh *bm)
static void bm_mesh_loops_calc_normals_for_vert_free_fn(const void *__restrict userdata, void *__restrict chunk)
static void bm_partial_faces_parallel_range_calc_normals_cb(void *userdata, const int iter, const TaskParallelTLS *__restrict UNUSED(tls))
static void bm_edge_tag_from_smooth(const float(*fnos)[3], BMEdge *e, const float split_angle_cos)
#define BM_LNORSPACE_UPDATE
void BM_lnorspace_invalidate(BMesh *bm, const bool do_invalidate_all)
void BM_normals_loops_edges_tag(BMesh *bm, const bool do_edges)
struct BMVertsCalcNormalsWithCoordsData BMVertsCalcNormalsWithCoordsData
void BM_lnorspace_rebuild(BMesh *bm, bool preserve_clnor)
bool BM_custom_loop_normals_to_vector_layer(BMesh *bm)
static bool bm_mesh_loops_split_lnor_fans(BMesh *bm, MLoopNorSpaceArray *lnors_spacearr, const float(*new_lnors)[3])
static void bm_mesh_loops_calc_normals__single_threaded(BMesh *bm, const float(*vcos)[3], const float(*fnos)[3], float(*r_lnos)[3], MLoopNorSpaceArray *r_lnors_spacearr, const short(*clnors_data)[2], const int cd_loop_clnors_offset, const bool do_rebuild, const float split_angle_cos)
#define EDGE_TAG_FROM_SPLIT_ANGLE_BYPASS
static int bm_mesh_loops_calc_normals_for_loop(BMesh *bm, const float(*vcos)[3], const float(*fnos)[3], const short(*clnors_data)[2], const int cd_loop_clnors_offset, const bool has_clnors, BLI_Stack *edge_vectors, BMLoop *l_curr, float(*r_lnos)[3], MLoopNorSpaceArray *r_lnors_spacearr)
static void bm_vert_calc_normals_cb(void *UNUSED(userdata), MempoolIterData *mp_v, const TaskParallelTLS *__restrict UNUSED(tls))
static void bm_mesh_loops_calc_normals_for_vert_init_fn(const void *__restrict userdata, void *__restrict chunk)
void BM_loops_calc_normal_vcos(BMesh *bm, const float(*vcos)[3], const float(*vnos)[3], const float(*fnos)[3], const bool use_split_normals, const float split_angle, float(*r_lnos)[3], MLoopNorSpaceArray *r_lnors_spacearr, short(*clnors_data)[2], const int cd_loop_clnors_offset, const bool do_rebuild)
BMesh Compute Loop Normals from/to external data.
static void bm_loop_normal_mark_indiv_do_loop(BMLoop *l, BLI_bitmap *loops, MLoopNorSpaceArray *lnor_spacearr, int *totloopsel, const bool do_all_loops_of_vert)
void BM_mesh_normals_update(BMesh *bm)
#define LNOR_SPACE_TRIGO_THRESHOLD
void BM_lnorspace_err(BMesh *bm)
BMLoopNorEditDataArray * BM_loop_normal_editdata_array_init(BMesh *bm, const bool do_all_loops_of_vert)
BLI_INLINE bool bm_edge_is_smooth_no_angle_test(const BMEdge *e, const BMLoop *l_a, const BMLoop *l_b)
static void loop_normal_editdata_init(BMesh *bm, BMLoopNorEditData *lnor_ed, BMVert *v, BMLoop *l, const int offset)
void BM_loop_normal_editdata_array_free(BMLoopNorEditDataArray *lnors_ed_arr)
static int bm_loop_normal_mark_indiv(BMesh *bm, BLI_bitmap *loops, const bool do_all_loops_of_vert)
static void bm_vert_calc_normals_impl(BMVert *v)
static void bm_mesh_loops_custom_normals_set(BMesh *bm, const float(*vcos)[3], const float(*fnos)[3], MLoopNorSpaceArray *r_lnors_spacearr, short(*r_clnors_data)[2], const int cd_loop_clnors_offset, float(*new_lnors)[3], const int cd_new_lnors_offset, bool do_split_fans)
static void bm_vert_calc_normals_with_coords_cb(void *userdata, MempoolIterData *mp_v, const TaskParallelTLS *__restrict UNUSED(tls))
static void bm_mesh_loops_calc_normals_for_vert_without_clnors_fn(void *userdata, MempoolIterData *mp_v, const TaskParallelTLS *__restrict tls)
BLI_INLINE void bm_vert_calc_normals_accum_loop(const BMLoop *l_iter, const float e1diff[3], const float e2diff[3], const float f_no[3], float v_no[3])
static void bm_mesh_loops_calc_normals_for_vert_with_clnors_fn(void *userdata, MempoolIterData *mp_v, const TaskParallelTLS *__restrict tls)
struct BMLoopsCalcNormalsWithCoords_TLS BMLoopsCalcNormalsWithCoords_TLS
bool BM_loop_check_cyclic_smooth_fan(BMLoop *l_curr)
static void bm_mesh_loops_calc_normals_for_vert_with_clnors(BMesh *bm, const float(*vcos)[3], const float(*fnos)[3], float(*r_lnos)[3], const short(*clnors_data)[2], const int cd_loop_clnors_offset, const bool do_rebuild, const float split_angle_cos, MLoopNorSpaceArray *r_lnors_spacearr, BLI_Stack *edge_vectors, BMVert *v)
static void bm_mesh_loops_calc_normals__multi_threaded(BMesh *bm, const float(*vcos)[3], const float(*fnos)[3], float(*r_lnos)[3], MLoopNorSpaceArray *r_lnors_spacearr, const short(*clnors_data)[2], const int cd_loop_clnors_offset, const bool do_rebuild, const float split_angle_cos)
static void bm_partial_verts_parallel_range_calc_normal_cb(void *userdata, const int iter, const TaskParallelTLS *__restrict UNUSED(tls))
struct BMLoopsCalcNormalsWithCoordsData BMLoopsCalcNormalsWithCoordsData
void BM_verts_calc_normal_vcos(BMesh *bm, const float(*fnos)[3], const float(*vcos)[3], float(*vnos)[3])
BMesh Compute Normals from/to external data.
static void bm_mesh_edges_sharp_tag(BMesh *bm, const float(*fnos)[3], float split_angle_cos, const bool do_sharp_edges_tag)
void BM_edges_sharp_from_angle_set(BMesh *bm, const float split_angle)
void BM_custom_loop_normals_from_vector_layer(BMesh *bm, bool add_sharp_edges)
static void bm_edge_tag_from_smooth_and_set_sharp(const float(*fnos)[3], BMEdge *e, const float split_angle_cos)
static void bm_mesh_loops_calc_normals_no_autosmooth(BMesh *bm, const float(*vnos)[3], const float(*fnos)[3], float(*r_lnos)[3])
static void bm_mesh_loops_calc_normals_for_vert_reduce_fn(const void *__restrict userdata, void *__restrict UNUSED(chunk_join), void *__restrict chunk)
static void bm_mesh_loops_calc_normals(BMesh *bm, const float(*vcos)[3], const float(*fnos)[3], float(*r_lnos)[3], MLoopNorSpaceArray *r_lnors_spacearr, const short(*clnors_data)[2], const int cd_loop_clnors_offset, const bool do_rebuild, const float split_angle_cos)
float BM_face_calc_normal(const BMFace *f, float r_no[3])
BMESH UPDATE FACE NORMAL.
#define BM_ELEM_API_FLAG_DISABLE(element, f)
#define BM_ELEM_API_FLAG_TEST(element, f)
#define BM_ELEM_API_FLAG_ENABLE(element, f)
bool BM_edge_loop_pair(BMEdge *e, BMLoop **r_la, BMLoop **r_lb)
BMLoop * BM_vert_step_fan_loop(BMLoop *l, BMEdge **e_step)
BMLoop * BM_face_vert_share_loop(BMFace *f, BMVert *v)
Return the Loop Shared by Face and Vertex.
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 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
IconTextureDrawCall normal
ccl_gpu_kernel_postfix ccl_global float int int int int float bool int offset
void(* MEM_freeN)(void *vmemh)
void *(* MEM_callocN)(size_t len, const char *str)
void *(* MEM_mallocN)(size_t len, const char *str)
static void clear(Message *msg)
static const pxr::TfToken b("b", pxr::TfToken::Immortal)
struct BMEditSelection * prev
BMLoopNorEditData ** lidx_to_lnor_editdata
BMLoopNorEditData * lnor_editdata
int cd_custom_normal_offset
struct BMLoop * radial_next
const float split_angle_cos
const short(* clnors_data)[2]
MLoopNorSpaceArray * r_lnors_spacearr
const int cd_loop_clnors_offset
MLoopNorSpaceArray lnors_spacearr_buf
MLoopNorSpaceArray * lnors_spacearr
BMPartialUpdate_Params params
struct MLoopNorSpaceArray * lnor_spacearr
MLoopNorSpace ** lspacearr
TaskParallelReduceFunc func_reduce
TaskParallelFreeFunc func_free
TaskParallelInitFunc func_init
size_t userdata_chunk_size