diff options
| author | Hans Goudey <h.goudey@me.com> | 2022-08-31 22:17:29 +0300 |
|---|---|---|
| committer | Hans Goudey <h.goudey@me.com> | 2022-08-31 22:17:29 +0300 |
| commit | 495df255251137e5ea9c72d63cae49074c83e695 (patch) | |
| tree | bd5763d3ee88c8749264dc3939cbf6d4baab2e54 | |
| parent | 44f8056fdf69ee499b22f36e30c0533339eb4c4c (diff) | |
Use C++ methods to retrieve geometry data
100 files changed, 682 insertions, 663 deletions
diff --git a/source/blender/blenkernel/BKE_mesh.h b/source/blender/blenkernel/BKE_mesh.h index 0adcbd74e31..a6dcc3f5139 100644 --- a/source/blender/blenkernel/BKE_mesh.h +++ b/source/blender/blenkernel/BKE_mesh.h @@ -1113,44 +1113,40 @@ BLI_INLINE MDeformVert *BKE_mesh_deform_verts_for_write(Mesh *mesh) # include "BLI_span.hh" -namespace blender::bke { - -inline Span<MVert> mesh_vertices(const Mesh &mesh) +inline blender::Span<MVert> Mesh::vertices() const { - return {BKE_mesh_vertices(&mesh), mesh.totvert}; + return {BKE_mesh_vertices(this), this->totvert}; } -inline MutableSpan<MVert> mesh_vertices_for_write(Mesh &mesh) +inline blender::MutableSpan<MVert> Mesh::vertices_for_write() { - return {BKE_mesh_vertices_for_write(&mesh), mesh.totvert}; + return {BKE_mesh_vertices_for_write(this), this->totvert}; } -inline Span<MEdge> mesh_edges(const Mesh &mesh) +inline blender::Span<MEdge> Mesh::edges() const { - return {BKE_mesh_edges(&mesh), mesh.totedge}; + return {BKE_mesh_edges(this), this->totedge}; } -inline MutableSpan<MEdge> mesh_edges_for_write(Mesh &mesh) +inline blender::MutableSpan<MEdge> Mesh::edges_for_write() { - return {BKE_mesh_edges_for_write(&mesh), mesh.totedge}; + return {BKE_mesh_edges_for_write(this), this->totedge}; } -inline Span<MPoly> mesh_polygons(const Mesh &mesh) +inline blender::Span<MPoly> Mesh::polygons() const { - return {BKE_mesh_polygons(&mesh), mesh.totpoly}; + return {BKE_mesh_polygons(this), this->totpoly}; } -inline MutableSpan<MPoly> mesh_polygons_for_write(Mesh &mesh) +inline blender::MutableSpan<MPoly> Mesh::polygons_for_write() { - return {BKE_mesh_polygons_for_write(&mesh), mesh.totpoly}; + return {BKE_mesh_polygons_for_write(this), this->totpoly}; } -inline Span<MLoop> mesh_loops(const Mesh &mesh) +inline blender::Span<MLoop> Mesh::loops() const { - return {BKE_mesh_loops(&mesh), mesh.totloop}; + return {BKE_mesh_loops(this), this->totloop}; } -inline MutableSpan<MLoop> mesh_loops_for_write(Mesh &mesh) +inline blender::MutableSpan<MLoop> Mesh::loops_for_write() { - return {BKE_mesh_loops_for_write(&mesh), mesh.totloop}; + return {BKE_mesh_loops_for_write(this), this->totloop}; } -} // namespace blender::bke - #endif diff --git a/source/blender/blenkernel/intern/DerivedMesh.cc b/source/blender/blenkernel/intern/DerivedMesh.cc index cb3f9113747..46a8caafa70 100644 --- a/source/blender/blenkernel/intern/DerivedMesh.cc +++ b/source/blender/blenkernel/intern/DerivedMesh.cc @@ -2003,7 +2003,7 @@ void mesh_get_mapped_verts_coords(Mesh *me_eval, float (*r_cos)[3], const int to MEM_freeN(userData.vertex_visit); } else { - const Span<MVert> verts = blender::bke::mesh_vertices(*me_eval); + const Span<MVert> verts = me_eval->vertices(); for (int i = 0; i < totcos; i++) { copy_v3_v3(r_cos[i], verts[i].co); } @@ -2018,9 +2018,9 @@ static void mesh_init_origspace(Mesh *mesh) CD_ORIGSPACE_MLOOP); const int numpoly = mesh->totpoly; // const int numloop = mesh->totloop; - const Span<MVert> verts = blender::bke::mesh_vertices(*mesh); - const Span<MPoly> polys = blender::bke::mesh_polygons(*mesh); - const Span<MLoop> loops = blender::bke::mesh_loops(*mesh); + const Span<MVert> verts = mesh->vertices(); + const Span<MPoly> polys = mesh->polygons(); + const Span<MLoop> loops = mesh->loops(); const MPoly *mp = polys.data(); int i, j, k; diff --git a/source/blender/blenkernel/intern/bvhutils.cc b/source/blender/blenkernel/intern/bvhutils.cc index 023bdef6051..ba72a924f6d 100644 --- a/source/blender/blenkernel/intern/bvhutils.cc +++ b/source/blender/blenkernel/intern/bvhutils.cc @@ -1249,10 +1249,10 @@ BVHTree *BKE_bvhtree_from_mesh_get(struct BVHTreeFromMesh *data, looptri = BKE_mesh_runtime_looptri_ensure(mesh); looptri_len = BKE_mesh_runtime_looptri_len(mesh); } - const Span<MVert> verts = blender::bke::mesh_vertices(*mesh); - const Span<MEdge> edges = blender::bke::mesh_edges(*mesh); - const Span<MPoly> polys = blender::bke::mesh_polygons(*mesh); - const Span<MLoop> loops = blender::bke::mesh_loops(*mesh); + const Span<MVert> verts = mesh->vertices(); + const Span<MEdge> edges = mesh->edges(); + const Span<MPoly> polys = mesh->polygons(); + const Span<MLoop> loops = mesh->loops(); /* Setup BVHTreeFromMesh */ bvhtree_from_mesh_setup_data(nullptr, @@ -1316,7 +1316,7 @@ BVHTree *BKE_bvhtree_from_mesh_get(struct BVHTreeFromMesh *data, case BVHTREE_FROM_LOOPTRI_NO_HIDDEN: { blender::bke::AttributeAccessor attributes = blender::bke::mesh_attributes(*mesh); mask = looptri_no_hidden_map_get( - blender::bke::mesh_polygons(*mesh).data(), + mesh->polygons().data(), attributes.lookup_or_default(".hide_poly", ATTR_DOMAIN_FACE, false), looptri_len, &mask_bits_act_len); diff --git a/source/blender/blenkernel/intern/crazyspace.cc b/source/blender/blenkernel/intern/crazyspace.cc index 86cc93bb976..17fb9fdb03e 100644 --- a/source/blender/blenkernel/intern/crazyspace.cc +++ b/source/blender/blenkernel/intern/crazyspace.cc @@ -187,9 +187,9 @@ void BKE_crazyspace_set_quats_mesh(Mesh *me, BLI_bitmap *vert_tag = BLI_BITMAP_NEW(me->totvert, __func__); /* first store two sets of tangent vectors in vertices, we derive it just from the face-edges */ - const Span<MVert> verts = mesh_vertices(*me); - const Span<MPoly> polys = mesh_polygons(*me); - const Span<MLoop> loops = mesh_loops(*me); + const Span<MVert> verts = me->vertices(); + const Span<MPoly> polys = me->polygons(); + const Span<MLoop> loops = me->loops(); for (int i = 0; i < me->totpoly; i++) { const MPoly *poly = &polys[i]; diff --git a/source/blender/blenkernel/intern/curve_to_mesh_convert.cc b/source/blender/blenkernel/intern/curve_to_mesh_convert.cc index ce91a5a1c10..47cd8495b18 100644 --- a/source/blender/blenkernel/intern/curve_to_mesh_convert.cc +++ b/source/blender/blenkernel/intern/curve_to_mesh_convert.cc @@ -640,10 +640,10 @@ Mesh *curve_to_mesh_sweep(const CurvesGeometry &main, offsets.vert.last(), offsets.edge.last(), 0, offsets.loop.last(), offsets.poly.last()); mesh->flag |= ME_AUTOSMOOTH; mesh->smoothresh = DEG2RADF(180.0f); - MutableSpan<MVert> verts = mesh_vertices_for_write(*mesh); - MutableSpan<MEdge> edges = mesh_edges_for_write(*mesh); - MutableSpan<MPoly> polys = mesh_polygons_for_write(*mesh); - MutableSpan<MLoop> loops = mesh_loops_for_write(*mesh); + MutableSpan<MVert> verts = mesh->vertices_for_write(); + MutableSpan<MEdge> edges = mesh->edges_for_write(); + MutableSpan<MPoly> polys = mesh->polygons_for_write(); + MutableSpan<MLoop> loops = mesh->loops_for_write(); foreach_curve_combination(curves_info, offsets, [&](const CombinationInfo &info) { fill_mesh_topology(info.vert_range.start(), diff --git a/source/blender/blenkernel/intern/geometry_component_mesh.cc b/source/blender/blenkernel/intern/geometry_component_mesh.cc index 3052ab77185..11ca2ba2087 100644 --- a/source/blender/blenkernel/intern/geometry_component_mesh.cc +++ b/source/blender/blenkernel/intern/geometry_component_mesh.cc @@ -134,7 +134,7 @@ VArray<float3> mesh_normals_varray(const Mesh &mesh, * instead of the GeometryComponent API to avoid calculating unnecessary values and to * allow normalizing the result more simply. */ Span<float3> vert_normals{(float3 *)BKE_mesh_vertex_normals_ensure(&mesh), mesh.totvert}; - const Span<MEdge> edges = bke::mesh_edges(mesh); + const Span<MEdge> edges = mesh.edges(); Array<float3> edge_normals(mask.min_array_size()); for (const int i : mask) { const MEdge &edge = edges[i]; @@ -175,7 +175,7 @@ static void adapt_mesh_domain_corner_to_point_impl(const Mesh &mesh, MutableSpan<T> r_values) { BLI_assert(r_values.size() == mesh.totvert); - const Span<MLoop> loops = mesh_loops(mesh); + const Span<MLoop> loops = mesh.loops(); attribute_math::DefaultMixer<T> mixer(r_values); @@ -195,7 +195,7 @@ void adapt_mesh_domain_corner_to_point_impl(const Mesh &mesh, MutableSpan<bool> r_values) { BLI_assert(r_values.size() == mesh.totvert); - const Span<MLoop> loops = mesh_loops(mesh); + const Span<MLoop> loops = mesh.loops(); Array<bool> loose_verts(mesh.totvert, true); @@ -239,7 +239,7 @@ static GVArray adapt_mesh_domain_corner_to_point(const Mesh &mesh, const GVArray */ static GVArray adapt_mesh_domain_point_to_corner(const Mesh &mesh, const GVArray &varray) { - const Span<MLoop> loops = mesh_loops(mesh); + const Span<MLoop> loops = mesh.loops(); GVArray new_varray; attribute_math::convert_to_static_type(varray.type(), [&](auto dummy) { @@ -255,7 +255,7 @@ static GVArray adapt_mesh_domain_point_to_corner(const Mesh &mesh, const GVArray static GVArray adapt_mesh_domain_corner_to_face(const Mesh &mesh, const GVArray &varray) { - const Span<MPoly> polys = mesh_polygons(mesh); + const Span<MPoly> polys = mesh.polygons(); GVArray new_varray; attribute_math::convert_to_static_type(varray.type(), [&](auto dummy) { @@ -299,8 +299,8 @@ static void adapt_mesh_domain_corner_to_edge_impl(const Mesh &mesh, MutableSpan<T> r_values) { BLI_assert(r_values.size() == mesh.totedge); - const Span<MPoly> polys = mesh_polygons(mesh); - const Span<MLoop> loops = mesh_loops(mesh); + const Span<MPoly> polys = mesh.polygons(); + const Span<MLoop> loops = mesh.loops(); attribute_math::DefaultMixer<T> mixer(r_values); @@ -329,8 +329,8 @@ void adapt_mesh_domain_corner_to_edge_impl(const Mesh &mesh, MutableSpan<bool> r_values) { BLI_assert(r_values.size() == mesh.totedge); - const Span<MPoly> polys = mesh_polygons(mesh); - const Span<MLoop> loops = mesh_loops(mesh); + const Span<MPoly> polys = mesh.polygons(); + const Span<MLoop> loops = mesh.loops(); /* It may be possible to rely on the #ME_LOOSEEDGE flag, but that seems error-prone. */ Array<bool> loose_edges(mesh.totedge, true); @@ -384,8 +384,8 @@ void adapt_mesh_domain_face_to_point_impl(const Mesh &mesh, MutableSpan<T> r_values) { BLI_assert(r_values.size() == mesh.totvert); - const Span<MPoly> polys = mesh_polygons(mesh); - const Span<MLoop> loops = mesh_loops(mesh); + const Span<MPoly> polys = mesh.polygons(); + const Span<MLoop> loops = mesh.loops(); attribute_math::DefaultMixer<T> mixer(r_values); @@ -409,8 +409,8 @@ void adapt_mesh_domain_face_to_point_impl(const Mesh &mesh, MutableSpan<bool> r_values) { BLI_assert(r_values.size() == mesh.totvert); - const Span<MPoly> polys = mesh_polygons(mesh); - const Span<MLoop> loops = mesh_loops(mesh); + const Span<MPoly> polys = mesh.polygons(); + const Span<MLoop> loops = mesh.loops(); r_values.fill(false); for (const int poly_index : polys.index_range()) { @@ -446,7 +446,7 @@ void adapt_mesh_domain_face_to_corner_impl(const Mesh &mesh, MutableSpan<T> r_values) { BLI_assert(r_values.size() == mesh.totloop); - const Span<MPoly> polys = mesh_polygons(mesh); + const Span<MPoly> polys = mesh.polygons(); threading::parallel_for(polys.index_range(), 1024, [&](const IndexRange range) { for (const int poly_index : range) { @@ -477,8 +477,8 @@ void adapt_mesh_domain_face_to_edge_impl(const Mesh &mesh, MutableSpan<T> r_values) { BLI_assert(r_values.size() == mesh.totedge); - const Span<MPoly> polys = mesh_polygons(mesh); - const Span<MLoop> loops = mesh_loops(mesh); + const Span<MPoly> polys = mesh.polygons(); + const Span<MLoop> loops = mesh.loops(); attribute_math::DefaultMixer<T> mixer(r_values); @@ -500,8 +500,8 @@ void adapt_mesh_domain_face_to_edge_impl(const Mesh &mesh, MutableSpan<bool> r_values) { BLI_assert(r_values.size() == mesh.totedge); - const Span<MPoly> polys = mesh_polygons(mesh); - const Span<MLoop> loops = mesh_loops(mesh); + const Span<MPoly> polys = mesh.polygons(); + const Span<MLoop> loops = mesh.loops(); r_values.fill(false); for (const int poly_index : polys.index_range()) { @@ -532,8 +532,8 @@ static GVArray adapt_mesh_domain_face_to_edge(const Mesh &mesh, const GVArray &v static GVArray adapt_mesh_domain_point_to_face(const Mesh &mesh, const GVArray &varray) { - const Span<MPoly> polys = mesh_polygons(mesh); - const Span<MLoop> loops = mesh_loops(mesh); + const Span<MPoly> polys = mesh.polygons(); + const Span<MLoop> loops = mesh.loops(); GVArray new_varray; attribute_math::convert_to_static_type(varray.type(), [&](auto dummy) { @@ -575,7 +575,7 @@ static GVArray adapt_mesh_domain_point_to_face(const Mesh &mesh, const GVArray & static GVArray adapt_mesh_domain_point_to_edge(const Mesh &mesh, const GVArray &varray) { - const Span<MEdge> edges = mesh_edges(mesh); + const Span<MEdge> edges = mesh.edges(); GVArray new_varray; attribute_math::convert_to_static_type(varray.type(), [&](auto dummy) { @@ -612,8 +612,8 @@ void adapt_mesh_domain_edge_to_corner_impl(const Mesh &mesh, MutableSpan<T> r_values) { BLI_assert(r_values.size() == mesh.totloop); - const Span<MPoly> polys = mesh_polygons(mesh); - const Span<MLoop> loops = mesh_loops(mesh); + const Span<MPoly> polys = mesh.polygons(); + const Span<MLoop> loops = mesh.loops(); attribute_math::DefaultMixer<T> mixer(r_values); @@ -640,8 +640,8 @@ void adapt_mesh_domain_edge_to_corner_impl(const Mesh &mesh, MutableSpan<bool> r_values) { BLI_assert(r_values.size() == mesh.totloop); - const Span<MPoly> polys = mesh_polygons(mesh); - const Span<MLoop> loops = mesh_loops(mesh); + const Span<MPoly> polys = mesh.polygons(); + const Span<MLoop> loops = mesh.loops(); r_values.fill(false); @@ -678,7 +678,7 @@ static void adapt_mesh_domain_edge_to_point_impl(const Mesh &mesh, MutableSpan<T> r_values) { BLI_assert(r_values.size() == mesh.totvert); - const Span<MEdge> edges = mesh_edges(mesh); + const Span<MEdge> edges = mesh.edges(); attribute_math::DefaultMixer<T> mixer(r_values); @@ -699,7 +699,7 @@ void adapt_mesh_domain_edge_to_point_impl(const Mesh &mesh, MutableSpan<bool> r_values) { BLI_assert(r_values.size() == mesh.totvert); - const Span<MEdge> edges = mesh_edges(mesh); + const Span<MEdge> edges = mesh.edges(); r_values.fill(false); for (const int edge_index : edges.index_range()) { @@ -727,8 +727,8 @@ static GVArray adapt_mesh_domain_edge_to_point(const Mesh &mesh, const GVArray & static GVArray adapt_mesh_domain_edge_to_face(const Mesh &mesh, const GVArray &varray) { - const Span<MPoly> polys = mesh_polygons(mesh); - const Span<MLoop> loops = mesh_loops(mesh); + const Span<MPoly> polys = mesh.polygons(); + const Span<MLoop> loops = mesh.loops(); GVArray new_varray; attribute_math::convert_to_static_type(varray.type(), [&](auto dummy) { diff --git a/source/blender/blenkernel/intern/gpencil_geom.cc b/source/blender/blenkernel/intern/gpencil_geom.cc index 26d9e9051f2..9eb3775cb19 100644 --- a/source/blender/blenkernel/intern/gpencil_geom.cc +++ b/source/blender/blenkernel/intern/gpencil_geom.cc @@ -2465,8 +2465,8 @@ static void gpencil_generate_edgeloops(Object *ob, return; } const float(*vert_normals)[3] = BKE_mesh_vertex_normals_ensure(me); - const Span<MVert> verts = blender::bke::mesh_vertices(*me); - const Span<MEdge> edges = blender::bke::mesh_edges(*me); + const Span<MVert> verts = me->vertices(); + const Span<MEdge> edges = me->edges(); /* Arrays for all edge vertices (forward and backward) that form a edge loop. * This is reused for each edge-loop to create gpencil stroke. */ @@ -2677,9 +2677,9 @@ bool BKE_gpencil_convert_mesh(Main *bmain, /* Use evaluated data to get mesh with all modifiers on top. */ Object *ob_eval = (Object *)DEG_get_evaluated_object(depsgraph, ob_mesh); const Mesh *me_eval = BKE_object_get_evaluated_mesh(ob_eval); - const Span<MVert> verts = blender::bke::mesh_vertices(*me_eval); - const Span<MPoly> polys = blender::bke::mesh_polygons(*me_eval); - const Span<MLoop> loops = blender::bke::mesh_loops(*me_eval); + const Span<MVert> verts = me_eval->vertices(); + const Span<MPoly> polys = me_eval->polygons(); + const Span<MLoop> loops = me_eval->loops(); int mpoly_len = me_eval->totpoly; char element_name[200]; diff --git a/source/blender/blenkernel/intern/mesh.cc b/source/blender/blenkernel/intern/mesh.cc index 58f5c51be16..dd293f4cf50 100644 --- a/source/blender/blenkernel/intern/mesh.cc +++ b/source/blender/blenkernel/intern/mesh.cc @@ -462,8 +462,8 @@ static int customdata_compare( CD_MASK_MLOOPUV | CD_MASK_PROP_BYTE_COLOR | CD_MASK_MDEFORMVERT; const uint64_t cd_mask_all_attr = CD_MASK_PROP_ALL | cd_mask_non_generic; - const Span<MLoop> loops_1 = blender::bke::mesh_loops(*m1); - const Span<MLoop> loops_2 = blender::bke::mesh_loops(*m2); + const Span<MLoop> loops_1 = m1->loops(); + const Span<MLoop> loops_2 = m2->loops(); for (int i = 0; i < c1->totlayer; i++) { l1 = &c1->layers[i]; @@ -1248,7 +1248,7 @@ float (*BKE_mesh_orco_verts_get(Object *ob))[3] /* Get appropriate vertex coordinates */ float(*vcos)[3] = (float(*)[3])MEM_calloc_arrayN(me->totvert, sizeof(*vcos), "orco mesh"); - const Span<MVert> verts = blender::bke::mesh_vertices(*tme); + const Span<MVert> verts = tme->vertices(); int totvert = min_ii(tme->totvert, me->totvert); @@ -1423,7 +1423,7 @@ void BKE_mesh_material_remap(Mesh *me, const uint *remap, uint remap_len) void BKE_mesh_smooth_flag_set(Mesh *me, const bool use_smooth) { - MutableSpan<MPoly> polys = blender::bke::mesh_polygons_for_write(*me); + MutableSpan<MPoly> polys = me->polygons_for_write(); if (use_smooth) { for (MPoly &poly : polys) { poly.flag |= ME_SMOOTH; @@ -1487,8 +1487,8 @@ int BKE_mesh_edge_other_vert(const MEdge *e, int v) void BKE_mesh_looptri_get_real_edges(const Mesh *mesh, const MLoopTri *looptri, int r_edges[3]) { - const Span<MEdge> edges = blender::bke::mesh_edges(*mesh); - const Span<MLoop> loops = blender::bke::mesh_loops(*mesh); + const Span<MEdge> edges = mesh->edges(); + const Span<MLoop> loops = mesh->loops(); for (int i = 2, i_next = 0; i_next < 3; i = i_next++) { const MLoop *l1 = &loops[looptri->tri[i]], *l2 = &loops[looptri->tri[i_next]]; @@ -1511,7 +1511,7 @@ bool BKE_mesh_minmax(const Mesh *me, float r_min[3], float r_max[3]) float3 min; float3 max; }; - const Span<MVert> verts = blender::bke::mesh_vertices(*me); + const Span<MVert> verts = me->vertices(); const Result minmax = threading::parallel_reduce( verts.index_range(), @@ -1536,7 +1536,7 @@ bool BKE_mesh_minmax(const Mesh *me, float r_min[3], float r_max[3]) void BKE_mesh_transform(Mesh *me, const float mat[4][4], bool do_keys) { - MutableSpan<MVert> verts = blender::bke::mesh_vertices_for_write(*me); + MutableSpan<MVert> verts = me->vertices_for_write(); for (MVert &vert : verts) { mul_m4_v3(mat, vert.co); @@ -1571,7 +1571,7 @@ void BKE_mesh_transform(Mesh *me, const float mat[4][4], bool do_keys) void BKE_mesh_translate(Mesh *me, const float offset[3], const bool do_keys) { - MutableSpan<MVert> verts = blender::bke::mesh_vertices_for_write(*me); + MutableSpan<MVert> verts = me->vertices_for_write(); for (MVert &vert : verts) { add_v3_v3(vert.co, offset); } @@ -1599,8 +1599,8 @@ void BKE_mesh_do_versions_cd_flag_init(Mesh *mesh) return; } - const Span<MVert> verts = blender::bke::mesh_vertices(*mesh); - const Span<MEdge> edges = blender::bke::mesh_edges(*mesh); + const Span<MVert> verts = mesh->vertices(); + const Span<MEdge> edges = mesh->edges(); for (const MVert &vert : verts) { if (vert.bweight != 0) { @@ -1642,9 +1642,9 @@ void BKE_mesh_mselect_validate(Mesh *me) if (me->totselect == 0) { return; } - const Span<MVert> verts = blender::bke::mesh_vertices(*me); - const Span<MEdge> edges = blender::bke::mesh_edges(*me); - const Span<MPoly> polys = blender::bke::mesh_polygons(*me); + const Span<MVert> verts = me->vertices(); + const Span<MEdge> edges = me->edges(); + const Span<MPoly> polys = me->polygons(); mselect_src = me->mselect; mselect_dst = (MSelect *)MEM_malloc_arrayN( @@ -1772,7 +1772,7 @@ float (*BKE_mesh_vert_coords_alloc(const Mesh *mesh, int *r_vert_len))[3] void BKE_mesh_vert_coords_apply(Mesh *mesh, const float (*vert_coords)[3]) { - MutableSpan<MVert> verts = blender::bke::mesh_vertices_for_write(*mesh); + MutableSpan<MVert> verts = mesh->vertices_for_write(); for (const int i : verts.index_range()) { copy_v3_v3(verts[i].co, vert_coords[i]); } @@ -1783,7 +1783,7 @@ void BKE_mesh_vert_coords_apply_with_mat4(Mesh *mesh, const float (*vert_coords)[3], const float mat[4][4]) { - MutableSpan<MVert> verts = blender::bke::mesh_vertices_for_write(*mesh); + MutableSpan<MVert> verts = mesh->vertices_for_write(); for (const int i : verts.index_range()) { mul_v3_m4v3(verts[i].co, mat, vert_coords[i]); } @@ -1821,10 +1821,10 @@ void BKE_mesh_calc_normals_split_ex(Mesh *mesh, /* may be nullptr */ clnors = (short(*)[2])CustomData_get_layer(&mesh->ldata, CD_CUSTOMLOOPNORMAL); - const Span<MVert> verts = blender::bke::mesh_vertices(*mesh); - const Span<MEdge> edges = blender::bke::mesh_edges(*mesh); - const Span<MPoly> polys = blender::bke::mesh_polygons(*mesh); - const Span<MLoop> loops = blender::bke::mesh_loops(*mesh); + const Span<MVert> verts = mesh->vertices(); + const Span<MEdge> edges = mesh->edges(); + const Span<MPoly> polys = mesh->polygons(); + const Span<MLoop> loops = mesh->loops(); BKE_mesh_normals_loop_split(verts.data(), BKE_mesh_vertex_normals_ensure(mesh), @@ -1882,7 +1882,7 @@ static int split_faces_prepare_new_verts(Mesh *mesh, const int loops_len = mesh->totloop; int verts_len = mesh->totvert; - MutableSpan<MLoop> loops = blender::bke::mesh_loops_for_write(*mesh); + MutableSpan<MLoop> loops = mesh->loops_for_write(); BKE_mesh_vertex_normals_ensure(mesh); float(*vert_normals)[3] = BKE_mesh_vertex_normals_for_write(mesh); @@ -1957,9 +1957,9 @@ static int split_faces_prepare_new_edges(Mesh *mesh, { const int num_polys = mesh->totpoly; int num_edges = mesh->totedge; - MutableSpan<MEdge> edges = blender::bke::mesh_edges_for_write(*mesh); - MutableSpan<MLoop> loops = blender::bke::mesh_loops_for_write(*mesh); - const Span<MPoly> polys = blender::bke::mesh_polygons(*mesh); + MutableSpan<MEdge> edges = mesh->edges_for_write(); + MutableSpan<MLoop> loops = mesh->loops_for_write(); + const Span<MPoly> polys = mesh->polygons(); BLI_bitmap *edges_used = BLI_BITMAP_NEW(num_edges, __func__); EdgeHash *edges_hash = BLI_edgehash_new_ex(__func__, num_edges); @@ -2041,7 +2041,7 @@ static void split_faces_split_new_edges(Mesh *mesh, const int num_new_edges) { const int num_edges = mesh->totedge - num_new_edges; - MutableSpan<MEdge> edges = blender::bke::mesh_edges_for_write(*mesh); + MutableSpan<MEdge> edges = mesh->edges_for_write(); /* Remember new_edges is a single linklist, so its items are in reversed order... */ MEdge *new_med = &edges[mesh->totedge - 1]; diff --git a/source/blender/blenkernel/intern/mesh_boolean_convert.cc b/source/blender/blenkernel/intern/mesh_boolean_convert.cc index fe9c5023c15..d5671b53267 100644 --- a/source/blender/blenkernel/intern/mesh_boolean_convert.cc +++ b/source/blender/blenkernel/intern/mesh_boolean_convert.cc @@ -162,7 +162,7 @@ const MPoly *MeshesToIMeshInfo::input_mpoly_for_orig_index(int orig_index, int orig_mesh_index = input_mesh_for_imesh_face(orig_index); BLI_assert(0 <= orig_mesh_index && orig_mesh_index < meshes.size()); const Mesh *me = meshes[orig_mesh_index]; - const Span<MPoly> polys = bke::mesh_polygons(*me); + const Span<MPoly> polys = me->polygons(); int index_in_mesh = orig_index - mesh_poly_offset[orig_mesh_index]; BLI_assert(0 <= index_in_mesh && index_in_mesh < me->totpoly); const MPoly *mp = &polys[index_in_mesh]; @@ -189,7 +189,7 @@ const MVert *MeshesToIMeshInfo::input_mvert_for_orig_index(int orig_index, int orig_mesh_index = input_mesh_for_imesh_vert(orig_index); BLI_assert(0 <= orig_mesh_index && orig_mesh_index < meshes.size()); const Mesh *me = meshes[orig_mesh_index]; - const Span<MVert> verts = bke::mesh_vertices(*me); + const Span<MVert> verts = me->vertices(); int index_in_mesh = orig_index - mesh_vert_offset[orig_mesh_index]; BLI_assert(0 <= index_in_mesh && index_in_mesh < me->totvert); const MVert *mv = &verts[index_in_mesh]; @@ -210,7 +210,7 @@ const MEdge *MeshesToIMeshInfo::input_medge_for_orig_index(int orig_index, int orig_mesh_index = input_mesh_for_imesh_edge(orig_index); BLI_assert(0 <= orig_mesh_index && orig_mesh_index < meshes.size()); const Mesh *me = meshes[orig_mesh_index]; - const Span<MEdge> edges = blender::bke::mesh_edges(*me); + const Span<MEdge> edges = me->edges(); int index_in_mesh = orig_index - mesh_edge_offset[orig_mesh_index]; BLI_assert(0 <= index_in_mesh && index_in_mesh < me->totedge); const MEdge *medge = &edges[index_in_mesh]; @@ -309,9 +309,9 @@ static IMesh meshes_to_imesh(Span<const Mesh *> meshes, bool need_face_flip = r_info->has_negative_transform[mi] != r_info->has_negative_transform[0]; Vector<Vert *> verts(me->totvert); - const Span<MVert> mesh_verts = bke::mesh_vertices(*me); - const Span<MPoly> polys = bke::mesh_polygons(*me); - const Span<MLoop> loops = bke::mesh_loops(*me); + const Span<MVert> mesh_verts = me->vertices(); + const Span<MPoly> polys = me->polygons(); + const Span<MLoop> loops = me->loops(); /* Allocate verts * Skip the matrix multiplication for each point when there is no transform for a mesh, @@ -487,7 +487,7 @@ static int fill_orig_loops(const Face *f, MutableSpan<int> r_orig_loops) { r_orig_loops.fill(-1); - const Span<MLoop> orig_loops = bke::mesh_loops(*orig_me); + const Span<MLoop> orig_loops = orig_me->loops(); int orig_mplen = orig_mp->totloop; if (f->size() != orig_mplen) { @@ -563,8 +563,8 @@ static void get_poly2d_cos(const Mesh *me, const float4x4 &trans_mat, float r_axis_mat[3][3]) { - const Span<MVert> verts = bke::mesh_vertices(*me); - const Span<MLoop> loops = bke::mesh_loops(*me); + const Span<MVert> verts = me->vertices(); + const Span<MLoop> loops = me->loops(); const Span<MLoop> poly_loops = loops.slice(mp->loopstart, mp->totloop); /* Project coordinates to 2d in cos_2d, using normal as projection axis. */ @@ -609,8 +609,8 @@ static void copy_or_interp_loop_attributes(Mesh *dest_mesh, get_poly2d_cos(orig_me, orig_mp, cos_2d, mim.to_target_transform[orig_me_index], axis_mat); } CustomData *target_cd = &dest_mesh->ldata; - const Span<MVert> dst_vertices = bke::mesh_vertices(*dest_mesh); - const Span<MLoop> dst_loops = bke::mesh_loops(*dest_mesh); + const Span<MVert> dst_vertices = dest_mesh->vertices(); + const Span<MLoop> dst_loops = dest_mesh->loops(); for (int i = 0; i < mp->totloop; ++i) { int loop_index = mp->loopstart + i; int orig_loop_index = norig > 0 ? orig_loops[i] : -1; @@ -723,7 +723,7 @@ static Mesh *imesh_to_mesh(IMesh *im, MeshesToIMeshInfo &mim) merge_vertex_loop_poly_customdata_layers(result, mim); /* Set the vertex coordinate values and other data. */ - MutableSpan<MVert> vertices = bke::mesh_vertices_for_write(*result); + MutableSpan<MVert> vertices = result->vertices_for_write(); for (int vi : im->vert_index_range()) { const Vert *v = im->vert(vi); MVert *mv = &vertices[vi]; @@ -742,8 +742,8 @@ static Mesh *imesh_to_mesh(IMesh *im, MeshesToIMeshInfo &mim) bke::mesh_attributes_for_write(*result).lookup_or_add_for_write_only_span<int>( "material_index", ATTR_DOMAIN_FACE); int cur_loop_index = 0; - MutableSpan<MLoop> dst_loops = bke::mesh_loops_for_write(*result); - MutableSpan<MPoly> dst_polys = bke::mesh_polygons_for_write(*result); + MutableSpan<MLoop> dst_loops = result->loops_for_write(); + MutableSpan<MPoly> dst_polys = result->polygons_for_write(); MLoop *l = dst_loops.data(); for (int fi : im->face_index_range()) { const Face *f = im->face(fi); @@ -784,7 +784,7 @@ static Mesh *imesh_to_mesh(IMesh *im, MeshesToIMeshInfo &mim) /* Now that the MEdges are populated, we can copy over the required attributes and custom layers. */ - MutableSpan<MEdge> edges = bke::mesh_edges_for_write(*result); + MutableSpan<MEdge> edges = result->edges_for_write(); for (int fi : im->face_index_range()) { const Face *f = im->face(fi); const MPoly *mp = &dst_polys[fi]; @@ -857,8 +857,8 @@ Mesh *direct_mesh_boolean(Span<const Mesh *> meshes, /* Store intersecting edge indices. */ if (r_intersecting_edges != nullptr) { - const Span<MPoly> polys = bke::mesh_polygons(*result); - const Span<MLoop> loops = bke::mesh_loops(*result); + const Span<MPoly> polys = result->polygons(); + const Span<MLoop> loops = result->loops(); for (int fi : m_out.face_index_range()) { const Face &face = *m_out.face(fi); const MPoly &poly = polys[fi]; diff --git a/source/blender/blenkernel/intern/mesh_calc_edges.cc b/source/blender/blenkernel/intern/mesh_calc_edges.cc index 405047c5692..8a8960fb8a7 100644 --- a/source/blender/blenkernel/intern/mesh_calc_edges.cc +++ b/source/blender/blenkernel/intern/mesh_calc_edges.cc @@ -80,7 +80,7 @@ static void add_existing_edges_to_hash_maps(Mesh *mesh, uint32_t parallel_mask) { /* Assume existing edges are valid. */ - const Span<MEdge> edges = bke::mesh_edges(*mesh); + const Span<MEdge> edges = mesh->edges(); threading::parallel_for_each(edge_maps, [&](EdgeMap &edge_map) { const int task_index = &edge_map - edge_maps.data(); for (const MEdge &edge : edges) { @@ -97,8 +97,8 @@ static void add_polygon_edges_to_hash_maps(Mesh *mesh, MutableSpan<EdgeMap> edge_maps, uint32_t parallel_mask) { - const Span<MPoly> polys = mesh_polygons(*mesh); - const Span<MLoop> loops = mesh_loops(*mesh); + const Span<MPoly> polys = mesh->polygons(); + const Span<MLoop> loops = mesh->loops(); threading::parallel_for_each(edge_maps, [&](EdgeMap &edge_map) { const int task_index = &edge_map - edge_maps.data(); for (const MPoly &poly : polys) { @@ -159,8 +159,8 @@ static void update_edge_indices_in_poly_loops(Mesh *mesh, Span<EdgeMap> edge_maps, uint32_t parallel_mask) { - const Span<MPoly> polys = bke::mesh_polygons(*mesh); - MutableSpan<MLoop> loops = mesh_loops_for_write(*mesh); + const Span<MPoly> polys = mesh->polygons(); + MutableSpan<MLoop> loops = mesh->loops_for_write(); threading::parallel_for(IndexRange(mesh->totpoly), 100, [&](IndexRange range) { for (const int poly_index : range) { const MPoly &poly = polys[poly_index]; diff --git a/source/blender/blenkernel/intern/mesh_convert.cc b/source/blender/blenkernel/intern/mesh_convert.cc index 794077d7b00..5a44c46e999 100644 --- a/source/blender/blenkernel/intern/mesh_convert.cc +++ b/source/blender/blenkernel/intern/mesh_convert.cc @@ -81,9 +81,9 @@ static void make_edges_mdata_extend(Mesh &mesh) const MPoly *mp; int i; - MutableSpan<MEdge> edges = blender::bke::mesh_edges_for_write(mesh); - const Span<MPoly> polys = blender::bke::mesh_polygons(mesh); - MutableSpan<MLoop> loops = blender::bke::mesh_loops_for_write(mesh); + MutableSpan<MEdge> edges = mesh.edges_for_write(); + const Span<MPoly> polys = mesh.polygons(); + MutableSpan<MLoop> loops = mesh.loops_for_write(); const int eh_reserve = max_ii(totedge, BLI_EDGEHASH_SIZE_GUESS_FROM_POLYS(mesh.totpoly)); EdgeHash *eh = BLI_edgehash_new_ex(__func__, eh_reserve); @@ -185,10 +185,10 @@ static Mesh *mesh_nurbs_displist_to_mesh(const Curve *cu, const ListBase *dispba } Mesh *mesh = BKE_mesh_new_nomain(totvert, totedge, 0, totloop, totpoly); - MutableSpan<MVert> verts = blender::bke::mesh_vertices_for_write(*mesh); - MutableSpan<MEdge> edges = blender::bke::mesh_edges_for_write(*mesh); - MutableSpan<MPoly> polys = blender::bke::mesh_polygons_for_write(*mesh); - MutableSpan<MLoop> loops = blender::bke::mesh_loops_for_write(*mesh); + MutableSpan<MVert> verts = mesh->vertices_for_write(); + MutableSpan<MEdge> edges = mesh->edges_for_write(); + MutableSpan<MPoly> polys = mesh->polygons_for_write(); + MutableSpan<MLoop> loops = mesh->loops_for_write(); MVert *mvert = verts.data(); MEdge *medge = edges.data(); @@ -457,10 +457,10 @@ static void appendPolyLineVert(ListBase *lb, uint index) void BKE_mesh_to_curve_nurblist(const Mesh *me, ListBase *nurblist, const int edge_users_test) { - const Span<MVert> verts = blender::bke::mesh_vertices(*me); - const Span<MEdge> mesh_edges = blender::bke::mesh_edges(*me); - const Span<MPoly> polys = blender::bke::mesh_polygons(*me); - const Span<MLoop> loops = blender::bke::mesh_loops(*me); + const Span<MVert> verts = me->vertices(); + const Span<MEdge> mesh_edges = me->edges(); + const Span<MPoly> polys = me->polygons(); + const Span<MLoop> loops = me->loops(); const MEdge *med; const MPoly *mp; @@ -691,7 +691,7 @@ void BKE_mesh_from_pointcloud(const PointCloud *pointcloud, Mesh *me) CustomDataLayer *pos_layer = &me->vdata.layers[layer_idx]; float(*positions)[3] = (float(*)[3])pos_layer->data; - MutableSpan<MVert> verts = blender::bke::mesh_vertices_for_write(*me); + MutableSpan<MVert> verts = me->vertices_for_write(); for (int i = 0; i < me->totvert; i++) { copy_v3_v3(verts[i].co, positions[i]); } @@ -702,7 +702,7 @@ void BKE_mesh_from_pointcloud(const PointCloud *pointcloud, Mesh *me) void BKE_mesh_edges_set_draw_render(Mesh *mesh) { - MutableSpan<MEdge> edges = blender::bke::mesh_edges_for_write(*mesh); + MutableSpan<MEdge> edges = mesh->edges_for_write(); for (int i = 0; i < mesh->totedge; i++) { edges[i].flag |= ME_EDGEDRAW | ME_EDGERENDER; } @@ -1170,7 +1170,7 @@ Mesh *BKE_mesh_create_derived_for_modifier(struct Depsgraph *depsgraph, if (build_shapekey_layers && me->key && (kb = (KeyBlock *)BLI_findlink(&me->key->block, ob_eval->shapenr - 1))) { - MutableSpan<MVert> verts = blender::bke::mesh_vertices_for_write(*me); + MutableSpan<MVert> verts = me->vertices_for_write(); BKE_keyblock_convert_to_mesh(kb, verts.data(), me->totvert); } @@ -1274,7 +1274,7 @@ static void shapekey_layers_to_keyblocks(Mesh *mesh_src, Mesh *mesh_dst, int act kb->data = kbcos = (float(*)[3])MEM_malloc_arrayN(kb->totelem, sizeof(float[3]), __func__); if (kb->uid == actshape_uid) { - const Span<MVert> verts = blender::bke::mesh_vertices(*mesh_src); + const Span<MVert> verts = mesh_src->vertices(); for (j = 0; j < mesh_src->totvert; j++, kbcos++) { copy_v3_v3(*kbcos, verts[j].co); } @@ -1385,30 +1385,30 @@ void BKE_mesh_nomain_to_mesh(Mesh *mesh_src, CustomData_add_layer(&tmp.vdata, CD_MVERT, CD_ASSIGN, - (alloctype == CD_ASSIGN) ? mesh_vertices_for_write(*mesh_src).data() : - MEM_dupallocN(mesh_vertices(*mesh_src).data()), + (alloctype == CD_ASSIGN) ? mesh_src->vertices_for_write().data() : + MEM_dupallocN(mesh_src->vertices().data()), totvert); } if (!CustomData_has_layer(&tmp.edata, CD_MEDGE)) { CustomData_add_layer(&tmp.edata, CD_MEDGE, CD_ASSIGN, - (alloctype == CD_ASSIGN) ? mesh_edges_for_write(*mesh_src).data() : - MEM_dupallocN(mesh_edges(*mesh_src).data()), + (alloctype == CD_ASSIGN) ? mesh_src->edges_for_write().data() : + MEM_dupallocN(mesh_src->edges().data()), totedge); } if (!CustomData_has_layer(&tmp.pdata, CD_MPOLY)) { CustomData_add_layer(&tmp.ldata, CD_MLOOP, CD_ASSIGN, - (alloctype == CD_ASSIGN) ? mesh_loops_for_write(*mesh_src).data() : - MEM_dupallocN(mesh_loops(*mesh_src).data()), + (alloctype == CD_ASSIGN) ? mesh_src->loops_for_write().data() : + MEM_dupallocN(mesh_src->loops().data()), tmp.totloop); CustomData_add_layer(&tmp.pdata, CD_MPOLY, CD_ASSIGN, - (alloctype == CD_ASSIGN) ? mesh_polygons_for_write(*mesh_src).data() : - MEM_dupallocN(mesh_polygons(*mesh_src).data()), + (alloctype == CD_ASSIGN) ? mesh_src->polygons_for_write().data() : + MEM_dupallocN(mesh_src->polygons().data()), tmp.totpoly); } @@ -1490,7 +1490,7 @@ void BKE_mesh_nomain_to_meshkey(Mesh *mesh_src, Mesh *mesh_dst, KeyBlock *kb) kb->totelem = totvert; fp = (float *)kb->data; - const Span<MVert> verts = blender::bke::mesh_vertices(*mesh_src); + const Span<MVert> verts = mesh_src->vertices(); for (a = 0; a < kb->totelem; a++, fp += 3) { copy_v3_v3(fp, verts[a].co); } diff --git a/source/blender/blenkernel/intern/mesh_evaluate.cc b/source/blender/blenkernel/intern/mesh_evaluate.cc index 176f315ff7d..746f8362ddf 100644 --- a/source/blender/blenkernel/intern/mesh_evaluate.cc +++ b/source/blender/blenkernel/intern/mesh_evaluate.cc @@ -205,9 +205,9 @@ float BKE_mesh_calc_poly_area(const MPoly *mpoly, const MLoop *loopstart, const float BKE_mesh_calc_area(const Mesh *me) { - const Span<MVert> vertts = blender::bke::mesh_vertices(*me); - const Span<MPoly> polys = blender::bke::mesh_polygons(*me); - const Span<MLoop> loops = blender::bke::mesh_loops(*me); + const Span<MVert> vertts = me->vertices(); + const Span<MPoly> polys = me->polygons(); + const Span<MLoop> loops = me->loops(); float total_area = 0.0f; for (const MPoly &poly : polys) { @@ -400,7 +400,7 @@ void BKE_mesh_poly_edgebitmap_insert(uint *edge_bitmap, const MPoly *mp, const M bool BKE_mesh_center_median(const Mesh *me, float r_cent[3]) { - const Span<MVert> verts = blender::bke::mesh_vertices(*me); + const Span<MVert> verts = me->vertices(); zero_v3(r_cent); for (const MVert &vert : verts) { add_v3_v3(r_cent, vert.co); @@ -415,9 +415,9 @@ bool BKE_mesh_center_median(const Mesh *me, float r_cent[3]) bool BKE_mesh_center_median_from_polys(const Mesh *me, float r_cent[3]) { int tot = 0; - const Span<MVert> verts = blender::bke::mesh_vertices(*me); - const Span<MPoly> polys = blender::bke::mesh_polygons(*me); - const Span<MLoop> loops = blender::bke::mesh_loops(*me); + const Span<MVert> verts = me->vertices(); + const Span<MPoly> polys = me->polygons(); + const Span<MLoop> loops = me->loops(); zero_v3(r_cent); for (const MPoly &poly : polys) { int loopend = poly.loopstart + poly.totloop; @@ -746,9 +746,9 @@ void BKE_mesh_flush_hidden_from_verts(Mesh *me) return; } const VArraySpan<bool> hide_vert_span{hide_vert}; - const Span<MEdge> edges = mesh_edges(*me); - const Span<MPoly> polys = mesh_polygons(*me); - const Span<MLoop> loops = mesh_loops(*me); + const Span<MEdge> edges = me->edges(); + const Span<MPoly> polys = me->polygons(); + const Span<MLoop> loops = me->loops(); /* Hide edges when either of their vertices are hidden. */ SpanAttributeWriter<bool> hide_edge = attributes.lookup_or_add_for_write_only_span<bool>( @@ -786,8 +786,8 @@ void BKE_mesh_flush_hidden_from_polys(Mesh *me) return; } const VArraySpan<bool> hide_poly_span{hide_poly}; - const Span<MPoly> polys = mesh_polygons(*me); - const Span<MLoop> loops = mesh_loops(*me); + const Span<MPoly> polys = me->polygons(); + const Span<MLoop> loops = me->loops(); SpanAttributeWriter<bool> hide_vert = attributes.lookup_or_add_for_write_only_span<bool>( ".hide_vert", ATTR_DOMAIN_POINT); SpanAttributeWriter<bool> hide_edge = attributes.lookup_or_add_for_write_only_span<bool>( @@ -857,12 +857,12 @@ void BKE_mesh_flush_select_from_polys_ex(MVert *mvert, } void BKE_mesh_flush_select_from_polys(Mesh *me) { - BKE_mesh_flush_select_from_polys_ex(blender::bke::mesh_vertices_for_write(*me).data(), + BKE_mesh_flush_select_from_polys_ex(me->vertices_for_write().data(), me->totvert, - blender::bke::mesh_loops(*me).data(), - blender::bke::mesh_edges_for_write(*me).data(), + me->loops().data(), + me->edges_for_write().data(), me->totedge, - blender::bke::mesh_polygons(*me).data(), + me->polygons().data(), me->totpoly); } @@ -909,12 +909,12 @@ void BKE_mesh_flush_select_from_verts(Mesh *me) { const blender::bke::AttributeAccessor attributes = blender::bke::mesh_attributes(*me); mesh_flush_select_from_verts( - blender::bke::mesh_vertices(*me), - blender::bke::mesh_loops(*me), + me->vertices(), + me->loops(), attributes.lookup_or_default<bool>(".hide_edge", ATTR_DOMAIN_EDGE, false), attributes.lookup_or_default<bool>(".hide_poly", ATTR_DOMAIN_FACE, false), - blender::bke::mesh_edges_for_write(*me), - blender::bke::mesh_polygons_for_write(*me)); + me->edges_for_write(), + me->polygons_for_write()); } /** \} */ diff --git a/source/blender/blenkernel/intern/mesh_fair.cc b/source/blender/blenkernel/intern/mesh_fair.cc index e5a826af576..0fe58366449 100644 --- a/source/blender/blenkernel/intern/mesh_fair.cc +++ b/source/blender/blenkernel/intern/mesh_fair.cc @@ -195,10 +195,10 @@ class MeshFairingContext : public FairingContext { totvert_ = mesh->totvert; totloop_ = mesh->totloop; - MutableSpan<MVert> verts = blender::bke::mesh_vertices_for_write(*mesh); - medge_ = blender::bke::mesh_edges(*mesh); - mpoly_ = blender::bke::mesh_polygons(*mesh); - mloop_ = blender::bke::mesh_loops(*mesh); + MutableSpan<MVert> verts = mesh->vertices_for_write(); + medge_ = mesh->edges(); + mpoly_ = mesh->polygons(); + mloop_ = mesh->loops(); BKE_mesh_vert_loop_map_create(&vlmap_, &vlmap_mem_, mpoly_.data(), diff --git a/source/blender/blenkernel/intern/mesh_legacy_convert.cc b/source/blender/blenkernel/intern/mesh_legacy_convert.cc index d06c7acfefa..635ab73b869 100644 --- a/source/blender/blenkernel/intern/mesh_legacy_convert.cc +++ b/source/blender/blenkernel/intern/mesh_legacy_convert.cc @@ -322,7 +322,7 @@ void BKE_mesh_convert_mfaces_to_mpolys(Mesh *mesh) mesh->totface, mesh->totloop, mesh->totpoly, - blender::bke::mesh_edges_for_write(*mesh).data(), + mesh->edges_for_write().data(), (MFace *)CustomData_get_layer(&mesh->fdata, CD_MFACE), &mesh->totloop, &mesh->totpoly); @@ -379,7 +379,7 @@ void BKE_mesh_do_versions_convert_mfaces_to_mpolys(Mesh *mesh) mesh->totface, mesh->totloop, mesh->totpoly, - blender::bke::mesh_edges_for_write(*mesh).data(), + mesh->edges_for_write().data(), (MFace *)CustomData_get_layer(&mesh->fdata, CD_MFACE), &mesh->totloop, &mesh->totpoly); @@ -919,7 +919,7 @@ void BKE_mesh_legacy_convert_hide_layers_to_flags(Mesh *mesh) using namespace blender::bke; const AttributeAccessor attributes = mesh_attributes(*mesh); - MutableSpan<MVert> verts = mesh_vertices_for_write(*mesh); + MutableSpan<MVert> verts = mesh->vertices_for_write(); const VArray<bool> hide_vert = attributes.lookup_or_default<bool>( ".hide_vert", ATTR_DOMAIN_POINT, false); threading::parallel_for(verts.index_range(), 4096, [&](IndexRange range) { @@ -928,7 +928,7 @@ void BKE_mesh_legacy_convert_hide_layers_to_flags(Mesh *mesh) } }); - MutableSpan<MEdge> edges = mesh_edges_for_write(*mesh); + MutableSpan<MEdge> edges = mesh->edges_for_write(); const VArray<bool> hide_edge = attributes.lookup_or_default<bool>( ".hide_edge", ATTR_DOMAIN_EDGE, false); threading::parallel_for(edges.index_range(), 4096, [&](IndexRange range) { @@ -937,7 +937,7 @@ void BKE_mesh_legacy_convert_hide_layers_to_flags(Mesh *mesh) } }); - MutableSpan<MPoly> polys = mesh_polygons_for_write(*mesh); + MutableSpan<MPoly> polys = mesh->polygons_for_write(); const VArray<bool> hide_poly = attributes.lookup_or_default<bool>( ".hide_poly", ATTR_DOMAIN_FACE, false); threading::parallel_for(polys.index_range(), 4096, [&](IndexRange range) { @@ -953,7 +953,7 @@ void BKE_mesh_legacy_convert_flags_to_hide_layers(Mesh *mesh) using namespace blender::bke; MutableAttributeAccessor attributes = mesh_attributes_for_write(*mesh); - const Span<MVert> verts = mesh_vertices(*mesh); + const Span<MVert> verts = mesh->vertices(); if (std::any_of( verts.begin(), verts.end(), [](const MVert &vert) { return vert.flag & ME_HIDE; })) { SpanAttributeWriter<bool> hide_vert = attributes.lookup_or_add_for_write_only_span<bool>( @@ -966,7 +966,7 @@ void BKE_mesh_legacy_convert_flags_to_hide_layers(Mesh *mesh) hide_vert.finish(); } - const Span<MEdge> edges = mesh_edges(*mesh); + const Span<MEdge> edges = mesh->edges(); if (std::any_of( edges.begin(), edges.end(), [](const MEdge &edge) { return edge.flag & ME_HIDE; })) { SpanAttributeWriter<bool> hide_edge = attributes.lookup_or_add_for_write_only_span<bool>( @@ -979,7 +979,7 @@ void BKE_mesh_legacy_convert_flags_to_hide_layers(Mesh *mesh) hide_edge.finish(); } - const Span<MPoly> polys = mesh_polygons(*mesh); + const Span<MPoly> polys = mesh->polygons(); if (std::any_of( polys.begin(), polys.end(), [](const MPoly &poly) { return poly.flag & ME_HIDE; })) { SpanAttributeWriter<bool> hide_poly = attributes.lookup_or_add_for_write_only_span<bool>( @@ -1003,7 +1003,7 @@ void BKE_mesh_legacy_convert_material_indices_to_mpoly(Mesh *mesh) using namespace blender; using namespace blender::bke; const AttributeAccessor attributes = mesh_attributes(*mesh); - MutableSpan<MPoly> polys = mesh_polygons_for_write(*mesh); + MutableSpan<MPoly> polys = mesh->polygons_for_write(); const VArray<int> material_indices = attributes.lookup_or_default<int>( "material_index", ATTR_DOMAIN_FACE, 0); threading::parallel_for(polys.index_range(), 4096, [&](IndexRange range) { @@ -1018,7 +1018,7 @@ void BKE_mesh_legacy_convert_mpoly_to_material_indices(Mesh *mesh) using namespace blender; using namespace blender::bke; MutableAttributeAccessor attributes = mesh_attributes_for_write(*mesh); - const Span<MPoly> polys = mesh_polygons(*mesh); + const Span<MPoly> polys = mesh->polygons(); if (std::any_of( polys.begin(), polys.end(), [](const MPoly &poly) { return poly.mat_nr != 0; })) { SpanAttributeWriter<int> material_indices = attributes.lookup_or_add_for_write_only_span<int>( diff --git a/source/blender/blenkernel/intern/mesh_normals.cc b/source/blender/blenkernel/intern/mesh_normals.cc index 240d8e8124e..7217cbf5880 100644 --- a/source/blender/blenkernel/intern/mesh_normals.cc +++ b/source/blender/blenkernel/intern/mesh_normals.cc @@ -369,9 +369,9 @@ const float (*BKE_mesh_vertex_normals_ensure(const Mesh *mesh))[3] /* Isolate task because a mutex is locked and computing normals is multi-threaded. */ blender::threading::isolate_task([&]() { Mesh &mesh_mutable = *const_cast<Mesh *>(mesh); - const Span<MVert> verts = blender::bke::mesh_vertices(mesh_mutable); - const Span<MPoly> polys = blender::bke::mesh_polygons(mesh_mutable); - const Span<MLoop> loops = blender::bke::mesh_loops(mesh_mutable); + const Span<MVert> verts = mesh_mutable.vertices(); + const Span<MPoly> polys = mesh_mutable.polygons(); + const Span<MLoop> loops = mesh_mutable.loops(); vert_normals = BKE_mesh_vertex_normals_for_write(&mesh_mutable); poly_normals = BKE_mesh_poly_normals_for_write(&mesh_mutable); @@ -417,9 +417,9 @@ const float (*BKE_mesh_poly_normals_ensure(const Mesh *mesh))[3] /* Isolate task because a mutex is locked and computing normals is multi-threaded. */ blender::threading::isolate_task([&]() { Mesh &mesh_mutable = *const_cast<Mesh *>(mesh); - const Span<MVert> verts = blender::bke::mesh_vertices(mesh_mutable); - const Span<MPoly> polys = blender::bke::mesh_polygons(mesh_mutable); - const Span<MLoop> loops = blender::bke::mesh_loops(mesh_mutable); + const Span<MVert> verts = mesh_mutable.vertices(); + const Span<MPoly> polys = mesh_mutable.polygons(); + const Span<MLoop> loops = mesh_mutable.loops(); poly_normals = BKE_mesh_poly_normals_for_write(&mesh_mutable); @@ -2063,10 +2063,10 @@ static void mesh_set_custom_normals(Mesh *mesh, float (*r_custom_nors)[3], const clnors = (short(*)[2])CustomData_add_layer( &mesh->ldata, CD_CUSTOMLOOPNORMAL, CD_SET_DEFAULT, nullptr, numloops); } - const Span<MVert> verts = blender::bke::mesh_vertices(*mesh); - MutableSpan<MEdge> edges = blender::bke::mesh_edges_for_write(*mesh); - const Span<MPoly> polys = blender::bke::mesh_polygons(*mesh); - const Span<MLoop> loops = blender::bke::mesh_loops(*mesh); + const Span<MVert> verts = mesh->vertices(); + MutableSpan<MEdge> edges = mesh->edges_for_write(); + const Span<MPoly> polys = mesh->polygons(); + const Span<MLoop> loops = mesh->loops(); mesh_normals_loop_custom_set(verts.data(), BKE_mesh_vertex_normals_ensure(mesh), diff --git a/source/blender/blenkernel/intern/mesh_remesh_voxel.cc b/source/blender/blenkernel/intern/mesh_remesh_voxel.cc index b4c9560448b..1b583b6a851 100644 --- a/source/blender/blenkernel/intern/mesh_remesh_voxel.cc +++ b/source/blender/blenkernel/intern/mesh_remesh_voxel.cc @@ -61,8 +61,8 @@ static Mesh *remesh_quadriflow(const Mesh *input_mesh, void (*update_cb)(void *, float progress, int *cancel), void *update_cb_data) { - const Span<MVert> input_verts = blender::bke::mesh_vertices(*input_mesh); - const Span<MLoop> input_loops = blender::bke::mesh_loops(*input_mesh); + const Span<MVert> input_verts = input_mesh->vertices(); + const Span<MLoop> input_loops = input_mesh->loops(); const MLoopTri *looptri = BKE_mesh_runtime_looptri_ensure(input_mesh); /* Gather the required data for export to the internal quadriflow mesh format. */ @@ -124,9 +124,9 @@ static Mesh *remesh_quadriflow(const Mesh *input_mesh, /* Construct the new output mesh */ Mesh *mesh = BKE_mesh_new_nomain(qrd.out_totverts, 0, 0, qrd.out_totfaces * 4, qrd.out_totfaces); - MutableSpan<MVert> mesh_verts = blender::bke::mesh_vertices_for_write(*mesh); - MutableSpan<MPoly> polys = blender::bke::mesh_polygons_for_write(*mesh); - MutableSpan<MLoop> loops = blender::bke::mesh_loops_for_write(*mesh); + MutableSpan<MVert> mesh_verts = mesh->vertices_for_write(); + MutableSpan<MPoly> polys = mesh->polygons_for_write(); + MutableSpan<MLoop> loops = mesh->loops_for_write(); for (const int i : IndexRange(qrd.out_totverts)) { copy_v3_v3(mesh_verts[i].co, &qrd.out_verts[i * 3]); @@ -190,8 +190,8 @@ Mesh *BKE_mesh_remesh_quadriflow(const Mesh *mesh, static openvdb::FloatGrid::Ptr remesh_voxel_level_set_create(const Mesh *mesh, const float voxel_size) { - const Span<MVert> verts = blender::bke::mesh_vertices(*mesh); - const Span<MLoop> loops = blender::bke::mesh_loops(*mesh); + const Span<MVert> verts = mesh->vertices(); + const Span<MLoop> loops = mesh->loops(); Span<MLoopTri> looptris{BKE_mesh_runtime_looptri_ensure(mesh), BKE_mesh_runtime_looptri_len(mesh)}; @@ -230,9 +230,9 @@ static Mesh *remesh_voxel_volume_to_mesh(const openvdb::FloatGrid::Ptr level_set Mesh *mesh = BKE_mesh_new_nomain( vertices.size(), 0, 0, quads.size() * 4 + tris.size() * 3, quads.size() + tris.size()); - MutableSpan<MVert> mesh_verts = blender::bke::mesh_vertices_for_write(*mesh); - MutableSpan<MPoly> mesh_polys = blender::bke::mesh_polygons_for_write(*mesh); - MutableSpan<MLoop> mesh_loops = blender::bke::mesh_loops_for_write(*mesh); + MutableSpan<MVert> mesh_verts = mesh->vertices_for_write(); + MutableSpan<MPoly> mesh_polys = mesh->polygons_for_write(); + MutableSpan<MLoop> mesh_loops = mesh->loops_for_write(); for (const int i : mesh_verts.index_range()) { copy_v3_v3(mesh_verts[i].co, float3(vertices[i].x(), vertices[i].y(), vertices[i].z())); diff --git a/source/blender/blenkernel/intern/mesh_runtime.cc b/source/blender/blenkernel/intern/mesh_runtime.cc index 84440bd6e3c..c04a9f2b6f9 100644 --- a/source/blender/blenkernel/intern/mesh_runtime.cc +++ b/source/blender/blenkernel/intern/mesh_runtime.cc @@ -150,9 +150,9 @@ void BKE_mesh_runtime_looptri_recalc(Mesh *mesh) { mesh_ensure_looptri_data(mesh); BLI_assert(mesh->totpoly == 0 || mesh->runtime.looptris.array_wip != nullptr); - const Span<MVert> verts = blender::bke::mesh_vertices(*mesh); - const Span<MPoly> polys = blender::bke::mesh_polygons(*mesh); - const Span<MLoop> loops = blender::bke::mesh_loops(*mesh); + const Span<MVert> verts = mesh->vertices(); + const Span<MPoly> polys = mesh->polygons(); + const Span<MLoop> loops = mesh->loops(); BKE_mesh_recalc_looptri(loops.data(), polys.data(), @@ -330,10 +330,10 @@ bool BKE_mesh_runtime_is_valid(Mesh *me_eval) printf("MESH: %s\n", me_eval->id.name + 2); } - MutableSpan<MVert> verts = blender::bke::mesh_vertices_for_write(*me_eval); - MutableSpan<MEdge> edges = blender::bke::mesh_edges_for_write(*me_eval); - MutableSpan<MPoly> polys = blender::bke::mesh_polygons_for_write(*me_eval); - MutableSpan<MLoop> loops = blender::bke::mesh_loops_for_write(*me_eval); + MutableSpan<MVert> verts = me_eval->vertices_for_write(); + MutableSpan<MEdge> edges = me_eval->edges_for_write(); + MutableSpan<MPoly> polys = me_eval->polygons_for_write(); + MutableSpan<MLoop> loops = me_eval->loops_for_write(); is_valid &= BKE_mesh_validate_all_customdata( &me_eval->vdata, diff --git a/source/blender/blenkernel/intern/mesh_sample.cc b/source/blender/blenkernel/intern/mesh_sample.cc index 4c86a651ab2..f37246ced94 100644 --- a/source/blender/blenkernel/intern/mesh_sample.cc +++ b/source/blender/blenkernel/intern/mesh_sample.cc @@ -21,7 +21,7 @@ BLI_NOINLINE static void sample_point_attribute(const Mesh &mesh, const IndexMask mask, const MutableSpan<T> dst) { - const Span<MLoop> loops = mesh_loops(mesh); + const Span<MLoop> loops = mesh.loops(); const Span<MLoopTri> looptris{BKE_mesh_runtime_looptri_ensure(&mesh), BKE_mesh_runtime_looptri_len(&mesh)}; @@ -159,8 +159,8 @@ Span<float3> MeshAttributeInterpolator::ensure_barycentric_coords() } bary_coords_.reinitialize(mask_.min_array_size()); - const Span<MVert> verts = mesh_vertices(*mesh_); - const Span<MLoop> loops = mesh_loops(*mesh_); + const Span<MVert> verts = mesh_->vertices(); + const Span<MLoop> loops = mesh_->loops(); const Span<MLoopTri> looptris{BKE_mesh_runtime_looptri_ensure(mesh_), BKE_mesh_runtime_looptri_len(mesh_)}; @@ -189,8 +189,8 @@ Span<float3> MeshAttributeInterpolator::ensure_nearest_weights() } nearest_weights_.reinitialize(mask_.min_array_size()); - const Span<MVert> verts = mesh_vertices(*mesh_); - const Span<MLoop> loops = mesh_loops(*mesh_); + const Span<MVert> verts = mesh_->vertices(); + const Span<MLoop> loops = mesh_->loops(); const Span<MLoopTri> looptris{BKE_mesh_runtime_looptri_ensure(mesh_), BKE_mesh_runtime_looptri_len(mesh_)}; @@ -263,8 +263,8 @@ int sample_surface_points_spherical(RandomNumberGenerator &rng, Vector<int> &r_looptri_indices, Vector<float3> &r_positions) { - const Span<MVert> verts = mesh_vertices(mesh); - const Span<MLoop> loops = mesh_loops(mesh); + const Span<MVert> verts = mesh.vertices(); + const Span<MLoop> loops = mesh.loops(); const Span<MLoopTri> looptris{BKE_mesh_runtime_looptri_ensure(&mesh), BKE_mesh_runtime_looptri_len(&mesh)}; @@ -361,8 +361,8 @@ int sample_surface_points_projected( Vector<int> &r_looptri_indices, Vector<float3> &r_positions) { - const Span<MVert> verts = mesh_vertices(mesh); - const Span<MLoop> loops = mesh_loops(mesh); + const Span<MVert> verts = mesh.vertices(); + const Span<MLoop> loops = mesh.loops(); const Span<MLoopTri> looptris{BKE_mesh_runtime_looptri_ensure(&mesh), BKE_mesh_runtime_looptri_len(&mesh)}; diff --git a/source/blender/blenkernel/intern/mesh_validate.cc b/source/blender/blenkernel/intern/mesh_validate.cc index 409fb1fdc24..972841405e3 100644 --- a/source/blender/blenkernel/intern/mesh_validate.cc +++ b/source/blender/blenkernel/intern/mesh_validate.cc @@ -1067,10 +1067,10 @@ bool BKE_mesh_validate(Mesh *me, const bool do_verbose, const bool cddata_check_ do_verbose, true, &changed); - MutableSpan<MVert> verts = blender::bke::mesh_vertices_for_write(*me); - MutableSpan<MEdge> edges = blender::bke::mesh_edges_for_write(*me); - MutableSpan<MPoly> polys = blender::bke::mesh_polygons_for_write(*me); - MutableSpan<MLoop> loops = blender::bke::mesh_loops_for_write(*me); + MutableSpan<MVert> verts = me->vertices_for_write(); + MutableSpan<MEdge> edges = me->edges_for_write(); + MutableSpan<MPoly> polys = me->polygons_for_write(); + MutableSpan<MLoop> loops = me->loops_for_write(); BKE_mesh_validate_arrays(me, verts.data(), @@ -1120,10 +1120,10 @@ bool BKE_mesh_is_valid(Mesh *me) do_fixes, &changed); - MutableSpan<MVert> verts = blender::bke::mesh_vertices_for_write(*me); - MutableSpan<MEdge> edges = blender::bke::mesh_edges_for_write(*me); - MutableSpan<MPoly> polys = blender::bke::mesh_polygons_for_write(*me); - MutableSpan<MLoop> loops = blender::bke::mesh_loops_for_write(*me); + MutableSpan<MVert> verts = me->vertices_for_write(); + MutableSpan<MEdge> edges = me->edges_for_write(); + MutableSpan<MPoly> polys = me->polygons_for_write(); + MutableSpan<MLoop> loops = me->loops_for_write(); is_valid &= BKE_mesh_validate_arrays( me, @@ -1202,8 +1202,8 @@ void BKE_mesh_strip_loose_faces(Mesh *me) void BKE_mesh_strip_loose_polysloops(Mesh *me) { - MutableSpan<MPoly> polys = blender::bke::mesh_polygons_for_write(*me); - MutableSpan<MLoop> loops = blender::bke::mesh_loops_for_write(*me); + MutableSpan<MPoly> polys = me->polygons_for_write(); + MutableSpan<MLoop> loops = me->loops_for_write(); MPoly *p; MLoop *l; @@ -1279,7 +1279,7 @@ void BKE_mesh_strip_loose_edges(Mesh *me) MEdge *e; int a, b; uint *new_idx = (uint *)MEM_mallocN(sizeof(int) * me->totedge, __func__); - MutableSpan<MEdge> edges = blender::bke::mesh_edges_for_write(*me); + MutableSpan<MEdge> edges = me->edges_for_write(); for (a = b = 0, e = edges.data(); a < me->totedge; a++, e++) { if (e->v1 != e->v2) { @@ -1302,7 +1302,7 @@ void BKE_mesh_strip_loose_edges(Mesh *me) /* And now, update loops' edge indices. */ /* XXX We hope no loop was pointing to a striped edge! * Else, its e will be set to INVALID_LOOP_EDGE_MARKER :/ */ - MutableSpan<MLoop> loops = blender::bke::mesh_loops_for_write(*me); + MutableSpan<MLoop> loops = me->loops_for_write(); for (MLoop &loop : loops) { loop.e = new_idx[loop.e]; } @@ -1498,9 +1498,9 @@ void BKE_mesh_calc_edges_legacy(Mesh *me, const bool use_old) { MEdge *medge; int totedge = 0; - const Span<MVert> verts = blender::bke::mesh_vertices(*me); - const Span<MPoly> polys = blender::bke::mesh_polygons(*me); - MutableSpan<MLoop> loops = blender::bke::mesh_loops_for_write(*me); + const Span<MVert> verts = me->vertices(); + const Span<MPoly> polys = me->polygons(); + MutableSpan<MLoop> loops = me->loops_for_write(); mesh_calc_edges_mdata(verts.data(), (MFace *)CustomData_get_layer(&me->fdata, CD_MFACE), @@ -1528,8 +1528,8 @@ void BKE_mesh_calc_edges_legacy(Mesh *me, const bool use_old) void BKE_mesh_calc_edges_loose(Mesh *mesh) { - const Span<MLoop> loops = blender::bke::mesh_loops(*mesh); - MutableSpan<MEdge> edges = blender::bke::mesh_edges_for_write(*mesh); + const Span<MLoop> loops = mesh->loops(); + MutableSpan<MEdge> edges = mesh->edges_for_write(); for (const int i : edges.index_range()) { edges[i].flag |= ME_LOOSEEDGE; diff --git a/source/blender/blenkernel/intern/mesh_wrapper.cc b/source/blender/blenkernel/intern/mesh_wrapper.cc index 84c3d740386..fe28fc37d45 100644 --- a/source/blender/blenkernel/intern/mesh_wrapper.cc +++ b/source/blender/blenkernel/intern/mesh_wrapper.cc @@ -197,7 +197,7 @@ void BKE_mesh_wrapper_vert_coords_copy(const Mesh *me, case ME_WRAPPER_TYPE_MDATA: case ME_WRAPPER_TYPE_SUBD: { BLI_assert(vert_coords_len <= me->totvert); - const Span<MVert> verts = blender::bke::mesh_vertices(*me); + const Span<MVert> verts = me->vertices(); for (int i = 0; i < vert_coords_len; i++) { copy_v3_v3(vert_coords[i], verts[i].co); } @@ -235,7 +235,7 @@ void BKE_mesh_wrapper_vert_coords_copy_with_mat4(const Mesh *me, case ME_WRAPPER_TYPE_MDATA: case ME_WRAPPER_TYPE_SUBD: { BLI_assert(vert_coords_len == me->totvert); - const Span<MVert> verts = blender::bke::mesh_vertices(*me); + const Span<MVert> verts = me->vertices(); for (int i = 0; i < vert_coords_len; i++) { mul_v3_m4v3(vert_coords[i], mat, verts[i].co); } diff --git a/source/blender/blenkernel/intern/object.cc b/source/blender/blenkernel/intern/object.cc index be0f1cc1210..25f780b92a2 100644 --- a/source/blender/blenkernel/intern/object.cc +++ b/source/blender/blenkernel/intern/object.cc @@ -4757,7 +4757,7 @@ bool BKE_object_shapekey_remove(Main *bmain, Object *ob, KeyBlock *kb) switch (ob->type) { case OB_MESH: { Mesh *mesh = (Mesh *)ob->data; - MutableSpan<MVert> verts = blender::bke::mesh_vertices_for_write(*mesh); + MutableSpan<MVert> verts = mesh->vertices_for_write(); BKE_keyblock_convert_to_mesh(key->refkey, verts.data(), mesh->totvert); break; } @@ -5254,7 +5254,7 @@ KDTree_3d *BKE_object_as_kdtree(Object *ob, int *r_tot) const int *index; if (me_eval && (index = (const int *)CustomData_get_layer(&me_eval->vdata, CD_ORIGINDEX))) { - const Span<MVert> verts = blender::bke::mesh_vertices(*me); + const Span<MVert> verts = me->vertices(); /* Tree over-allocates in case where some verts have #ORIGINDEX_NONE. */ tot = 0; @@ -5271,7 +5271,7 @@ KDTree_3d *BKE_object_as_kdtree(Object *ob, int *r_tot) } } else { - const Span<MVert> verts = blender::bke::mesh_vertices(*me); + const Span<MVert> verts = me->vertices(); tot = verts.size(); tree = BLI_kdtree_3d_new(tot); diff --git a/source/blender/blenkernel/intern/object_dupli.cc b/source/blender/blenkernel/intern/object_dupli.cc index 027b18c006a..d42404922e3 100644 --- a/source/blender/blenkernel/intern/object_dupli.cc +++ b/source/blender/blenkernel/intern/object_dupli.cc @@ -628,7 +628,7 @@ static void make_duplis_verts(const DupliContext *ctx) VertexDupliData_Mesh vdd{}; vdd.params = vdd_params; vdd.totvert = me_eval->totvert; - vdd.mvert = blender::bke::mesh_vertices(*me_eval).data(); + vdd.mvert = me_eval->vertices().data(); vdd.vert_normals = BKE_mesh_vertex_normals_ensure(me_eval); vdd.orco = (const float(*)[3])CustomData_get_layer(&me_eval->vdata, CD_ORCO); @@ -1178,9 +1178,9 @@ static void make_duplis_faces(const DupliContext *ctx) FaceDupliData_Mesh fdd{}; fdd.params = fdd_params; fdd.totface = me_eval->totpoly; - fdd.mpoly = blender::bke::mesh_polygons(*me_eval).data(); - fdd.mloop = blender::bke::mesh_loops(*me_eval).data(); - fdd.mvert = blender::bke::mesh_vertices(*me_eval).data(); + fdd.mpoly = me_eval->polygons().data(); + fdd.mloop = me_eval->loops().data(); + fdd.mvert = me_eval->vertices().data(); fdd.mloopuv = (uv_idx != -1) ? (const MLoopUV *)CustomData_get_layer_n( &me_eval->ldata, CD_MLOOPUV, uv_idx) : nullptr; diff --git a/source/blender/blenkernel/intern/paint.cc b/source/blender/blenkernel/intern/paint.cc index f9828455433..88bebc2f813 100644 --- a/source/blender/blenkernel/intern/paint.cc +++ b/source/blender/blenkernel/intern/paint.cc @@ -1748,10 +1748,8 @@ static void sculpt_update_object(Depsgraph *depsgraph, /* If the fully evaluated mesh has the same topology as the deform-only version, use it. * This matters because 'deform eval' is very restrictive and excludes even modifiers that * simply recompute vertex weights. */ - if (blender::bke::mesh_polygons(*me_eval_deform).data() == - blender::bke::mesh_polygons(*me_eval).data() && - blender::bke::mesh_loops(*me_eval_deform).data() == - blender::bke::mesh_loops(*me_eval).data() && + if (me_eval_deform->polygons().data() == me_eval->polygons().data() && + me_eval_deform->loops().data() == me_eval->loops().data() && me_eval_deform->totvert == me_eval->totvert) { me_eval_deform = me_eval; } @@ -1952,8 +1950,8 @@ void BKE_sculpt_update_object_for_edit( int BKE_sculpt_mask_layers_ensure(Object *ob, MultiresModifierData *mmd) { Mesh *me = static_cast<Mesh *>(ob->data); - const blender::Span<MPoly> polys = blender::bke::mesh_polygons(*me); - const blender::Span<MLoop> loops = blender::bke::mesh_loops(*me); + const blender::Span<MPoly> polys = me->polygons(); + const blender::Span<MLoop> loops = me->loops(); int ret = 0; const float *paint_mask = static_cast<const float *>( @@ -2244,9 +2242,9 @@ static PBVH *build_pbvh_from_regular_mesh(Object *ob, Mesh *me_eval_deform, bool PBVH *pbvh = BKE_pbvh_new(); BKE_pbvh_respect_hide_set(pbvh, respect_hide); - blender::MutableSpan<MVert> verts = blender::bke::mesh_vertices_for_write(*me); - const blender::Span<MPoly> polys = blender::bke::mesh_polygons(*me); - const blender::Span<MLoop> loops = blender::bke::mesh_loops(*me); + blender::MutableSpan<MVert> verts = me->vertices_for_write(); + const blender::Span<MPoly> polys = me->polygons(); + const blender::Span<MLoop> loops = me->loops(); MLoopTri *looptri = static_cast<MLoopTri *>( MEM_malloc_arrayN(looptris_num, sizeof(*looptri), __func__)); diff --git a/source/blender/blenkernel/intern/pbvh_pixels.cc b/source/blender/blenkernel/intern/pbvh_pixels.cc index 84da8f6c089..f733f3145ec 100644 --- a/source/blender/blenkernel/intern/pbvh_pixels.cc +++ b/source/blender/blenkernel/intern/pbvh_pixels.cc @@ -292,7 +292,7 @@ static void update_pixels(PBVH *pbvh, Mesh *mesh, Image *image, ImageUser *image for (PBVHNode *node : nodes_to_update) { NodeData *node_data = static_cast<NodeData *>(node->pixels.node_data); - const Span<MLoop> loops = blender::bke::mesh_loops(*mesh); + const Span<MLoop> loops = mesh->loops(); init_triangles(pbvh, node, node_data, loops.data()); } diff --git a/source/blender/blenkernel/intern/subdiv_mesh.cc b/source/blender/blenkernel/intern/subdiv_mesh.cc index 27a1c6bfc25..c222fc46800 100644 --- a/source/blender/blenkernel/intern/subdiv_mesh.cc +++ b/source/blender/blenkernel/intern/subdiv_mesh.cc @@ -965,7 +965,7 @@ static void find_edge_neighbors(const Mesh *coarse_mesh, const MEdge *edge, const MEdge *neighbors[2]) { - const blender::Span<MEdge> coarse_edges = blender::bke::mesh_edges(*coarse_mesh); + const blender::Span<MEdge> coarse_edges = coarse_mesh->edges(); neighbors[0] = nullptr; neighbors[1] = nullptr; int neighbor_counters[2] = {0, 0}; diff --git a/source/blender/blenkernel/intern/volume_to_mesh.cc b/source/blender/blenkernel/intern/volume_to_mesh.cc index dbe255664bb..2005959d360 100644 --- a/source/blender/blenkernel/intern/volume_to_mesh.cc +++ b/source/blender/blenkernel/intern/volume_to_mesh.cc @@ -178,9 +178,9 @@ Mesh *volume_to_mesh(const openvdb::GridBase &grid, 0, 0, 0, - mesh_vertices_for_write(*mesh), - mesh_polygons_for_write(*mesh), - mesh_loops_for_write(*mesh)); + mesh->vertices_for_write(), + mesh->polygons_for_write(), + mesh->loops_for_write()); BKE_mesh_calc_edges(mesh, false, false); diff --git a/source/blender/bmesh/intern/bmesh_mesh_convert.cc b/source/blender/bmesh/intern/bmesh_mesh_convert.cc index e7299ec69dc..e0250db8c4b 100644 --- a/source/blender/bmesh/intern/bmesh_mesh_convert.cc +++ b/source/blender/bmesh/intern/bmesh_mesh_convert.cc @@ -366,7 +366,7 @@ void BM_mesh_bm_from_me(BMesh *bm, const Mesh *me, const struct BMeshFromMeshPar const int *material_indices = (const int *)CustomData_get_layer_named( &me->pdata, CD_PROP_INT32, "material_index"); - Span<MVert> mvert = blender::bke::mesh_vertices(*me); + Span<MVert> mvert = me->vertices(); Array<BMVert *> vtable(me->totvert); for (const int i : mvert.index_range()) { BMVert *v = vtable[i] = BM_vert_create( @@ -412,7 +412,7 @@ void BM_mesh_bm_from_me(BMesh *bm, const Mesh *me, const struct BMeshFromMeshPar bm->elem_index_dirty &= ~BM_VERT; /* Added in order, clear dirty flag. */ } - const Span<MEdge> medge = blender::bke::mesh_edges(*me); + const Span<MEdge> medge = me->edges(); Array<BMEdge *> etable(me->totedge); for (const int i : medge.index_range()) { BMEdge *e = etable[i] = BM_edge_create( @@ -444,8 +444,8 @@ void BM_mesh_bm_from_me(BMesh *bm, const Mesh *me, const struct BMeshFromMeshPar bm->elem_index_dirty &= ~BM_EDGE; /* Added in order, clear dirty flag. */ } - const Span<MPoly> mpoly = blender::bke::mesh_polygons(*me); - const Span<MLoop> mloop = blender::bke::mesh_loops(*me); + const Span<MPoly> mpoly = me->polygons(); + const Span<MLoop> mloop = me->loops(); /* Only needed for selection. */ @@ -1302,10 +1302,10 @@ void BM_mesh_bm_to_me_for_eval(BMesh *bm, Mesh *me, const CustomData_MeshMasks * BMVert *eve; BMEdge *eed; BMFace *efa; - MutableSpan<MVert> mvert = blender::bke::mesh_vertices_for_write(*me); - MutableSpan<MEdge> medge = blender::bke::mesh_edges_for_write(*me); - MutableSpan<MPoly> mpoly = blender::bke::mesh_polygons_for_write(*me); - MutableSpan<MLoop> loops = blender::bke::mesh_loops_for_write(*me); + MutableSpan<MVert> mvert = me->vertices_for_write(); + MutableSpan<MEdge> medge = me->edges_for_write(); + MutableSpan<MPoly> mpoly = me->polygons_for_write(); + MutableSpan<MLoop> loops = me->loops_for_write(); MLoop *mloop = loops.data(); unsigned int i, j; diff --git a/source/blender/compositor/nodes/COM_ConvertColorSpaceNode.cc b/source/blender/compositor/nodes/COM_ConvertColorSpaceNode.cc index 938ee80f4bd..7d557de66e4 100644 --- a/source/blender/compositor/nodes/COM_ConvertColorSpaceNode.cc +++ b/source/blender/compositor/nodes/COM_ConvertColorSpaceNode.cc @@ -27,7 +27,7 @@ ConvertColorSpaceNode::ConvertColorSpaceNode(bNode *editorNode) : Node(editorNod void ConvertColorSpaceNode::convert_to_operations(NodeConverter &converter, const CompositorContext &UNUSED(context)) const { - const bNode *b_node = get_bnode(); + const bNode *b_node = get_bnode(); NodeInput *inputSocketImage = this->get_input_socket(0); NodeOutput *outputSocketImage = this->get_output_socket(0); @@ -50,7 +50,7 @@ void ConvertColorSpaceNode::convert_to_operations(NodeConverter &converter, bool ConvertColorSpaceNode::performs_conversion(NodeConvertColorSpace &settings) const { - const bNode *b_node = get_bnode(); + const bNode *b_node = get_bnode(); if (IMB_colormanagement_space_name_is_data(settings.from_color_space)) { CLOG_INFO(&LOG, diff --git a/source/blender/compositor/nodes/COM_GlareNode.cc b/source/blender/compositor/nodes/COM_GlareNode.cc index eec05482655..d80e6f9543f 100644 --- a/source/blender/compositor/nodes/COM_GlareNode.cc +++ b/source/blender/compositor/nodes/COM_GlareNode.cc @@ -21,7 +21,7 @@ void GlareNode::convert_to_operations(NodeConverter &converter, const CompositorContext & /*context*/) const { const bNode *node = this->get_bnode(); -const NodeGlare *glare = (const NodeGlare *)node->storage; + const NodeGlare *glare = (const NodeGlare *)node->storage; GlareBaseOperation *glareoperation = nullptr; switch (glare->type) { diff --git a/source/blender/compositor/nodes/COM_SunBeamsNode.cc b/source/blender/compositor/nodes/COM_SunBeamsNode.cc index ff154d9014e..c33d9d0faf5 100644 --- a/source/blender/compositor/nodes/COM_SunBeamsNode.cc +++ b/source/blender/compositor/nodes/COM_SunBeamsNode.cc @@ -16,7 +16,7 @@ void SunBeamsNode::convert_to_operations(NodeConverter &converter, { NodeInput *input_socket = this->get_input_socket(0); NodeOutput *output_socket = this->get_output_socket(0); - const NodeSunBeams *data = (const NodeSunBeams *)get_bnode()->storage; + const NodeSunBeams *data = (const NodeSunBeams *)get_bnode()->storage; SunBeamsOperation *operation = new SunBeamsOperation(); operation->set_data(*data); diff --git a/source/blender/depsgraph/intern/builder/deg_builder_nodes.cc b/source/blender/depsgraph/intern/builder/deg_builder_nodes.cc index d25adc279d7..ca3e4543a23 100644 --- a/source/blender/depsgraph/intern/builder/deg_builder_nodes.cc +++ b/source/blender/depsgraph/intern/builder/deg_builder_nodes.cc @@ -1218,8 +1218,12 @@ void DepsgraphNodeBuilder::build_driver_id_property(ID *id, const char *rna_path /* Custom properties of bones are placed in their components to improve granularity. */ if (RNA_struct_is_a(ptr.type, &RNA_PoseBone)) { const bPoseChannel *pchan = static_cast<const bPoseChannel *>(ptr.data); - ensure_operation_node( - ptr.owner_id, NodeType::BONE, pchan->name, OperationCode::ID_PROPERTY, nullptr, prop_identifier); + ensure_operation_node(ptr.owner_id, + NodeType::BONE, + pchan->name, + OperationCode::ID_PROPERTY, + nullptr, + prop_identifier); } else { ensure_operation_node( diff --git a/source/blender/draw/intern/draw_cache_impl_subdivision.cc b/source/blender/draw/intern/draw_cache_impl_subdivision.cc index 9a50a6a53fb..9882ebf66f0 100644 --- a/source/blender/draw/intern/draw_cache_impl_subdivision.cc +++ b/source/blender/draw/intern/draw_cache_impl_subdivision.cc @@ -675,7 +675,7 @@ static void draw_subdiv_cache_extra_coarse_face_data_mesh(const MeshRenderData * Mesh *mesh, uint32_t *flags_data) { - const Span<MPoly> polys = blender::bke::mesh_polygons(*mesh); + const Span<MPoly> polys = mesh->polygons(); for (const int i : polys.index_range()) { uint32_t flag = 0; if ((polys[i].flag & ME_SMOOTH) != 0) { @@ -1095,7 +1095,7 @@ static bool draw_subdiv_build_cache(DRWSubdivCache *cache, } /* Only build polygon related data if we have polygons. */ - const Span<MPoly> polys = blender::bke::mesh_polygons(*mesh_eval); + const Span<MPoly> polys = mesh_eval->polygons(); if (cache->num_subdiv_loops != 0) { /* Build buffers for the PatchMap. */ draw_patch_map_build(&cache->gpu_patch_map, subdiv); @@ -2156,7 +2156,7 @@ void DRW_subdivide_loose_geom(DRWSubdivCache *subdiv_cache, MeshBufferCache *cac int subd_vert_offset = 0; /* Subdivide each loose coarse edge. */ - const Span<MEdge> coarse_edges = blender::bke::mesh_edges(*coarse_mesh); + const Span<MEdge> coarse_edges = coarse_mesh->edges(); for (int i = 0; i < coarse_loose_edge_len; i++) { const int coarse_edge_index = cache->loose_geom.edges[i]; const MEdge *coarse_edge = &coarse_edges[cache->loose_geom.edges[i]]; @@ -2187,7 +2187,7 @@ void DRW_subdivide_loose_geom(DRWSubdivCache *subdiv_cache, MeshBufferCache *cac } /* Copy the remaining loose_verts. */ - const Span<MVert> coarse_verts = blender::bke::mesh_vertices(*coarse_mesh); + const Span<MVert> coarse_verts = coarse_mesh->vertices(); for (int i = 0; i < coarse_loose_vert_len; i++) { const int coarse_vertex_index = cache->loose_geom.verts[i]; const MVert &coarse_vertex = coarse_verts[coarse_vertex_index]; diff --git a/source/blender/draw/intern/mesh_extractors/extract_mesh_vbo_sculpt_data.cc b/source/blender/draw/intern/mesh_extractors/extract_mesh_vbo_sculpt_data.cc index 0104224340d..4e3d4235487 100644 --- a/source/blender/draw/intern/mesh_extractors/extract_mesh_vbo_sculpt_data.cc +++ b/source/blender/draw/intern/mesh_extractors/extract_mesh_vbo_sculpt_data.cc @@ -129,8 +129,8 @@ static void extract_sculpt_data_init_subdiv(const DRWSubdivCache *subdiv_cache, GPUVertBuf *subdiv_mask_vbo = nullptr; const float *cd_mask = (const float *)CustomData_get_layer(cd_vdata, CD_PAINT_MASK); - const Span<MPoly> coarse_polys = bke::mesh_polygons(*coarse_mesh); - const Span<MLoop> coarse_loops = bke::mesh_loops(*coarse_mesh); + const Span<MPoly> coarse_polys = coarse_mesh->polygons(); + const Span<MLoop> coarse_loops = coarse_mesh->loops(); if (cd_mask) { GPUVertFormat mask_format = {0}; diff --git a/source/blender/draw/intern/mesh_extractors/extract_mesh_vbo_weights.cc b/source/blender/draw/intern/mesh_extractors/extract_mesh_vbo_weights.cc index 268c96814f2..509331f2f1e 100644 --- a/source/blender/draw/intern/mesh_extractors/extract_mesh_vbo_weights.cc +++ b/source/blender/draw/intern/mesh_extractors/extract_mesh_vbo_weights.cc @@ -172,7 +172,7 @@ static void extract_weights_init_subdiv(const DRWSubdivCache *subdiv_cache, extract_weights_init(mr, cache, coarse_weights, _data); if (mr->extract_type != MR_EXTRACT_BMESH) { - const Span<MPoly> coarse_polys = bke::mesh_polygons(*coarse_mesh); + const Span<MPoly> coarse_polys = coarse_mesh->polygons(); for (const int i : coarse_polys.index_range()) { const MPoly *mpoly = &coarse_polys[i]; extract_weights_iter_poly_mesh(mr, mpoly, i, _data); diff --git a/source/blender/editors/curves/intern/curves_ops.cc b/source/blender/editors/curves/intern/curves_ops.cc index a383d9768d2..6582ce6e6d7 100644 --- a/source/blender/editors/curves/intern/curves_ops.cc +++ b/source/blender/editors/curves/intern/curves_ops.cc @@ -286,7 +286,7 @@ static void try_convert_single_object(Object &curves_ob, const bke::CurvesSurfaceTransforms transforms{curves_ob, &surface_ob}; const MFace *mfaces = (const MFace *)CustomData_get_layer(&surface_me.fdata, CD_MFACE); - const Span<MVert> verts = bke::mesh_vertices(surface_me); + const Span<MVert> verts = surface_me.vertices(); for (const int new_hair_i : IndexRange(hair_num)) { const int curve_i = new_hair_i; @@ -542,8 +542,8 @@ static void snap_curves_to_surface_exec_object(Object &curves_ob, CurvesGeometry &curves = CurvesGeometry::wrap(curves_id.geometry); const Mesh &surface_mesh = *static_cast<const Mesh *>(surface_ob.data); - const Span<MVert> verts = bke::mesh_vertices(surface_mesh); - const Span<MLoop> loops = bke::mesh_loops(surface_mesh); + const Span<MVert> verts = surface_mesh.vertices(); + const Span<MLoop> loops = surface_mesh.loops(); const Span<MLoopTri> surface_looptris = {BKE_mesh_runtime_looptri_ensure(&surface_mesh), BKE_mesh_runtime_looptri_len(&surface_mesh)}; VArraySpan<float2> surface_uv_map; diff --git a/source/blender/editors/mesh/editface.cc b/source/blender/editors/mesh/editface.cc index bc3e34af661..7256d90fe13 100644 --- a/source/blender/editors/mesh/editface.cc +++ b/source/blender/editors/mesh/editface.cc @@ -73,11 +73,11 @@ void paintface_flush_flags(bContext *C, Mesh *me_eval = (Mesh *)ob_eval->runtime.data_eval; bke::MutableAttributeAccessor attributes_eval = bke::mesh_attributes_for_write(*me_eval); bool updated = false; - const Span<MPoly> me_polys = bke::mesh_polygons(*me); + const Span<MPoly> me_polys = me->polygons(); if (me_orig != nullptr && me_eval != nullptr && me_orig->totpoly == me->totpoly) { /* Update the COW copy of the mesh. */ - MutableSpan<MPoly> orig_polys = bke::mesh_polygons_for_write(*me_orig); + MutableSpan<MPoly> orig_polys = me_orig->polygons_for_write(); for (int i = 0; i < me->totpoly; i++) { orig_polys[i].flag = me_polys[i].flag; } @@ -92,7 +92,7 @@ void paintface_flush_flags(bContext *C, /* Mesh polys => Final derived polys */ if ((index_array = (const int *)CustomData_get_layer(&me_eval->pdata, CD_ORIGINDEX))) { - MutableSpan<MPoly> eval_polys = bke::mesh_polygons_for_write(*me_orig); + MutableSpan<MPoly> eval_polys = me_orig->polygons_for_write(); /* loop over final derived polys */ for (const int i : eval_polys.index_range()) { if (index_array[i] != ORIGINDEX_NONE) { @@ -141,7 +141,7 @@ void paintface_hide(bContext *C, Object *ob, const bool unselected) return; } - MutableSpan<MPoly> polys = bke::mesh_polygons_for_write(*me); + MutableSpan<MPoly> polys = me->polygons_for_write(); bke::MutableAttributeAccessor attributes = bke::mesh_attributes_for_write(*me); bke::SpanAttributeWriter<bool> hide_poly = attributes.lookup_or_add_for_write_span<bool>( ".hide_poly", ATTR_DOMAIN_FACE); @@ -174,7 +174,7 @@ void paintface_reveal(bContext *C, Object *ob, const bool select) return; } - MutableSpan<MPoly> polys = bke::mesh_polygons_for_write(*me); + MutableSpan<MPoly> polys = me->polygons_for_write(); bke::MutableAttributeAccessor attributes = bke::mesh_attributes_for_write(*me); if (select) { @@ -206,9 +206,9 @@ static void select_linked_tfaces_with_seams(Mesh *me, const uint index, const bo BLI_bitmap *edge_tag = BLI_BITMAP_NEW(me->totedge, __func__); BLI_bitmap *poly_tag = BLI_BITMAP_NEW(me->totpoly, __func__); - const Span<MEdge> edges = bke::mesh_edges(*me); - MutableSpan<MPoly> polys = bke::mesh_polygons_for_write(*me); - const Span<MLoop> loops = bke::mesh_loops(*me); + const Span<MEdge> edges = me->edges(); + MutableSpan<MPoly> polys = me->polygons_for_write(); + const Span<MLoop> loops = me->loops(); bke::AttributeAccessor attributes = bke::mesh_attributes(*me); const VArray<bool> hide_poly = attributes.lookup_or_default<bool>( ".hide_poly", ATTR_DOMAIN_FACE, false); @@ -305,7 +305,7 @@ bool paintface_deselect_all_visible(bContext *C, Object *ob, int action, bool fl return false; } - MutableSpan<MPoly> polys = bke::mesh_polygons_for_write(*me); + MutableSpan<MPoly> polys = me->polygons_for_write(); bke::AttributeAccessor attributes = bke::mesh_attributes(*me); const VArray<bool> hide_poly = attributes.lookup_or_default<bool>( ".hide_poly", ATTR_DOMAIN_FACE, false); @@ -369,9 +369,9 @@ bool paintface_minmax(Object *ob, float r_min[3], float r_max[3]) copy_m3_m4(bmat, ob->obmat); - const Span<MVert> verts = bke::mesh_vertices(*me); - const Span<MPoly> polys = bke::mesh_polygons(*me); - const Span<MLoop> loops = bke::mesh_loops(*me); + const Span<MVert> verts = me->vertices(); + const Span<MPoly> polys = me->polygons(); + const Span<MLoop> loops = me->loops(); bke::AttributeAccessor attributes = bke::mesh_attributes(*me); const VArray<bool> hide_poly = attributes.lookup_or_default<bool>( ".hide_poly", ATTR_DOMAIN_FACE, false); @@ -409,7 +409,7 @@ bool paintface_mouse_select(bContext *C, /* Get the face under the cursor */ Mesh *me = BKE_mesh_from_object(ob); - MutableSpan<MPoly> polys = bke::mesh_polygons_for_write(*me); + MutableSpan<MPoly> polys = me->polygons_for_write(); bke::AttributeAccessor attributes = bke::mesh_attributes(*me); const VArray<bool> hide_poly = attributes.lookup_or_default<bool>( ".hide_poly", ATTR_DOMAIN_FACE, false); @@ -494,8 +494,8 @@ void paintvert_flush_flags(Object *ob) index_array = (const int *)CustomData_get_layer(&me_eval->vdata, CD_ORIGINDEX); - const Span<MVert> vertices = bke::mesh_vertices_for_write(*me); - MutableSpan<MVert> vertices_eval = bke::mesh_vertices_for_write(*me_eval); + const Span<MVert> vertices = me->vertices_for_write(); + MutableSpan<MVert> vertices_eval = me_eval->vertices_for_write(); if (index_array) { int orig_index; @@ -529,7 +529,7 @@ bool paintvert_deselect_all_visible(Object *ob, int action, bool flush_flags) return false; } - MutableSpan<MVert> verts = bke::mesh_vertices_for_write(*me); + MutableSpan<MVert> verts = me->vertices_for_write(); bke::AttributeAccessor attributes = bke::mesh_attributes(*me); const VArray<bool> hide_vert = attributes.lookup_or_default<bool>( ".hide_vert", ATTR_DOMAIN_POINT, false); @@ -606,7 +606,7 @@ void paintvert_select_ungrouped(Object *ob, bool extend, bool flush_flags) paintvert_deselect_all_visible(ob, SEL_DESELECT, false); } - MutableSpan<MVert> verts = bke::mesh_vertices_for_write(*me); + MutableSpan<MVert> verts = me->vertices_for_write(); bke::AttributeAccessor attributes = bke::mesh_attributes(*me); const VArray<bool> hide_vert = attributes.lookup_or_default<bool>( ".hide_vert", ATTR_DOMAIN_POINT, false); @@ -635,7 +635,7 @@ void paintvert_hide(bContext *C, Object *ob, const bool unselected) return; } - MutableSpan<MVert> verts = bke::mesh_vertices_for_write(*me); + MutableSpan<MVert> verts = me->vertices_for_write(); bke::MutableAttributeAccessor attributes = bke::mesh_attributes_for_write(*me); bke::SpanAttributeWriter<bool> hide_vert = attributes.lookup_or_add_for_write_span<bool>( ".hide_vert", ATTR_DOMAIN_POINT); @@ -668,7 +668,7 @@ void paintvert_reveal(bContext *C, Object *ob, const bool select) return; } - MutableSpan<MVert> verts = bke::mesh_vertices_for_write(*me); + MutableSpan<MVert> verts = me->vertices_for_write(); bke::MutableAttributeAccessor attributes = bke::mesh_attributes_for_write(*me); const VArray<bool> hide_vert = attributes.lookup_or_default<bool>( ".hide_vert", ATTR_DOMAIN_POINT, false); diff --git a/source/blender/editors/mesh/mesh_data.cc b/source/blender/editors/mesh/mesh_data.cc index 55e8afeb056..f41a5128c5c 100644 --- a/source/blender/editors/mesh/mesh_data.cc +++ b/source/blender/editors/mesh/mesh_data.cc @@ -776,10 +776,10 @@ static int mesh_customdata_custom_splitnormals_add_exec(bContext *C, wmOperator /* Tag edges as sharp according to smooth threshold if needed, * to preserve autosmooth shading. */ if (me->flag & ME_AUTOSMOOTH) { - const Span<MVert> verts = blender::bke::mesh_vertices(*me); - MutableSpan<MEdge> edges = blender::bke::mesh_edges_for_write(*me); - const Span<MPoly> polys = blender::bke::mesh_polygons(*me); - const Span<MLoop> loops = blender::bke::mesh_loops(*me); + const Span<MVert> verts = me->vertices(); + MutableSpan<MEdge> edges = me->edges_for_write(); + const Span<MPoly> polys = me->polygons(); + const Span<MLoop> loops = me->loops(); BKE_edges_sharp_from_angle_set(verts.data(), verts.size(), @@ -893,7 +893,7 @@ static void mesh_add_verts(Mesh *mesh, int len) const int old_vertex_num = mesh->totvert; mesh->totvert = totvert; - MutableSpan<MVert> verts = blender::bke::mesh_vertices_for_write(*mesh); + MutableSpan<MVert> verts = mesh->vertices_for_write(); for (MVert &vert : verts.drop_front(old_vertex_num)) { vert.flag = SELECT; } @@ -926,7 +926,7 @@ static void mesh_add_edges(Mesh *mesh, int len) const int old_edges_num = mesh->totedge; mesh->totedge = totedge; - MutableSpan<MEdge> edges = blender::bke::mesh_edges_for_write(*mesh); + MutableSpan<MEdge> edges = mesh->edges_for_write(); for (MEdge &edge : edges.drop_front(old_edges_num)) { edge.flag = ME_EDGEDRAW | ME_EDGERENDER | SELECT; } @@ -986,7 +986,7 @@ static void mesh_add_polys(Mesh *mesh, int len) const int old_polys_num = mesh->totpoly; mesh->totpoly = totpoly; - MutableSpan<MPoly> polys = blender::bke::mesh_polygons_for_write(*mesh); + MutableSpan<MPoly> polys = mesh->polygons_for_write(); for (MPoly &poly : polys.drop_front(old_polys_num)) { poly.flag = ME_FACE_SEL; } diff --git a/source/blender/editors/mesh/meshtools.cc b/source/blender/editors/mesh/meshtools.cc index bc4597a3e75..a6abd0a2a59 100644 --- a/source/blender/editors/mesh/meshtools.cc +++ b/source/blender/editors/mesh/meshtools.cc @@ -905,7 +905,7 @@ static bool ed_mesh_mirror_topo_table_update(Object *ob, Mesh *me_eval) static int mesh_get_x_mirror_vert_spatial(Object *ob, Mesh *me_eval, int index) { Mesh *me = static_cast<Mesh *>(ob->data); - const Span<MVert> verts = blender::bke::mesh_vertices(me_eval ? *me_eval : *me); + const Span<MVert> verts = me_eval ? me_eval->vertices() : me->vertices(); float vec[3]; @@ -1142,7 +1142,7 @@ int *mesh_get_x_mirror_faces(Object *ob, BMEditMesh *em, Mesh *me_eval) mirrorverts = static_cast<int *>(MEM_callocN(sizeof(int) * totvert, "MirrorVerts")); mirrorfaces = static_cast<int *>(MEM_callocN(sizeof(int[2]) * totface, "MirrorFaces")); - const Span<MVert> verts = blender::bke::mesh_vertices(me_eval ? *me_eval : *me); + const Span<MVert> verts = me_eval ? me_eval->vertices() : me->vertices(); MFace *mface = (MFace *)CustomData_get_layer(&(me_eval ? me_eval : me)->fdata, CD_MFACE); ED_mesh_mirror_spatial_table_begin(ob, em, me_eval); @@ -1274,9 +1274,9 @@ bool ED_mesh_pick_face_vert( const float mval_f[2] = {(float)mval[0], (float)mval[1]}; float len_best = FLT_MAX; - const Span<MVert> verts = blender::bke::mesh_vertices(*me_eval); - const Span<MPoly> polys = blender::bke::mesh_polygons(*me_eval); - const Span<MLoop> loops = blender::bke::mesh_loops(*me_eval); + const Span<MVert> verts = me_eval->vertices(); + const Span<MPoly> polys = me_eval->polygons(); + const Span<MLoop> loops = me_eval->loops(); const int *index_mp_to_orig = (const int *)CustomData_get_layer(&me_eval->pdata, CD_ORIGINDEX); @@ -1410,7 +1410,7 @@ bool ED_mesh_pick_vert( } /* setup data */ - const Span<MVert> verts = blender::bke::mesh_vertices(*me); + const Span<MVert> verts = me->vertices(); data.mvert = verts.data(); data.region = region; data.mval_f = mval_f; diff --git a/source/blender/editors/object/object_modifier.cc b/source/blender/editors/object/object_modifier.cc index b1cdddb22be..adf5bfa1ad5 100644 --- a/source/blender/editors/object/object_modifier.cc +++ b/source/blender/editors/object/object_modifier.cc @@ -592,8 +592,8 @@ bool ED_object_modifier_convert_psys_to_mesh(ReportList *UNUSED(reports), CustomData_add_layer(&me->edata, CD_MEDGE, CD_SET_DEFAULT, nullptr, edges_num); CustomData_add_layer(&me->fdata, CD_MFACE, CD_SET_DEFAULT, nullptr, 0); - blender::MutableSpan<MVert> verts = blender::bke::mesh_vertices_for_write(*me); - blender::MutableSpan<MEdge> edges = blender::bke::mesh_edges_for_write(*me); + blender::MutableSpan<MVert> verts = me->vertices_for_write(); + blender::MutableSpan<MEdge> edges = me->edges_for_write(); MVert *mvert = verts.data(); MEdge *medge = edges.data(); @@ -2638,15 +2638,15 @@ static void skin_armature_bone_create(Object *skin_ob, static Object *modifier_skin_armature_create(Depsgraph *depsgraph, Main *bmain, Object *skin_ob) { Mesh *me = static_cast<Mesh *>(skin_ob->data); - const Span<MVert> me_verts = blender::bke::mesh_vertices(*me); - const Span<MEdge> me_edges = blender::bke::mesh_edges(*me); + const Span<MVert> me_verts = me->vertices(); + const Span<MEdge> me_edges = me->edges(); Scene *scene_eval = DEG_get_evaluated_scene(depsgraph); Object *ob_eval = DEG_get_evaluated_object(depsgraph, skin_ob); const Mesh *me_eval_deform = mesh_get_eval_deform( depsgraph, scene_eval, ob_eval, &CD_MASK_BAREMESH); - const Span<MVert> verts_eval = blender::bke::mesh_vertices(*me_eval_deform); + const Span<MVert> verts_eval = me_eval_deform->vertices(); /* add vertex weights to original mesh */ CustomData_add_layer(&me->vdata, CD_MDEFORMVERT, CD_SET_DEFAULT, nullptr, me->totvert); diff --git a/source/blender/editors/object/object_remesh.cc b/source/blender/editors/object/object_remesh.cc index 5c5151f6330..56cccd984b6 100644 --- a/source/blender/editors/object/object_remesh.cc +++ b/source/blender/editors/object/object_remesh.cc @@ -131,7 +131,7 @@ static int voxel_remesh_exec(bContext *C, wmOperator *op) } /* Output mesh will be all smooth or all flat shading. */ - const Span<MPoly> polygons = blender::bke::mesh_polygons(*mesh); + const Span<MPoly> polygons = mesh->polygons(); const bool smooth_normals = polygons.first().flag & ME_SMOOTH; float isovalue = 0.0f; @@ -682,9 +682,9 @@ static bool mesh_is_manifold_consistent(Mesh *mesh) * check that the direction of the faces are consistent and doesn't suddenly * flip */ - const Span<MVert> verts = blender::bke::mesh_vertices(*mesh); - const Span<MEdge> edges = blender::bke::mesh_edges(*mesh); - const Span<MLoop> loops = blender::bke::mesh_loops(*mesh); + const Span<MVert> verts = mesh->vertices(); + const Span<MEdge> edges = mesh->edges(); + const Span<MLoop> loops = mesh->loops(); bool is_manifold_consistent = true; char *edge_faces = (char *)MEM_callocN(mesh->totedge * sizeof(char), "remesh_manifold_check"); diff --git a/source/blender/editors/object/object_vgroup.cc b/source/blender/editors/object/object_vgroup.cc index d33f1d0afac..aadfa523a3e 100644 --- a/source/blender/editors/object/object_vgroup.cc +++ b/source/blender/editors/object/object_vgroup.cc @@ -197,7 +197,7 @@ bool ED_vgroup_parray_alloc(ID *id, return true; } if (CustomData_has_layer(&me->vdata, CD_MDEFORMVERT)) { - const blender::Span<MVert> verts = blender::bke::mesh_vertices(*me); + const blender::Span<MVert> verts = me->vertices(); MDeformVert *dvert = (MDeformVert *)CustomData_get_layer(&me->vdata, CD_MDEFORMVERT); *dvert_tot = me->totvert; @@ -660,7 +660,7 @@ static void vgroup_copy_active_to_sel(Object *ob, eVGroupSelect subset_type) } } else { - const blender::Span<MVert> verts = blender::bke::mesh_vertices(*me); + const blender::Span<MVert> verts = me->vertices(); MDeformVert *dv; int v_act; @@ -1054,7 +1054,7 @@ static void vgroup_select_verts(Object *ob, int select) MDeformVert *dv; int i; - mv = blender::bke::mesh_vertices_for_write(*me).data(); + mv = me->vertices_for_write().data(); dv = BKE_mesh_deform_verts_for_write(me); for (i = 0; i < me->totvert; i++, mv++, dv++) { @@ -1217,8 +1217,8 @@ static bool vgroup_normalize(Object *ob) * count is an int passed by reference so it can be assigned the value of the length here. */ static blender::Vector<int> getSurroundingVerts(Mesh *me, int vert) { - const MPoly *mp = blender::bke::mesh_polygons(*me).data(); - const MLoop *loops = blender::bke::mesh_loops(*me).data(); + const MPoly *mp = me->polygons().data(); + const MLoop *loops = me->loops().data(); int i = me->totpoly; blender::Vector<int> verts; @@ -1352,7 +1352,7 @@ static void moveCloserToDistanceFromPlane(Depsgraph *depsgraph, Mesh *me_deform; MDeformWeight *dw, *dw_eval; MVert m; - const blender::Span<MVert> verts = blender::bke::mesh_vertices(*me_deform); + const blender::Span<MVert> verts = me_deform->vertices(); MDeformVert *dvert = (MDeformVert *)CustomData_get_layer(&me->vdata, CD_MDEFORMVERT) + index; MDeformVert *dvert_eval = (MDeformVert *)CustomData_get_layer(&mesh_eval->vdata, CD_MDEFORMVERT) + @@ -1526,7 +1526,7 @@ static void vgroup_fix( int i; Mesh *me = static_cast<Mesh *>(ob->data); - MVert *mvert = blender::bke::mesh_vertices_for_write(*me).data(); + MVert *mvert = me->vertices_for_write().data(); if (!(me->editflag & ME_EDIT_PAINT_VERT_SEL)) { return; } @@ -1541,7 +1541,7 @@ static void vgroup_fix( Mesh *me_deform = mesh_get_eval_deform( depsgraph, scene_eval, object_eval, &CD_MASK_BAREMESH); - const blender::Span<MVert> verts_deform = blender::bke::mesh_vertices(*me_deform); + const blender::Span<MVert> verts_deform = me_deform->vertices(); k = count; while (k--) { p[k] = verts_deform[verts[k]]; @@ -1937,8 +1937,7 @@ static void vgroup_smooth_subset(Object *ob, emap_mem = nullptr; } else { - BKE_mesh_vert_edge_map_create( - &emap, &emap_mem, blender::bke::mesh_edges(*me).data(), me->totvert, me->totedge); + BKE_mesh_vert_edge_map_create(&emap, &emap_mem, me->edges().data(), me->totvert, me->totedge); } weight_accum_prev = static_cast<float *>( @@ -1977,8 +1976,8 @@ static void vgroup_smooth_subset(Object *ob, } } else { - const blender::Span<MVert> verts = blender::bke::mesh_vertices(*me); - const blender::Span<MEdge> edges = blender::bke::mesh_edges(*me); + const blender::Span<MVert> verts = me->vertices(); + const blender::Span<MEdge> edges = me->edges(); for (int i = 0; i < dvert_tot; i++) { const MVert *v = &verts[i]; if (IS_ME_VERT_WRITE(v)) { @@ -2052,10 +2051,10 @@ static void vgroup_smooth_subset(Object *ob, } else { int j; - const blender::Span<MEdge> edges = blender::bke::mesh_edges(*me); + const blender::Span<MEdge> edges = me->edges(); /* checked already */ - BLI_assert(IS_ME_VERT_WRITE(&blender::bke::mesh_vertices(*me)[i])); + BLI_assert(IS_ME_VERT_WRITE(&me->vertices()[i])); for (j = 0; j < emap[i].count; j++) { const MEdge *e = &edges[emap[i].indices[j]]; @@ -2473,7 +2472,7 @@ void ED_vgroup_mirror(Object *ob, } BLI_bitmap *vert_tag = BLI_BITMAP_NEW(me->totvert, __func__); - const MVert *verts = blender::bke::mesh_vertices(*me).data(); + const MVert *verts = me->vertices().data(); MDeformVert *dverts = BKE_mesh_deform_verts_for_write(me); for (vidx = 0, mv = verts; vidx < me->totvert; vidx++, mv++) { @@ -2627,7 +2626,7 @@ static void vgroup_assign_verts(Object *ob, const float weight) } } else { - const blender::Span<MVert> verts = blender::bke::mesh_vertices(*me); + const blender::Span<MVert> verts = me->vertices(); MDeformVert *dvert = BKE_mesh_deform_verts_for_write(me); MDeformVert *dv = dvert; @@ -4356,7 +4355,7 @@ static void vgroup_copy_active_to_sel_single(Object *ob, const int def_nr) return; } - const blender::Span<MVert> verts = blender::bke::mesh_vertices(*me); + const blender::Span<MVert> verts = me->vertices(); MDeformVert *dvert = BKE_mesh_deform_verts_for_write(me); dv = dvert; diff --git a/source/blender/editors/sculpt_paint/curves_sculpt_add.cc b/source/blender/editors/sculpt_paint/curves_sculpt_add.cc index c9208f7196d..c53d06b3937 100644 --- a/source/blender/editors/sculpt_paint/curves_sculpt_add.cc +++ b/source/blender/editors/sculpt_paint/curves_sculpt_add.cc @@ -138,8 +138,8 @@ struct AddOperationExecutor { return; } surface_eval_ = BKE_object_get_evaluated_mesh(surface_ob_eval_); - surface_verts_eval_ = bke::mesh_vertices(*surface_eval_); - surface_loops_eval_ = bke::mesh_loops(*surface_eval_); + surface_verts_eval_ = surface_eval_->vertices(); + surface_loops_eval_ = surface_eval_->loops(); surface_looptris_eval_ = {BKE_mesh_runtime_looptri_ensure(surface_eval_), BKE_mesh_runtime_looptri_len(surface_eval_)}; BKE_bvhtree_from_mesh_get(&surface_bvh_eval_, surface_eval_, BVHTREE_FROM_LOOPTRI, 2); diff --git a/source/blender/editors/sculpt_paint/curves_sculpt_puff.cc b/source/blender/editors/sculpt_paint/curves_sculpt_puff.cc index 799ac450a15..062bacc7add 100644 --- a/source/blender/editors/sculpt_paint/curves_sculpt_puff.cc +++ b/source/blender/editors/sculpt_paint/curves_sculpt_puff.cc @@ -119,8 +119,8 @@ struct PuffOperationExecutor { reinterpret_cast<const float3 *>(CustomData_get_layer(&surface_->ldata, CD_NORMAL)), surface_->totloop}; - surface_verts_ = bke::mesh_vertices(*surface_); - surface_loops_ = bke::mesh_loops(*surface_); + surface_verts_ = surface_->vertices(); + surface_loops_ = surface_->loops(); surface_looptris_ = {BKE_mesh_runtime_looptri_ensure(surface_), BKE_mesh_runtime_looptri_len(surface_)}; BKE_bvhtree_from_mesh_get(&surface_bvh_, surface_, BVHTREE_FROM_LOOPTRI, 2); diff --git a/source/blender/editors/sculpt_paint/curves_sculpt_slide.cc b/source/blender/editors/sculpt_paint/curves_sculpt_slide.cc index 62059533855..e884d7c4fd9 100644 --- a/source/blender/editors/sculpt_paint/curves_sculpt_slide.cc +++ b/source/blender/editors/sculpt_paint/curves_sculpt_slide.cc @@ -201,8 +201,8 @@ struct SlideOperationExecutor { } surface_looptris_eval_ = {BKE_mesh_runtime_looptri_ensure(surface_eval_), BKE_mesh_runtime_looptri_len(surface_eval_)}; - surface_verts_eval_ = bke::mesh_vertices(*surface_eval_); - surface_loops_eval_ = bke::mesh_loops(*surface_eval_); + surface_verts_eval_ = surface_eval_->vertices(); + surface_loops_eval_ = surface_eval_->loops(); if (surface_eval_->totpoly == 0) { report_empty_evaluated_surface(stroke_extension.reports); return; @@ -322,8 +322,8 @@ struct SlideOperationExecutor { { const float4x4 brush_transform_inv = brush_transform.inverted(); - const Span<MVert> verts_orig_su = bke::mesh_vertices(*surface_orig_); - const Span<MLoop> loops_orig = bke::mesh_loops(*surface_orig_); + const Span<MVert> verts_orig_su = surface_orig_->vertices(); + const Span<MLoop> loops_orig = surface_orig_->loops(); MutableSpan<float3> positions_orig_cu = curves_orig_->positions_for_write(); MutableSpan<float2> surface_uv_coords = curves_orig_->surface_uv_coords_for_write(); diff --git a/source/blender/editors/sculpt_paint/paint_vertex.cc b/source/blender/editors/sculpt_paint/paint_vertex.cc index aacced02e60..9d5a7459b80 100644 --- a/source/blender/editors/sculpt_paint/paint_vertex.cc +++ b/source/blender/editors/sculpt_paint/paint_vertex.cc @@ -1237,8 +1237,8 @@ static void vertex_paint_init_session_data(const ToolSettings *ts, Object *ob) } Mesh *me = (Mesh *)ob->data; - const Span<MPoly> polys = blender::bke::mesh_polygons(*me); - const Span<MLoop> loops = bke::mesh_loops(*me); + const Span<MPoly> polys = me->polygons(); + const Span<MLoop> loops = me->loops(); if (gmap->vert_to_loop == nullptr) { gmap->vert_map_mem = nullptr; @@ -4088,9 +4088,9 @@ static bool vertex_color_set(Object *ob, ColorPaint4f paintcol_in, CustomDataLay } else { Color *color_layer = static_cast<Color *>(layer->data); - const Span<MVert> verts = blender::bke::mesh_vertices(*me); - const Span<MPoly> polys = blender::bke::mesh_polygons(*me); - const Span<MLoop> loops = blender::bke::mesh_loops(*me); + const Span<MVert> verts = me->vertices(); + const Span<MPoly> polys = me->polygons(); + const Span<MLoop> loops = me->loops(); for (const int i : polys.index_range()) { const MPoly &poly = polys[i]; diff --git a/source/blender/editors/sculpt_paint/paint_vertex_color_ops.cc b/source/blender/editors/sculpt_paint/paint_vertex_color_ops.cc index dcdeba84b2b..7737265bb1f 100644 --- a/source/blender/editors/sculpt_paint/paint_vertex_color_ops.cc +++ b/source/blender/editors/sculpt_paint/paint_vertex_color_ops.cc @@ -159,8 +159,8 @@ static IndexMask get_selected_indices(const Mesh &mesh, Vector<int64_t> &indices) { using namespace blender; - Span<MVert> verts = bke::mesh_vertices(mesh); - Span<MPoly> polys = bke::mesh_polygons(mesh); + Span<MVert> verts = mesh.vertices(); + Span<MPoly> polys = mesh.polygons(); bke::AttributeAccessor attributes = bke::mesh_attributes(mesh); diff --git a/source/blender/editors/space_spreadsheet/spreadsheet_data_source_geometry.cc b/source/blender/editors/space_spreadsheet/spreadsheet_data_source_geometry.cc index a8fccef1c23..3c79e66f436 100644 --- a/source/blender/editors/space_spreadsheet/spreadsheet_data_source_geometry.cc +++ b/source/blender/editors/space_spreadsheet/spreadsheet_data_source_geometry.cc @@ -168,9 +168,9 @@ std::unique_ptr<ColumnValues> GeometryDataSource::get_column_values( else if (G.debug_value == 4001 && component_->type() == GEO_COMPONENT_TYPE_MESH) { const MeshComponent &component = static_cast<const MeshComponent &>(*component_); if (const Mesh *mesh = component.get_for_read()) { - const Span<MEdge> edges = bke::mesh_edges(*mesh); - const Span<MPoly> polys = bke::mesh_polygons(*mesh); - const Span<MLoop> loops = bke::mesh_loops(*mesh); + const Span<MEdge> edges = mesh->edges(); + const Span<MPoly> polys = mesh->polygons(); + const Span<MLoop> loops = mesh->loops(); if (domain_ == ATTR_DOMAIN_EDGE) { if (STREQ(column_id.name, "Vertex 1")) { diff --git a/source/blender/editors/transform/transform_snap_object.cc b/source/blender/editors/transform/transform_snap_object.cc index 80160217801..e4c152bc630 100644 --- a/source/blender/editors/transform/transform_snap_object.cc +++ b/source/blender/editors/transform/transform_snap_object.cc @@ -244,10 +244,10 @@ static SnapData_Mesh *snap_object_data_mesh_get(SnapObjectContext *sctx, SnapData_Mesh *sod; bool init = false; - const Span<MVert> verts = blender::bke::mesh_vertices(*me_eval); - const Span<MEdge> edges = blender::bke::mesh_edges(*me_eval); - const Span<MPoly> polys = blender::bke::mesh_polygons(*me_eval); - const Span<MLoop> loops = blender::bke::mesh_loops(*me_eval); + const Span<MVert> verts = me_eval->vertices(); + const Span<MEdge> edges = me_eval->edges(); + const Span<MPoly> polys = me_eval->polygons(); + const Span<MLoop> loops = me_eval->loops(); if (std::unique_ptr<SnapData_Mesh> *sod_p = sctx->mesh_caches.lookup_ptr(ob_eval)) { sod = sod_p->get(); diff --git a/source/blender/freestyle/intern/blender_interface/BlenderFileLoader.cpp b/source/blender/freestyle/intern/blender_interface/BlenderFileLoader.cpp index dfcee30d451..1aa3f2cc54a 100644 --- a/source/blender/freestyle/intern/blender_interface/BlenderFileLoader.cpp +++ b/source/blender/freestyle/intern/blender_interface/BlenderFileLoader.cpp @@ -380,8 +380,8 @@ int BlenderFileLoader::testDegenerateTriangle(float v1[3], float v2[3], float v3 static bool testEdgeMark(Mesh *me, const FreestyleEdge *fed, const MLoopTri *lt, int i) { - const Span<MEdge> edges = blender::bke::mesh_edges(*me); - const Span<MLoop> loops = blender::bke::mesh_loops(*me); + const Span<MEdge> edges = me->edges(); + const Span<MLoop> loops = me->loops(); const MLoop *mloop = &loops[lt->tri[i]]; const MLoop *mloop_next = &loops[lt->tri[(i + 1) % 3]]; @@ -399,9 +399,9 @@ void BlenderFileLoader::insertShapeNode(Object *ob, Mesh *me, int id) { char *name = ob->id.name + 2; - const Span<MVert> mesh_verts = blender::bke::mesh_vertices(*me); - const Span<MPoly> mesh_polys = blender::bke::mesh_polygons(*me); - const Span<MLoop> mesh_loops = blender::bke::mesh_loops(*me); + const Span<MVert> mesh_verts = me->vertices(); + const Span<MPoly> mesh_polys = me->polygons(); + const Span<MLoop> mesh_loops = me->loops(); // Compute loop triangles int tottri = poly_to_tri_count(me->totpoly, me->totloop); diff --git a/source/blender/geometry/intern/add_curves_on_mesh.cc b/source/blender/geometry/intern/add_curves_on_mesh.cc index ae9879f5e2b..7490694bf12 100644 --- a/source/blender/geometry/intern/add_curves_on_mesh.cc +++ b/source/blender/geometry/intern/add_curves_on_mesh.cc @@ -245,8 +245,8 @@ AddCurvesOnMeshOutputs add_curves_on_mesh(CurvesGeometry &curves, Vector<float2> used_uvs; /* Find faces that the passed in uvs belong to. */ - const Span<MVert> surface_verts = bke::mesh_vertices(*inputs.surface); - const Span<MLoop> surface_loops = bke::mesh_loops(*inputs.surface); + const Span<MVert> surface_verts = inputs.surface->vertices(); + const Span<MLoop> surface_loops = inputs.surface->loops(); for (const int i : inputs.uvs.index_range()) { const float2 &uv = inputs.uvs[i]; const ReverseUVSampler::Result result = inputs.reverse_uv_sampler->sample(uv); diff --git a/source/blender/geometry/intern/mesh_merge_by_distance.cc b/source/blender/geometry/intern/mesh_merge_by_distance.cc index a9089139a80..ad39f686dd4 100644 --- a/source/blender/geometry/intern/mesh_merge_by_distance.cc +++ b/source/blender/geometry/intern/mesh_merge_by_distance.cc @@ -1165,9 +1165,9 @@ static void weld_mesh_context_create(const Mesh &mesh, WeldMesh *r_weld_mesh) { const int mvert_len = mesh.totvert; - const Span<MEdge> edges = bke::mesh_edges(mesh); - const Span<MPoly> polys = bke::mesh_polygons(mesh); - const Span<MLoop> loops = bke::mesh_loops(mesh); + const Span<MEdge> edges = mesh.edges(); + const Span<MPoly> polys = mesh.polygons(); + const Span<MLoop> loops = mesh.loops(); Vector<WeldVert> wvert = weld_vert_ctx_alloc_and_setup(vert_dest_map, vert_kill_len); r_weld_mesh->vert_kill_len = vert_kill_len; @@ -1360,8 +1360,8 @@ static Mesh *create_merged_mesh(const Mesh &mesh, MutableSpan<int> vert_dest_map, const int removed_vertex_count) { - const Span<MPoly> src_polys = bke::mesh_polygons(mesh); - const Span<MLoop> src_loops = bke::mesh_loops(mesh); + const Span<MPoly> src_polys = mesh.polygons(); + const Span<MLoop> src_loops = mesh.loops(); const int totvert = mesh.totvert; const int totedge = mesh.totedge; @@ -1375,9 +1375,9 @@ static Mesh *create_merged_mesh(const Mesh &mesh, Mesh *result = BKE_mesh_new_nomain_from_template( &mesh, result_nverts, result_nedges, 0, result_nloops, result_npolys); - MutableSpan<MEdge> dst_edges = bke::mesh_edges_for_write(*result); - MutableSpan<MPoly> dst_polys = bke::mesh_polygons_for_write(*result); - MutableSpan<MLoop> dst_loops = bke::mesh_loops_for_write(*result); + MutableSpan<MEdge> dst_edges = result->edges_for_write(); + MutableSpan<MPoly> dst_polys = result->polygons_for_write(); + MutableSpan<MLoop> dst_loops = result->loops_for_write(); /* Vertices. */ @@ -1570,7 +1570,7 @@ std::optional<Mesh *> mesh_merge_by_distance_all(const Mesh &mesh, KDTree_3d *tree = BLI_kdtree_3d_new(selection.size()); - const Span<MVert> verts = bke::mesh_vertices(mesh); + const Span<MVert> verts = mesh.vertices(); for (const int i : selection) { BLI_kdtree_3d_insert(tree, i, verts[i].co); } @@ -1597,8 +1597,8 @@ std::optional<Mesh *> mesh_merge_by_distance_connected(const Mesh &mesh, const float merge_distance, const bool only_loose_edges) { - const Span<MVert> verts = bke::mesh_vertices(mesh); - const Span<MEdge> edges = bke::mesh_edges(mesh); + const Span<MVert> verts = mesh.vertices(); + const Span<MEdge> edges = mesh.edges(); int vert_kill_len = 0; diff --git a/source/blender/geometry/intern/mesh_primitive_cuboid.cc b/source/blender/geometry/intern/mesh_primitive_cuboid.cc index 1609954ae41..1e734a82e43 100644 --- a/source/blender/geometry/intern/mesh_primitive_cuboid.cc +++ b/source/blender/geometry/intern/mesh_primitive_cuboid.cc @@ -405,9 +405,9 @@ Mesh *create_cuboid_mesh(const float3 &size, Mesh *mesh = BKE_mesh_new_nomain( config.vertex_count, 0, 0, config.loop_count, config.poly_count); - MutableSpan<MVert> verts = bke::mesh_vertices_for_write(*mesh); - MutableSpan<MPoly> polys = bke::mesh_polygons_for_write(*mesh); - MutableSpan<MLoop> loops = bke::mesh_loops_for_write(*mesh); + MutableSpan<MVert> verts = mesh->vertices_for_write(); + MutableSpan<MPoly> polys = mesh->polygons_for_write(); + MutableSpan<MLoop> loops = mesh->loops_for_write(); calculate_vertices(config, verts); diff --git a/source/blender/geometry/intern/mesh_to_curve_convert.cc b/source/blender/geometry/intern/mesh_to_curve_convert.cc index 907f6c07a7e..1951c960d0d 100644 --- a/source/blender/geometry/intern/mesh_to_curve_convert.cc +++ b/source/blender/geometry/intern/mesh_to_curve_convert.cc @@ -214,7 +214,7 @@ static CurveFromEdgesOutput edges_to_curve_point_indices(Span<MVert> verts, static Vector<std::pair<int, int>> get_selected_edges(const Mesh &mesh, const IndexMask selection) { Vector<std::pair<int, int>> selected_edges; - const Span<MEdge> edges = bke::mesh_edges(mesh); + const Span<MEdge> edges = mesh.edges(); for (const int i : selection) { selected_edges.append({edges[i].v1, edges[i].v2}); } @@ -224,7 +224,7 @@ static Vector<std::pair<int, int>> get_selected_edges(const Mesh &mesh, const In bke::CurvesGeometry mesh_to_curve_convert(const Mesh &mesh, const IndexMask selection) { Vector<std::pair<int, int>> selected_edges = get_selected_edges(mesh, selection); - const Span<MVert> verts = bke::mesh_vertices(mesh); + const Span<MVert> verts = mesh.vertices(); CurveFromEdgesOutput output = edges_to_curve_point_indices(verts, selected_edges); return create_curve_from_vert_indices( diff --git a/source/blender/geometry/intern/mesh_to_volume.cc b/source/blender/geometry/intern/mesh_to_volume.cc index 43636a4a9f0..39078b1c511 100644 --- a/source/blender/geometry/intern/mesh_to_volume.cc +++ b/source/blender/geometry/intern/mesh_to_volume.cc @@ -30,7 +30,7 @@ class OpenVDBMeshAdapter { }; OpenVDBMeshAdapter::OpenVDBMeshAdapter(const Mesh &mesh, float4x4 transform) - : vertices_(bke::mesh_vertices(mesh)), loops_(bke::mesh_loops(mesh)), transform_(transform) + : vertices_(mesh.vertices()), loops_(mesh.loops()), transform_(transform) { /* This only updates a cache and can be considered to be logically const. */ const MLoopTri *looptris = BKE_mesh_runtime_looptri_ensure(&mesh); diff --git a/source/blender/geometry/intern/realize_instances.cc b/source/blender/geometry/intern/realize_instances.cc index d4fde2943c4..fcf296de6f0 100644 --- a/source/blender/geometry/intern/realize_instances.cc +++ b/source/blender/geometry/intern/realize_instances.cc @@ -864,10 +864,10 @@ static AllMeshesInfo preprocess_meshes(const GeometrySet &geometry_set, MeshRealizeInfo &mesh_info = info.realize_info[mesh_index]; const Mesh *mesh = info.order[mesh_index]; mesh_info.mesh = mesh; - mesh_info.verts = bke::mesh_vertices(*mesh); - mesh_info.edges = bke::mesh_edges(*mesh); - mesh_info.polys = bke::mesh_polygons(*mesh); - mesh_info.loops = bke::mesh_loops(*mesh); + mesh_info.verts = mesh->vertices(); + mesh_info.edges = mesh->edges(); + mesh_info.polys = mesh->polygons(); + mesh_info.loops = mesh->loops(); /* Create material index mapping. */ mesh_info.material_index_map.reinitialize(std::max<int>(mesh->totcol, 1)); @@ -1046,10 +1046,10 @@ static void execute_realize_mesh_tasks(const RealizeInstancesOptions &options, MeshComponent &dst_component = r_realized_geometry.get_component_for_write<MeshComponent>(); dst_component.replace(dst_mesh); bke::MutableAttributeAccessor dst_attributes = bke::mesh_attributes_for_write(*dst_mesh); - MutableSpan<MVert> dst_verts = bke::mesh_vertices_for_write(*dst_mesh); - MutableSpan<MEdge> dst_edges = bke::mesh_edges_for_write(*dst_mesh); - MutableSpan<MPoly> dst_polys = bke::mesh_polygons_for_write(*dst_mesh); - MutableSpan<MLoop> dst_loops = bke::mesh_loops_for_write(*dst_mesh); + MutableSpan<MVert> dst_verts = dst_mesh->vertices_for_write(); + MutableSpan<MEdge> dst_edges = dst_mesh->edges_for_write(); + MutableSpan<MPoly> dst_polys = dst_mesh->polygons_for_write(); + MutableSpan<MLoop> dst_loops = dst_mesh->loops_for_write(); /* Copy settings from the first input geometry set with a mesh. */ const RealizeMeshTask &first_task = tasks.first(); diff --git a/source/blender/io/alembic/exporter/abc_writer_mesh.cc b/source/blender/io/alembic/exporter/abc_writer_mesh.cc index 4c9abfdee37..3805f1bc0b2 100644 --- a/source/blender/io/alembic/exporter/abc_writer_mesh.cc +++ b/source/blender/io/alembic/exporter/abc_writer_mesh.cc @@ -431,7 +431,7 @@ static void get_vertices(struct Mesh *mesh, std::vector<Imath::V3f> &points) points.clear(); points.resize(mesh->totvert); - const Span<MVert> vertices = bke::mesh_vertices(*mesh); + const Span<MVert> vertices = mesh->vertices(); for (int i = 0, e = mesh->totvert; i < e; i++) { copy_yup_from_zup(points[i].getValue(), vertices[i].co); } @@ -442,8 +442,8 @@ static void get_topology(struct Mesh *mesh, std::vector<int32_t> &loop_counts, bool &r_has_flat_shaded_poly) { - const Span<MPoly> polys = bke::mesh_polygons(*mesh); - const Span<MLoop> loops = bke::mesh_loops(*mesh); + const Span<MPoly> polys = mesh->polygons(); + const Span<MLoop> loops = mesh->loops(); r_has_flat_shaded_poly = false; poly_verts.clear(); @@ -477,7 +477,7 @@ static void get_edge_creases(struct Mesh *mesh, lengths.clear(); sharpnesses.clear(); - const Span<MEdge> edges = bke::mesh_edges(*mesh); + const Span<MEdge> edges = mesh->edges(); for (const int i : edges.index_range()) { const float sharpness = static_cast<float>(edges[i].crease) * factor; @@ -536,7 +536,7 @@ static void get_loop_normals(struct Mesh *mesh, /* NOTE: data needs to be written in the reverse order. */ int abc_index = 0; - const Span<MPoly> polys = bke::mesh_polygons(*mesh); + const Span<MPoly> polys = mesh->polygons(); for (const int i : polys.index_range()) { const MPoly *mp = &polys[i]; diff --git a/source/blender/io/alembic/intern/abc_reader_mesh.cc b/source/blender/io/alembic/intern/abc_reader_mesh.cc index 5553951db67..dadfa93a6fb 100644 --- a/source/blender/io/alembic/intern/abc_reader_mesh.cc +++ b/source/blender/io/alembic/intern/abc_reader_mesh.cc @@ -152,7 +152,7 @@ static void read_mverts(CDStreamConfig &config, const AbcMeshData &mesh_data) void read_mverts(Mesh &mesh, const P3fArraySamplePtr positions, const N3fArraySamplePtr normals) { - MutableSpan<MVert> verts = bke::mesh_vertices_for_write(mesh); + MutableSpan<MVert> verts = mesh.vertices_for_write(); for (int i = 0; i < positions->size(); i++) { MVert &mvert = verts[i]; Imath::V3f pos_in = (*positions)[i]; @@ -270,7 +270,7 @@ static void process_loop_normals(CDStreamConfig &config, const N3fArraySamplePtr float(*lnors)[3] = static_cast<float(*)[3]>( MEM_malloc_arrayN(loop_count, sizeof(float[3]), "ABC::FaceNormals")); - MutableSpan<MPoly> polys = bke::mesh_polygons_for_write(*mesh); + MutableSpan<MPoly> polys = mesh->polygons_for_write(); MPoly *mpoly = polys.data(); const N3fArraySample &loop_normals = *loop_normals_ptr; int abc_index = 0; @@ -517,9 +517,9 @@ CDStreamConfig get_config(Mesh *mesh, const bool use_vertex_interpolation) { CDStreamConfig config; config.mesh = mesh; - config.verts = bke::mesh_vertices_for_write(*mesh); - config.loops = bke::mesh_loops_for_write(*mesh); - config.polys = bke::mesh_polygons_for_write(*mesh); + config.verts = mesh->vertices_for_write(); + config.loops = mesh->loops_for_write(); + config.polys = mesh->polygons_for_write(); config.loopdata = &mesh->ldata; config.add_customdata_cb = add_customdata_cb; config.use_vertex_interpolation = use_vertex_interpolation; @@ -759,7 +759,7 @@ Mesh *AbcMeshReader::read_mesh(Mesh *existing_mesh, /* Here we assume that the number of materials doesn't change, i.e. that * the material slots that were created when the object was loaded from * Alembic are still valid now. */ - MutableSpan<MPoly> polys = bke::mesh_polygons_for_write(*new_mesh); + MutableSpan<MPoly> polys = new_mesh->polygons_for_write(); if (!polys.is_empty()) { std::map<std::string, int> mat_map; bke::MutableAttributeAccessor attributes = bke::mesh_attributes_for_write(*new_mesh); @@ -916,7 +916,7 @@ static void read_edge_creases(Mesh *mesh, return; } - MutableSpan<MEdge> edges = blender::bke::mesh_edges_for_write(*mesh); + MutableSpan<MEdge> edges = mesh->edges_for_write(); EdgeHash *edge_hash = BLI_edgehash_new_ex(__func__, edges.size()); for (const int i : edges.index_range()) { diff --git a/source/blender/io/collada/GeometryExporter.cpp b/source/blender/io/collada/GeometryExporter.cpp index 5946a4375f0..f8123432f4e 100644 --- a/source/blender/io/collada/GeometryExporter.cpp +++ b/source/blender/io/collada/GeometryExporter.cpp @@ -119,7 +119,7 @@ void GeometryExporter::operator()(Object *ob) if (this->export_settings.get_include_shapekeys()) { Key *key = BKE_key_from_object(ob); if (key) { - blender::MutableSpan<MVert> verts = blender::bke::mesh_vertices_for_write(*me); + blender::MutableSpan<MVert> verts = me->vertices_for_write(); KeyBlock *kb = (KeyBlock *)key->block.first; /* skip the basis */ kb = kb->next; @@ -200,7 +200,7 @@ void GeometryExporter::export_key_mesh(Object *ob, Mesh *me, KeyBlock *kb) void GeometryExporter::createLooseEdgeList(Object *ob, Mesh *me, std::string &geom_id) { - const Span<MEdge> edges = blender::bke::mesh_edges(*me); + const Span<MEdge> edges = me->edges(); int totedges = me->totedge; int edges_in_linelist = 0; std::vector<unsigned int> edge_list; @@ -287,7 +287,7 @@ static bool collect_vertex_counts_per_poly(Mesh *me, int material_index, std::vector<unsigned long> &vcount_list) { - const Span<MPoly> polys = blender::bke::mesh_polygons(*me); + const Span<MPoly> polys = me->polygons(); const blender::bke::AttributeAccessor attributes = blender::bke::mesh_attributes(*me); const blender::VArray<int> material_indices = attributes.lookup_or_default<int>( "material_index", ATTR_DOMAIN_FACE, 0); @@ -322,8 +322,8 @@ void GeometryExporter::create_mesh_primitive_list(short material_index, std::string &geom_id, std::vector<BCPolygonNormalsIndices> &norind) { - const Span<MPoly> polys = blender::bke::mesh_polygons(*me); - const Span<MLoop> loops = blender::bke::mesh_loops(*me); + const Span<MPoly> polys = me->polygons(); + const Span<MLoop> loops = me->loops(); std::vector<unsigned long> vcount_list; @@ -434,7 +434,7 @@ void GeometryExporter::create_mesh_primitive_list(short material_index, void GeometryExporter::createVertsSource(std::string geom_id, Mesh *me) { - const Span<MVert> verts = blender::bke::mesh_vertices(*me); + const Span<MVert> verts = me->vertices(); COLLADASW::FloatSourceF source(mSW); source.setId(getIdBySemantics(geom_id, COLLADASW::InputSemantic::POSITION)); @@ -500,7 +500,7 @@ void GeometryExporter::createVertexColorSource(std::string geom_id, Mesh *me) source.prepareToAppendValues(); - const Span<MPoly> polys = blender::bke::mesh_polygons(*me); + const Span<MPoly> polys = me->polygons(); for (const int i : polys.index_range()) { const MPoly &poly = polys[i]; const MLoopCol *mlc = mloopcol + poly.loopstart; @@ -530,7 +530,7 @@ std::string GeometryExporter::makeTexcoordSourceId(std::string &geom_id, void GeometryExporter::createTexcoordsSource(std::string geom_id, Mesh *me) { int totuv = me->totloop; - const Span<MPoly> polys = blender::bke::mesh_polygons(*me); + const Span<MPoly> polys = me->polygons(); int num_layers = CustomData_number_of_layers(&me->ldata, CD_MLOOPUV); @@ -615,10 +615,10 @@ void GeometryExporter::create_normals(std::vector<Normal> &normals, std::map<Normal, unsigned int> shared_normal_indices; int last_normal_index = -1; - const Span<MVert> verts = blender::bke::mesh_vertices(*me); + const Span<MVert> verts = me->vertices(); const float(*vert_normals)[3] = BKE_mesh_vertex_normals_ensure(me); - const Span<MPoly> polys = blender::bke::mesh_polygons(*me); - const Span<MLoop> loops = blender::bke::mesh_loops(*me); + const Span<MPoly> polys = me->polygons(); + const Span<MLoop> loops = me->loops(); const float(*lnors)[3] = nullptr; bool use_custom_normals = false; diff --git a/source/blender/io/collada/MeshImporter.cpp b/source/blender/io/collada/MeshImporter.cpp index b2852199157..8aa1685030f 100644 --- a/source/blender/io/collada/MeshImporter.cpp +++ b/source/blender/io/collada/MeshImporter.cpp @@ -344,7 +344,7 @@ void MeshImporter::read_vertices(COLLADAFW::Mesh *mesh, Mesh *me) me->totvert = pos.getFloatValues()->getCount() / stride; CustomData_add_layer(&me->vdata, CD_MVERT, CD_SET_DEFAULT, nullptr, me->totvert); - MutableSpan<MVert> verts = blender::bke::mesh_vertices_for_write(*me); + MutableSpan<MVert> verts = me->vertices_for_write(); for (const int i : verts.index_range()) { get_vector(verts[i].co, pos, i, stride); } @@ -553,7 +553,7 @@ void MeshImporter::mesh_add_edges(Mesh *mesh, int len) CustomData_free(&mesh->edata, mesh->totedge); mesh->edata = edata; - MutableSpan<MEdge> edges = blender::bke::mesh_edges_for_write(*mesh); + MutableSpan<MEdge> edges = mesh->edges_for_write(); /* set default flags */ medge = &edges[mesh->totedge]; @@ -573,7 +573,7 @@ void MeshImporter::read_lines(COLLADAFW::Mesh *mesh, Mesh *me) /* unsigned int total_edge_count = loose_edge_count + face_edge_count; */ /* UNUSED */ mesh_add_edges(me, loose_edge_count); - MutableSpan<MEdge> edges = blender::bke::mesh_edges_for_write(*me); + MutableSpan<MEdge> edges = me->edges_for_write(); MEdge *med = edges.data() + face_edge_count; COLLADAFW::MeshPrimitiveArray &prim_arr = mesh->getMeshPrimitives(); @@ -607,8 +607,8 @@ void MeshImporter::read_polys(COLLADAFW::Mesh *collada_mesh, Mesh *me) UVDataWrapper uvs(collada_mesh->getUVCoords()); VCOLDataWrapper vcol(collada_mesh->getColors()); - MutableSpan<MPoly> polys = blender::bke::mesh_polygons_for_write(*me); - MutableSpan<MLoop> loops = blender::bke::mesh_loops_for_write(*me); + MutableSpan<MPoly> polys = me->polygons_for_write(); + MutableSpan<MLoop> loops = me->loops_for_write(); MPoly *mpoly = polys.data(); MLoop *mloop = loops.data(); int loop_index = 0; diff --git a/source/blender/io/stl/importer/stl_import_mesh.cc b/source/blender/io/stl/importer/stl_import_mesh.cc index e484dfe1944..d85185ede6e 100644 --- a/source/blender/io/stl/importer/stl_import_mesh.cc +++ b/source/blender/io/stl/importer/stl_import_mesh.cc @@ -77,7 +77,7 @@ Mesh *STLMeshHelper::to_mesh(Main *bmain, char *mesh_name) mesh->totvert = verts_.size(); CustomData_add_layer(&mesh->vdata, CD_MVERT, CD_SET_DEFAULT, nullptr, mesh->totvert); - MutableSpan<MVert> verts = bke::mesh_vertices_for_write(*mesh); + MutableSpan<MVert> verts = mesh->vertices_for_write(); for (int i = 0; i < mesh->totvert; i++) { copy_v3_v3(verts[i].co, verts_[i]); } @@ -86,8 +86,8 @@ Mesh *STLMeshHelper::to_mesh(Main *bmain, char *mesh_name) mesh->totloop = tris_.size() * 3; CustomData_add_layer(&mesh->pdata, CD_MPOLY, CD_SET_DEFAULT, nullptr, mesh->totpoly); CustomData_add_layer(&mesh->ldata, CD_MLOOP, CD_SET_DEFAULT, nullptr, mesh->totloop); - MutableSpan<MPoly> polys = bke::mesh_polygons_for_write(*mesh); - MutableSpan<MLoop> loops = bke::mesh_loops_for_write(*mesh); + MutableSpan<MPoly> polys = mesh->polygons_for_write(); + MutableSpan<MLoop> loops = mesh->loops_for_write(); threading::parallel_for(tris_.index_range(), 2048, [&](IndexRange tris_range) { for (const int i : tris_range) { polys[i].loopstart = 3 * i; diff --git a/source/blender/io/usd/intern/usd_reader_mesh.cc b/source/blender/io/usd/intern/usd_reader_mesh.cc index 38a364104e7..14d281acc51 100644 --- a/source/blender/io/usd/intern/usd_reader_mesh.cc +++ b/source/blender/io/usd/intern/usd_reader_mesh.cc @@ -309,8 +309,8 @@ bool USDMeshReader::topology_changed(const Mesh *existing_mesh, const double mot void USDMeshReader::read_mpolys(Mesh *mesh) { - MutableSpan<MPoly> polys = bke::mesh_polygons_for_write(*mesh); - MutableSpan<MLoop> loops = bke::mesh_loops_for_write(*mesh); + MutableSpan<MPoly> polys = mesh->polygons_for_write(); + MutableSpan<MLoop> loops = mesh->loops_for_write(); int loop_index = 0; @@ -397,7 +397,7 @@ void USDMeshReader::read_uvs(Mesh *mesh, const double motionSampleTime, const bo } } - const Span<MLoop> loops = bke::mesh_loops(*mesh); + const Span<MLoop> loops = mesh->loops(); for (int i = 0; i < face_counts_.size(); i++) { const int face_size = face_counts_[i]; @@ -513,8 +513,8 @@ void USDMeshReader::read_colors(Mesh *mesh, const double motionSampleTime) MLoopCol *colors = static_cast<MLoopCol *>(cd_ptr); - const Span<MPoly> polys = bke::mesh_polygons(*mesh); - const Span<MLoop> loops = bke::mesh_loops(*mesh); + const Span<MPoly> polys = mesh->polygons(); + const Span<MLoop> loops = mesh->loops(); for (const int i : polys.index_range()) { const MPoly &poly = polys[i]; for (int j = 0; j < poly.totloop; ++j) { @@ -627,7 +627,7 @@ void USDMeshReader::process_normals_face_varying(Mesh *mesh) float(*lnors)[3] = static_cast<float(*)[3]>( MEM_malloc_arrayN(loop_count, sizeof(float[3]), "USD::FaceNormals")); - const Span<MPoly> polys = bke::mesh_polygons(*mesh); + const Span<MPoly> polys = mesh->polygons(); for (const int i : polys.index_range()) { const MPoly &poly = polys[i]; for (int j = 0; j < poly.totloop; j++) { @@ -668,7 +668,7 @@ void USDMeshReader::process_normals_uniform(Mesh *mesh) float(*lnors)[3] = static_cast<float(*)[3]>( MEM_malloc_arrayN(mesh->totloop, sizeof(float[3]), "USD::FaceNormals")); - const Span<MPoly> polys = bke::mesh_polygons(*mesh); + const Span<MPoly> polys = mesh->polygons(); for (const int i : polys.index_range()) { const MPoly &poly = polys[i]; for (int j = 0; j < poly.totloop; j++) { @@ -695,7 +695,7 @@ void USDMeshReader::read_mesh_sample(ImportSettings *settings, * in code that expect this data to be there. */ if (new_mesh || (settings->read_flag & MOD_MESHSEQ_READ_VERT) != 0) { - MutableSpan<MVert> verts = bke::mesh_vertices_for_write(*mesh); + MutableSpan<MVert> verts = mesh->vertices_for_write(); for (int i = 0; i < positions_.size(); i++) { MVert &mvert = verts[i]; mvert.co[0] = positions_[i][0]; @@ -910,7 +910,7 @@ Mesh *USDMeshReader::read_mesh(Mesh *existing_mesh, /* Here we assume that the number of materials doesn't change, i.e. that * the material slots that were created when the object was loaded from * USD are still valid now. */ - MutableSpan<MPoly> polys = bke::mesh_polygons_for_write(*active_mesh); + MutableSpan<MPoly> polys = active_mesh->polygons_for_write(); if (!polys.is_empty() && import_params_.import_materials) { std::map<pxr::SdfPath, int> mat_map; bke::MutableAttributeAccessor attributes = bke::mesh_attributes_for_write(*active_mesh); diff --git a/source/blender/io/usd/intern/usd_writer_mesh.cc b/source/blender/io/usd/intern/usd_writer_mesh.cc index c599e26c21a..f6250eebd5d 100644 --- a/source/blender/io/usd/intern/usd_writer_mesh.cc +++ b/source/blender/io/usd/intern/usd_writer_mesh.cc @@ -246,7 +246,7 @@ static void get_vertices(const Mesh *mesh, USDMeshData &usd_mesh_data) { usd_mesh_data.points.reserve(mesh->totvert); - const Span<MVert> verts = bke::mesh_vertices(*mesh); + const Span<MVert> verts = mesh->vertices(); for (const int i : verts.index_range()) { usd_mesh_data.points.push_back(pxr::GfVec3f(verts[i].co)); } @@ -269,8 +269,8 @@ static void get_loops_polys(const Mesh *mesh, USDMeshData &usd_mesh_data) usd_mesh_data.face_vertex_counts.reserve(mesh->totpoly); usd_mesh_data.face_indices.reserve(mesh->totloop); - const Span<MPoly> polys = bke::mesh_polygons(*mesh); - const Span<MLoop> loops = bke::mesh_loops(*mesh); + const Span<MPoly> polys = mesh->polygons(); + const Span<MLoop> loops = mesh->loops(); for (const int i : polys.index_range()) { const MPoly &poly = polys[i]; @@ -285,7 +285,7 @@ static void get_edge_creases(const Mesh *mesh, USDMeshData &usd_mesh_data) { const float factor = 1.0f / 255.0f; - const Span<MEdge> edges = bke::mesh_edges(*mesh); + const Span<MEdge> edges = mesh->edges(); float sharpness; for (const int i : edges.index_range()) { const MEdge &edge = edges[i]; @@ -399,8 +399,8 @@ void USDGenericMeshWriter::write_normals(const Mesh *mesh, pxr::UsdGeomMesh usd_ { pxr::UsdTimeCode timecode = get_export_time_code(); const float(*lnors)[3] = static_cast<float(*)[3]>(CustomData_get_layer(&mesh->ldata, CD_NORMAL)); - const Span<MPoly> polys = bke::mesh_polygons(*mesh); - const Span<MLoop> loops = bke::mesh_loops(*mesh); + const Span<MPoly> polys = mesh->polygons(); + const Span<MLoop> loops = mesh->loops(); pxr::VtVec3fArray loop_normals; loop_normals.reserve(mesh->totloop); diff --git a/source/blender/io/wavefront_obj/exporter/obj_export_mesh.cc b/source/blender/io/wavefront_obj/exporter/obj_export_mesh.cc index daf20895c0d..4bf9cf3f85c 100644 --- a/source/blender/io/wavefront_obj/exporter/obj_export_mesh.cc +++ b/source/blender/io/wavefront_obj/exporter/obj_export_mesh.cc @@ -188,9 +188,9 @@ void OBJMesh::ensure_mesh_edges() const void OBJMesh::calc_smooth_groups(const bool use_bitflags) { - const Span<MEdge> edges = bke::mesh_edges(*export_mesh_eval_); - const Span<MPoly> polys = bke::mesh_polygons(*export_mesh_eval_); - const Span<MLoop> loops = bke::mesh_loops(*export_mesh_eval_); + const Span<MEdge> edges = export_mesh_eval_->edges(); + const Span<MPoly> polys = export_mesh_eval_->polygons(); + const Span<MLoop> loops = export_mesh_eval_->loops(); poly_smooth_groups_ = BKE_mesh_calc_smoothgroups(edges.data(), edges.size(), polys.data(), @@ -242,7 +242,7 @@ const Material *OBJMesh::get_object_material(const int16_t mat_nr) const bool OBJMesh::is_ith_poly_smooth(const int poly_index) const { - const Span<MPoly> polygons = bke::mesh_polygons(*export_mesh_eval_); + const Span<MPoly> polygons = export_mesh_eval_->polygons(); return polygons[poly_index].flag & ME_SMOOTH; } @@ -268,7 +268,7 @@ const char *OBJMesh::get_object_material_name(const int16_t mat_nr) const float3 OBJMesh::calc_vertex_coords(const int vert_index, const float scaling_factor) const { float3 r_coords; - const Span<MVert> verts = bke::mesh_vertices(*export_mesh_eval_); + const Span<MVert> verts = export_mesh_eval_->vertices(); copy_v3_v3(r_coords, verts[vert_index].co); mul_m4_v3(world_and_axes_transform_, r_coords); mul_v3_fl(r_coords, scaling_factor); @@ -277,8 +277,8 @@ float3 OBJMesh::calc_vertex_coords(const int vert_index, const float scaling_fac Vector<int> OBJMesh::calc_poly_vertex_indices(const int poly_index) const { - const Span<MPoly> polys = bke::mesh_polygons(*export_mesh_eval_); - const Span<MLoop> loops = bke::mesh_loops(*export_mesh_eval_); + const Span<MPoly> polys = export_mesh_eval_->polygons(); + const Span<MLoop> loops = export_mesh_eval_->loops(); const MPoly &mpoly = polys[poly_index]; const MLoop *mloop = &loops[mpoly.loopstart]; const int totloop = mpoly.totloop; @@ -291,8 +291,8 @@ Vector<int> OBJMesh::calc_poly_vertex_indices(const int poly_index) const void OBJMesh::store_uv_coords_and_indices() { - const Span<MPoly> polys = bke::mesh_polygons(*export_mesh_eval_); - const Span<MLoop> loops = bke::mesh_loops(*export_mesh_eval_); + const Span<MPoly> polys = export_mesh_eval_->polygons(); + const Span<MLoop> loops = export_mesh_eval_->loops(); const int totvert = export_mesh_eval_->totvert; const MLoopUV *mloopuv = static_cast<const MLoopUV *>( CustomData_get_layer(&export_mesh_eval_->ldata, CD_MLOOPUV)); @@ -347,9 +347,9 @@ Span<int> OBJMesh::calc_poly_uv_indices(const int poly_index) const float3 OBJMesh::calc_poly_normal(const int poly_index) const { float3 r_poly_normal; - const Span<MVert> verts = blender::bke::mesh_vertices(*export_mesh_eval_); - const Span<MPoly> polys = blender::bke::mesh_polygons(*export_mesh_eval_); - const Span<MLoop> loops = blender::bke::mesh_loops(*export_mesh_eval_); + const Span<MVert> verts = export_mesh_eval_->vertices(); + const Span<MPoly> polys = export_mesh_eval_->polygons(); + const Span<MLoop> loops = export_mesh_eval_->loops(); const MPoly &poly = polys[poly_index]; BKE_mesh_calc_poly_normal(&poly, &loops[poly.loopstart], verts.data(), r_poly_normal); mul_m3_v3(world_and_axes_normal_transform_, r_poly_normal); @@ -375,7 +375,7 @@ static float3 round_float3_to_n_digits(const float3 &v, int round_digits) void OBJMesh::store_normal_coords_and_indices() { - const Span<MPoly> polys = bke::mesh_polygons(*export_mesh_eval_); + const Span<MPoly> polys = export_mesh_eval_->polygons(); /* We'll round normal components to 4 digits. * This will cover up some minor differences @@ -436,7 +436,7 @@ Vector<int> OBJMesh::calc_poly_normal_indices(const int poly_index) const if (loop_to_normal_index_.is_empty()) { return {}; } - const Span<MPoly> polys = bke::mesh_polygons(*export_mesh_eval_); + const Span<MPoly> polys = export_mesh_eval_->polygons(); const MPoly &mpoly = polys[poly_index]; const int totloop = mpoly.totloop; Vector<int> r_poly_normal_indices(totloop); @@ -460,8 +460,8 @@ int16_t OBJMesh::get_poly_deform_group_index(const int poly_index, { BLI_assert(poly_index < export_mesh_eval_->totpoly); BLI_assert(group_weights.size() == BKE_object_defgroup_count(&export_object_eval_)); - const Span<MPoly> polys = bke::mesh_polygons(*export_mesh_eval_); - const Span<MLoop> loops = bke::mesh_loops(*export_mesh_eval_); + const Span<MPoly> polys = export_mesh_eval_->polygons(); + const Span<MLoop> loops = export_mesh_eval_->loops(); const MDeformVert *dvert = BKE_mesh_deform_verts(export_mesh_eval_); if (!dvert) { return NOT_FOUND; @@ -500,7 +500,7 @@ const char *OBJMesh::get_poly_deform_group_name(const int16_t def_group_index) c std::optional<std::array<int, 2>> OBJMesh::calc_loose_edge_vert_indices(const int edge_index) const { - const Span<MEdge> edges = bke::mesh_edges(*export_mesh_eval_); + const Span<MEdge> edges = export_mesh_eval_->edges(); const MEdge &edge = edges[edge_index]; if (edge.flag & ME_LOOSEEDGE) { return std::array<int, 2>{static_cast<int>(edge.v1), static_cast<int>(edge.v2)}; diff --git a/source/blender/io/wavefront_obj/importer/obj_import_mesh.cc b/source/blender/io/wavefront_obj/importer/obj_import_mesh.cc index bdae0dea876..f6c45a96358 100644 --- a/source/blender/io/wavefront_obj/importer/obj_import_mesh.cc +++ b/source/blender/io/wavefront_obj/importer/obj_import_mesh.cc @@ -157,7 +157,7 @@ void MeshFromGeometry::fixup_invalid_faces() void MeshFromGeometry::create_vertices(Mesh *mesh) { - MutableSpan<MVert> verts = bke::mesh_vertices_for_write(*mesh); + MutableSpan<MVert> verts = mesh->vertices_for_write(); /* Go through all the global vertex indices from min to max, * checking which ones are actually and building a global->local * index mapping. Write out the used vertex positions into the Mesh @@ -184,8 +184,8 @@ void MeshFromGeometry::create_polys_loops(Mesh *mesh, bool use_vertex_groups) dvert = BKE_mesh_deform_verts_for_write(mesh); } - MutableSpan<MPoly> polys = bke::mesh_polygons_for_write(*mesh); - MutableSpan<MLoop> loops = bke::mesh_loops_for_write(*mesh); + MutableSpan<MPoly> polys = mesh->polygons_for_write(); + MutableSpan<MLoop> loops = mesh->loops_for_write(); bke::SpanAttributeWriter<int> material_indices = bke::mesh_attributes_for_write(*mesh).lookup_or_add_for_write_only_span<int>( "material_index", ATTR_DOMAIN_FACE); @@ -246,7 +246,7 @@ void MeshFromGeometry::create_vertex_groups(Object *obj) void MeshFromGeometry::create_edges(Mesh *mesh) { - MutableSpan<MEdge> edges = bke::mesh_edges_for_write(*mesh); + MutableSpan<MEdge> edges = mesh->edges_for_write(); const int64_t tot_edges{mesh_geometry_.edges_.size()}; const int64_t total_verts{mesh_geometry_.get_vertex_count()}; diff --git a/source/blender/io/wavefront_obj/tests/obj_importer_tests.cc b/source/blender/io/wavefront_obj/tests/obj_importer_tests.cc index 5cf13960bb4..669a7ba80cf 100644 --- a/source/blender/io/wavefront_obj/tests/obj_importer_tests.cc +++ b/source/blender/io/wavefront_obj/tests/obj_importer_tests.cc @@ -96,7 +96,7 @@ class obj_importer_test : public BlendfileLoadingBaseTest { EXPECT_EQ(mesh->totedge, exp.mesh_totedge_or_curve_endp); EXPECT_EQ(mesh->totpoly, exp.mesh_totpoly_or_curve_order); EXPECT_EQ(mesh->totloop, exp.mesh_totloop_or_curve_cyclic); - const Span<MVert> verts = bke::mesh_vertices(*mesh); + const Span<MVert> verts = mesh->vertices(); EXPECT_V3_NEAR(verts.first().co, exp.vert_first, 0.0001f); EXPECT_V3_NEAR(verts.last().co, exp.vert_last, 0.0001f); const float3 *lnors = (const float3 *)(CustomData_get_layer(&mesh->ldata, CD_NORMAL)); diff --git a/source/blender/makesdna/DNA_mesh_types.h b/source/blender/makesdna/DNA_mesh_types.h index 8d9402cb98e..cfa9425bc3d 100644 --- a/source/blender/makesdna/DNA_mesh_types.h +++ b/source/blender/makesdna/DNA_mesh_types.h @@ -10,8 +10,17 @@ #include "DNA_ID.h" #include "DNA_customdata_types.h" #include "DNA_defs.h" +#include "DNA_meshdata_types.h" #include "DNA_session_uuid_types.h" +/** Workaround to forward-declare C++ type in C header. */ +#ifdef __cplusplus +namespace blender { +template<typename T> class Span; +template<typename T> class MutableSpan; +} // namespace blender +#endif + #ifdef __cplusplus extern "C" { #endif @@ -301,6 +310,20 @@ typedef struct Mesh { void *_pad2; Mesh_Runtime runtime; + +#ifdef __cplusplus + blender::Span<MVert> vertices() const; + blender::MutableSpan<MVert> vertices_for_write(); + + blender::Span<MEdge> edges() const; + blender::MutableSpan<MEdge> edges_for_write(); + + blender::Span<MPoly> polygons() const; + blender::MutableSpan<MPoly> polygons_for_write(); + + blender::Span<MLoop> loops() const; + blender::MutableSpan<MLoop> loops_for_write(); +#endif } Mesh; /* deprecated by MTFace, only here for file reading */ diff --git a/source/blender/modifiers/intern/MOD_boolean.cc b/source/blender/modifiers/intern/MOD_boolean.cc index dc1ad7841b4..39667a3f1d5 100644 --- a/source/blender/modifiers/intern/MOD_boolean.cc +++ b/source/blender/modifiers/intern/MOD_boolean.cc @@ -144,7 +144,7 @@ static Mesh *get_quick_mesh( invert_m4_m4(imat, ob_self->obmat); mul_m4_m4m4(omat, imat, ob_operand_ob->obmat); - MutableSpan<MVert> verts = blender::bke::mesh_vertices_for_write(*result); + MutableSpan<MVert> verts = result->vertices_for_write(); for (const int i : verts.index_range()) { mul_m4_v3(omat, verts[i].co); } diff --git a/source/blender/modifiers/intern/MOD_mask.cc b/source/blender/modifiers/intern/MOD_mask.cc index 2676ad7e863..e5ffea9702b 100644 --- a/source/blender/modifiers/intern/MOD_mask.cc +++ b/source/blender/modifiers/intern/MOD_mask.cc @@ -169,7 +169,7 @@ static void computed_masked_edges(const Mesh *mesh, uint *r_edges_masked_num) { BLI_assert(mesh->totedge == r_edge_map.size()); - const Span<MEdge> edges = blender::bke::mesh_edges(*mesh); + const Span<MEdge> edges = mesh->edges(); uint edges_masked_num = 0; for (int i : IndexRange(mesh->totedge)) { @@ -195,7 +195,7 @@ static void computed_masked_edges_smooth(const Mesh *mesh, uint *r_verts_add_num) { BLI_assert(mesh->totedge == r_edge_map.size()); - const Span<MEdge> edges = blender::bke::mesh_edges(*mesh); + const Span<MEdge> edges = mesh->edges(); uint edges_masked_num = 0; uint verts_add_num = 0; @@ -231,8 +231,8 @@ static void computed_masked_polygons(const Mesh *mesh, uint *r_loops_masked_num) { BLI_assert(mesh->totvert == vertex_mask.size()); - const Span<MPoly> polys = blender::bke::mesh_polygons(*mesh); - const Span<MLoop> loops = blender::bke::mesh_loops(*mesh); + const Span<MPoly> polys = mesh->polygons(); + const Span<MLoop> loops = mesh->loops(); r_masked_poly_indices.reserve(mesh->totpoly); r_loop_starts.reserve(mesh->totpoly); @@ -277,8 +277,8 @@ static void compute_interpolated_polygons(const Mesh *mesh, /* NOTE: this reserve can only lift the capacity if there are ngons, which get split. */ r_masked_poly_indices.reserve(r_masked_poly_indices.size() + verts_add_num); r_loop_starts.reserve(r_loop_starts.size() + verts_add_num); - const Span<MPoly> polys = blender::bke::mesh_polygons(*mesh); - const Span<MLoop> loops = blender::bke::mesh_loops(*mesh); + const Span<MPoly> polys = mesh->polygons(); + const Span<MLoop> loops = mesh->loops(); uint edges_add_num = 0; uint polys_add_num = 0; @@ -338,8 +338,8 @@ static void copy_masked_vertices_to_new_mesh(const Mesh &src_mesh, Span<int> vertex_map) { BLI_assert(src_mesh.totvert == vertex_map.size()); - const Span<MVert> src_verts = blender::bke::mesh_vertices(src_mesh); - MutableSpan<MVert> dst_verts = blender::bke::mesh_vertices_for_write(dst_mesh); + const Span<MVert> src_verts = src_mesh.vertices(); + MutableSpan<MVert> dst_verts = dst_mesh.vertices_for_write(); for (const int i_src : vertex_map.index_range()) { const int i_dst = vertex_map[i_src]; @@ -378,10 +378,10 @@ static void add_interp_verts_copy_edges_to_new_mesh(const Mesh &src_mesh, { BLI_assert(src_mesh.totvert == vertex_mask.size()); BLI_assert(src_mesh.totedge == r_edge_map.size()); - const Span<MVert> src_verts = blender::bke::mesh_vertices(src_mesh); - const Span<MEdge> src_edges = blender::bke::mesh_edges(src_mesh); - MutableSpan<MVert> dst_verts = blender::bke::mesh_vertices_for_write(dst_mesh); - MutableSpan<MEdge> dst_edges = blender::bke::mesh_edges_for_write(dst_mesh); + const Span<MVert> src_verts = src_mesh.vertices(); + const Span<MEdge> src_edges = src_mesh.edges(); + MutableSpan<MVert> dst_verts = dst_mesh.vertices_for_write(); + MutableSpan<MEdge> dst_edges = dst_mesh.edges_for_write(); uint vert_index = dst_mesh.totvert - verts_add_num; uint edge_index = edges_masked_num - verts_add_num; @@ -437,8 +437,8 @@ static void copy_masked_edges_to_new_mesh(const Mesh &src_mesh, Span<int> vertex_map, Span<int> edge_map) { - const Span<MEdge> src_edges = blender::bke::mesh_edges(src_mesh); - MutableSpan<MEdge> dst_edges = blender::bke::mesh_edges_for_write(dst_mesh); + const Span<MEdge> src_edges = src_mesh.edges(); + MutableSpan<MEdge> dst_edges = dst_mesh.edges_for_write(); BLI_assert(src_mesh.totvert == vertex_map.size()); BLI_assert(src_mesh.totedge == edge_map.size()); @@ -466,10 +466,10 @@ static void copy_masked_polys_to_new_mesh(const Mesh &src_mesh, Span<int> new_loop_starts, int polys_masked_num) { - const Span<MPoly> src_polys = blender::bke::mesh_polygons(src_mesh); - const Span<MLoop> src_loops = blender::bke::mesh_loops(src_mesh); - MutableSpan<MPoly> dst_polys = blender::bke::mesh_polygons_for_write(dst_mesh); - MutableSpan<MLoop> dst_loops = blender::bke::mesh_loops_for_write(dst_mesh); + const Span<MPoly> src_polys = src_mesh.polygons(); + const Span<MLoop> src_loops = src_mesh.loops(); + MutableSpan<MPoly> dst_polys = dst_mesh.polygons_for_write(); + MutableSpan<MLoop> dst_loops = dst_mesh.loops_for_write(); for (const int i_dst : IndexRange(polys_masked_num)) { const int i_src = masked_poly_indices[i_dst]; @@ -507,11 +507,11 @@ static void add_interpolated_polys_to_new_mesh(const Mesh &src_mesh, int polys_masked_num, int edges_add_num) { - const Span<MPoly> src_polys = blender::bke::mesh_polygons(src_mesh); - const Span<MLoop> src_loops = blender::bke::mesh_loops(src_mesh); - MutableSpan<MEdge> dst_edges = blender::bke::mesh_edges_for_write(dst_mesh); - MutableSpan<MPoly> dst_polys = blender::bke::mesh_polygons_for_write(dst_mesh); - MutableSpan<MLoop> dst_loops = blender::bke::mesh_loops_for_write(dst_mesh); + const Span<MPoly> src_polys = src_mesh.polygons(); + const Span<MLoop> src_loops = src_mesh.loops(); + MutableSpan<MEdge> dst_edges = dst_mesh.edges_for_write(); + MutableSpan<MPoly> dst_polys = dst_mesh.polygons_for_write(); + MutableSpan<MLoop> dst_loops = dst_mesh.loops_for_write(); int edge_index = dst_mesh.totedge - edges_add_num; int sub_poly_index = 0; diff --git a/source/blender/modifiers/intern/MOD_meshsequencecache.cc b/source/blender/modifiers/intern/MOD_meshsequencecache.cc index 605fe40f7d1..bdaa90af5d8 100644 --- a/source/blender/modifiers/intern/MOD_meshsequencecache.cc +++ b/source/blender/modifiers/intern/MOD_meshsequencecache.cc @@ -178,12 +178,12 @@ static Mesh *modifyMesh(ModifierData *md, const ModifierEvalContext *ctx, Mesh * } if (me != nullptr) { - const Span<MVert> mesh_verts = blender::bke::mesh_vertices(*mesh); - const Span<MEdge> mesh_edges = blender::bke::mesh_edges(*mesh); - const Span<MPoly> mesh_polys = blender::bke::mesh_polygons(*mesh); - const Span<MVert> me_vertices = blender::bke::mesh_vertices(*me); - const Span<MEdge> me_edges = blender::bke::mesh_edges(*me); - const Span<MPoly> me_polygons = blender::bke::mesh_polygons(*me); + const Span<MVert> mesh_verts = mesh->vertices(); + const Span<MEdge> mesh_edges = mesh->edges(); + const Span<MPoly> mesh_polys = mesh->polygons(); + const Span<MVert> me_vertices = me->vertices(); + const Span<MEdge> me_edges = me->edges(); + const Span<MPoly> me_polygons = me->polygons(); /* TODO(sybren+bastien): possibly check relevant custom data layers (UV/color depending on * flags) and duplicate those too. diff --git a/source/blender/nodes/geometry/nodes/node_geo_convex_hull.cc b/source/blender/nodes/geometry/nodes/node_geo_convex_hull.cc index f2c635dd770..d03f036eaa4 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_convex_hull.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_convex_hull.cc @@ -46,7 +46,7 @@ static Mesh *hull_from_bullet(const Mesh *mesh, Span<float3> coords) } /* Copy vertices. */ - MutableSpan<MVert> dst_verts = bke::mesh_vertices_for_write(*result); + MutableSpan<MVert> dst_verts = result->vertices_for_write(); for (const int i : IndexRange(verts_num)) { float co[3]; int original_index; @@ -74,7 +74,7 @@ static Mesh *hull_from_bullet(const Mesh *mesh, Span<float3> coords) * to a loop and edges need to be created from that. */ Array<MLoop> mloop_src(loops_num); uint edge_index = 0; - MutableSpan<MEdge> edges = bke::mesh_edges_for_write(*result); + MutableSpan<MEdge> edges = result->edges_for_write(); for (const int i : IndexRange(loops_num)) { int v_from; @@ -109,8 +109,8 @@ static Mesh *hull_from_bullet(const Mesh *mesh, Span<float3> coords) /* Copy faces. */ Array<int> loops; int j = 0; - MutableSpan<MPoly> polys = bke::mesh_polygons_for_write(*result); - MutableSpan<MLoop> mesh_loops = bke::mesh_loops_for_write(*result); + MutableSpan<MPoly> polys = result->polygons_for_write(); + MutableSpan<MLoop> mesh_loops = result->loops_for_write(); MLoop *loop = mesh_loops.data(); for (const int i : IndexRange(faces_num)) { diff --git a/source/blender/nodes/geometry/nodes/node_geo_curve_fill.cc b/source/blender/nodes/geometry/nodes/node_geo_curve_fill.cc index 30906078024..580886ad6be 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_curve_fill.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_curve_fill.cc @@ -79,10 +79,10 @@ static Mesh *cdt_to_mesh(const meshintersect::CDT_result<double> &result) } Mesh *mesh = BKE_mesh_new_nomain(vert_len, edge_len, 0, loop_len, poly_len); - MutableSpan<MVert> verts = bke::mesh_vertices_for_write(*mesh); - MutableSpan<MEdge> edges = bke::mesh_edges_for_write(*mesh); - MutableSpan<MPoly> polys = bke::mesh_polygons_for_write(*mesh); - MutableSpan<MLoop> loops = bke::mesh_loops_for_write(*mesh); + MutableSpan<MVert> verts = mesh->vertices_for_write(); + MutableSpan<MEdge> edges = mesh->edges_for_write(); + MutableSpan<MPoly> polys = mesh->polygons_for_write(); + MutableSpan<MLoop> loops = mesh->loops_for_write(); for (const int i : IndexRange(result.vert.size())) { copy_v3_v3(verts[i].co, float3((float)result.vert[i].x, (float)result.vert[i].y, 0.0f)); diff --git a/source/blender/nodes/geometry/nodes/node_geo_deform_curves_on_surface.cc b/source/blender/nodes/geometry/nodes/node_geo_deform_curves_on_surface.cc index 0cd2b9767d1..07b419cc05c 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_deform_curves_on_surface.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_deform_curves_on_surface.cc @@ -66,11 +66,11 @@ static void deform_curves(const CurvesGeometry &curves, const float4x4 curves_to_surface = surface_to_curves.inverted(); - const Span<MVert> surface_verts_old = bke::mesh_vertices(surface_mesh_old); - const Span<MLoop> surface_loops_old = bke::mesh_loops(surface_mesh_old); + const Span<MVert> surface_verts_old = surface_mesh_old.vertices(); + const Span<MLoop> surface_loops_old = surface_mesh_old.loops(); - const Span<MVert> surface_verts_new = bke::mesh_vertices(surface_mesh_new); - const Span<MLoop> surface_loops_new = bke::mesh_loops(surface_mesh_new); + const Span<MVert> surface_verts_new = surface_mesh_new.vertices(); + const Span<MLoop> surface_loops_new = surface_mesh_new.loops(); threading::parallel_for(curves.curves_range(), 256, [&](const IndexRange range) { for (const int curve_i : range) { diff --git a/source/blender/nodes/geometry/nodes/node_geo_delete_geometry.cc b/source/blender/nodes/geometry/nodes/node_geo_delete_geometry.cc index 2420e048e18..a4096efb79f 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_delete_geometry.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_delete_geometry.cc @@ -161,7 +161,7 @@ static void copy_face_corner_attributes(const Map<AttributeIDRef, AttributeKind> const Span<int> selected_poly_indices, const Mesh &mesh_in) { - const Span<MPoly> polys = bke::mesh_polygons(mesh_in); + const Span<MPoly> polys = mesh_in.polygons(); Vector<int64_t> indices; indices.reserve(selected_loops_num); for (const int src_poly_index : selected_poly_indices) { @@ -181,8 +181,8 @@ static void copy_masked_vertices_to_new_mesh(const Mesh &src_mesh, Span<int> vertex_map) { BLI_assert(src_mesh.totvert == vertex_map.size()); - const Span<MVert> src_verts = bke::mesh_vertices(src_mesh); - MutableSpan<MVert> dst_verts = bke::mesh_vertices_for_write(dst_mesh); + const Span<MVert> src_verts = src_mesh.vertices(); + MutableSpan<MVert> dst_verts = dst_mesh.vertices_for_write(); for (const int i_src : vertex_map.index_range()) { const int i_dst = vertex_map[i_src]; @@ -196,8 +196,8 @@ static void copy_masked_vertices_to_new_mesh(const Mesh &src_mesh, static void copy_masked_edges_to_new_mesh(const Mesh &src_mesh, Mesh &dst_mesh, Span<int> edge_map) { BLI_assert(src_mesh.totedge == edge_map.size()); - const Span<MEdge> src_edges = bke::mesh_edges(src_mesh); - MutableSpan<MEdge> dst_edges = bke::mesh_edges_for_write(dst_mesh); + const Span<MEdge> src_edges = src_mesh.edges(); + MutableSpan<MEdge> dst_edges = dst_mesh.edges_for_write(); for (const int i_src : IndexRange(src_mesh.totedge)) { const int i_dst = edge_map[i_src]; @@ -215,8 +215,8 @@ static void copy_masked_edges_to_new_mesh(const Mesh &src_mesh, { BLI_assert(src_mesh.totvert == vertex_map.size()); BLI_assert(src_mesh.totedge == edge_map.size()); - const Span<MEdge> src_edges = bke::mesh_edges(src_mesh); - MutableSpan<MEdge> dst_edges = bke::mesh_edges_for_write(dst_mesh); + const Span<MEdge> src_edges = src_mesh.edges(); + MutableSpan<MEdge> dst_edges = dst_mesh.edges_for_write(); for (const int i_src : IndexRange(src_mesh.totedge)) { const int i_dst = edge_map[i_src]; @@ -239,10 +239,10 @@ static void copy_masked_polys_to_new_mesh(const Mesh &src_mesh, Span<int> masked_poly_indices, Span<int> new_loop_starts) { - const Span<MPoly> src_polygons = bke::mesh_polygons(src_mesh); - const Span<MLoop> src_loops = bke::mesh_loops(src_mesh); - MutableSpan<MPoly> dst_polygons = bke::mesh_polygons_for_write(dst_mesh); - MutableSpan<MLoop> dst_loops = bke::mesh_loops_for_write(dst_mesh); + const Span<MPoly> src_polygons = src_mesh.polygons(); + const Span<MLoop> src_loops = src_mesh.loops(); + MutableSpan<MPoly> dst_polygons = dst_mesh.polygons_for_write(); + MutableSpan<MLoop> dst_loops = dst_mesh.loops_for_write(); for (const int i_dst : masked_poly_indices.index_range()) { const int i_src = masked_poly_indices[i_dst]; @@ -270,10 +270,10 @@ static void copy_masked_polys_to_new_mesh(const Mesh &src_mesh, Span<int> masked_poly_indices, Span<int> new_loop_starts) { - const Span<MPoly> src_polygons = bke::mesh_polygons(src_mesh); - const Span<MLoop> src_loops = bke::mesh_loops(src_mesh); - MutableSpan<MPoly> dst_polygons = bke::mesh_polygons_for_write(dst_mesh); - MutableSpan<MLoop> dst_loops = bke::mesh_loops_for_write(dst_mesh); + const Span<MPoly> src_polygons = src_mesh.polygons(); + const Span<MLoop> src_loops = src_mesh.loops(); + MutableSpan<MPoly> dst_polygons = dst_mesh.polygons_for_write(); + MutableSpan<MLoop> dst_loops = dst_mesh.loops_for_write(); for (const int i_dst : masked_poly_indices.index_range()) { const int i_src = masked_poly_indices[i_dst]; @@ -302,10 +302,10 @@ static void copy_masked_polys_to_new_mesh(const Mesh &src_mesh, Span<int> masked_poly_indices, Span<int> new_loop_starts) { - const Span<MPoly> src_polygons = bke::mesh_polygons(src_mesh); - const Span<MLoop> src_loops = bke::mesh_loops(src_mesh); - MutableSpan<MPoly> dst_polygons = bke::mesh_polygons_for_write(dst_mesh); - MutableSpan<MLoop> dst_loops = bke::mesh_loops_for_write(dst_mesh); + const Span<MPoly> src_polygons = src_mesh.polygons(); + const Span<MLoop> src_loops = src_mesh.loops(); + MutableSpan<MPoly> dst_polygons = dst_mesh.polygons_for_write(); + MutableSpan<MLoop> dst_loops = dst_mesh.loops_for_write(); for (const int i_dst : masked_poly_indices.index_range()) { const int i_src = masked_poly_indices[i_dst]; @@ -433,7 +433,7 @@ static void compute_selected_edges_from_vertex_selection(const Mesh &mesh, int *r_selected_edges_num) { BLI_assert(mesh.totedge == r_edge_map.size()); - const Span<MEdge> edges = bke::mesh_edges(mesh); + const Span<MEdge> edges = mesh.edges(); int selected_edges_num = 0; for (const int i : IndexRange(mesh.totedge)) { @@ -460,8 +460,8 @@ static void compute_selected_polygons_from_vertex_selection(const Mesh &mesh, int *r_selected_loops_num) { BLI_assert(mesh.totvert == vertex_selection.size()); - const Span<MPoly> polys = bke::mesh_polygons(mesh); - const Span<MLoop> loops = bke::mesh_loops(mesh); + const Span<MPoly> polys = mesh.polygons(); + const Span<MLoop> loops = mesh.loops(); r_selected_poly_indices.reserve(mesh.totpoly); r_loop_starts.reserve(mesh.totloop); @@ -503,7 +503,7 @@ static void compute_selected_vertices_and_edges_from_edge_selection( int *r_selected_edges_num) { BLI_assert(mesh.totedge == edge_selection.size()); - const Span<MEdge> edges = bke::mesh_edges(mesh); + const Span<MEdge> edges = mesh.edges(); int selected_edges_num = 0; int selected_verts_num = 0; @@ -565,8 +565,8 @@ static void compute_selected_polygons_from_edge_selection(const Mesh &mesh, int *r_selected_polys_num, int *r_selected_loops_num) { - const Span<MPoly> polys = bke::mesh_polygons(mesh); - const Span<MLoop> loops = bke::mesh_loops(mesh); + const Span<MPoly> polys = mesh.polygons(); + const Span<MLoop> loops = mesh.loops(); r_selected_poly_indices.reserve(mesh.totpoly); r_loop_starts.reserve(mesh.totloop); @@ -714,7 +714,7 @@ static void compute_selected_polygons_from_poly_selection(const Mesh &mesh, int *r_selected_loops_num) { BLI_assert(mesh.totpoly == poly_selection.size()); - const Span<MPoly> polys = bke::mesh_polygons(mesh); + const Span<MPoly> polys = mesh.polygons(); r_selected_poly_indices.reserve(mesh.totpoly); r_loop_starts.reserve(mesh.totloop); @@ -748,8 +748,8 @@ static void compute_selected_mesh_data_from_poly_selection_edge_face( { BLI_assert(mesh.totpoly == poly_selection.size()); BLI_assert(mesh.totedge == r_edge_map.size()); - const Span<MPoly> polys = bke::mesh_polygons(mesh); - const Span<MLoop> loops = bke::mesh_loops(mesh); + const Span<MPoly> polys = mesh.polygons(); + const Span<MLoop> loops = mesh.loops(); r_edge_map.fill(-1); @@ -799,8 +799,8 @@ static void compute_selected_mesh_data_from_poly_selection(const Mesh &mesh, { BLI_assert(mesh.totpoly == poly_selection.size()); BLI_assert(mesh.totedge == r_edge_map.size()); - const Span<MPoly> polys = bke::mesh_polygons(mesh); - const Span<MLoop> loops = bke::mesh_loops(mesh); + const Span<MPoly> polys = mesh.polygons(); + const Span<MLoop> loops = mesh.loops(); r_vertex_map.fill(-1); r_edge_map.fill(-1); @@ -996,7 +996,7 @@ static void do_mesh_separation(GeometrySet &geometry_set, selected_polys_num); /* Copy the selected parts of the mesh over to the new mesh. */ - bke::mesh_vertices_for_write(*mesh_out).copy_from(bke::mesh_vertices(mesh_in)); + mesh_out->vertices_for_write().copy_from(mesh_in.vertices()); copy_masked_edges_to_new_mesh(mesh_in, *mesh_out, edge_map); copy_masked_polys_to_new_mesh( mesh_in, *mesh_out, edge_map, selected_poly_indices, new_loop_starts); @@ -1059,8 +1059,8 @@ static void do_mesh_separation(GeometrySet &geometry_set, &mesh_in, mesh_in.totvert, mesh_in.totedge, 0, selected_loops_num, selected_polys_num); /* Copy the selected parts of the mesh over to the new mesh. */ - bke::mesh_vertices_for_write(*mesh_out).copy_from(bke::mesh_vertices(mesh_in)); - bke::mesh_edges_for_write(*mesh_out).copy_from(bke::mesh_edges(mesh_in)); + mesh_out->vertices_for_write().copy_from(mesh_in.vertices()); + mesh_out->edges_for_write().copy_from(mesh_in.edges()); copy_masked_polys_to_new_mesh(mesh_in, *mesh_out, selected_poly_indices, new_loop_starts); /* Copy attributes. */ diff --git a/source/blender/nodes/geometry/nodes/node_geo_distribute_points_on_faces.cc b/source/blender/nodes/geometry/nodes/node_geo_distribute_points_on_faces.cc index 3641ffba64b..2bb321a349a 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_distribute_points_on_faces.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_distribute_points_on_faces.cc @@ -105,8 +105,8 @@ static void sample_mesh_surface(const Mesh &mesh, Vector<float3> &r_bary_coords, Vector<int> &r_looptri_indices) { - const Span<MVert> verts = bke::mesh_vertices(mesh); - const Span<MLoop> loops = bke::mesh_loops(mesh); + const Span<MVert> verts = mesh.vertices(); + const Span<MLoop> loops = mesh.loops(); const Span<MLoopTri> looptris{BKE_mesh_runtime_looptri_ensure(&mesh), BKE_mesh_runtime_looptri_len(&mesh)}; @@ -350,8 +350,8 @@ BLI_NOINLINE static void compute_attribute_outputs(const Mesh &mesh, attribute_outputs.rotation_id.get(), ATTR_DOMAIN_POINT); } - const Span<MVert> verts = bke::mesh_vertices(mesh); - const Span<MLoop> loops = bke::mesh_loops(mesh); + const Span<MVert> verts = mesh.vertices(); + const Span<MLoop> loops = mesh.loops(); const Span<MLoopTri> looptris{BKE_mesh_runtime_looptri_ensure(&mesh), BKE_mesh_runtime_looptri_len(&mesh)}; diff --git a/source/blender/nodes/geometry/nodes/node_geo_dual_mesh.cc b/source/blender/nodes/geometry/nodes/node_geo_dual_mesh.cc index a94c4413bd4..1b9e9ae9b4a 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_dual_mesh.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_dual_mesh.cc @@ -209,9 +209,9 @@ static void calc_boundaries(const Mesh &mesh, { BLI_assert(r_vertex_types.size() == mesh.totvert); BLI_assert(r_edge_types.size() == mesh.totedge); - const Span<MEdge> edges = bke::mesh_edges(mesh); - const Span<MPoly> polys = bke::mesh_polygons(mesh); - const Span<MLoop> loops = bke::mesh_loops(mesh); + const Span<MEdge> edges = mesh.edges(); + const Span<MPoly> polys = mesh.polygons(); + const Span<MLoop> loops = mesh.loops(); r_vertex_types.fill(VertexType::Loose); r_edge_types.fill(EdgeType::Loose); @@ -263,8 +263,8 @@ static void calc_boundaries(const Mesh &mesh, static void create_vertex_poly_map(const Mesh &mesh, MutableSpan<Vector<int>> r_vertex_poly_indices) { - const Span<MPoly> polygons = bke::mesh_polygons(mesh); - const Span<MLoop> loops = bke::mesh_loops(mesh); + const Span<MPoly> polygons = mesh.polygons(); + const Span<MLoop> loops = mesh.loops(); for (const int i : polygons.index_range()) { const MPoly &poly = polygons[i]; const Span<MLoop> poly_loops = loops.slice(poly.loopstart, poly.totloop); @@ -635,10 +635,10 @@ static void calc_dual_mesh(GeometrySet &geometry_set, const bool keep_boundaries) { const Mesh &mesh_in = *in_component.get_for_read(); - const Span<MVert> src_verts = bke::mesh_vertices(mesh_in); - const Span<MEdge> src_edges = bke::mesh_edges(mesh_in); - const Span<MPoly> src_polys = bke::mesh_polygons(mesh_in); - const Span<MLoop> src_loops = bke::mesh_loops(mesh_in); + const Span<MVert> src_verts = mesh_in.vertices(); + const Span<MEdge> src_edges = mesh_in.edges(); + const Span<MPoly> src_polys = mesh_in.polygons(); + const Span<MLoop> src_loops = mesh_in.loops(); Map<AttributeIDRef, AttributeKind> attributes; geometry_set.gather_attributes_for_propagation( @@ -921,10 +921,10 @@ static void calc_dual_mesh(GeometrySet &geometry_set, bke::mesh_attributes(mesh_in), bke::mesh_attributes_for_write(*mesh_out)); - MutableSpan<MVert> dst_verts = bke::mesh_vertices_for_write(*mesh_out); - MutableSpan<MEdge> dst_edges = bke::mesh_edges_for_write(*mesh_out); - MutableSpan<MPoly> dst_polys = bke::mesh_polygons_for_write(*mesh_out); - MutableSpan<MLoop> dst_loops = bke::mesh_loops_for_write(*mesh_out); + MutableSpan<MVert> dst_verts = mesh_out->vertices_for_write(); + MutableSpan<MEdge> dst_edges = mesh_out->edges_for_write(); + MutableSpan<MPoly> dst_polys = mesh_out->polygons_for_write(); + MutableSpan<MLoop> dst_loops = mesh_out->loops_for_write(); int loop_start = 0; for (const int i : IndexRange(mesh_out->totpoly)) { diff --git a/source/blender/nodes/geometry/nodes/node_geo_duplicate_elements.cc b/source/blender/nodes/geometry/nodes/node_geo_duplicate_elements.cc index f6a4d2e6cf8..9af1536a194 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_duplicate_elements.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_duplicate_elements.cc @@ -486,7 +486,7 @@ static void copy_stable_id_faces(const Mesh &mesh, VArraySpan<int> src{src_attribute.varray.typed<int>()}; MutableSpan<int> dst = dst_attribute.span.typed<int>(); - const Span<MPoly> polys = bke::mesh_polygons(mesh); + const Span<MPoly> polys = mesh.polygons(); int loop_index = 0; for (const int i_poly : selection.index_range()) { const IndexRange range = range_for_offsets_index(poly_offsets, i_poly); @@ -522,10 +522,10 @@ static void duplicate_faces(GeometrySet &geometry_set, geometry_set.keep_only_during_modify({GEO_COMPONENT_TYPE_MESH}); const Mesh &mesh = *geometry_set.get_mesh_for_read(); - const Span<MVert> verts = bke::mesh_vertices(mesh); - const Span<MEdge> edges = bke::mesh_edges(mesh); - const Span<MPoly> polys = bke::mesh_polygons(mesh); - const Span<MLoop> loops = bke::mesh_loops(mesh); + const Span<MVert> verts = mesh.vertices(); + const Span<MEdge> edges = mesh.edges(); + const Span<MPoly> polys = mesh.polygons(); + const Span<MLoop> loops = mesh.loops(); bke::MeshFieldContext field_context{mesh, ATTR_DOMAIN_FACE}; FieldEvaluator evaluator(field_context, polys.size()); @@ -547,10 +547,10 @@ static void duplicate_faces(GeometrySet &geometry_set, offsets[selection.size()] = total_polys; Mesh *new_mesh = BKE_mesh_new_nomain(total_loops, total_loops, 0, total_loops, total_polys); - MutableSpan<MVert> new_verts = bke::mesh_vertices_for_write(*new_mesh); - MutableSpan<MEdge> new_edges = bke::mesh_edges_for_write(*new_mesh); - MutableSpan<MPoly> new_polys = bke::mesh_polygons_for_write(*new_mesh); - MutableSpan<MLoop> new_loops = bke::mesh_loops_for_write(*new_mesh); + MutableSpan<MVert> new_verts = new_mesh->vertices_for_write(); + MutableSpan<MEdge> new_edges = new_mesh->edges_for_write(); + MutableSpan<MPoly> new_polys = new_mesh->polygons_for_write(); + MutableSpan<MLoop> new_loops = new_mesh->loops_for_write(); Array<int> vert_mapping(new_verts.size()); Array<int> edge_mapping(new_edges.size()); @@ -689,7 +689,7 @@ static void copy_stable_id_edges(const Mesh &mesh, return; } - const Span<MEdge> edges = bke::mesh_edges(mesh); + const Span<MEdge> edges = mesh.edges(); VArraySpan<int> src{src_attribute.varray.typed<int>()}; MutableSpan<int> dst = dst_attribute.span.typed<int>(); @@ -723,7 +723,7 @@ static void duplicate_edges(GeometrySet &geometry_set, return; }; const Mesh &mesh = *geometry_set.get_mesh_for_read(); - const Span<MEdge> edges = bke::mesh_edges(mesh); + const Span<MEdge> edges = mesh.edges(); bke::MeshFieldContext field_context{mesh, ATTR_DOMAIN_EDGE}; FieldEvaluator evaluator{field_context, edges.size()}; @@ -736,7 +736,7 @@ static void duplicate_edges(GeometrySet &geometry_set, Array<int> edge_offsets = accumulate_counts_to_offsets(selection, counts); Mesh *new_mesh = BKE_mesh_new_nomain(edge_offsets.last() * 2, edge_offsets.last(), 0, 0, 0); - MutableSpan<MEdge> new_edges = bke::mesh_edges_for_write(*new_mesh); + MutableSpan<MEdge> new_edges = new_mesh->edges_for_write(); Array<int> vert_orig_indices(edge_offsets.last() * 2); threading::parallel_for(selection.index_range(), 1024, [&](IndexRange range) { @@ -904,7 +904,7 @@ static void duplicate_points_mesh(GeometrySet &geometry_set, const IndexAttributes &attribute_outputs) { const Mesh &mesh = *geometry_set.get_mesh_for_read(); - const Span<MVert> src_verts = bke::mesh_vertices(mesh); + const Span<MVert> src_verts = mesh.vertices(); bke::MeshFieldContext field_context{mesh, ATTR_DOMAIN_POINT}; FieldEvaluator evaluator{field_context, src_verts.size()}; @@ -917,7 +917,7 @@ static void duplicate_points_mesh(GeometrySet &geometry_set, Array<int> offsets = accumulate_counts_to_offsets(selection, counts); Mesh *new_mesh = BKE_mesh_new_nomain(offsets.last(), 0, 0, 0, 0); - MutableSpan<MVert> dst_verts = bke::mesh_vertices_for_write(*new_mesh); + MutableSpan<MVert> dst_verts = new_mesh->vertices_for_write(); threaded_slice_fill(offsets.as_span(), selection, src_verts, dst_verts); diff --git a/source/blender/nodes/geometry/nodes/node_geo_edge_paths_to_selection.cc b/source/blender/nodes/geometry/nodes/node_geo_edge_paths_to_selection.cc index 13b6a57e8b8..ac66e3906a7 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_edge_paths_to_selection.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_edge_paths_to_selection.cc @@ -25,7 +25,7 @@ static void edge_paths_to_selection(const Mesh &src_mesh, const Span<int> next_indices, MutableSpan<bool> r_selection) { - const Span<MEdge> edges = bke::mesh_edges(src_mesh); + const Span<MEdge> edges = src_mesh.edges(); Array<bool> selection(src_mesh.totvert, false); diff --git a/source/blender/nodes/geometry/nodes/node_geo_extrude_mesh.cc b/source/blender/nodes/geometry/nodes/node_geo_extrude_mesh.cc index b4427903ed6..d81b335ebb3 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_extrude_mesh.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_extrude_mesh.cc @@ -238,16 +238,15 @@ static void extrude_mesh_vertices(Mesh &mesh, const VArray<float3> offsets = evaluator.get_evaluated<float3>(0); /* This allows parallelizing attribute mixing for new edges. */ - Array<Vector<int>> vert_to_edge_map = create_vert_to_edge_map(orig_vert_size, - bke::mesh_edges(mesh)); + Array<Vector<int>> vert_to_edge_map = create_vert_to_edge_map(orig_vert_size, mesh.edges()); expand_mesh(mesh, selection.size(), selection.size(), 0, 0); const IndexRange new_vert_range{orig_vert_size, selection.size()}; const IndexRange new_edge_range{orig_edge_size, selection.size()}; - MutableSpan<MVert> new_verts = bke::mesh_vertices_for_write(mesh).slice(new_vert_range); - MutableSpan<MEdge> new_edges = bke::mesh_edges_for_write(mesh).slice(new_edge_range); + MutableSpan<MVert> new_verts = mesh.vertices_for_write().slice(new_vert_range); + MutableSpan<MEdge> new_edges = mesh.edges_for_write().slice(new_edge_range); for (const int i_selection : selection.index_range()) { new_edges[i_selection] = new_loose_edge(selection[i_selection], new_vert_range[i_selection]); @@ -312,8 +311,8 @@ static void extrude_mesh_vertices(Mesh &mesh, static Array<Vector<int, 2>> mesh_calculate_polys_of_edge(const Mesh &mesh) { - Span<MPoly> polys = bke::mesh_polygons(mesh); - Span<MLoop> loops = bke::mesh_loops(mesh); + Span<MPoly> polys = mesh.polygons(); + Span<MLoop> loops = mesh.loops(); Array<Vector<int, 2>> polys_of_edge(mesh.totedge); for (const int i_poly : polys.index_range()) { @@ -371,7 +370,7 @@ template<typename T> static VectorSet<int> vert_indices_from_edges(const Mesh &mesh, const Span<T> edge_indices) { static_assert(is_same_any_v<T, int, int64_t>); - const Span<MEdge> edges = bke::mesh_edges(mesh); + const Span<MEdge> edges = mesh.edges(); VectorSet<int> vert_indices; vert_indices.reserve(edge_indices.size()); @@ -389,8 +388,8 @@ static void extrude_mesh_edges(Mesh &mesh, const AttributeOutputs &attribute_outputs) { const int orig_vert_size = mesh.totvert; - Span<MEdge> orig_edges = bke::mesh_edges(mesh); - Span<MPoly> orig_polys = bke::mesh_polygons(mesh); + Span<MEdge> orig_edges = mesh.edges(); + Span<MPoly> orig_polys = mesh.polygons(); const int orig_loop_size = mesh.totloop; bke::MeshFieldContext edge_context{mesh, ATTR_DOMAIN_EDGE}; @@ -439,12 +438,12 @@ static void extrude_mesh_edges(Mesh &mesh, new_poly_range.size(), new_loop_range.size()); - MutableSpan<MEdge> edges = bke::mesh_edges_for_write(mesh); + MutableSpan<MEdge> edges = mesh.edges_for_write(); MutableSpan<MEdge> connect_edges = edges.slice(connect_edge_range); MutableSpan<MEdge> duplicate_edges = edges.slice(duplicate_edge_range); - MutableSpan<MPoly> polys = bke::mesh_polygons_for_write(mesh); + MutableSpan<MPoly> polys = mesh.polygons_for_write(); MutableSpan<MPoly> new_polys = polys.slice(new_poly_range); - MutableSpan<MLoop> loops = bke::mesh_loops_for_write(mesh); + MutableSpan<MLoop> loops = mesh.loops_for_write(); MutableSpan<MLoop> new_loops = loops.slice(new_loop_range); for (const int i : connect_edges.index_range()) { @@ -607,7 +606,7 @@ static void extrude_mesh_edges(Mesh &mesh, return true; }); - MutableSpan<MVert> new_verts = bke::mesh_vertices_for_write(mesh).slice(new_vert_range); + MutableSpan<MVert> new_verts = mesh.vertices_for_write().slice(new_vert_range); if (edge_offsets.is_single()) { const float3 offset = edge_offsets.get_internal_single(); threading::parallel_for(new_verts.index_range(), 1024, [&](const IndexRange range) { @@ -653,9 +652,9 @@ static void extrude_mesh_face_regions(Mesh &mesh, const AttributeOutputs &attribute_outputs) { const int orig_vert_size = mesh.totvert; - Span<MEdge> orig_edges = bke::mesh_edges(mesh); - Span<MPoly> orig_polys = bke::mesh_polygons(mesh); - Span<MLoop> orig_loops = bke::mesh_loops(mesh); + Span<MEdge> orig_edges = mesh.edges(); + Span<MPoly> orig_polys = mesh.polygons(); + Span<MLoop> orig_loops = mesh.loops(); bke::MeshFieldContext poly_context{mesh, ATTR_DOMAIN_FACE}; FieldEvaluator poly_evaluator{poly_context, mesh.totpoly}; @@ -782,13 +781,13 @@ static void extrude_mesh_face_regions(Mesh &mesh, side_poly_range.size(), side_loop_range.size()); - MutableSpan<MEdge> edges = bke::mesh_edges_for_write(mesh); + MutableSpan<MEdge> edges = mesh.edges_for_write(); MutableSpan<MEdge> connect_edges = edges.slice(connect_edge_range); MutableSpan<MEdge> boundary_edges = edges.slice(boundary_edge_range); MutableSpan<MEdge> new_inner_edges = edges.slice(new_inner_edge_range); - MutableSpan<MPoly> polys = bke::mesh_polygons_for_write(mesh); + MutableSpan<MPoly> polys = mesh.polygons_for_write(); MutableSpan<MPoly> new_polys = polys.slice(side_poly_range); - MutableSpan<MLoop> loops = bke::mesh_loops_for_write(mesh); + MutableSpan<MLoop> loops = mesh.loops_for_write(); MutableSpan<MLoop> new_loops = loops.slice(side_loop_range); /* Initialize the edges that form the sides of the extrusion. */ @@ -977,7 +976,7 @@ static void extrude_mesh_face_regions(Mesh &mesh, /* Translate vertices based on the offset. If the vertex is used by a selected edge, it will * have been duplicated and only the new vertex should use the offset. Otherwise the vertex might * still need an offset, but it was reused on the inside of a region of extruded faces. */ - MutableSpan<MVert> verts = bke::mesh_vertices_for_write(mesh); + MutableSpan<MVert> verts = mesh.vertices_for_write(); if (poly_offsets.is_single()) { const float3 offset = poly_offsets.get_internal_single(); threading::parallel_for( @@ -1039,8 +1038,8 @@ static void extrude_individual_mesh_faces(Mesh &mesh, { const int orig_vert_size = mesh.totvert; const int orig_edge_size = mesh.totedge; - Span<MPoly> orig_polys = bke::mesh_polygons(mesh); - Span<MLoop> orig_loops = bke::mesh_loops(mesh); + Span<MPoly> orig_polys = mesh.polygons(); + Span<MLoop> orig_loops = mesh.loops(); /* Use a mesh for the result of the evaluation because the mesh is reallocated before * the vertices are moved, and the evaluated result might reference an attribute. */ @@ -1079,13 +1078,13 @@ static void extrude_individual_mesh_faces(Mesh &mesh, side_poly_range.size(), side_loop_range.size()); - MutableSpan<MVert> new_verts = bke::mesh_vertices_for_write(mesh).slice(new_vert_range); - MutableSpan<MEdge> edges = bke::mesh_edges_for_write(mesh); + MutableSpan<MVert> new_verts = mesh.vertices_for_write().slice(new_vert_range); + MutableSpan<MEdge> edges = mesh.edges_for_write(); MutableSpan<MEdge> connect_edges = edges.slice(connect_edge_range); MutableSpan<MEdge> duplicate_edges = edges.slice(duplicate_edge_range); - MutableSpan<MPoly> polys = bke::mesh_polygons_for_write(mesh); + MutableSpan<MPoly> polys = mesh.polygons_for_write(); MutableSpan<MPoly> new_polys = polys.slice(side_poly_range); - MutableSpan<MLoop> loops = bke::mesh_loops_for_write(mesh); + MutableSpan<MLoop> loops = mesh.loops_for_write(); /* For every selected polygon, build the faces that form the sides of the extrusion. Filling some * of this data like the new edges or polygons could be easily split into separate loops, which diff --git a/source/blender/nodes/geometry/nodes/node_geo_flip_faces.cc b/source/blender/nodes/geometry/nodes/node_geo_flip_faces.cc index 5c31b597e01..2d642ad13d5 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_flip_faces.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_flip_faces.cc @@ -30,8 +30,8 @@ static void mesh_flip_faces(Mesh &mesh, const Field<bool> &selection_field) evaluator.evaluate(); const IndexMask selection = evaluator.get_evaluated_as_mask(0); - const Span<MPoly> polys = bke::mesh_polygons(mesh); - MutableSpan<MLoop> loops = bke::mesh_loops_for_write(mesh); + const Span<MPoly> polys = mesh.polygons(); + MutableSpan<MLoop> loops = mesh.loops_for_write(); for (const int i : selection.index_range()) { const MPoly &poly = polys[selection[i]]; diff --git a/source/blender/nodes/geometry/nodes/node_geo_input_mesh_edge_angle.cc b/source/blender/nodes/geometry/nodes/node_geo_input_mesh_edge_angle.cc index 94402c94c14..4b5ea1c8742 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_input_mesh_edge_angle.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_input_mesh_edge_angle.cc @@ -64,9 +64,9 @@ class AngleFieldInput final : public bke::MeshFieldInput { const eAttrDomain domain, IndexMask UNUSED(mask)) const final { - const Span<MVert> verts = bke::mesh_vertices(mesh); - const Span<MPoly> polys = bke::mesh_polygons(mesh); - const Span<MLoop> loops = bke::mesh_loops(mesh); + const Span<MVert> verts = mesh.vertices(); + const Span<MPoly> polys = mesh.polygons(); + const Span<MLoop> loops = mesh.loops(); Array<EdgeMapEntry> edge_map = create_edge_map(polys, loops, mesh.totedge); auto angle_fn = [edge_map = std::move(edge_map), verts, polys, loops](const int i) -> float { @@ -109,10 +109,10 @@ class SignedAngleFieldInput final : public bke::MeshFieldInput { const eAttrDomain domain, IndexMask UNUSED(mask)) const final { - const Span<MVert> verts = bke::mesh_vertices(mesh); - const Span<MEdge> edges = bke::mesh_edges(mesh); - const Span<MPoly> polys = bke::mesh_polygons(mesh); - const Span<MLoop> loops = bke::mesh_loops(mesh); + const Span<MVert> verts = mesh.vertices(); + const Span<MEdge> edges = mesh.edges(); + const Span<MPoly> polys = mesh.polygons(); + const Span<MLoop> loops = mesh.loops(); Array<EdgeMapEntry> edge_map = create_edge_map(polys, loops, mesh.totedge); auto angle_fn = diff --git a/source/blender/nodes/geometry/nodes/node_geo_input_mesh_edge_neighbors.cc b/source/blender/nodes/geometry/nodes/node_geo_input_mesh_edge_neighbors.cc index 17b9dd739b7..716cbf589d9 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_input_mesh_edge_neighbors.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_input_mesh_edge_neighbors.cc @@ -28,7 +28,7 @@ class EdgeNeighborCountFieldInput final : public bke::MeshFieldInput { const eAttrDomain domain, IndexMask UNUSED(mask)) const final { - const Span<MLoop> loops = bke::mesh_loops(mesh); + const Span<MLoop> loops = mesh.loops(); Array<int> face_count(mesh.totedge, 0); for (const MLoop &loop : loops) { face_count[loop.e]++; diff --git a/source/blender/nodes/geometry/nodes/node_geo_input_mesh_edge_vertices.cc b/source/blender/nodes/geometry/nodes/node_geo_input_mesh_edge_vertices.cc index 81e9badf347..7fd2df7c552 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_input_mesh_edge_vertices.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_input_mesh_edge_vertices.cc @@ -31,7 +31,7 @@ static VArray<int> construct_edge_vertices_gvarray(const Mesh &mesh, const VertexNumber vertex, const eAttrDomain domain) { - const Span<MEdge> edges = bke::mesh_edges(mesh); + const Span<MEdge> edges = mesh.edges(); if (domain == ATTR_DOMAIN_EDGE) { if (vertex == VERTEX_ONE) { return VArray<int>::ForFunc(edges.size(), @@ -79,8 +79,8 @@ static VArray<float3> construct_edge_positions_gvarray(const Mesh &mesh, const VertexNumber vertex, const eAttrDomain domain) { - const Span<MVert> verts = bke::mesh_vertices(mesh); - const Span<MEdge> edges = bke::mesh_edges(mesh); + const Span<MVert> verts = mesh.vertices(); + const Span<MEdge> edges = mesh.edges(); if (vertex == VERTEX_ONE) { return bke::mesh_attributes(mesh).adapt_domain<float3>( diff --git a/source/blender/nodes/geometry/nodes/node_geo_input_mesh_face_area.cc b/source/blender/nodes/geometry/nodes/node_geo_input_mesh_face_area.cc index a466b63e027..7dfeaa8e8d9 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_input_mesh_face_area.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_input_mesh_face_area.cc @@ -18,9 +18,9 @@ static void node_declare(NodeDeclarationBuilder &b) static VArray<float> construct_face_area_varray(const Mesh &mesh, const eAttrDomain domain) { - const Span<MVert> verts = bke::mesh_vertices(mesh); - const Span<MPoly> polys = bke::mesh_polygons(mesh); - const Span<MLoop> loops = bke::mesh_loops(mesh); + const Span<MVert> verts = mesh.vertices(); + const Span<MPoly> polys = mesh.polygons(); + const Span<MLoop> loops = mesh.loops(); auto area_fn = [verts, polys, loops](const int i) -> float { const MPoly &poly = polys[i]; diff --git a/source/blender/nodes/geometry/nodes/node_geo_input_mesh_face_is_planar.cc b/source/blender/nodes/geometry/nodes/node_geo_input_mesh_face_is_planar.cc index 1a82ae61c1b..b316639fd0a 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_input_mesh_face_is_planar.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_input_mesh_face_is_planar.cc @@ -37,9 +37,9 @@ class PlanarFieldInput final : public bke::MeshFieldInput { const eAttrDomain domain, IndexMask /*mask*/) const final { - const Span<MVert> verts = bke::mesh_vertices(mesh); - const Span<MPoly> polys = bke::mesh_polygons(mesh); - const Span<MLoop> loops = bke::mesh_loops(mesh); + const Span<MVert> verts = mesh.vertices(); + const Span<MPoly> polys = mesh.polygons(); + const Span<MLoop> loops = mesh.loops(); const Span<float3> poly_normals{(float3 *)BKE_mesh_poly_normals_ensure(&mesh), mesh.totpoly}; bke::MeshFieldContext context{mesh, ATTR_DOMAIN_FACE}; diff --git a/source/blender/nodes/geometry/nodes/node_geo_input_mesh_face_neighbors.cc b/source/blender/nodes/geometry/nodes/node_geo_input_mesh_face_neighbors.cc index 01b4f65788f..59d30b997a6 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_input_mesh_face_neighbors.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_input_mesh_face_neighbors.cc @@ -21,8 +21,8 @@ static void node_declare(NodeDeclarationBuilder &b) static VArray<int> construct_neighbor_count_varray(const Mesh &mesh, const eAttrDomain domain) { - const Span<MPoly> polys = bke::mesh_polygons(mesh); - const Span<MLoop> loops = bke::mesh_loops(mesh); + const Span<MPoly> polys = mesh.polygons(); + const Span<MLoop> loops = mesh.loops(); Array<int> edge_count(mesh.totedge, 0); for (const MLoop &loop : loops) { @@ -70,7 +70,7 @@ class FaceNeighborCountFieldInput final : public bke::MeshFieldInput { static VArray<int> construct_vertex_count_varray(const Mesh &mesh, const eAttrDomain domain) { - const Span<MPoly> polys = bke::mesh_polygons(mesh); + const Span<MPoly> polys = mesh.polygons(); return bke::mesh_attributes(mesh).adapt_domain<int>( VArray<int>::ForFunc(polys.size(), [polys](const int i) -> float { return polys[i].totloop; }), diff --git a/source/blender/nodes/geometry/nodes/node_geo_input_mesh_island.cc b/source/blender/nodes/geometry/nodes/node_geo_input_mesh_island.cc index 89ef06705e7..53cb3d0a19f 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_input_mesh_island.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_input_mesh_island.cc @@ -33,7 +33,7 @@ class IslandFieldInput final : public bke::MeshFieldInput { const eAttrDomain domain, IndexMask UNUSED(mask)) const final { - const Span<MEdge> edges = bke::mesh_edges(mesh); + const Span<MEdge> edges = mesh.edges(); DisjointSet islands(mesh.totvert); for (const int i : edges.index_range()) { @@ -74,7 +74,7 @@ class IslandCountFieldInput final : public bke::MeshFieldInput { const eAttrDomain domain, IndexMask UNUSED(mask)) const final { - const Span<MEdge> edges = bke::mesh_edges(mesh); + const Span<MEdge> edges = mesh.edges(); DisjointSet islands(mesh.totvert); for (const int i : edges.index_range()) { diff --git a/source/blender/nodes/geometry/nodes/node_geo_input_mesh_vertex_neighbors.cc b/source/blender/nodes/geometry/nodes/node_geo_input_mesh_vertex_neighbors.cc index 23f7988edf7..ab44a6c8515 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_input_mesh_vertex_neighbors.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_input_mesh_vertex_neighbors.cc @@ -22,7 +22,7 @@ static void node_declare(NodeDeclarationBuilder &b) static VArray<int> construct_vertex_count_gvarray(const Mesh &mesh, const eAttrDomain domain) { - const Span<MEdge> edges = bke::mesh_edges(mesh); + const Span<MEdge> edges = mesh.edges(); if (domain == ATTR_DOMAIN_POINT) { Array<int> counts(mesh.totvert, 0); for (const int i : edges.index_range()) { @@ -62,7 +62,7 @@ class VertexCountFieldInput final : public bke::MeshFieldInput { static VArray<int> construct_face_count_gvarray(const Mesh &mesh, const eAttrDomain domain) { - const Span<MLoop> loops = bke::mesh_loops(mesh); + const Span<MLoop> loops = mesh.loops(); if (domain == ATTR_DOMAIN_POINT) { Array<int> vertices(mesh.totvert, 0); for (const int i : loops.index_range()) { diff --git a/source/blender/nodes/geometry/nodes/node_geo_input_shortest_edge_paths.cc b/source/blender/nodes/geometry/nodes/node_geo_input_shortest_edge_paths.cc index 7ebcae07cef..e13edc8f979 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_input_shortest_edge_paths.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_input_shortest_edge_paths.cc @@ -28,7 +28,7 @@ struct EdgeVertMap { EdgeVertMap(const Mesh &mesh) { - const Span<MEdge> edges = bke::mesh_edges(mesh); + const Span<MEdge> edges = mesh.edges(); edges_by_vertex_map.reinitialize(mesh.totvert); for (const int edge_i : edges.index_range()) { const MEdge &edge = edges[edge_i]; @@ -45,7 +45,7 @@ static void shortest_paths(const Mesh &mesh, MutableSpan<int> r_next_index, MutableSpan<float> r_cost) { - const Span<MEdge> edges = bke::mesh_edges(mesh); + const Span<MEdge> edges = mesh.edges(); Array<bool> visited(mesh.totvert, false); std::priority_queue<VertPriority, std::vector<VertPriority>, std::greater<VertPriority>> queue; diff --git a/source/blender/nodes/geometry/nodes/node_geo_mesh_primitive_circle.cc b/source/blender/nodes/geometry/nodes/node_geo_mesh_primitive_circle.cc index 772a6b44ec2..ba3871adc76 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_mesh_primitive_circle.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_mesh_primitive_circle.cc @@ -109,10 +109,10 @@ static Mesh *create_circle_mesh(const float radius, circle_corner_total(fill_type, verts_num), circle_face_total(fill_type, verts_num)); BKE_id_material_eval_ensure_default_slot(&mesh->id); - MutableSpan<MVert> verts = bke::mesh_vertices_for_write(*mesh); - MutableSpan<MEdge> edges = bke::mesh_edges_for_write(*mesh); - MutableSpan<MPoly> polys = bke::mesh_polygons_for_write(*mesh); - MutableSpan<MLoop> loops = bke::mesh_loops_for_write(*mesh); + MutableSpan<MVert> verts = mesh->vertices_for_write(); + MutableSpan<MEdge> edges = mesh->edges_for_write(); + MutableSpan<MPoly> polys = mesh->polygons_for_write(); + MutableSpan<MLoop> loops = mesh->loops_for_write(); /* Assign vertex coordinates. */ const float angle_delta = 2.0f * (M_PI / static_cast<float>(verts_num)); diff --git a/source/blender/nodes/geometry/nodes/node_geo_mesh_primitive_cone.cc b/source/blender/nodes/geometry/nodes/node_geo_mesh_primitive_cone.cc index cdc305fc658..98ae1ef1275 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_mesh_primitive_cone.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_mesh_primitive_cone.cc @@ -657,7 +657,7 @@ static Mesh *create_vertex_mesh() { /* Returns a mesh with a single vertex at the origin. */ Mesh *mesh = BKE_mesh_new_nomain(1, 0, 0, 0, 0); - copy_v3_fl3(bke::mesh_vertices_for_write(*mesh).first().co, 0.0f, 0.0f, 0.0f); + copy_v3_fl3(mesh->vertices_for_write().first().co, 0.0f, 0.0f, 0.0f); return mesh; } @@ -689,10 +689,10 @@ Mesh *create_cylinder_or_cone_mesh(const float radius_top, config.tot_verts, config.tot_edges, 0, config.tot_corners, config.tot_faces); BKE_id_material_eval_ensure_default_slot(&mesh->id); - MutableSpan<MVert> verts = bke::mesh_vertices_for_write(*mesh); - MutableSpan<MEdge> edges = bke::mesh_edges_for_write(*mesh); - MutableSpan<MPoly> polys = bke::mesh_polygons_for_write(*mesh); - MutableSpan<MLoop> loops = bke::mesh_loops_for_write(*mesh); + MutableSpan<MVert> verts = mesh->vertices_for_write(); + MutableSpan<MEdge> edges = mesh->edges_for_write(); + MutableSpan<MPoly> polys = mesh->polygons_for_write(); + MutableSpan<MLoop> loops = mesh->loops_for_write(); calculate_cone_vertices(verts, config); calculate_cone_edges(edges, config); diff --git a/source/blender/nodes/geometry/nodes/node_geo_mesh_primitive_grid.cc b/source/blender/nodes/geometry/nodes/node_geo_mesh_primitive_grid.cc index c44d7838b8a..656c5988bef 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_mesh_primitive_grid.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_mesh_primitive_grid.cc @@ -49,10 +49,10 @@ Mesh *create_grid_mesh(const int verts_x, 0, edges_x * edges_y * 4, edges_x * edges_y); - MutableSpan<MVert> verts = bke::mesh_vertices_for_write(*mesh); - MutableSpan<MEdge> edges = bke::mesh_edges_for_write(*mesh); - MutableSpan<MPoly> polys = bke::mesh_polygons_for_write(*mesh); - MutableSpan<MLoop> loops = bke::mesh_loops_for_write(*mesh); + MutableSpan<MVert> verts = mesh->vertices_for_write(); + MutableSpan<MEdge> edges = mesh->edges_for_write(); + MutableSpan<MPoly> polys = mesh->polygons_for_write(); + MutableSpan<MLoop> loops = mesh->loops_for_write(); { const float dx = edges_x == 0 ? 0.0f : size_x / edges_x; diff --git a/source/blender/nodes/geometry/nodes/node_geo_mesh_primitive_line.cc b/source/blender/nodes/geometry/nodes/node_geo_mesh_primitive_line.cc index 0402919acc5..130fb8ae589 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_mesh_primitive_line.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_mesh_primitive_line.cc @@ -179,8 +179,8 @@ Mesh *create_line_mesh(const float3 start, const float3 delta, const int count) Mesh *mesh = BKE_mesh_new_nomain(count, count - 1, 0, 0, 0); BKE_id_material_eval_ensure_default_slot(&mesh->id); - MutableSpan<MVert> vertices = bke::mesh_vertices_for_write(*mesh); - MutableSpan<MEdge> edges = bke::mesh_edges_for_write(*mesh); + MutableSpan<MVert> vertices = mesh->vertices_for_write(); + MutableSpan<MEdge> edges = mesh->edges_for_write(); threading::parallel_invoke( 1024 < count, diff --git a/source/blender/nodes/geometry/nodes/node_geo_mesh_primitive_uv_sphere.cc b/source/blender/nodes/geometry/nodes/node_geo_mesh_primitive_uv_sphere.cc index 22ab6d85316..48a95bfcb49 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_mesh_primitive_uv_sphere.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_mesh_primitive_uv_sphere.cc @@ -301,10 +301,10 @@ static Mesh *create_uv_sphere_mesh(const float radius, const int segments, const sphere_corner_total(segments, rings), sphere_face_total(segments, rings)); BKE_id_material_eval_ensure_default_slot(&mesh->id); - MutableSpan<MVert> verts = bke::mesh_vertices_for_write(*mesh); - MutableSpan<MEdge> edges = bke::mesh_edges_for_write(*mesh); - MutableSpan<MPoly> polys = bke::mesh_polygons_for_write(*mesh); - MutableSpan<MLoop> loops = bke::mesh_loops_for_write(*mesh); + MutableSpan<MVert> verts = mesh->vertices_for_write(); + MutableSpan<MEdge> edges = mesh->edges_for_write(); + MutableSpan<MPoly> polys = mesh->polygons_for_write(); + MutableSpan<MLoop> loops = mesh->loops_for_write(); threading::parallel_invoke( 1024 < segments * rings, diff --git a/source/blender/nodes/geometry/nodes/node_geo_scale_elements.cc b/source/blender/nodes/geometry/nodes/node_geo_scale_elements.cc index 72a46fddb4f..fc467a9424d 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_scale_elements.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_scale_elements.cc @@ -158,10 +158,10 @@ static void scale_vertex_islands_uniformly(Mesh &mesh, const UniformScaleParams ¶ms, const GetVertexIndicesFn get_vertex_indices) { - MutableSpan<MVert> verts = bke::mesh_vertices_for_write(mesh); - const Span<MEdge> edges = bke::mesh_edges(mesh); - const Span<MPoly> polys = bke::mesh_polygons(mesh); - const Span<MLoop> loops = bke::mesh_loops(mesh); + MutableSpan<MVert> verts = mesh.vertices_for_write(); + const Span<MEdge> edges = mesh.edges(); + const Span<MPoly> polys = mesh.polygons(); + const Span<MLoop> loops = mesh.loops(); threading::parallel_for(islands.index_range(), 256, [&](const IndexRange range) { for (const int island_index : range) { @@ -199,10 +199,10 @@ static void scale_vertex_islands_on_axis(Mesh &mesh, const AxisScaleParams ¶ms, const GetVertexIndicesFn get_vertex_indices) { - MutableSpan<MVert> verts = bke::mesh_vertices_for_write(mesh); - const Span<MEdge> edges = bke::mesh_edges(mesh); - const Span<MPoly> polys = bke::mesh_polygons(mesh); - const Span<MLoop> loops = bke::mesh_loops(mesh); + MutableSpan<MVert> verts = mesh.vertices_for_write(); + const Span<MEdge> edges = mesh.edges(); + const Span<MPoly> polys = mesh.polygons(); + const Span<MLoop> loops = mesh.loops(); threading::parallel_for(islands.index_range(), 256, [&](const IndexRange range) { for (const int island_index : range) { @@ -245,8 +245,8 @@ static void scale_vertex_islands_on_axis(Mesh &mesh, static Vector<ElementIsland> prepare_face_islands(const Mesh &mesh, const IndexMask face_selection) { - const Span<MPoly> polys = bke::mesh_polygons(mesh); - const Span<MLoop> loops = bke::mesh_loops(mesh); + const Span<MPoly> polys = mesh.polygons(); + const Span<MLoop> loops = mesh.loops(); /* Use the disjoint set data structure to determine which vertices have to be scaled together. */ DisjointSet disjoint_set(mesh.totvert); @@ -342,7 +342,7 @@ static void scale_faces_uniformly(Mesh &mesh, const UniformScaleFields &fields) static Vector<ElementIsland> prepare_edge_islands(const Mesh &mesh, const IndexMask edge_selection) { - const Span<MEdge> edges = bke::mesh_edges(mesh); + const Span<MEdge> edges = mesh.edges(); /* Use the disjoint set data structure to determine which vertices have to be scaled together. */ DisjointSet disjoint_set(mesh.totvert); diff --git a/source/blender/nodes/geometry/nodes/node_geo_set_position.cc b/source/blender/nodes/geometry/nodes/node_geo_set_position.cc index 2495b3d5e0b..ce453a8ef32 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_set_position.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_set_position.cc @@ -36,7 +36,7 @@ static void set_computed_position_and_offset(GeometryComponent &component, switch (component.type()) { case GEO_COMPONENT_TYPE_MESH: { Mesh *mesh = static_cast<MeshComponent &>(component).get_for_write(); - MutableSpan<MVert> verts = bke::mesh_vertices_for_write(*mesh); + MutableSpan<MVert> verts = mesh->vertices_for_write(); if (in_positions.is_same(positions.varray)) { devirtualize_varray(in_offsets, [&](const auto in_offsets) { threading::parallel_for( diff --git a/source/blender/nodes/geometry/nodes/node_geo_transfer_attribute.cc b/source/blender/nodes/geometry/nodes/node_geo_transfer_attribute.cc index 69c71f074d6..6be37a02bd5 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_transfer_attribute.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_transfer_attribute.cc @@ -264,9 +264,9 @@ static void get_closest_mesh_corners(const Mesh &mesh, const MutableSpan<float> r_distances_sq, const MutableSpan<float3> r_positions) { - const Span<MVert> verts = bke::mesh_vertices(mesh); - const Span<MPoly> polys = bke::mesh_polygons(mesh); - const Span<MLoop> loops = bke::mesh_loops(mesh); + const Span<MVert> verts = mesh.vertices(); + const Span<MPoly> polys = mesh.polygons(); + const Span<MLoop> loops = mesh.loops(); BLI_assert(mesh.totloop > 0); Array<int> poly_indices(positions.size()); diff --git a/source/blender/nodes/geometry/nodes/node_geo_uv_pack_islands.cc b/source/blender/nodes/geometry/nodes/node_geo_uv_pack_islands.cc index 979e4c7bbec..5900e234220 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_uv_pack_islands.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_uv_pack_islands.cc @@ -37,9 +37,9 @@ static VArray<float3> construct_uv_gvarray(const Mesh &mesh, const float margin, const eAttrDomain domain) { - const Span<MVert> verts = bke::mesh_vertices(mesh); - const Span<MPoly> polys = bke::mesh_polygons(mesh); - const Span<MLoop> loops = bke::mesh_loops(mesh); + const Span<MVert> verts = mesh.vertices(); + const Span<MPoly> polys = mesh.polygons(); + const Span<MLoop> loops = mesh.loops(); bke::MeshFieldContext face_context{mesh, ATTR_DOMAIN_FACE}; FieldEvaluator face_evaluator{face_context, polys.size()}; diff --git a/source/blender/nodes/geometry/nodes/node_geo_uv_unwrap.cc b/source/blender/nodes/geometry/nodes/node_geo_uv_unwrap.cc index 96fd5a900ee..3095cac6a50 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_uv_unwrap.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_uv_unwrap.cc @@ -62,10 +62,10 @@ static VArray<float3> construct_uv_gvarray(const Mesh &mesh, const GeometryNodeUVUnwrapMethod method, const eAttrDomain domain) { - const Span<MVert> verts = bke::mesh_vertices(mesh); - const Span<MEdge> edges = bke::mesh_edges(mesh); - const Span<MPoly> polys = bke::mesh_polygons(mesh); - const Span<MLoop> loops = bke::mesh_loops(mesh); + const Span<MVert> verts = mesh.vertices(); + const Span<MEdge> edges = mesh.edges(); + const Span<MPoly> polys = mesh.polygons(); + const Span<MLoop> loops = mesh.loops(); bke::MeshFieldContext face_context{mesh, ATTR_DOMAIN_FACE}; FieldEvaluator face_evaluator{face_context, polys.size()}; diff --git a/source/blender/nodes/geometry/nodes/node_geo_volume_to_mesh.cc b/source/blender/nodes/geometry/nodes/node_geo_volume_to_mesh.cc index b1751fd0b4d..5788a744041 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_volume_to_mesh.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_volume_to_mesh.cc @@ -123,9 +123,9 @@ static Mesh *create_mesh_from_volume_grids(Span<openvdb::GridBase::ConstPtr> gri Mesh *mesh = BKE_mesh_new_nomain(vert_offset, 0, 0, loop_offset, poly_offset); BKE_id_material_eval_ensure_default_slot(&mesh->id); - MutableSpan<MVert> verts = bke::mesh_vertices_for_write(*mesh); - MutableSpan<MPoly> polys = bke::mesh_polygons_for_write(*mesh); - MutableSpan<MLoop> loops = bke::mesh_loops_for_write(*mesh); + MutableSpan<MVert> verts = mesh->vertices_for_write(); + MutableSpan<MPoly> polys = mesh->polygons_for_write(); + MutableSpan<MLoop> loops = mesh->loops_for_write(); for (const int i : grids.index_range()) { const bke::OpenVDBMeshData &data = mesh_data[i]; diff --git a/source/blender/render/intern/texture_margin.cc b/source/blender/render/intern/texture_margin.cc index ab3df0c65ba..eae849e1968 100644 --- a/source/blender/render/intern/texture_margin.cc +++ b/source/blender/render/intern/texture_margin.cc @@ -505,8 +505,8 @@ static void generate_margin(ImBuf *ibuf, totpoly = me->totpoly; totloop = me->totloop; totedge = me->totedge; - mpoly = bke::mesh_polygons(*me).data(); - mloop = bke::mesh_loops(*me).data(); + mpoly = me->polygons().data(); + mloop = me->loops().data(); if ((uv_layer == nullptr) || (uv_layer[0] == '\0')) { mloopuv = static_cast<const MLoopUV *>(CustomData_get_layer(&me->ldata, CD_MLOOPUV)); @@ -520,7 +520,7 @@ static void generate_margin(ImBuf *ibuf, tottri = poly_to_tri_count(me->totpoly, me->totloop); looptri_mem = static_cast<MLoopTri *>(MEM_mallocN(sizeof(*looptri) * tottri, __func__)); BKE_mesh_recalc_looptri( - mloop, mpoly, bke::mesh_vertices(*me).data(), me->totloop, me->totpoly, looptri_mem); + mloop, mpoly, me->vertices().data(), me->totloop, me->totpoly, looptri_mem); looptri = looptri_mem; } else { |