blender
/
blender
136
406
Fork 589
Code Issues 6.2k Pull Requests 751 Projects 19 Wiki Activity

Cleanup: Use C++ accessor functions in C++ code

This commit is contained in:
Hans Goudey 2023-01-19 16:30:28 -06:00
parent 932a211f6c
commit 22f2bf804c
19 changed files with 98 additions and 91 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

19
source/blender/blenkernel/intern/key.cc
View File

@ -2235,8 +2235,8 @@ void BKE_keyblock_mesh_calc_normals(const KeyBlock *kb,
BKE_keyblock_convert_to_mesh(kb, positions, mesh->totvert);
const MEdge *edges = BKE_mesh_edges(mesh);
const MPoly *polys = BKE_mesh_polys(mesh);
const int *corner_verts = BKE_mesh_corner_verts(mesh);
const int *corner_edges = BKE_mesh_corner_edges(mesh);
const blender::Span<int> corner_verts = mesh->corner_verts();
const blender::Span<int> corner_edges = mesh->corner_edges();
const bool loop_normals_needed = r_loop_normals != nullptr;
const bool vert_normals_needed = r_vert_normals != nullptr || loop_normals_needed;
@ -2259,13 +2259,18 @@ void BKE_keyblock_mesh_calc_normals(const KeyBlock *kb,
}
if (poly_normals_needed) {
BKE_mesh_calc_normals_poly(
positions, mesh->totvert, corner_verts, mesh->totloop, polys, mesh->totpoly, poly_normals);
BKE_mesh_calc_normals_poly(positions,
mesh->totvert,
corner_verts.data(),
mesh->totloop,
polys,
mesh->totpoly,
poly_normals);
}
if (vert_normals_needed) {
BKE_mesh_calc_normals_poly_and_vertex(positions,
mesh->totvert,
corner_verts,
corner_verts.data(),
mesh->totloop,
polys,
mesh->totpoly,
@ -2282,8 +2287,8 @@ void BKE_keyblock_mesh_calc_normals(const KeyBlock *kb,
mesh->totvert,
edges,
mesh->totedge,
corner_verts,
corner_edges,
corner_verts.data(),
corner_edges.data(),
r_loop_normals,
mesh->totloop,
polys,

2
source/blender/blenkernel/intern/mesh_merge_customdata.cc
View File

@ -117,7 +117,7 @@ void BKE_mesh_merge_customdata_for_apply_modifier(Mesh *me)
BKE_mesh_vert_loop_map_create(&vert_to_loop,
&vert_map_mem,
BKE_mesh_polys(me),
BKE_mesh_corner_verts(me),
me->corner_verts().data(),
me->totvert,
me->totpoly,
me->totloop);

18
source/blender/blenkernel/intern/mesh_mirror.cc
View File

@ -212,12 +212,8 @@ Mesh *BKE_mesh_mirror_apply_mirror_on_axis_for_modifier(MirrorModifierData *mmd,
memcpy(BKE_mesh_edges_for_write(result), BKE_mesh_edges(mesh), sizeof(MEdge) * mesh->totedge);
}
if (!CustomData_has_layer(&mesh->pdata, CD_MPOLY)) {
memcpy(BKE_mesh_corner_verts_for_write(result),
BKE_mesh_corner_verts(mesh),
sizeof(int) * mesh->totloop);
memcpy(BKE_mesh_corner_edges_for_write(result),
BKE_mesh_corner_edges(mesh),
sizeof(int) * mesh->totloop);
result->corner_verts_for_write().copy_from(mesh->corner_verts());
result->corner_edges_for_write().copy_from(mesh->corner_edges());
memcpy(BKE_mesh_polys_for_write(result), BKE_mesh_polys(mesh), sizeof(MPoly) * mesh->totpoly);
}
@ -317,7 +313,7 @@ Mesh *BKE_mesh_mirror_apply_mirror_on_axis_for_modifier(MirrorModifierData *mmd,
/* adjust mirrored poly loopstart indices, and reverse loop order (normals) */
mp = BKE_mesh_polys_for_write(result) + maxPolys;
int *corner_edges = BKE_mesh_corner_edges_for_write(result);
blender::MutableSpan<int> corner_edges = result->corner_edges_for_write();
for (i = 0; i < maxPolys; i++, mp++) {
int j, e;
@ -334,7 +330,7 @@ Mesh *BKE_mesh_mirror_apply_mirror_on_axis_for_modifier(MirrorModifierData *mmd,
1);
}
int *corner_edge_2 = corner_edges + mp->loopstart + maxLoops;
int *corner_edge_2 = &corner_edges[mp->loopstart + maxLoops];
e = corner_edge_2[0];
for (j = 0; j < mp->totloop - 1; j++) {
corner_edge_2[j] = corner_edge_2[j + 1];
@ -345,7 +341,7 @@ Mesh *BKE_mesh_mirror_apply_mirror_on_axis_for_modifier(MirrorModifierData *mmd,
}
/* adjust mirrored loop vertex and edge indices */
int *corner_verts = BKE_mesh_corner_verts_for_write(result);
blender::MutableSpan<int> corner_verts = result->corner_verts_for_write();
for (i = 0; i < maxLoops; i++) {
corner_verts[maxLoops + i] += maxVerts;
corner_edges[maxLoops + i] += maxEdges;
@ -419,8 +415,8 @@ Mesh *BKE_mesh_mirror_apply_mirror_on_axis_for_modifier(MirrorModifierData *mmd,
result->totvert,
BKE_mesh_edges(result),
result->totedge,
BKE_mesh_corner_verts(result),
BKE_mesh_corner_edges(result),
result->corner_verts().data(),
result->corner_edges().data(),
loop_normals,
totloop,
BKE_mesh_polys(result),

34
source/blender/blenkernel/intern/mesh_remap.cc
View File

@ -568,7 +568,7 @@ void BKE_mesh_remap_calc_verts_from_mesh(const int mode,
MREMAP_MODE_VERT_POLYINTERP_NEAREST,
MREMAP_MODE_VERT_POLYINTERP_VNORPROJ)) {
const MPoly *polys_src = BKE_mesh_polys(me_src);
const int *corner_verts_src = BKE_mesh_corner_verts(me_src);
const blender::Span<int> corner_verts_src = me_src->corner_verts();
float(*vcos_src)[3] = BKE_mesh_vert_coords_alloc(me_src, nullptr);
const float(*vert_normals_dst)[3] = BKE_mesh_vertex_normals_ensure(me_dst);
@ -597,7 +597,7 @@ void BKE_mesh_remap_calc_verts_from_mesh(const int mode,
const MLoopTri *lt = &treedata.looptri[rayhit.index];
const MPoly *mp_src = &polys_src[lt->poly];
const int sources_num = mesh_remap_interp_poly_data_get(mp_src,
corner_verts_src,
corner_verts_src.data(),
(const float(*)[3])vcos_src,
rayhit.co,
&tmp_buff_size,
@ -635,7 +635,7 @@ void BKE_mesh_remap_calc_verts_from_mesh(const int mode,
if (mode == MREMAP_MODE_VERT_POLY_NEAREST) {
int index;
mesh_remap_interp_poly_data_get(mp,
corner_verts_src,
corner_verts_src.data(),
(const float(*)[3])vcos_src,
nearest.co,
&tmp_buff_size,
@ -650,7 +650,7 @@ void BKE_mesh_remap_calc_verts_from_mesh(const int mode,
}
else if (mode == MREMAP_MODE_VERT_POLYINTERP_NEAREST) {
const int sources_num = mesh_remap_interp_poly_data_get(mp,
corner_verts_src,
corner_verts_src.data(),
(const float(*)[3])vcos_src,
nearest.co,
&tmp_buff_size,
@ -875,7 +875,7 @@ void BKE_mesh_remap_calc_edges_from_mesh(const int mode,
else if (mode == MREMAP_MODE_EDGE_POLY_NEAREST) {
const MEdge *edges_src = BKE_mesh_edges(me_src);
const MPoly *polys_src = BKE_mesh_polys(me_src);
const int *corner_edges_src = BKE_mesh_corner_edges(me_src);
const blender::Span<int> corner_edges_src = me_src->corner_edges();
float(*vcos_src)[3] = BKE_mesh_vert_coords_alloc(me_src, nullptr);
BKE_bvhtree_from_mesh_get(&treedata, me_src, BVHTREE_FROM_LOOPTRI, 2);
@ -1315,8 +1315,8 @@ void BKE_mesh_remap_calc_loops_from_mesh(const int mode,
float(*vcos_src)[3] = nullptr;
const MEdge *edges_src = BKE_mesh_edges(me_src);
const int num_edges_src = me_src->totedge;
const int *corner_verts_src = BKE_mesh_corner_verts(me_src);
const int *corner_edges_src = BKE_mesh_corner_edges(me_src);
const blender::Span<int> corner_verts_src = me_src->corner_verts();
const blender::Span<int> corner_edges_src = me_src->corner_edges();
const int num_loops_src = me_src->totloop;
const MPoly *polys_src = BKE_mesh_polys(me_src);
const int num_polys_src = me_src->totpoly;
@ -1408,7 +1408,7 @@ void BKE_mesh_remap_calc_loops_from_mesh(const int mode,
BKE_mesh_vert_loop_map_create(&vert_to_loop_map_src,
&vert_to_loop_map_src_buff,
polys_src,
corner_verts_src,
corner_verts_src.data(),
num_verts_src,
num_polys_src,
num_loops_src);
@ -1416,7 +1416,7 @@ void BKE_mesh_remap_calc_loops_from_mesh(const int mode,
BKE_mesh_vert_poly_map_create(&vert_to_poly_map_src,
&vert_to_poly_map_src_buff,
polys_src,
corner_verts_src,
corner_verts_src.data(),
num_verts_src,
num_polys_src,
num_loops_src);
@ -1430,7 +1430,7 @@ void BKE_mesh_remap_calc_loops_from_mesh(const int mode,
num_edges_src,
polys_src,
num_polys_src,
corner_edges_src,
corner_edges_src.data(),
num_loops_src);
if (use_from_vert) {
loop_to_poly_map_src = static_cast<int *>(
@ -1462,8 +1462,8 @@ void BKE_mesh_remap_calc_loops_from_mesh(const int mode,
num_edges_src,
polys_src,
num_polys_src,
corner_verts_src,
corner_edges_src,
corner_verts_src.data(),
corner_edges_src.data(),
num_loops_src,
&island_store);
@ -1500,8 +1500,8 @@ void BKE_mesh_remap_calc_loops_from_mesh(const int mode,
positions_src,
edge_to_poly_map_src,
num_edges_src,
corner_verts_src,
corner_edges_src,
corner_verts_src.data(),
corner_edges_src.data(),
polys_src,
num_polys_src,
&as_graphdata[tindex]);
@ -1562,7 +1562,7 @@ void BKE_mesh_remap_calc_loops_from_mesh(const int mode,
}
bvhtree_from_mesh_looptri_ex(&treedata[tindex],
positions_src,
corner_verts_src,
corner_verts_src.data(),
looptri_src,
num_looptri_src,
looptri_active,
@ -2048,7 +2048,7 @@ void BKE_mesh_remap_calc_loops_from_mesh(const int mode,
if (mode == MREMAP_MODE_LOOP_POLY_NEAREST) {
mesh_remap_interp_poly_data_get(mp_src,
corner_verts_src,
corner_verts_src.data(),
(const float(*)[3])vcos_src,
hit_co,
&buff_size_interp,
@ -2070,7 +2070,7 @@ void BKE_mesh_remap_calc_loops_from_mesh(const int mode,
else {
const int sources_num = mesh_remap_interp_poly_data_get(
mp_src,
corner_verts_src,
corner_verts_src.data(),
(const float(*)[3])vcos_src,
hit_co,
&buff_size_interp,

4
source/blender/draw/intern/draw_cache_extract_mesh_render_data.cc
View File

@ -549,8 +549,8 @@ MeshRenderData *mesh_render_data_create(Object *object,
mr->vert_positions = mr->me->vert_positions().data();
mr->medge = BKE_mesh_edges(mr->me);
mr->mpoly = BKE_mesh_polys(mr->me);
mr->corner_verts = BKE_mesh_corner_verts(mr->me);
mr->corner_edges = BKE_mesh_corner_edges(mr->me);
mr->corner_verts = mr->me->corner_verts().data();
mr->corner_edges = mr->me->corner_edges().data();
mr->v_origindex = static_cast<const int *>(CustomData_get_layer(&mr->me->vdata, CD_ORIGINDEX));
mr->e_origindex = static_cast<const int *>(CustomData_get_layer(&mr->me->edata, CD_ORIGINDEX));

8
source/blender/modifiers/intern/MOD_array.cc
View File

@ -281,8 +281,8 @@ static void mesh_merge_transform(Mesh *result,
float(*result_positions)[3] = BKE_mesh_vert_positions_for_write(result);
MEdge *result_edges = BKE_mesh_edges_for_write(result);
MPoly *result_polys = BKE_mesh_polys_for_write(result);
int *result_corner_verts = BKE_mesh_corner_verts_for_write(result);
int *result_corner_edges = BKE_mesh_corner_edges_for_write(result);
blender::MutableSpan<int> result_corner_verts = result->corner_verts_for_write();
blender::MutableSpan<int> result_corner_edges = result->corner_edges_for_write();
CustomData_copy_data(&cap_mesh->vdata, &result->vdata, 0, cap_verts_index, cap_nverts);
CustomData_copy_data(&cap_mesh->edata, &result->edata, 0, cap_edges_index, cap_nedges);
@ -538,8 +538,8 @@ static Mesh *arrayModifier_doArray(ArrayModifierData *amd,
float(*result_positions)[3] = BKE_mesh_vert_positions_for_write(result);
MEdge *result_edges = BKE_mesh_edges_for_write(result);
MPoly *result_polys = BKE_mesh_polys_for_write(result);
int *result_corner_verts = BKE_mesh_corner_verts_for_write(result);
int *result_corner_edges = BKE_mesh_corner_edges_for_write(result);
blender::MutableSpan<int> result_corner_verts = result->corner_verts_for_write();
blender::MutableSpan<int> result_corner_edges = result->corner_edges_for_write();
if (use_merge) {
/* Will need full_doubles_map for handling merge */

8
source/blender/modifiers/intern/MOD_build.cc
View File

@ -74,8 +74,8 @@ static Mesh *modifyMesh(ModifierData *md, const ModifierEvalContext *ctx, Mesh *
const int poly_src_num = mesh->totpoly;
const MEdge *medge_src = BKE_mesh_edges(mesh);
const MPoly *mpoly_src = BKE_mesh_polys(mesh);
const int *corner_verts_src = BKE_mesh_corner_verts(mesh);
const int *corner_edges_src = BKE_mesh_corner_edges(mesh);
const int *corner_verts_src = mesh->corner_verts().data();
const int *corner_edges_src = mesh->corner_edges().data();
int *vertMap = static_cast<int *>(MEM_malloc_arrayN(vert_src_num, sizeof(int), __func__));
int *edgeMap = static_cast<int *>(MEM_malloc_arrayN(edge_src_num, sizeof(int), __func__));
@ -198,8 +198,8 @@ static Mesh *modifyMesh(ModifierData *md, const ModifierEvalContext *ctx, Mesh *
mesh, BLI_ghash_len(vertHash), BLI_ghash_len(edgeHash), 0, loops_dst_num, faces_dst_num);
MEdge *result_edges = BKE_mesh_edges_for_write(result);
MPoly *result_polys = BKE_mesh_polys_for_write(result);
int *result_corner_verts = BKE_mesh_corner_verts_for_write(result);
int *result_corner_edges = BKE_mesh_corner_edges_for_write(result);
blender::MutableSpan<int> result_corner_verts = result->corner_verts_for_write();
blender::MutableSpan<int> result_corner_edges = result->corner_edges_for_write();
/* copy the vertices across */
GHASH_ITER (gh_iter, vertHash) {

8
source/blender/modifiers/intern/MOD_correctivesmooth.cc
View File

@ -129,7 +129,7 @@ static void mesh_get_boundaries(Mesh *mesh, float *smooth_weights)
{
const MEdge *medge = BKE_mesh_edges(mesh);
const MPoly *mpoly = BKE_mesh_polys(mesh);
const int *corner_edges = BKE_mesh_corner_edges(mesh);
const blender::Span<int> corner_edges = mesh->corner_edges();
const uint mpoly_num = (uint)mesh->totpoly;
const uint medge_num = (uint)mesh->totedge;
@ -440,7 +440,7 @@ static void calc_tangent_spaces(const Mesh *mesh,
const uint mpoly_num = (uint)mesh->totpoly;
const uint mvert_num = (uint)mesh->totvert;
const MPoly *mpoly = BKE_mesh_polys(mesh);
const int *corner_verts = BKE_mesh_corner_verts(mesh);
blender::Span<int> corner_verts = mesh->corner_verts();
uint i;
if (r_tangent_weights_per_vertex != nullptr) {
@ -521,7 +521,7 @@ static void calc_deltas(CorrectiveSmoothModifierData *csmd,
const float (*rest_coords)[3],
uint verts_num)
{
const int *corner_verts = BKE_mesh_corner_verts(mesh);
blender::Span<int> corner_verts = mesh->corner_verts();
const uint loops_num = (uint)mesh->totloop;
float(*smooth_vertex_coords)[3] = static_cast<float(*)[3]>(MEM_dupallocN(rest_coords));
@ -580,7 +580,7 @@ static void correctivesmooth_modifier_do(ModifierData *md,
((csmd->rest_source == MOD_CORRECTIVESMOOTH_RESTSOURCE_ORCO) &&
(((ID *)ob->data)->recalc & ID_RECALC_ALL));
const int *corner_verts = BKE_mesh_corner_verts(mesh);
blender::Span<int> corner_verts = mesh->corner_verts();
const uint loops_num = (uint)mesh->totloop;
bool use_only_smooth = (csmd->flag & MOD_CORRECTIVESMOOTH_ONLY_SMOOTH) != 0;

2
source/blender/modifiers/intern/MOD_displace.cc
View File

@ -312,7 +312,7 @@ static void displaceModifier_do(DisplaceModifierData *dmd,
vert_clnors = static_cast<float(*)[3]>(
MEM_malloc_arrayN(verts_num, sizeof(*vert_clnors), __func__));
BKE_mesh_normals_loop_to_vertex(verts_num,
BKE_mesh_corner_verts(mesh),
mesh->corner_verts().data(),
mesh->totloop,
(const float(*)[3])clnors,
vert_clnors);

2
source/blender/modifiers/intern/MOD_laplaciansmooth.cc
View File

@ -398,7 +398,7 @@ static void laplaciansmoothModifier_do(
}
sys->mpoly = BKE_mesh_polys(mesh);
sys->corner_verts = BKE_mesh_corner_verts(mesh);
sys->corner_verts = mesh->corner_verts().data();
sys->medges = BKE_mesh_edges(mesh);
sys->vertexCos = vertexCos;
sys->min_area = 0.00001f;

16
source/blender/modifiers/intern/MOD_normal_edit.cc
View File

@ -553,8 +553,8 @@ static Mesh *normalEditModifier_do(NormalEditModifierData *enmd,
const float(*positions)[3] = BKE_mesh_vert_positions(result);
const MEdge *edges = BKE_mesh_edges(result);
const MPoly *polys = BKE_mesh_polys(result);
int *corner_verts = BKE_mesh_corner_verts_for_write(result);
int *corner_edges = BKE_mesh_corner_edges_for_write(result);
blender::MutableSpan<int> corner_verts = result->corner_verts_for_write();
blender::MutableSpan<int> corner_edges = result->corner_edges_for_write();
int defgrp_index;
const MDeformVert *dvert;
@ -583,8 +583,8 @@ static Mesh *normalEditModifier_do(NormalEditModifierData *enmd,
verts_num,
edges,
edges_num,
corner_verts,
corner_edges,
corner_verts.data(),
corner_edges.data(),
loop_normals,
loops_num,
polys,
@ -624,8 +624,8 @@ static Mesh *normalEditModifier_do(NormalEditModifierData *enmd,
edges,
edges_num,
sharp_edges.span.data(),
corner_verts,
corner_edges,
corner_verts.data(),
corner_edges.data(),
loops_num,
polys,
polys_num);
@ -649,8 +649,8 @@ static Mesh *normalEditModifier_do(NormalEditModifierData *enmd,
edges,
edges_num,
sharp_edges.span.data(),
corner_verts,
corner_edges,
corner_verts.data(),
corner_edges.data(),
loops_num,
polys,
polys_num);

4
source/blender/modifiers/intern/MOD_ocean.cc
View File

@ -266,7 +266,7 @@ static Mesh *generate_ocean_geometry(OceanModifierData *omd, Mesh *mesh_orig, co
gogd.vert_positions = BKE_mesh_vert_positions_for_write(result);
gogd.mpolys = BKE_mesh_polys_for_write(result);
gogd.corner_verts = BKE_mesh_corner_verts_for_write(result);
gogd.corner_verts = result->corner_verts_for_write().data();
TaskParallelSettings settings;
BLI_parallel_range_settings_defaults(&settings);
@ -365,7 +365,7 @@ static Mesh *doOcean(ModifierData *md, const ModifierEvalContext *ctx, Mesh *mes
if (omd->flag & MOD_OCEAN_GENERATE_FOAM) {
const int polys_num = result->totpoly;
const int loops_num = result->totloop;
const int *corner_verts = BKE_mesh_corner_verts(result);
const blender::Span<int> corner_verts = result->corner_verts();
MLoopCol *mloopcols = static_cast<MLoopCol *>(CustomData_add_layer_named(&result->ldata,
CD_PROP_BYTE_COLOR,
CD_SET_DEFAULT,

8
source/blender/modifiers/intern/MOD_particleinstance.cc
View File

@ -317,13 +317,13 @@ static Mesh *modifyMesh(ModifierData *md, const ModifierEvalContext *ctx, Mesh *
result = BKE_mesh_new_nomain_from_template(mesh, maxvert, maxedge, 0, maxloop, maxpoly);
const MPoly *orig_mpoly = BKE_mesh_polys(mesh);
const int *orig_corner_verts = BKE_mesh_corner_verts(mesh);
const int *orig_corner_edges = BKE_mesh_corner_edges(mesh);
const blender::Span<int> orig_corner_verts = mesh->corner_verts();
const blender::Span<int> orig_corner_edges = mesh->corner_edges();
float(*positions)[3] = BKE_mesh_vert_positions_for_write(result);
MEdge *edges = BKE_mesh_edges_for_write(result);
MPoly *mpoly = BKE_mesh_polys_for_write(result);
int *corner_verts = BKE_mesh_corner_verts_for_write(result);
int *corner_edges = BKE_mesh_corner_edges_for_write(result);
blender::MutableSpan<int> corner_verts = result->corner_verts_for_write();
blender::MutableSpan<int> corner_edges = result->corner_edges_for_write();
MLoopCol *mloopcols_index = static_cast<MLoopCol *>(CustomData_get_layer_named_for_write(
&result->ldata, CD_PROP_BYTE_COLOR, pimd->index_layer_name, result->totloop));

4
source/blender/modifiers/intern/MOD_remesh.cc
View File

@ -63,7 +63,7 @@ static void init_dualcon_mesh(DualConInput *input, Mesh *mesh)
input->co_stride = sizeof(float[3]);
input->totco = mesh->totvert;
input->mloop = (DualConLoop)BKE_mesh_corner_verts(mesh);
input->mloop = (DualConLoop)mesh->corner_verts().data();
input->loop_stride = sizeof(int);
input->looptri = (DualConTri)BKE_mesh_runtime_looptri_ensure(mesh);
@ -96,7 +96,7 @@ static void *dualcon_alloc_output(int totvert, int totquad)
output->mesh = BKE_mesh_new_nomain(totvert, 0, 0, 4 * totquad, totquad);
output->vert_positions = BKE_mesh_vert_positions_for_write(output->mesh);
output->polys = BKE_mesh_polys_for_write(output->mesh);
output->corner_verts = BKE_mesh_corner_verts_for_write(output->mesh);
output->corner_verts = output->mesh->corner_verts_for_write().data();
return output;
}

8
source/blender/modifiers/intern/MOD_screw.cc
View File

@ -382,14 +382,14 @@ static Mesh *modifyMesh(ModifierData *md, const ModifierEvalContext *ctx, Mesh *
const float(*vert_positions_orig)[3] = BKE_mesh_vert_positions(mesh);
const MEdge *medge_orig = BKE_mesh_edges(mesh);
const MPoly *mpoly_orig = BKE_mesh_polys(mesh);
const int *corner_verts_orig = BKE_mesh_corner_verts(mesh);
const int *corner_edges_orig = BKE_mesh_corner_edges(mesh);
const blender::Span<int> corner_verts_orig = mesh->corner_verts();
const blender::Span<int> corner_edges_orig = mesh->corner_edges();
float(*vert_positions_new)[3] = BKE_mesh_vert_positions_for_write(result);
MEdge *medge_new = BKE_mesh_edges_for_write(result);
MPoly *mpoly_new = BKE_mesh_polys_for_write(result);
int *corner_verts_new = BKE_mesh_corner_verts_for_write(result);
int *corner_edges_new = BKE_mesh_corner_edges_for_write(result);
blender::MutableSpan<int> corner_verts_new = result->corner_verts_for_write();
blender::MutableSpan<int> corner_edges_new = result->corner_edges_for_write();
if (!CustomData_has_layer(&result->pdata, CD_ORIGINDEX)) {
CustomData_add_layer(&result->pdata, CD_ORIGINDEX, CD_SET_DEFAULT, nullptr, int(maxPolys));

14
source/blender/modifiers/intern/MOD_solidify_extrude.cc
View File

@ -63,7 +63,7 @@ static void mesh_calc_hq_normal(Mesh *mesh,
const int edges_num = mesh->totedge;
const int polys_num = mesh->totpoly;
const MPoly *mpoly = BKE_mesh_polys(mesh);
const int *corner_edges = BKE_mesh_corner_edges(mesh);
const blender::Span<int> corner_edges = mesh->corner_edges();
const MEdge *medge = BKE_mesh_edges(mesh);
const MPoly *mp = mpoly;
@ -212,8 +212,8 @@ Mesh *MOD_solidify_extrude_modifyMesh(ModifierData *md, const ModifierEvalContex
const float(*orig_vert_positions)[3] = BKE_mesh_vert_positions(mesh);
const MEdge *orig_medge = BKE_mesh_edges(mesh);
const MPoly *orig_mpoly = BKE_mesh_polys(mesh);
const int *orig_corner_verts = BKE_mesh_corner_verts(mesh);
const int *orig_corner_edges = BKE_mesh_corner_edges(mesh);
const blender::Span<int> orig_corner_verts = mesh->corner_verts();
const blender::Span<int> orig_corner_edges = mesh->corner_edges();
if (need_poly_normals) {
/* calculate only face normals */
@ -336,8 +336,8 @@ Mesh *MOD_solidify_extrude_modifyMesh(ModifierData *md, const ModifierEvalContex
float(*vert_positions)[3] = BKE_mesh_vert_positions_for_write(result);
MEdge *medge = BKE_mesh_edges_for_write(result);
MPoly *mpoly = BKE_mesh_polys_for_write(result);
int *corner_verts = BKE_mesh_corner_verts_for_write(result);
int *corner_edges = BKE_mesh_corner_edges_for_write(result);
blender::MutableSpan<int> corner_verts = result->corner_verts_for_write();
blender::MutableSpan<int> corner_edges = result->corner_edges_for_write();
if (do_shell) {
CustomData_copy_data(&mesh->vdata, &result->vdata, 0, 0, int(verts_num));
@ -1073,8 +1073,8 @@ Mesh *MOD_solidify_extrude_modifyMesh(ModifierData *md, const ModifierEvalContex
/* faces */
MPoly *mp = mpoly + (polys_num * stride);
int *new_corner_verts = corner_verts + (loops_num * stride);
int *new_corner_edges = corner_edges + (loops_num * stride);
int *new_corner_verts = &corner_verts[loops_num * stride];
int *new_corner_edges = &corner_edges[loops_num * stride];
j = 0;
for (i = 0; i < newPolys; i++, mp++) {
uint eidx = new_edge_arr[i];

8
source/blender/modifiers/intern/MOD_solidify_nonmanifold.cc
View File

@ -185,8 +185,8 @@ Mesh *MOD_solidify_nonmanifold_modifyMesh(ModifierData *md,
const float(*orig_vert_positions)[3] = BKE_mesh_vert_positions(mesh);
const MEdge *orig_medge = BKE_mesh_edges(mesh);
const MPoly *orig_mpoly = BKE_mesh_polys(mesh);
const int *orig_corner_verts = BKE_mesh_corner_verts(mesh);
const int *orig_corner_edges = BKE_mesh_corner_edges(mesh);
const blender::Span<int> orig_corner_verts = mesh->corner_verts();
const blender::Span<int> orig_corner_edges = mesh->corner_edges();
/* These might be null. */
const float *orig_vert_bweight = static_cast<const float *>(
@ -1989,8 +1989,8 @@ Mesh *MOD_solidify_nonmanifold_modifyMesh(ModifierData *md,
float(*vert_positions)[3] = BKE_mesh_vert_positions_for_write(result);
MEdge *medge = BKE_mesh_edges_for_write(result);
MPoly *mpoly = BKE_mesh_polys_for_write(result);
int *corner_verts = BKE_mesh_corner_verts_for_write(result);
int *corner_edges = BKE_mesh_corner_edges_for_write(result);
blender::MutableSpan<int> corner_verts = result->corner_verts_for_write();
blender::MutableSpan<int> corner_edges = result->corner_edges_for_write();
int *origindex_edge = static_cast<int *>(
CustomData_get_layer_for_write(&result->edata, CD_ORIGINDEX, result->totedge));

18
source/blender/render/intern/bake.cc
View File

@ -462,7 +462,7 @@ static TriTessFace *mesh_calc_tri_tessface(Mesh *me, bool tangent, Mesh *me_eval
const float(*positions)[3] = BKE_mesh_vert_positions(me);
const MPoly *polys = BKE_mesh_polys(me);
const int *corner_verts = BKE_mesh_corner_verts(me);
const blender::Span<int> corner_verts = me->corner_verts();
looptri = static_cast<MLoopTri *>(MEM_mallocN(sizeof(*looptri) * tottri, __func__));
triangles = static_cast<TriTessFace *>(MEM_callocN(sizeof(TriTessFace) * tottri, __func__));
@ -473,11 +473,17 @@ static TriTessFace *mesh_calc_tri_tessface(Mesh *me, bool tangent, Mesh *me_eval
const bool calculate_normal = precomputed_normals ? false : true;
if (precomputed_normals != nullptr) {
BKE_mesh_recalc_looptri_with_normals(
corner_verts, polys, positions, me->totloop, me->totpoly, looptri, precomputed_normals);
BKE_mesh_recalc_looptri_with_normals(corner_verts.data(),
polys,
positions,
me->totloop,
me->totpoly,
looptri,
precomputed_normals);
}
else {
BKE_mesh_recalc_looptri(corner_verts, polys, positions, me->totloop, me->totpoly, looptri);
BKE_mesh_recalc_looptri(
corner_verts.data(), polys, positions, me->totloop, me->totpoly, looptri);
}
const TSpace *tspace = nullptr;
@ -747,8 +753,8 @@ void RE_bake_pixels_populate(Mesh *me,
const float(*positions)[3] = BKE_mesh_vert_positions(me);
const MPoly *polys = BKE_mesh_polys(me);
const int *corner_verts = BKE_mesh_corner_verts(me);
BKE_mesh_recalc_looptri(corner_verts, polys, positions, me->totloop, me->totpoly, looptri);
const blender::Span<int> corner_verts = me->corner_verts();
BKE_mesh_recalc_looptri(corner_verts.data(), polys, positions, me->totloop, me->totpoly, looptri);
const int *material_indices = BKE_mesh_material_indices(me);
const int materials_num = targets->materials_num;

4
source/blender/render/intern/multires_bake.cc
View File

@ -494,10 +494,10 @@ static void do_multires_bake(MultiresBakeRender *bkr,
memcpy(BKE_mesh_polys_for_write(temp_mesh),
dm->getPolyArray(dm),
temp_mesh->totpoly * sizeof(MPoly));
memcpy(BKE_mesh_corner_verts_for_write(temp_mesh),
memcpy(temp_mesh->corner_verts_for_write().data(),
dm->getCornerVertArray(dm),
temp_mesh->totloop * sizeof(int));
memcpy(BKE_mesh_corner_edges_for_write(temp_mesh),
memcpy(temp_mesh->corner_edges_for_write().data(),
dm->getCornerEdgeArray(dm),
temp_mesh->totloop * sizeof(int));
const float(*vert_normals)[3] = BKE_mesh_vertex_normals_ensure(temp_mesh);