[Bf-blender-cvs] [9dc28d73fb1] refactor-mesh-corners-generic: Merge branch 'master' into refactor-mesh-corners-generic
Hans Goudey
noreply at git.blender.org
Sat Feb 4 04:22:55 CET 2023
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. @@
More information about the Bf-blender-cvs
mailing list