54 if (!vmap->
vert || !vmap->
buf) {
63 for (const int64_t face : range) {
64 const Span<float2> face_uvs = uv_map.slice(faces[face]);
65 winding[face] = cross_poly_v2(reinterpret_cast<const float (*)[2]>(face_uvs.data()),
66 uint(faces[face].size())) < 0.0f;
71 for (
const int64_t a : faces.index_range()) {
72 const IndexRange face = faces[a];
73 for (
const int64_t i : face.index_range()) {
74 buf->loop_of_face_index =
ushort(i);
75 buf->face_index =
uint(a);
76 buf->separate =
false;
77 buf->next = vmap->vert[corner_verts[face[i]]];
78 vmap->vert[corner_verts[face[i]]] = buf;
87 const float *uv, *uv2;
96 uv = uv_map[faces[
v->face_index].start() +
v->loop_of_face_index];
103 uv2 = uv_map[faces[iterv->face_index].start() + iterv->loop_of_face_index];
106 if (
fabsf(uv[0] - uv2[0]) < limit[0] &&
fabsf(uv[1] - uv2[1]) < limit[1] &&
107 (!use_winding || winding[iterv->face_index] == winding[
v->face_index]))
115 iterv->next = newvlist;
125 newvlist->separate =
true;
128 vmap->vert[
vert] = newvlist;
136 return vmap->
vert[
v];
143 MEM_delete(vmap->
vert);
146 MEM_delete(vmap->
buf);
155 const int3 *corner_tris,
157 const int *corner_verts,
166 for (i = 0; i < tris_num; i++) {
167 for (
int j = 3; j--;) {
168 map[corner_verts[corner_tris[i][j]]].
count++;
173 index_step = indices;
174 for (i = 0; i < totvert; i++) {
176 index_step += map[i].
count;
183 for (i = 0; i < tris_num; i++) {
184 for (
int j = 3; j--;) {
185 MeshElemMap *map_ele = &map[corner_verts[corner_tris[i][j]]];
197 const int *final_origindex,
206 for (i = 0; i < totfinal; i++) {
209 map[final_origindex[i]].
count++;
214 index_step = indices;
215 for (i = 0; i < totsource; i++) {
217 index_step += map[i].
count;
224 for (i = 0; i < totfinal; i++) {
238 const int *corner_tri_faces,
239 const int corner_tris_num)
246 index_step = indices;
253 for (
int i = 0; i < corner_tris_num; i++) {
291 return {offsets, r_indices};
370 const int *face_groups,
372 const int face_group_id,
373 const int face_group_id_overflowed,
374 int &r_bit_face_group_mask)
379 for (
const int face_idx : faces_from_item) {
380 int bit = face_groups[face_idx];
381 if (!
ELEM(bit, 0, face_group_id, face_group_id_overflowed) && !(r_bit_face_group_mask & bit)) {
382 r_bit_face_group_mask |= bit;
410 const bool use_bitflags,
411 const bool use_boundary_vertices_for_bitflags,
416 int *r_totedgeboundaries)
422 int num_edgeboundaries = 0;
425 constexpr int temp_face_group_id = 3;
429 constexpr int face_group_id_overflowed = 5;
432 bool group_id_overflow =
false;
436 *r_face_groups =
nullptr;
437 if (r_edge_boundaries) {
438 *r_edge_boundaries =
nullptr;
439 *r_totedgeboundaries = 0;
444 if (r_edge_boundaries) {
446 *r_totedgeboundaries = 0;
453 faces, corner_edges, totedge, edge_to_face_src_offsets, edge_to_face_src_indices);
457 if (use_bitflags && vert_face_map.
is_empty()) {
459 faces, corner_verts, totvert, vert_to_face_src_offsets, vert_to_face_src_indices);
467 int bit_face_group_mask = 0;
469 int ps_curr_idx = 0, ps_end_idx = 0;
471 for (face = face_prev; face < int(faces.
size()); face++) {
472 if (face_groups[face] == 0) {
477 if (face ==
int(faces.
size())) {
482 face_group_id = use_bitflags ? temp_face_group_id : ++tot_group;
485 face_prev = face + 1;
487 face_groups[face] = face_group_id;
488 face_stack[ps_end_idx++] = face;
490 while (ps_curr_idx != ps_end_idx) {
491 face = face_stack[ps_curr_idx++];
492 BLI_assert(face_groups[face] == face_group_id);
494 for (
const int64_t loop : faces[face]) {
495 const int edge = corner_edges[loop];
497 const Span<int> map_ele = edge_face_map[edge];
498 const int *p = map_ele.
data();
499 int i = int(map_ele.
size());
500 if (!edge_boundary_check(face,
int(loop), edge, i, map_ele)) {
505 if (face_groups[*p] == 0) {
506 face_groups[*p] = face_group_id;
507 face_stack[ps_end_idx++] = *p;
514 num_edgeboundaries++;
521 face_group_id_overflowed,
522 bit_face_group_mask);
523 if (use_boundary_vertices_for_bitflags) {
537 const int vert = corner_verts[loop];
541 face_group_id_overflowed,
542 bit_face_group_mask);
553 int i, *p, gid_bit = 0;
557 for (; (face_group_id & bit_face_group_mask) && (gid_bit < 32); gid_bit++) {
560 if (gid_bit > 31) [[unlikely]] {
572 "Warning, could not find an available id for current smooth group, faces will me "
574 "as out of any smooth group...\n");
577 face_group_id = face_group_id_overflowed;
579 group_id_overflow =
true;
581 tot_group = std::max(gid_bit, tot_group);
583 for (i = ps_end_idx, p = face_stack; i--; p++) {
584 face_groups[*p] = face_group_id;
594 if (group_id_overflow) [[unlikely]] {
595 int i = int(faces.
size()), *gid = face_groups;
597 if (*gid == face_group_id_overflowed) {
605 MEM_delete(face_stack);
607 *r_totgroup = tot_group;
608 *r_face_groups = face_groups;
609 if (r_edge_boundaries) {
610 *r_edge_boundaries = edge_boundaries;
611 *r_totedgeboundaries = num_edgeboundaries;
623 const bool use_bitflags,
624 const bool use_boundary_vertices_for_bitflags)
626 int *face_groups =
nullptr;
628 auto face_is_smooth = [&](
const int i) {
return sharp_faces.
is_empty() || !sharp_faces[i]; };
630 auto face_is_island_boundary_smooth = [&](
const int face_index,
632 const int edge_index,
633 const int edge_user_count,
637 if (face_is_smooth(face_index) && !(!sharp_edges.
is_empty() && sharp_edges[edge_index]) &&
638 (edge_user_count == 2))
641 const int other_face_index = (face_index == edge_face_map_elem[0]) ? edge_face_map_elem[1] :
642 edge_face_map_elem[0];
643 return !face_is_smooth(other_face_index);
656 use_boundary_vertices_for_bitflags,
657 face_is_island_boundary_smooth,
674 edges_num, 0, faces, corner_edges, {}, sharp_edges, sharp_faces, r_totgroup,
false,
false);
684 const bool use_boundary_vertices_for_bitflags,
696 use_boundary_vertices_for_bitflags);
699#define MISLAND_DEFAULT_BUFSIZE 64
702 const short item_type,
704 const short island_type,
705 const short innercut_type)
709 if (mem ==
nullptr) {
711 island_store->
mem = mem;
743 island_store->
islands =
nullptr;
748 if (island_store->
mem) {
757 if (island_store->
mem) {
759 island_store->
mem =
nullptr;
765 const int *items_indices,
766 const int num_island_items,
767 int *island_item_indices,
768 const int num_innercut_items,
769 int *innercut_item_indices)
774 const int curr_island_idx = island_store->
islands_num++;
775 const size_t curr_num_islands = size_t(island_store->
islands_num);
788 memcpy(islds, island_store->
islands,
sizeof(*islds) * (curr_num_islands - 1));
793 memcpy(innrcuts, island_store->
innercuts,
sizeof(*innrcuts) * (curr_num_islands - 1));
799 isld->
count = num_island_items;
800 isld->
indices =
static_cast<int *
>(
802 memcpy(isld->
indices, island_item_indices,
sizeof(*isld->
indices) *
size_t(num_island_items));
806 innrcut->
count = num_innercut_items;
807 innrcut->
indices =
static_cast<int *
>(
810 innercut_item_indices,
811 sizeof(*innrcut->
indices) *
size_t(num_innercut_items));
820 int *face_groups =
nullptr;
825 int num_pidx, num_lidx;
831 int num_edge_boundaries = 0;
832 char *edge_boundary_count =
nullptr;
833 int *edge_innercut_indices =
nullptr;
834 int num_einnercuts = 0;
841 int(corner_edges.
size()),
848 faces, corner_edges, totedge, edge_to_face_offsets, edge_to_face_indices);
856 auto mesh_check_island_boundary_uv = [&](
const int ,
858 const int edge_index,
862 return !uv_seams.
is_empty() && uv_seams[edge_index];
874 mesh_check_island_boundary_uv,
878 &num_edge_boundaries);
880 if (!num_face_groups) {
881 if (num_edge_boundaries) {
882 MEM_delete(edge_boundaries);
887 if (num_edge_boundaries) {
897 for (grp_idx = 1; grp_idx <= num_face_groups; grp_idx++) {
898 num_pidx = num_lidx = 0;
899 if (num_edge_boundaries) {
901 memset(edge_boundary_count, 0,
sizeof(*edge_boundary_count) *
size_t(totedge));
905 if (face_groups[p_idx] != grp_idx) {
908 face_indices[num_pidx++] = int(p_idx);
909 for (
const int64_t corner : faces[p_idx]) {
910 const int edge_i = corner_edges[corner];
911 loop_indices[num_lidx++] = int(corner);
913 (edge_boundary_count[edge_i] < 2))
915 edge_boundary_count[edge_i]++;
916 if (edge_boundary_count[edge_i] == 2) {
917 edge_innercut_indices[num_einnercuts++] = edge_i;
929 edge_innercut_indices);
932 MEM_delete(face_indices);
933 MEM_delete(loop_indices);
934 MEM_delete(face_groups);
936 if (num_edge_boundaries) {
937 MEM_delete(edge_boundaries);
940 if (num_edge_boundaries) {
941 MEM_delete(edge_boundary_count);
942 MEM_delete(edge_innercut_indices);
957 int(edges.
size()), uv_seams, faces, corner_edges, r_island_store);
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_MEMARENA_STD_BUFSIZE
Read Blender memory allocation and freeing.
const T & last(const int64_t n=0) const
void reinitialize(const int64_t new_size)
constexpr IndexRange()=default
Span< NewT > constexpr cast() const
constexpr const T * data() const
constexpr int64_t size() const
constexpr bool is_empty() const
IndexRange index_range() const
#define MISLAND_DEFAULT_BUFSIZE
void build_vert_to_face_indices(OffsetIndices< int > faces, Span< int > corner_verts, OffsetIndices< int > offsets, MutableSpan< int > face_indices)
GroupedSpan< int > build_vert_to_corner_map(Span< int > corner_verts, int verts_num, Array< int > &r_offsets, Array< int > &r_indices)
GroupedSpan< int > build_edge_to_corner_map(Span< int > corner_edges, int edges_num, Array< int > &r_offsets, Array< int > &r_indices)
static Array< int > create_reverse_offsets(const Span< int > indices, const int items_num)
int face_triangles_num(const int face_size)
GroupedSpan< int > build_edge_to_face_map(OffsetIndices< int > faces, Span< int > corner_edges, int edges_num, Array< int > &r_offsets, Array< int > &r_indices)
Array< int > build_corner_to_face_map(OffsetIndices< int > faces)
Array< int > build_vert_to_corner_indices(Span< int > corner_verts, OffsetIndices< int > offsets)
GroupedSpan< int > build_vert_to_face_map(OffsetIndices< int > faces, Span< int > corner_verts, int verts_num, Array< int > &r_offsets, Array< int > &r_indices)
GroupedSpan< int > build_vert_to_edge_map(Span< int2 > edges, int verts_num, Array< int > &r_offsets, Array< int > &r_indices)
void build_reverse_map(OffsetIndices< int > offsets, MutableSpan< int > r_map)
GroupedSpan< int > build_groups_from_indices(Span< int > indices, int groups_num, Array< int > &offset_data, Array< int > &index_data)
OffsetIndices< int > build_reverse_offsets(Span< int > indices, MutableSpan< int > offsets)
void reverse_indices_in_groups(Span< int > group_indices, OffsetIndices< int > offsets, MutableSpan< int > results, bool sort=true)
void parallel_for(const IndexRange range, const int64_t grain_size, const Function &function, const TaskSizeHints &size_hints=detail::TaskSizeHints_Static(1))
BLI_assert(slot->slot_subtype.map==BMO_OP_SLOT_SUBTYPE_MAP_FLT)
void BKE_mesh_uv_vert_map_free(UvVertMap *vmap)
MemArena * BLI_memarena_new(size_t bufsize, const char *name) ATTR_WARN_UNUSED_RESULT ATTR_RETURNS_NONNULL ATTR_NONNULL(2) ATTR_MALLOC
static void face_edge_loop_islands_calc_bitflags_exclude_at_boundary(const int *face_groups, const Span< int > faces_from_item, const int face_group_id, const int face_group_id_overflowed, int &r_bit_face_group_mask)
void * MEM_new_array_uninitialized(size_t len, size_t size, const char *str) ATTR_WARN_UNUSED_RESULT ATTR_ALLOC_SIZE(1
UvMapVert * BKE_mesh_uv_vert_map_get_vert(UvVertMap *vmap, unsigned int v)
MINLINE void sub_v2_v2v2(float r[2], const float a[2], const float b[2])
ATTR_WARN_UNUSED_RESULT const BMVert * v
int * BKE_mesh_calc_smoothgroups(int edges_num, OffsetIndices< int > faces, Span< int > corner_edges, Span< bool > sharp_edges, Span< bool > sharp_faces, int *r_totgroup)
VecBase< float, 2 > float2
VecBase< int32_t, 3 > int3
static void face_edge_loop_islands_calc(const int totedge, const int totvert, const OffsetIndices< int > faces, const Span< int > corner_edges, const Span< int > corner_verts, GroupedSpan< int > edge_face_map, GroupedSpan< int > vert_face_map, const bool use_bitflags, const bool use_boundary_vertices_for_bitflags, MeshRemap_CheckIslandBoundary edge_boundary_check, int **r_face_groups, int *r_totgroup, BLI_bitmap **r_edge_boundaries, int *r_totedgeboundaries)
void * MEM_new_zeroed(size_t len, const char *str) ATTR_WARN_UNUSED_RESULT ATTR_ALLOC_SIZE(1) ATTR_NONNULL(2)
void BLI_memarena_clear(MemArena *ma) ATTR_NONNULL(1)
void BKE_mesh_origindex_map_create_corner_tri(MeshElemMap **r_map, int **r_mem, OffsetIndices< int > faces, const int *corner_tri_faces, int corner_tris_num)
UvVertMap * BKE_mesh_uv_vert_map_create(OffsetIndices< int > faces, Span< int > corner_verts, Span< float2 > uv_map, int verts_num, const float2 &limit, bool use_winding)
void BKE_mesh_loop_islands_add(MeshIslandStore *island_store, int item_num, const int *items_indices, int num_island_items, int *island_item_indices, int num_innercut_items, int *innercut_item_indices)
void BKE_mesh_vert_corner_tri_map_create(MeshElemMap **r_map, int **r_mem, int totvert, const int3 *corner_tris, int tris_num, const int *corner_verts, int corners_num)
static int * mesh_calc_smoothgroups(const int edges_num, const int verts_num, const OffsetIndices< int > faces, const Span< int > corner_edges, const Span< int > corner_verts, const Span< bool > sharp_edges, const Span< bool > sharp_faces, int *r_totgroup, const bool use_bitflags, const bool use_boundary_vertices_for_bitflags)
void * BLI_memarena_alloc(MemArena *ma, size_t size) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1) ATTR_MALLOC ATTR_ALLOC_SIZE(2)
void BKE_mesh_loop_islands_clear(MeshIslandStore *island_store)
static bool mesh_calc_islands_loop_face_uv(const int totedge, const Span< bool > uv_seams, const OffsetIndices< int > faces, const Span< int > corner_edges, MeshIslandStore *r_island_store)
void BKE_mesh_loop_islands_free(MeshIslandStore *island_store)
void BKE_mesh_origindex_map_create(MeshElemMap **r_map, int **r_mem, int totsource, const int *final_origindex, int totfinal)
FunctionRef< bool(int face_index, int corner, int edge_index, int edge_user_count, const Span< int > edge_face_map_elem)> MeshRemap_CheckIslandBoundary
bool BKE_mesh_calc_islands_loop_face_edgeseam(Span< float3 > vert_positions, Span< int2 > edges, Span< bool > uv_seams, OffsetIndices< int > faces, Span< int > corner_verts, Span< int > corner_edges, MeshIslandStore *r_island_store)
void BKE_mesh_loop_islands_init(MeshIslandStore *island_store, short item_type, int items_num, short island_type, short innercut_type)
void BLI_memarena_free(MemArena *ma) ATTR_NONNULL(1)
void * MEM_new_array_zeroed(size_t len, size_t size, const char *str) ATTR_WARN_UNUSED_RESULT ATTR_ALLOC_SIZE(1
int * BKE_mesh_calc_smoothgroups_bitflags(int edges_num, int verts_num, OffsetIndices< int > faces, Span< int > corner_edges, Span< int > corner_verts, Span< bool > sharp_edges, Span< bool > sharp_faces, bool use_boundary_vertices_for_bitflags, int *r_totgroup)
void vert(const int vert_id, float4 &position)