39#define EDGE_TAG_FROM_SPLIT_ANGLE_BYPASS -FLT_MAX
43 const float split_angle_cos);
56#define BM_LNORSPACE_UPDATE _FLAG_MF
68 const float e1diff[3],
69 const float e2diff[3],
76 float dotprod =
dot_v3v3(e1diff, e2diff);
77 if ((l_iter->
prev->
e->
v1 == l_iter->
prev->
v) ^ (l_iter->
e->
v1 == l_iter->
v)) {
119 if (e_first !=
nullptr) {
120 float e1diff[3], e2diff[3];
124 if (l_first !=
nullptr) {
130 if (l_iter->
v ==
v) {
137 }
while ((l_iter = l_iter->
radial_next) != l_first);
150 MempoolIterData *mp_v,
165 if (e_first !=
nullptr) {
166 float e1diff[3], e2diff[3];
170 if (l_first !=
nullptr) {
178 if (l_iter->
v ==
v) {
188 }
while ((l_iter = l_iter->
radial_next) != l_first);
201 MempoolIterData *mp_v,
235 MempoolIterData *mp_f,
277 if (bmpinfo->
verts.is_empty() && bmpinfo->
faces.is_empty()) [[unlikely]] {
283 for (const int i : range) {
284 BMFace *f = bmpinfo->faces[i];
285 BM_face_calc_normal(f, f->no);
291 for (const int i : range) {
292 BMVert *v = bmpinfo->verts[i];
293 bm_vert_calc_normals_impl(v);
349 int index_face, index_loop = 0;
356 }
while ((l_curr = l_curr->
next) != l_first);
366 float split_angle_cos,
367 const bool do_sharp_edges_tag)
377 if (do_sharp_edges_tag) {
380 if (
e->l !=
nullptr) {
388 if (
e->l !=
nullptr) {
399 if (split_angle >=
float(
M_PI)) {
415 BMLoop *lfan_pivot_next = l_curr;
431 if (lfan_pivot_next == l_curr) {
460 const short (*clnors_data)[2],
461 const int cd_loop_clnors_offset,
462 const bool has_clnors,
510 if (r_lnors_spacearr) {
511 float vec_curr[3], vec_prev[3];
515 const BMVert *v_pivot = l_curr->
v;
538 const short (*clnor)[2] = clnors_data ?
539 &clnors_data[l_curr_index] :
540 static_cast<const short (*)[2]
>(
567 const BMEdge *e_org = l_curr->
e;
568 BMLoop *lfan_pivot, *lfan_pivot_next;
569 int lfan_pivot_index;
570 float lnor[3] = {0.0f, 0.0f, 0.0f};
571 float vec_curr[3], vec_next[3], vec_org[3];
574 int clnors_avg[2] = {0, 0};
575 const short (*clnor_ref)[2] =
nullptr;
576 int clnors_count = 0;
577 bool clnors_invalid =
false;
589 e_next = lfan_pivot->
e;
603 if (r_lnors_spacearr) {
604 edge_vectors->
append(vec_org);
610 if (lfan_pivot_next) {
615 e_next = (lfan_pivot->
e == e_next) ? lfan_pivot->
prev->
e : lfan_pivot->
e;
635 const BMFace *f = lfan_pivot->
f;
643 const short (*clnor)[2] = clnors_data ?
644 &clnors_data[lfan_pivot_index] :
646 lfan_pivot, cd_loop_clnors_offset));
648 clnors_invalid |= ((*clnor_ref)[0] != (*clnor)[0] || (*clnor_ref)[1] != (*clnor)[1]);
653 clnors_avg[0] += (*clnor)[0];
654 clnors_avg[1] += (*clnor)[1];
664 if (r_lnors_spacearr) {
667 if (e_next != e_org) {
669 edge_vectors->
append(vec_next);
683 lfan_pivot = lfan_pivot_next;
691 if (r_lnors_spacearr) {
692 if (lnor_len == 0.0f) [[unlikely]] {
699 edge_vectors->
clear();
702 if (clnors_invalid) {
705 clnors_avg[0] /= clnors_count;
706 clnors_avg[1] /= clnors_count;
714 clnor[0] = short(clnors_avg[0]);
715 clnor[1] = short(clnors_avg[1]);
730 if (lnor_len != 0.0f) [[likely]] {
748 if (r_lnors_spacearr) {
781 (l_a->
v !=
l_b->
v) &&
790 const float split_angle_cos)
794 bool is_smooth =
false;
796 if (split_angle_cos != -1.0f) {
800 if (
dot >= split_angle_cos) {
831 const float split_angle_cos)
835 bool is_smooth =
false;
837 if (split_angle_cos != -1.0f) {
841 if (
dot >= split_angle_cos) {
868 const short (*clnors_data)[2],
869 const int cd_loop_clnors_offset,
870 const bool do_rebuild,
871 const float split_angle_cos,
887 const bool has_clnors =
true;
889 int loops_of_vert_count = 0;
899 BMLoop *l_curr = e_curr_iter->
l;
900 if (l_curr ==
nullptr) {
909 if (l_curr->
v !=
v) {
919 loops_of_vert_count += 1;
922 if (index_best > index_test) {
923 index_best = index_test;
924 link_best = loops_of_vert;
926 }
while ((l_curr = l_curr->
radial_next) != e_curr_iter->
l);
929 if (loops_of_vert ==
nullptr) [[unlikely]] {
936 if (link_best != loops_of_vert) {
937 std::swap(link_best->
link, loops_of_vert->
link);
941 bool loops_of_vert_is_sorted =
false;
944 int loops_of_vert_handled = 0;
946 while (loops_of_vert !=
nullptr) {
948 loops_of_vert = loops_of_vert->
next;
955 cd_loop_clnors_offset,
965 BLI_assert(loops_of_vert_handled <= loops_of_vert_count);
966 if (loops_of_vert_handled == loops_of_vert_count) {
972 if (!loops_of_vert_is_sorted) {
973 if (loops_of_vert && loops_of_vert->
next) {
975 loops_of_vert_is_sorted =
true;
990 const bool do_rebuild,
991 const float split_angle_cos,
998 const bool has_clnors =
false;
999 const short (*clnors_data)[2] =
nullptr;
1002 const int cd_loop_clnors_offset = -1;
1009 BMLoop *l_curr = e_curr_iter->
l;
1010 if (l_curr ==
nullptr) {
1019 if (l_curr->
v !=
v) {
1023 }
while ((l_curr = l_curr->
radial_next) != e_curr_iter->
l);
1028 BMLoop *l_curr = e_curr_iter->
l;
1029 if (l_curr ==
nullptr) {
1033 if (l_curr->
v !=
v) {
1045 cd_loop_clnors_offset,
1051 }
while ((l_curr = l_curr->
radial_next) != e_curr_iter->
l);
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);
1081 std::unique_ptr<Vector<float3, 16>> edge_vectors =
nullptr;
1092 if (!r_lnors_spacearr && has_clnors) {
1094 r_lnors_spacearr = &_lnors_spacearr;
1096 if (r_lnors_spacearr) {
1098 edge_vectors = std::make_unique<Vector<float3, 16>>();
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;
1140 cd_loop_clnors_offset,
1146 }
while ((l_curr = l_curr->
next) != l_first);
1149 if (r_lnors_spacearr) {
1150 if (r_lnors_spacearr == &_lnors_spacearr) {
1180 void *__restrict chunk)
1184 if (
data->r_lnors_spacearr) {
1185 tls_data->edge_vectors = MEM_new<Vector<float3, 16>>(__func__);
1187 tls_data->lnors_spacearr = &tls_data->lnors_spacearr_buf;
1190 tls_data->lnors_spacearr =
nullptr;
1196 void *__restrict chunk)
1201 if (
data->r_lnors_spacearr) {
1207 void *__restrict chunk)
1212 if (
data->r_lnors_spacearr) {
1213 MEM_delete(tls_data->edge_vectors);
1218 void *userdata, MempoolIterData *mp_v,
const TaskParallelTLS *__restrict tls)
1221 if (
v->
e ==
nullptr) {
1232 data->cd_loop_clnors_offset,
1234 data->split_angle_cos,
1236 tls_data->lnors_spacearr,
1237 tls_data->edge_vectors,
1243 void *userdata, MempoolIterData *mp_v,
const TaskParallelTLS *__restrict tls)
1246 if (
v->
e ==
nullptr) {
1257 data->split_angle_cos,
1259 tls_data->lnors_spacearr,
1260 tls_data->edge_vectors,
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) {
1319 data.r_lnos = r_lnos;
1320 data.r_lnors_spacearr = r_lnors_spacearr;
1321 data.clnors_data = clnors_data;
1322 data.cd_loop_clnors_offset = cd_loop_clnors_offset;
1323 data.do_rebuild = do_rebuild;
1324 data.split_angle_cos = split_angle_cos;
1333 if (r_lnors_spacearr) {
1334 if (r_lnors_spacearr == &_lnors_spacearr) {
1345 const short (*clnors_data)[2],
1346 const int cd_loop_clnors_offset,
1347 const bool do_rebuild,
1348 const float split_angle_cos)
1357 cd_loop_clnors_offset,
1368 cd_loop_clnors_offset,
1375#define LNOR_SPACE_TRIGO_THRESHOLD (1.0f - 1e-4f)
1383 const float (*new_lnors)[3])
1386 bool changed =
false;
1398 printf(
"WARNING! Getting invalid nullptr loop space for loop %d!\n", i);
1419 BMLoop *prev_ml =
nullptr;
1420 const float *org_nor =
nullptr;
1425 const float *nor = new_lnors[lidx];
1445 loops = loops->
next;
1454 if (loops && org_nor) {
1457 const float *nor = new_lnors[lidx];
1469 MEM_delete(done_loops);
1479 short (*r_clnors_data)[2],
1480 const int cd_loop_clnors_offset,
1481 const float (*new_lnors)[3])
1493 printf(
"WARNING! Still getting invalid nullptr loop space in second loop for loop %d!\n",
1512 const float *nor = new_lnors[lidx];
1513 short *clnor =
static_cast<short *
>(r_clnors_data ?
1514 &r_clnors_data[lidx] :
1521 int avg_nor_count = 0;
1523 short clnor_data_tmp[2], *clnor_data;
1530 const float *nor = new_lnors[lidx];
1531 short *clnor =
static_cast<short *
>(
1532 r_clnors_data ? &r_clnors_data[lidx] :
1539 loops = loops->
next;
1543 mul_v3_fl(avg_nor, 1.0f /
float(avg_nor_count));
1545 lnors_spacearr->
lspacearr[i], avg_nor, clnor_data_tmp);
1548 clnor_data[0] = clnor_data_tmp[0];
1549 clnor_data[1] = clnor_data_tmp[1];
1555 MEM_delete(done_loops);
1569 short (*r_clnors_data)[2],
1570 const int cd_loop_clnors_offset,
1571 float (*new_lnors)[3],
1572 const int cd_new_lnors_offset,
1594 cd_loop_clnors_offset,
1599 float (*custom_lnors)[3] = new_lnors;
1601 if (new_lnors ==
nullptr) {
1635 cd_loop_clnors_offset,
1643 bm, r_lnors_spacearr, r_clnors_data, cd_loop_clnors_offset, custom_lnors);
1645 if (custom_lnors != new_lnors) {
1646 MEM_delete(custom_lnors);
1670 BMLoop *l_curr, *l_first;
1681 }
while ((l_curr = l_curr->
next) != l_first);
1689 const bool use_split_normals,
1692 short (*clnors_data)[2],
1693 const int cd_loop_clnors_offset,
1694 const bool do_rebuild)
1697 if (use_split_normals) {
1704 cd_loop_clnors_offset,
1730 bm, {}, {}, {},
true, r_lnors,
bm->
lnor_spacearr,
nullptr, cd_loop_clnors_offset,
false);
1734#define CLEAR_SPACEARRAY_THRESHOLD(x) ((x) / 2)
1802 MEM_delete(done_verts);
1825 if (preserve_clnor) {
1833 short (*clnor)[2] =
static_cast<short (*)[2]
>(
1848 bm, {}, {}, {},
true, r_lnors,
bm->
lnor_spacearr,
nullptr, cd_loop_clnors_offset,
true);
1855 if (preserve_clnor) {
1856 short (*clnor)[2] =
static_cast<short (*)[2]
>(
1892 if (vert_free_offset != -1) {
1904 else if (edge_free_offset != -1) {
1907 else if (face_free_offset != -1) {
1919 else if (loop_free_offset != -1) {
1975 bm, {}, {}, {},
true, lnors, temp,
nullptr, cd_loop_clnors_offset,
true);
2013 const bool do_all_loops_of_vert)
2023 if (do_all_loops_of_vert) {
2055 const bool do_all_loops_of_vert,
2074 const bool do_all_loops_of_vert,
2104 const bool do_all_loops_of_vert,
2159 const bool use_sel_face_history = sel_faces && (sel_edges || sel_verts);
2166 if (use_sel_face_history) {
2177 if (ese_prev->htype ==
BM_VERT) {
2180 reinterpret_cast<BMVert *
>(ese_prev->ele)),
2184 do_all_loops_of_vert);
2186 else if (ese_prev->htype ==
BM_EDGE) {
2193 do_all_loops_of_vert);
2200 do_all_loops_of_vert);
2208 if (totloopsel == 0) {
2235 float custom_normal[3];
2247 BMesh *
bm,
const bool do_all_loops_of_vert,
const char htype_override)
2270 if (htype_override != 0) {
2272 switch (htype_override) {
2304 lnors_ed_arr->
totloop = totloopsel;
2309 return lnors_ed_arr;
2313 const bool do_all_loops_of_vert)
2322 MEM_delete(lnors_ed_arr);
2357 const short *clnors_data =
static_cast<const short *
>(
2374 if (cd_custom_normal_offset == -1) {
2378 if (cd_normal_offset == -1) {
2391 cd_custom_normal_offset,
CustomData interface, see also DNA_customdata_types.h.
#define BLI_BITMAP_NEW(_num, _alloc_string)
#define BLI_BITMAP_TEST(_bitmap, _index)
#define BLI_BITMAP_ENABLE(_bitmap, _index)
#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)
Read Blender memory allocation and freeing.
#define UNUSED_VARS_NDEBUG(...)
#define BM_DISK_EDGE_NEXT(e, v)
#define BM_FACE_FIRST_LOOP(p)
#define BM_ELEM_CD_GET_FLOAT_P(ele, offset)
#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)
#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 CLEAR_SPACEARRAY_THRESHOLD(x)
#define BM_LNORSPACE_UPDATE
#define EDGE_TAG_FROM_SPLIT_ANGLE_BYPASS
#define BM_ELEM_API_FLAG_DISABLE(element, f)
#define BM_ELEM_API_FLAG_TEST(element, f)
#define BM_ELEM_API_FLAG_ENABLE(element, f)
constexpr bool is_empty() const
constexpr bool is_empty() const
void append(const T &value)
float dot(VecOp< float, D >, VecOp< float, D >) RET
#define LNOR_SPACE_TRIGO_THRESHOLD
float safe_acos_approx(float x)
void parallel_for(const IndexRange range, const int64_t grain_size, const Function &function, const TaskSizeHints &size_hints=detail::TaskSizeHints_Static(1))
static void bm_vert_calc_normals_impl(BMVert *v)
void BM_lnorspace_update(BMesh *bm)
bool BM_data_layer_free_named(BMesh *bm, CustomData *data, StringRef name)
int CustomData_get_offset(const CustomData *data, eCustomDataType type)
BLI_assert(slot->slot_subtype.map==BMO_OP_SLOT_SUBTYPE_MAP_FLT)
static void bm_mesh_loops_calc_normals_for_vert_free_fn(const void *__restrict userdata, void *__restrict chunk)
void BM_mesh_elem_index_ensure(BMesh *bm, const char htype)
void BM_data_layer_add(BMesh *bm, CustomData *data, int type)
MINLINE bool is_finite_v3(const float v[3]) ATTR_WARN_UNUSED_RESULT
LinkNode * BLI_linklist_sort(LinkNode *list, int(*cmp)(const void *, const void *)) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(2)
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])
static int bm_loop_normal_mark_faces(BMesh *bm, BLI_bitmap *loops, const bool do_all_loops_of_vert)
static void bm_mesh_loops_calc_normals__single_threaded(BMesh *bm, const Span< float3 > vcos, const Span< float3 > fnos, MutableSpan< float3 > r_lnos, MLoopNorSpaceArray *r_lnors_spacearr, const short(*clnors_data)[2], const int cd_loop_clnors_offset, const bool do_rebuild, const float split_angle_cos)
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
static void bm_mesh_loops_calc_normals_for_vert_with_clnors(BMesh *bm, const Span< float3 > vcos, const Span< float3 > fnos, MutableSpan< float3 > r_lnos, const short(*clnors_data)[2], const int cd_loop_clnors_offset, const bool do_rebuild, const float split_angle_cos, MLoopNorSpaceArray *r_lnors_spacearr, Vector< float3, 16 > *edge_vectors, BMVert *v)
ATTR_WARN_UNUSED_RESULT const BMLoop * l
static void bm_lnorspace_ensure_from_free_normals(BMesh *bm)
static void bm_mesh_loops_calc_normals_for_vert_without_clnors_fn(void *userdata, MempoolIterData *mp_v, const TaskParallelTLS *__restrict tls)
void BKE_lnor_spacearr_tls_join(MLoopNorSpaceArray *lnors_spacearr, MLoopNorSpaceArray *lnors_spacearr_tls)
bool CustomData_has_layer(const CustomData *data, eCustomDataType type)
static int bm_loop_index_cmp(const void *a, const void *b)
static void bm_edge_tag_from_smooth(Span< float3 > fnos, BMEdge *e, const float split_angle_cos)
BMLoop * BM_vert_step_fan_loop(BMLoop *l, BMEdge **e_step)
void BM_custom_loop_normals_from_vector_layer(BMesh *bm, bool add_sharp_edges)
static void bm_mesh_loops_calc_normals__multi_threaded(BMesh *bm, const Span< float3 > vcos, const Span< float3 > fnos, MutableSpan< float3 > r_lnos, MLoopNorSpaceArray *r_lnors_spacearr, const short(*clnors_data)[2], const int cd_loop_clnors_offset, const bool do_rebuild, const float split_angle_cos)
ATTR_WARN_UNUSED_RESULT const BMVert * v
void BM_loops_calc_normal_vcos(BMesh *bm, const Span< float3 > vcos, const Span< float3 > vnos, const Span< float3 > fnos, const bool use_split_normals, MutableSpan< float3 > r_lnos, 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 int bm_mesh_loops_calc_normals_for_loop(BMesh *bm, const Span< float3 > vcos, const Span< float3 > fnos, const short(*clnors_data)[2], const int cd_loop_clnors_offset, const bool has_clnors, Vector< float3, 16 > *edge_vectors, BMLoop *l_curr, MutableSpan< float3 > r_lnos, MLoopNorSpaceArray *r_lnors_spacearr)
void BM_edges_sharp_from_angle_set(BMesh *bm, const float split_angle)
void BM_lnorspacearr_store(BMesh *bm, MutableSpan< float3 > r_lnors)
void BM_mesh_normals_update_ex(BMesh *bm, const BMeshNormalsUpdate_Params *params)
BMesh Compute Normals.
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()
MINLINE void mul_v3_fl(float r[3], float f)
void BKE_lnor_spacearr_tls_init(MLoopNorSpaceArray *lnors_spacearr, MLoopNorSpaceArray *lnors_spacearr_tls)
BLI_INLINE void BLI_parallel_mempool_settings_defaults(TaskParallelSettings *settings)
void BM_lnorspace_err(BMesh *bm)
BLI_INLINE bool bm_edge_is_smooth_no_angle_test(const BMEdge *e, const BMLoop *l_a, const BMLoop *l_b)
bool BM_loop_check_cyclic_smooth_fan(BMLoop *l_curr)
MINLINE void madd_v3_v3fl(float r[3], const float a[3], float f)
static void bm_mesh_loops_custom_normals_set(BMesh *bm, const Span< float3 > vcos, const Span< float3 > fnos, 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_mesh_loops_calc_normals_for_vert_with_clnors_fn(void *userdata, MempoolIterData *mp_v, const TaskParallelTLS *__restrict tls)
static int bm_loop_normal_mark_edges(BMesh *bm, BLI_bitmap *loops, const bool do_all_loops_of_vert)
void * MEM_new_zeroed(size_t len, const char *str) ATTR_WARN_UNUSED_RESULT ATTR_ALLOC_SIZE(1) ATTR_NONNULL(2)
void BKE_lnor_space_define(MLoopNorSpace *lnor_space, const float lnor[3], const float vec_ref[3], const float vec_other[3], Span< float3 > edge_vectors)
void BKE_lnor_spacearr_init(MLoopNorSpaceArray *lnors_spacearr, int numLoops, char data_type)
BMesh const char void * 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 BKE_lnor_spacearr_clear(MLoopNorSpaceArray *lnors_spacearr)
void CustomData_set_layer_flag(CustomData *data, eCustomDataType type, eCustomDataLayer_Flag flag)
int CustomData_get_offset_named(const CustomData *data, eCustomDataType type, StringRef name)
ATTR_WARN_UNUSED_RESULT const BMLoop * l_b
void BM_loop_normal_editdata_array_free(BMLoopNorEditDataArray *lnors_ed_arr)
void BM_normals_loops_edges_tag(BMesh *bm, const bool do_edges)
static void bm_loop_normal_mark_edges_impl(BMesh *bm, BLI_bitmap *loops, const bool do_all_loops_of_vert, int *totloopsel_p)
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])
void BKE_lnor_space_custom_normal_to_data(const MLoopNorSpace *lnor_space, const float custom_lnor[3], short r_clnor_data[2])
static void bm_mesh_loops_calc_normals_no_autosmooth(BMesh *bm, const Span< float3 > vnos, const Span< float3 > fnos, MutableSpan< float3 > r_lnos)
static void bm_mesh_edges_sharp_tag(BMesh *bm, const Span< float3 > fnos, float split_angle_cos, const bool do_sharp_edges_tag)
static void bm_mesh_loops_calc_normals(BMesh *bm, const Span< float3 > vcos, const Span< float3 > fnos, MutableSpan< float3 > r_lnos, MLoopNorSpaceArray *r_lnors_spacearr, const short(*clnors_data)[2], const int cd_loop_clnors_offset, const bool do_rebuild, const float split_angle_cos)
void BKE_lnor_space_add_loop(MLoopNorSpaceArray *lnors_spacearr, MLoopNorSpace *lnor_space, int corner, void *bm_loop, bool is_single)
MINLINE void zero_v3(float r[3])
static void bm_mesh_loops_calc_normals_for_vert_init_fn(const void *__restrict userdata, void *__restrict chunk)
static void bm_face_calc_normals_cb(void *, MempoolIterData *mp_f, const TaskParallelTLS *__restrict)
MINLINE float normalize_v3_v3(float r[3], const float a[3])
MINLINE float normalize_v3(float n[3])
MINLINE void add_v3_v3(float r[3], const float a[3])
void BKE_lnor_spacearr_free(MLoopNorSpaceArray *lnors_spacearr)
bool BM_edge_loop_pair(BMEdge *e, BMLoop **r_la, BMLoop **r_lb)
static int bm_loop_normal_mark_verts(BMesh *bm, BLI_bitmap *loops, const bool do_all_loops_of_vert)
MINLINE void sub_v3_v3v3(float r[3], const float a[3], const float b[3])
static void bm_vert_calc_normals_with_coords(BMVert *v, BMVertsCalcNormalsWithCoordsData *data)
static void bm_mesh_loops_calc_normals_for_vert_without_clnors(BMesh *bm, const Span< float3 > vcos, const Span< float3 > fnos, MutableSpan< float3 > r_lnos, const bool do_rebuild, const float split_angle_cos, MLoopNorSpaceArray *r_lnors_spacearr, Vector< float3, 16 > *edge_vectors, BMVert *v)
@ MLNOR_SPACEARR_BMLOOP_PTR
MINLINE bool compare_v3v3(const float v1[3], const float v2[3], float limit) ATTR_WARN_UNUSED_RESULT
void BM_data_layer_ensure_named(BMesh *bm, CustomData *data, int type, const StringRef name)
static void bm_vert_calc_normals_with_coords_cb(void *userdata, MempoolIterData *mp_v, const TaskParallelTLS *__restrict)
static void bm_mesh_verts_calc_normals(BMesh *bm, const Span< float3 > fnos, const Span< float3 > vcos, MutableSpan< float3 > vnos)
static int bm_loop_normal_mark_indiv(BMesh *bm, BLI_bitmap *loops, const bool do_all_loops_of_vert)
float BM_face_calc_normal(const BMFace *f, float r_no[3])
BMESH UPDATE FACE NORMAL.
BMLoopNorEditDataArray * BM_loop_normal_editdata_array_init(BMesh *bm, const bool do_all_loops_of_vert)
static void bm_loop_normal_mark_verts_impl(BMesh *bm, BLI_bitmap *loops, const bool do_all_loops_of_vert, int *totloopsel_p)
BMLoopNorEditDataArray * BM_loop_normal_editdata_array_init_with_htype(BMesh *bm, const bool do_all_loops_of_vert, const char htype_override)
void BKE_lnor_space_custom_data_to_normal(const MLoopNorSpace *lnor_space, const short clnor_data[2], float r_custom_lnor[3])
static void bm_mesh_loops_calc_normals_for_vert_reduce_fn(const void *__restrict userdata, void *__restrict, void *__restrict chunk)
static void bm_loop_normal_mark_faces_impl(BMesh *bm, BLI_bitmap *loops, const bool do_all_loops_of_vert, int *totloopsel_p)
BMLoop * BM_face_vert_share_loop(BMFace *f, BMVert *v)
Return the Loop Shared by Face and Vertex.
static bool bm_mesh_loops_split_lnor_fans(BMesh *bm, MLoopNorSpaceArray *lnors_spacearr, const float(*new_lnors)[3])
VecBase< float, 3 > float3
void BM_mesh_normals_update_with_partial(BMesh *bm, const BMPartialUpdate *bmpinfo)
bool CustomData_has_layer_named(const CustomData *data, eCustomDataType type, StringRef name)
void BM_lnorspace_rebuild(BMesh *bm, bool preserve_clnor)
MINLINE float dot_v3v3(const float a[3], const float b[3]) ATTR_WARN_UNUSED_RESULT
bool BM_custom_loop_normals_to_vector_layer(BMesh *bm)
static void bm_edge_tag_from_smooth_and_set_sharp(Span< float3 > fnos, BMEdge *e, const float split_angle_cos)
static void loop_normal_editdata_init(BMesh *bm, BMLoopNorEditData *lnor_ed, BMVert *v, BMLoop *l, const int offset)
MINLINE bool is_zero_v3(const float v[3]) ATTR_WARN_UNUSED_RESULT
void BM_mesh_normals_update_with_partial_ex(BMesh *, const BMPartialUpdate *bmpinfo, const BMeshNormalsUpdate_Params *params)
static void bm_vert_calc_normals_cb(void *, MempoolIterData *mp_v, const TaskParallelTLS *__restrict)
ATTR_WARN_UNUSED_RESULT const BMVert const BMEdge * e
MINLINE int compare_ff(float a, float b, float max_diff)
void BM_iter_parallel(BMesh *bm, const char itype, TaskParallelMempoolFunc func, void *userdata, const TaskParallelSettings *settings)
Parallel (threaded) iterator, only available for most basic iteration-types (verts/edges/faces of mes...
void BM_mesh_normals_update(BMesh *bm)
void * MEM_new_array_zeroed(size_t len, size_t size, const char *str) ATTR_WARN_UNUSED_RESULT ATTR_ALLOC_SIZE(1
void BM_lnorspace_invalidate(BMesh *bm, const bool do_invalidate_all)
MLoopNorSpace * BKE_lnor_space_create(MLoopNorSpaceArray *lnors_spacearr)
void BM_verts_calc_normal_vcos(BMesh *bm, const Span< float3 > fnos, const Span< float3 > vcos, MutableSpan< float3 > vnos)
BMesh Compute Normals from/to external data.
KERNEL_FEATURE_LIGHT_PASSES KERNEL_FEATURE_PATH_GUIDING float
struct BMEditSelection * prev
BMLoopNorEditData * lnor_editdata
BMLoopNorEditData ** lidx_to_lnor_editdata
int cd_custom_normal_offset
struct BMLoop * radial_next
MutableSpan< float3 > r_lnos
const short(* clnors_data)[2]
int cd_loop_clnors_offset
MLoopNorSpaceArray * r_lnors_spacearr
Vector< float3, 16 > * edge_vectors
MLoopNorSpaceArray * lnors_spacearr
MLoopNorSpaceArray lnors_spacearr_buf
BMPartialUpdate_Params params
MutableSpan< float3 > vnos
ListBaseT< BMEditSelection > selected
struct MLoopNorSpaceArray * lnor_spacearr
MLoopNorSpace ** lspacearr
TaskParallelReduceFunc func_reduce
TaskParallelInitFunc func_init
size_t userdata_chunk_size
TaskParallelFreeFunc func_free