Commit: 9dc28d73fb1f684ebc0f985ef0e0bc4a1b801cd6 Author: Hans Goudey Date: Fri Feb 3 22:10:48 2023 -0500 Branches: refactor-mesh-corners-generic https://developer.blender.org/rB9dc28d73fb1f684ebc0f985ef0e0bc4a1b801cd6
Merge branch 'master' into refactor-mesh-corners-generic =================================================================== =================================================================== diff --cc source/blender/blenkernel/intern/multires_reshape.hh index 01beb6dc04c,8e112f18d7b..417944b7d89 --- a/source/blender/blenkernel/intern/multires_reshape.hh +++ b/source/blender/blenkernel/intern/multires_reshape.hh @@@ -31,12 -32,11 +31,12 @@@ struct MultiresReshapeContext /* Base mesh from original object. * NOTE: Does NOT include any leading modifiers in it. */ - struct Mesh *base_mesh; + Mesh *base_mesh; const float (*base_positions)[3]; - const struct MEdge *base_edges; - const struct MPoly *base_polys; + const MEdge *base_edges; + const MPoly *base_polys; - const MLoop *base_loops; + const int *base_corner_verts; + const int *base_corner_edges; /* Subdivision surface created for multires modifier. * diff --cc source/blender/bmesh/intern/bmesh_mesh_convert.cc index 55602d2f130,d58337400a2..ec75c8e828c --- a/source/blender/bmesh/intern/bmesh_mesh_convert.cc +++ b/source/blender/bmesh/intern/bmesh_mesh_convert.cc @@@ -111,10 -111,31 +111,32 @@@ 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, + Span<int> poly_verts, + Span<int> poly_edges, Span<BMVert *> vtable, Span<BMEdge *> etable) { @@@ -1299,6 -1309,197 +1321,197 @@@ 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) + { + 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; + } + + 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<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; + } + } + }); + } + + 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) { ++ MutableSpan<int> dst_corner_verts = mesh.corner_verts_for_write(); ++ MutableSpan<int> dst_corner_edges = mesh.corner_edges_for_write(); ++ threading::parallel_for(bm_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); ++ dst_corner_verts[loop_i] = BM_elem_index_get(src_loop.v); ++ dst_corner_edges[loop_i] = BM_elem_index_get(src_loop.e); + CustomData_from_bmesh_block(&bm.ldata, &mesh.ldata, src_loop.head.data, loop_i); + } + }); + } + + } // namespace blender + /* NOTE: The function is called from multiple threads with the same input BMesh and different * mesh objects. */ void BM_mesh_bm_to_me_for_eval(BMesh *bm, Mesh *me, const CustomData_MeshMasks *cd_ @@ 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