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. @@ _______________________________________________ Bf-blender-cvs mailing list Bf-blender-cvs@blender.org List details, subscription details or unsubscribe: https://lists.blender.org/mailman/listinfo/bf-blender-cvs