[Bf-blender-cvs] [3ab2f6242aa] refactor-mesh-sharp-face-generic: Merge branch 'master' into refactor-mesh-sharp-face-generic
Hans Goudey
noreply at git.blender.org
Sat Feb 4 04:02:45 CET 2023
Commit: 3ab2f6242aaab5cda6057da0e5bca4467ca1b3b2
Author: Hans Goudey
Date: Fri Feb 3 21:57:19 2023 -0500
Branches: refactor-mesh-sharp-face-generic
https://developer.blender.org/rB3ab2f6242aaab5cda6057da0e5bca4467ca1b3b2
Merge branch 'master' into refactor-mesh-sharp-face-generic
===================================================================
===================================================================
diff --cc source/blender/blenkernel/intern/pbvh.c
index e9f5a50f2cc,6b21568ba38..209b8c40872
--- a/source/blender/blenkernel/intern/pbvh.c
+++ b/source/blender/blenkernel/intern/pbvh.c
@@@ -563,9 -554,9 +563,9 @@@ static void build_sub(PBVH *pbvh
}
/* Decide whether this is a leaf or not */
- const bool below_leaf_limit = count <= pbvh->leaf_limit || depth == STACK_FIXED_DEPTH - 1;
+ const bool below_leaf_limit = count <= pbvh->leaf_limit || depth >= STACK_FIXED_DEPTH - 1;
if (below_leaf_limit) {
- if (!leaf_needs_material_split(pbvh, offset, count)) {
+ if (!leaf_needs_material_split(pbvh, sharp_faces, offset, count)) {
build_leaf(pbvh, node_index, prim_bbc, offset, count);
if (node_index == 0) {
diff --cc source/blender/bmesh/intern/bmesh_construct.h
index 1a74d492a8d,0b85abdaa92..036605e6b67
--- a/source/blender/bmesh/intern/bmesh_construct.h
+++ b/source/blender/bmesh/intern/bmesh_construct.h
@@@ -170,10 -170,7 +170,6 @@@ void BM_mesh_copy_init_customdata_all_l
const struct BMAllocTemplate *allocsize);
BMesh *BM_mesh_copy(BMesh *bm_old);
- char BM_edge_flag_from_mflag(short mflag);
- /* ME -> BM */
- short BM_edge_flag_to_mflag(BMEdge *e);
--
#ifdef __cplusplus
}
#endif
diff --cc source/blender/bmesh/intern/bmesh_mesh_convert.cc
index 40021a4e0ab,d58337400a2..33f11286de3
--- a/source/blender/bmesh/intern/bmesh_mesh_convert.cc
+++ b/source/blender/bmesh/intern/bmesh_mesh_convert.cc
@@@ -111,6 -111,28 +111,18 @@@ using blender::MutableSpan
using blender::Span;
using blender::StringRef;
+ static char bm_edge_flag_from_mflag(const short mflag)
+ {
+ return ((mflag & ME_SEAM) ? BM_ELEM_SEAM : 0) | ((mflag & ME_EDGEDRAW) ? BM_ELEM_DRAW : 0);
+ }
-static char bm_face_flag_from_mflag(const char mflag)
-{
- return ((mflag & ME_SMOOTH) ? BM_ELEM_SMOOTH : 0);
-}
+
+ static short bm_edge_flag_to_mflag(const BMEdge *e)
+ {
+ const char hflag = e->head.hflag;
+
+ return ((hflag & BM_ELEM_SEAM) ? ME_SEAM : 0) | ((hflag & BM_ELEM_DRAW) ? ME_EDGEDRAW : 0);
+ }
-static char bm_face_flag_to_mflag(const BMFace *f)
-{
- const char hflag = f->head.hflag;
-
- return ((hflag & BM_ELEM_SMOOTH) ? ME_SMOOTH : 0);
-}
+
/* Static function for alloc (duplicate in modifiers_bmesh.c) */
static BMFace *bm_face_create_from_mpoly(BMesh &bm,
Span<MLoop> loops,
@@@ -1301,6 -1309,197 +1313,204 @@@ void BM_mesh_bm_to_me(Main *bmain, BMes
multires_topology_changed(me);
}
+ namespace blender {
+
+ static void bm_vert_table_build(BMesh &bm,
+ MutableSpan<const BMVert *> table,
+ bool &need_select_vert,
+ bool &need_hide_vert)
+ {
+ char hflag = 0;
+ BMIter iter;
+ int i;
+ BMVert *vert;
+ BM_ITER_MESH_INDEX (vert, &iter, &bm, BM_VERTS_OF_MESH, i) {
+ BM_elem_index_set(vert, i); /* set_inline */
+ table[i] = vert;
+ hflag |= vert->head.hflag;
+ }
+ need_select_vert = (hflag & BM_ELEM_SELECT) != 0;
+ need_hide_vert = (hflag & BM_ELEM_HIDDEN) != 0;
+ }
+
+ static void bm_edge_table_build(BMesh &bm,
+ MutableSpan<const BMEdge *> table,
+ bool &need_select_edge,
+ bool &need_hide_edge,
+ bool &need_sharp_edge)
+ {
+ char hflag = 0;
+ BMIter iter;
+ int i;
+ BMEdge *edge;
+ BM_ITER_MESH_INDEX (edge, &iter, &bm, BM_EDGES_OF_MESH, i) {
+ BM_elem_index_set(edge, i); /* set_inline */
+ table[i] = edge;
+ hflag |= edge->head.hflag;
+ }
+ need_select_edge = (hflag & BM_ELEM_SELECT) != 0;
+ need_hide_edge = (hflag & BM_ELEM_HIDDEN) != 0;
+ need_sharp_edge = (hflag & BM_ELEM_SMOOTH) != 0;
+ }
+
+ static void bm_face_loop_table_build(BMesh &bm,
+ MutableSpan<const BMFace *> face_table,
+ MutableSpan<const BMLoop *> loop_table,
+ bool &need_select_poly,
+ bool &need_hide_poly,
- bool &need_material_index)
++ bool &need_material_index,
++ bool &need_sharp_face)
+ {
+ char hflag = 0;
+ BMIter iter;
+ int face_i = 0;
+ int loop_i = 0;
+ BMFace *face;
+ BM_ITER_MESH_INDEX (face, &iter, &bm, BM_FACES_OF_MESH, face_i) {
+ BM_elem_index_set(face, face_i); /* set_inline */
+ face_table[face_i] = face;
+ hflag |= face->head.hflag;
+ need_material_index |= face->mat_nr != 0;
+
+ BMLoop *loop = BM_FACE_FIRST_LOOP(face);
+ for ([[maybe_unused]] const int i : IndexRange(face->len)) {
+ BM_elem_index_set(loop, loop_i); /* set_inline */
+ loop_table[loop_i] = loop;
+ loop = loop->next;
+ loop_i++;
+ }
+ }
+ need_select_poly = (hflag & BM_ELEM_SELECT) != 0;
+ need_hide_poly = (hflag & BM_ELEM_HIDDEN) != 0;
++ need_sharp_face = (hflag & BM_ELEM_SMOOTH);
+ }
+
+ static void bm_to_mesh_verts(const BMesh &bm,
+ const Span<const BMVert *> bm_verts,
+ Mesh &mesh,
+ MutableSpan<bool> select_vert,
+ MutableSpan<bool> hide_vert)
+ {
+ MutableSpan<float3> dst_vert_positions = mesh.vert_positions_for_write();
+ threading::parallel_for(dst_vert_positions.index_range(), 1024, [&](const IndexRange range) {
+ for (const int vert_i : range) {
+ const BMVert &src_vert = *bm_verts[vert_i];
+ copy_v3_v3(dst_vert_positions[vert_i], src_vert.co);
+ CustomData_from_bmesh_block(&bm.vdata, &mesh.vdata, src_vert.head.data, vert_i);
+ }
+ if (!select_vert.is_empty()) {
+ for (const int vert_i : range) {
+ select_vert[vert_i] = BM_elem_flag_test(bm_verts[vert_i], BM_ELEM_SELECT);
+ }
+ }
+ if (!hide_vert.is_empty()) {
+ for (const int vert_i : range) {
+ hide_vert[vert_i] = BM_elem_flag_test(bm_verts[vert_i], BM_ELEM_HIDDEN);
+ }
+ }
+ });
+ }
+
+ static void bm_to_mesh_edges(const BMesh &bm,
+ const Span<const BMEdge *> bm_edges,
+ Mesh &mesh,
+ MutableSpan<bool> select_edge,
+ MutableSpan<bool> hide_edge,
+ MutableSpan<bool> sharp_edge)
+ {
+ MutableSpan<MEdge> dst_edges = mesh.edges_for_write();
+ threading::parallel_for(dst_edges.index_range(), 512, [&](const IndexRange range) {
+ for (const int edge_i : range) {
+ const BMEdge &src_edge = *bm_edges[edge_i];
+ MEdge &dst_edge = dst_edges[edge_i];
+ dst_edge.v1 = BM_elem_index_get(src_edge.v1);
+ dst_edge.v2 = BM_elem_index_get(src_edge.v2);
+ dst_edge.flag = bm_edge_flag_to_mflag(&src_edge);
+
+ /* Handle this differently to editmode switching; only enable draw for single user
+ * edges rather than calculating angle. */
+ if ((dst_edge.flag & ME_EDGEDRAW) == 0) {
+ if (src_edge.l && src_edge.l == src_edge.l->radial_next) {
+ dst_edge.flag |= ME_EDGEDRAW;
+ }
+ }
+
+ CustomData_from_bmesh_block(&bm.edata, &mesh.edata, src_edge.head.data, edge_i);
+ }
+ if (!select_edge.is_empty()) {
+ for (const int edge_i : range) {
+ select_edge[edge_i] = BM_elem_flag_test(bm_edges[edge_i], BM_ELEM_SELECT);
+ }
+ }
+ if (!hide_edge.is_empty()) {
+ for (const int edge_i : range) {
+ hide_edge[edge_i] = BM_elem_flag_test(bm_edges[edge_i], BM_ELEM_HIDDEN);
+ }
+ }
+ if (!sharp_edge.is_empty()) {
+ for (const int edge_i : range) {
+ sharp_edge[edge_i] = !BM_elem_flag_test(bm_edges[edge_i], BM_ELEM_SMOOTH);
+ }
+ }
+ });
+ }
+
+ static void bm_to_mesh_faces(const BMesh &bm,
+ const Span<const BMFace *> bm_faces,
+ Mesh &mesh,
+ MutableSpan<bool> select_poly,
+ MutableSpan<bool> hide_poly,
++ MutableSpan<bool> sharp_faces,
+ MutableSpan<int> material_indices)
+ {
+ MutableSpan<MPoly> dst_polys = mesh.polys_for_write();
+ threading::parallel_for(dst_polys.index_range(), 1024, [&](const IndexRange range) {
+ for (const int face_i : range) {
+ const BMFace &src_face = *bm_faces[face_i];
+ MPoly &dst_poly = dst_polys[face_i];
+ dst_poly.totloop = src_face.len;
+ dst_poly.loopstart = BM_elem_index_get(BM_FACE_FIRST_LOOP(&src_face));
- dst_poly.flag = bm_face_flag_to_mflag(&src_face);
+ CustomData_from_bmesh_block(&bm.pdata, &mesh.pdata, src_face.head.data, face_i);
+ }
+ if (!select_poly.is_empty()) {
+ for (const int face_i : range) {
+ select_poly[face_i] = BM_elem_flag_test(bm_faces[face_i], BM_ELEM_SELECT);
+ }
+ }
+ if (!hide_poly.is_empty()) {
+ for (const int face_i : range) {
+ hide_poly[face_i] = BM_elem_flag_test(bm_faces[face_i], BM_ELEM_HIDDEN);
+ }
+ }
+ if (!material_indices.is_empty()) {
+ for (const int face_i : range) {
+ material_indices[face_i] = bm_faces[face_i]->mat_nr;
+ }
+ }
++ if (!sharp_faces.is_empty()) {
++ for (const int face_i : range) {
++ sharp_faces[face_i] = !BM_elem_flag_test(bm_faces[face_i], BM_ELEM_SMOOTH);
++ }
++ }
+ });
+ }
+
+ static void bm_to_mesh_loops(const BMesh &bm, const Span<const BMLoop *> bm_loops, Mesh &mesh)
+ {
+ MutableSpan<MLoop> dst_loops = mesh.loops_for_write();
+ threading::parallel_for(dst_loops.index_range(), 1024, [&](const IndexRange range) {
+ for (const int loop_i : range) {
+ const BMLoop &src_loop = *bm_loops[loop_i];
+ MLoop &dst_loop = dst_loops[loop_i];
+ dst_loop.v = BM_elem_index_get(src_loop.v);
+ dst_loop.e = BM_elem_index_get(src_loop.e);
+ CustomData_from_bm
@@ Diff output truncated at 10240 characters. @@
More information about the Bf-blender-cvs
mailing list