archive/blender-archive
Archived
1
1
Fork 0
Code Pull Requests Packages Activity

Cleanup: Access mesh data with spans

Browse Source 
Similar to cb62ab5b28, in newly C++ files.
This commit is contained in:
Hans Goudey
2023-03-01 12:47:55 -05:00
parent 7ca63d40dc
commit d939ecc46f
8 changed files with 158 additions and 207 deletions
Download Patch File Download Diff File Expand all files Collapse all files

10
source/blender/blenkernel/intern/data_transfer.cc
View File

@@ -421,8 +421,8 @@ static void data_transfer_dtdata_type_postprocess(Object * /*ob_src*/,
const int num_verts_dst = me_dst->totvert;
const blender::Span<MEdge> edges_dst = me_dst->edges();
blender::MutableSpan<MPoly> polys_dst = me_dst->polys_for_write();
MLoop *loops_dst = BKE_mesh_loops_for_write(me_dst);
const int num_loops_dst = me_dst->totloop;
blender::MutableSpan<MLoop> loops_dst = me_dst->loops_for_write();
CustomData *ldata_dst = &me_dst->ldata;
const float(*poly_nors_dst)[3] = BKE_mesh_poly_normals_ensure(me_dst);
@@ -433,7 +433,7 @@ static void data_transfer_dtdata_type_postprocess(Object * /*ob_src*/,
if (!custom_nors_dst) {
custom_nors_dst = static_cast<short(*)[2]>(CustomData_add_layer(
ldata_dst, CD_CUSTOMLOOPNORMAL, CD_SET_DEFAULT, nullptr, num_loops_dst));
ldata_dst, CD_CUSTOMLOOPNORMAL, CD_SET_DEFAULT, nullptr, loops_dst.size()));
}
bke::MutableAttributeAccessor attributes = me_dst->attributes_for_write();
@@ -446,9 +446,9 @@ static void data_transfer_dtdata_type_postprocess(Object * /*ob_src*/,
num_verts_dst,
edges_dst.data(),
edges_dst.size(),
loops_dst,
loops_dst.data(),
loop_nors_dst,
num_loops_dst,
loops_dst.size(),
polys_dst.data(),
poly_nors_dst,
polys_dst.size(),

66
source/blender/blenkernel/intern/fluid.cc
View File

@@ -938,7 +938,7 @@ struct ObstaclesFromDMData {
FluidEffectorSettings *fes;
const float (*vert_positions)[3];
const MLoop *mloop;
blender::Span<MLoop> loops;
blender::Span<MLoopTri> looptris;
BVHTreeFromMesh *tree;
@@ -973,7 +973,7 @@ static void obstacles_from_mesh_task_cb(void *__restrict userdata,
/* Calculate object velocities. Result in bb->velocity. */
update_velocities(data->fes,
data->vert_positions,
data->mloop,
data->loops.data(),
data->looptris.data(),
bb->velocity,
index,
@@ -1008,7 +1008,7 @@ static void obstacles_from_mesh(Object *coll_ob,
int min[3], max[3], res[3];
const MLoop *mloop = BKE_mesh_loops(me);
const blender::Span<MLoop> loops = me->loops();
const blender::Span<MLoopTri> looptris = me->looptris();
numverts = me->totvert;
@@ -1072,7 +1072,7 @@ static void obstacles_from_mesh(Object *coll_ob,
ObstaclesFromDMData data{};
data.fes = fes;
data.vert_positions = positions;
data.mloop = mloop;
data.loops = loops;
data.looptris = looptris;
data.tree = &tree_data;
data.bb = bb;
@@ -1981,7 +1981,7 @@ struct EmitFromDMData {
const float (*vert_positions)[3];
const float (*vert_normals)[3];
const MLoop *mloop;
blender::Span<MLoop> loops;
blender::Span<MLoopTri> looptris;
const float (*mloopuv)[2];
const MDeformVert *dvert;
@@ -2015,7 +2015,7 @@ static void emit_from_mesh_task_cb(void *__restrict userdata,
sample_mesh(data->ffs,
data->vert_positions,
data->vert_normals,
data->mloop,
data->loops.data(),
data->looptris.data(),
data->mloopuv,
bb->influence,
@@ -2065,7 +2065,7 @@ static void emit_from_mesh(
Mesh *me = BKE_mesh_copy_for_eval(ffs->mesh, false);
float(*positions)[3] = BKE_mesh_vert_positions_for_write(me);
const MLoop *mloop = BKE_mesh_loops(me);
const blender::Span<MLoop> loops = me->loops();
const blender::Span<MLoopTri> looptris = me->looptris();
const int numverts = me->totvert;
const MDeformVert *dvert = BKE_mesh_deform_verts(me);
@@ -2142,7 +2142,7 @@ static void emit_from_mesh(
data.ffs = ffs;
data.vert_positions = positions;
data.vert_normals = vert_normals;
data.mloop = mloop;
data.loops = loops;
data.looptris = looptris;
data.mloopuv = mloopuv;
data.dvert = dvert;
@@ -3208,8 +3208,6 @@ static Mesh *create_liquid_geometry(FluidDomainSettings *fds,
Object *ob)
{
Mesh *me;
MPoly *mpolys;
MLoop *mloops;
float min[3];
float max[3];
float size[3];
@@ -3252,8 +3250,8 @@ static Mesh *create_liquid_geometry(FluidDomainSettings *fds,
return nullptr;
}
float(*positions)[3] = BKE_mesh_vert_positions_for_write(me);
mpolys = BKE_mesh_polys_for_write(me);
mloops = BKE_mesh_loops_for_write(me);
blender::MutableSpan<MPoly> polys = me->polys_for_write();
blender::MutableSpan<MLoop> loops = me->loops_for_write();
/* Get size (dimension) but considering scaling. */
copy_v3_v3(cell_size_scaled, fds->cell_size);
@@ -3339,17 +3337,17 @@ static Mesh *create_liquid_geometry(FluidDomainSettings *fds,
int *material_indices = BKE_mesh_material_indices_for_write(me);
/* Loop for triangles. */
for (i = 0; i < num_faces; i++, mpolys++, mloops += 3) {
for (const int i : polys.index_range()) {
/* Initialize from existing face. */
material_indices[i] = mp_mat_nr;
mpolys->flag = mp_flag;
polys[i].flag = mp_flag;
mpolys->loopstart = i * 3;
mpolys->totloop = 3;
polys[i].loopstart = i * 3;
polys[i].totloop = 3;
mloops[0].v = manta_liquid_get_triangle_x_at(fds->fluid, i);
mloops[1].v = manta_liquid_get_triangle_y_at(fds->fluid, i);
mloops[2].v = manta_liquid_get_triangle_z_at(fds->fluid, i);
loops[i * 3 + 0].v = manta_liquid_get_triangle_x_at(fds->fluid, i);
loops[i * 3 + 1].v = manta_liquid_get_triangle_y_at(fds->fluid, i);
loops[i * 3 + 2].v = manta_liquid_get_triangle_z_at(fds->fluid, i);
# ifdef DEBUG_PRINT
/* Debugging: Print mesh faces. */
printf("mloops[0].v: %d, mloops[1].v: %d, mloops[2].v: %d\n",
@@ -3367,8 +3365,6 @@ static Mesh *create_liquid_geometry(FluidDomainSettings *fds,
static Mesh *create_smoke_geometry(FluidDomainSettings *fds, Mesh *orgmesh, Object *ob)
{
Mesh *result;
MPoly *mpolys;
MLoop *mloops;
float min[3];
float max[3];
float *co;
@@ -3387,8 +3383,8 @@ static Mesh *create_smoke_geometry(FluidDomainSettings *fds, Mesh *orgmesh, Obje
result = BKE_mesh_new_nomain(num_verts, 0, num_faces * 4, num_faces);
float(*positions)[3] = BKE_mesh_vert_positions_for_write(result);
mpolys = BKE_mesh_polys_for_write(result);
mloops = BKE_mesh_loops_for_write(result);
blender::MutableSpan<MPoly> polys = result->polys_for_write();
blender::MutableSpan<MLoop> loops = result->loops_for_write();
if (num_verts) {
/* Volume bounds. */
@@ -3433,8 +3429,8 @@ static Mesh *create_smoke_geometry(FluidDomainSettings *fds, Mesh *orgmesh, Obje
/* Create faces. */
/* Top side. */
mp = &mpolys[0];
ml = &mloops[0 * 4];
mp = &polys[0];
ml = &loops[0 * 4];
mp->loopstart = 0 * 4;
mp->totloop = 4;
ml[0].v = 0;
@@ -3442,8 +3438,8 @@ static Mesh *create_smoke_geometry(FluidDomainSettings *fds, Mesh *orgmesh, Obje
ml[2].v = 2;
ml[3].v = 3;
/* Right side. */
mp = &mpolys[1];
ml = &mloops[1 * 4];
mp = &polys[1];
ml = &loops[1 * 4];
mp->loopstart = 1 * 4;
mp->totloop = 4;
ml[0].v = 2;
@@ -3451,8 +3447,8 @@ static Mesh *create_smoke_geometry(FluidDomainSettings *fds, Mesh *orgmesh, Obje
ml[2].v = 5;
ml[3].v = 6;
/* Bottom side. */
mp = &mpolys[2];
ml = &mloops[2 * 4];
mp = &polys[2];
ml = &loops[2 * 4];
mp->loopstart = 2 * 4;
mp->totloop = 4;
ml[0].v = 7;
@@ -3460,8 +3456,8 @@ static Mesh *create_smoke_geometry(FluidDomainSettings *fds, Mesh *orgmesh, Obje
ml[2].v = 5;
ml[3].v = 4;
/* Left side. */
mp = &mpolys[3];
ml = &mloops[3 * 4];
mp = &polys[3];
ml = &loops[3 * 4];
mp->loopstart = 3 * 4;
mp->totloop = 4;
ml[0].v = 0;
@@ -3469,8 +3465,8 @@ static Mesh *create_smoke_geometry(FluidDomainSettings *fds, Mesh *orgmesh, Obje
ml[2].v = 7;
ml[3].v = 4;
/* Front side. */
mp = &mpolys[4];
ml = &mloops[4 * 4];
mp = &polys[4];
ml = &loops[4 * 4];
mp->loopstart = 4 * 4;
mp->totloop = 4;
ml[0].v = 3;
@@ -3478,8 +3474,8 @@ static Mesh *create_smoke_geometry(FluidDomainSettings *fds, Mesh *orgmesh, Obje
ml[2].v = 6;
ml[3].v = 7;
/* Back side. */
mp = &mpolys[5];
ml = &mloops[5 * 4];
mp = &polys[5];
ml = &loops[5 * 4];
mp->loopstart = 5 * 4;
mp->totloop = 4;
ml[0].v = 1;

2
source/blender/blenloader/intern/versioning_290.cc
View File

@@ -828,7 +828,7 @@ void blo_do_versions_290(FileData *fd, Library * /*lib*/, Main *bmain)
me->totedge,
(MFace *)CustomData_get_layer_for_write(&me->fdata, CD_MFACE, me->totface),
me->totface,
BKE_mesh_loops_for_write(me),
me->loops_for_write().data(),
polys.size(),
polys.data(),
me->totpoly,

8
source/blender/editors/mesh/mesh_mirror.cc
View File

@@ -204,11 +204,9 @@ void ED_mesh_mirrtopo_init(BMEditMesh *em,
}
else {
totedge = me->totedge;
medge = BKE_mesh_edges(me);
for (a = 0, med = medge; a < totedge; a++, med++) {
const uint i1 = med->v1, i2 = med->v2;
topo_hash[i1]++;
topo_hash[i2]++;
for (const MEdge &edge : me->edges()) {
topo_hash[edge.v1]++;
topo_hash[edge.v2]++;
}
}

74
source/blender/modifiers/intern/MOD_laplaciandeform.cc
View File

@@ -139,35 +139,34 @@ static void deleteLaplacianSystem(LaplacianSystem *sys)
}
static void createFaceRingMap(const int mvert_tot,
const MLoopTri *mlooptri,
const int mtri_tot,
const MLoop *mloop,
blender::Span<MLoopTri> looptris,
blender::Span<MLoop> loops,
MeshElemMap **r_map,
int **r_indices)
{
int i, j, indices_num = 0;
int indices_num = 0;
int *indices, *index_iter;
MeshElemMap *map = MEM_cnew_array<MeshElemMap>(mvert_tot, __func__);
const MLoopTri *mlt;
for (i = 0, mlt = mlooptri; i < mtri_tot; i++, mlt++) {
for (j = 0; j < 3; j++) {
const uint v_index = mloop[mlt->tri[j]].v;
for (const int i : looptris.index_range()) {
const MLoopTri &mlt = looptris[i];
for (int j = 0; j < 3; j++) {
const uint v_index = loops[mlt.tri[j]].v;
map[v_index].count++;
indices_num++;
}
}
indices = MEM_cnew_array<int>(indices_num, __func__);
index_iter = indices;
for (i = 0; i < mvert_tot; i++) {
for (int i = 0; i < mvert_tot; i++) {
map[i].indices = index_iter;
index_iter += map[i].count;
map[i].count = 0;
}
for (i = 0, mlt = mlooptri; i < mtri_tot; i++, mlt++) {
for (j = 0; j < 3; j++) {
const uint v_index = mloop[mlt->tri[j]].v;
for (const int i : looptris.index_range()) {
const MLoopTri &mlt = looptris[i];
for (int j = 0; j < 3; j++) {
const uint v_index = loops[mlt.tri[j]].v;
map[v_index].indices[map[v_index].count] = i;
map[v_index].count++;
}
@@ -177,19 +176,17 @@ static void createFaceRingMap(const int mvert_tot,
}
static void createVertRingMap(const int mvert_tot,
const MEdge *medge,
const int medge_tot,
const blender::Span<MEdge> edges,
MeshElemMap **r_map,
int **r_indices)
{
MeshElemMap *map = MEM_cnew_array<MeshElemMap>(mvert_tot, __func__);
int i, vid[2], indices_num = 0;
int *indices, *index_iter;
const MEdge *me;
for (i = 0, me = medge; i < medge_tot; i++, me++) {
vid[0] = me->v1;
vid[1] = me->v2;
for (const int i : edges.index_range()) {
vid[0] = edges[i].v1;
vid[1] = edges[i].v2;
map[vid[0]].count++;
map[vid[1]].count++;
indices_num += 2;
@@ -201,9 +198,9 @@ static void createVertRingMap(const int mvert_tot,
index_iter += map[i].count;
map[i].count = 0;
}
for (i = 0, me = medge; i < medge_tot; i++, me++) {
vid[0] = me->v1;
vid[1] = me->v2;
for (const int i : edges.index_range()) {
vid[0] = edges[i].v1;
vid[1] = edges[i].v2;
map[vid[0]].indices[map[vid[0]].count] = vid[1];
map[vid[0]].count++;
map[vid[1]].indices[map[vid[1]].count] = vid[0];
@@ -533,8 +530,6 @@ static void initSystem(
if (isValidVertexGroup(lmd, ob, mesh)) {
int *index_anchors = static_cast<int *>(
MEM_malloc_arrayN(verts_num, sizeof(int), __func__)); /* over-alloc */
const MLoopTri *mlooptri;
const MLoop *mloop;
STACK_DECLARE(index_anchors);
@@ -552,13 +547,13 @@ static void initSystem(
}
}
const blender::Span<MEdge> edges = mesh->edges();
const blender::Span<MLoop> loops = mesh->loops();
const blender::Span<MLoopTri> looptris = mesh->looptris();
anchors_num = STACK_SIZE(index_anchors);
lmd->cache_system = initLaplacianSystem(verts_num,
mesh->totedge,
BKE_mesh_runtime_looptri_len(mesh),
anchors_num,
lmd->anchor_grp_name,
lmd->repeat);
lmd->cache_system = initLaplacianSystem(
verts_num, edges.size(), looptris.size(), anchors_num, lmd->anchor_grp_name, lmd->repeat);
sys = (LaplacianSystem *)lmd->cache_system;
memcpy(sys->index_anchors, index_anchors, sizeof(int) * anchors_num);
memcpy(sys->co, vertexCos, sizeof(float[3]) * verts_num);
@@ -567,22 +562,13 @@ static void initSystem(
memcpy(lmd->vertexco, vertexCos, sizeof(float[3]) * verts_num);
lmd->verts_num = verts_num;
createFaceRingMap(mesh->totvert,
BKE_mesh_runtime_looptri_ensure(mesh),
BKE_mesh_runtime_looptri_len(mesh),
BKE_mesh_loops(mesh),
&sys->ringf_map,
&sys->ringf_indices);
createVertRingMap(
mesh->totvert, BKE_mesh_edges(mesh), mesh->totedge, &sys->ringv_map, &sys->ringv_indices);
mlooptri = BKE_mesh_runtime_looptri_ensure(mesh);
mloop = BKE_mesh_loops(mesh);
createFaceRingMap(mesh->totvert, looptris, loops, &sys->ringf_map, &sys->ringf_indices);
createVertRingMap(mesh->totvert, edges, &sys->ringv_map, &sys->ringv_indices);
for (i = 0; i < sys->tris_num; i++) {
sys->tris[i][0] = mloop[mlooptri[i].tri[0]].v;
sys->tris[i][1] = mloop[mlooptri[i].tri[1]].v;
sys->tris[i][2] = mloop[mlooptri[i].tri[2]].v;
sys->tris[i][0] = loops[looptris[i].tri[0]].v;
sys->tris[i][1] = loops[looptris[i].tri[1]].v;
sys->tris[i][2] = loops[looptris[i].tri[2]].v;
}
}
}

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

@@ -125,10 +125,9 @@ static void mix_normals(const float mix_factor,
const float mix_limit,
const short mix_mode,
const int verts_num,
const MLoop *mloop,
const blender::Span<MLoop> loops,
float (*nos_old)[3],
float (*nos_new)[3],
const int loops_num)
float (*nos_new)[3])
{
/* Mix with org normals... */
float *facs = nullptr, *wfac;
@@ -136,12 +135,12 @@ static void mix_normals(const float mix_factor,
int i;
if (dvert) {
facs = static_cast<float *>(MEM_malloc_arrayN(size_t(loops_num), sizeof(*facs), __func__));
facs = static_cast<float *>(MEM_malloc_arrayN(size_t(loops.size()), sizeof(*facs), __func__));
BKE_defvert_extract_vgroup_to_loopweights(
dvert, defgrp_index, verts_num, mloop, loops_num, use_invert_vgroup, facs);
dvert, defgrp_index, verts_num, loops.data(), loops.size(), use_invert_vgroup, facs);
}
for (i = loops_num, no_new = nos_new, no_old = nos_old, wfac = facs; i--;
for (i = loops.size(), no_new = nos_new, no_old = nos_old, wfac = facs; i--;
no_new++, no_old++, wfac++) {
const float fac = facs ? *wfac * mix_factor : mix_factor;
@@ -174,25 +173,24 @@ static void mix_normals(const float mix_factor,
/* Check poly normals and new loop normals are compatible, otherwise flip polygons
* (and invert matching poly normals). */
static bool polygons_check_flip(MLoop *mloop,
static bool polygons_check_flip(blender::MutableSpan<MLoop> loops,
float (*nos)[3],
CustomData *ldata,
const int totloop,
const MPoly *mpoly,
float (*poly_normals)[3],
const int polys_num)
const blender::Span<MPoly> polys,
float (*poly_normals)[3])
{
const MPoly *mp;
MDisps *mdisp = static_cast<MDisps *>(CustomData_get_layer_for_write(ldata, CD_MDISPS, totloop));
MDisps *mdisp = static_cast<MDisps *>(
CustomData_get_layer_for_write(ldata, CD_MDISPS, loops.size()));
int i;
bool flipped = false;
for (i = 0, mp = mpoly; i < polys_num; i++, mp++) {
for (const int i : polys.index_range()) {
const MPoly &poly = polys[i];
float norsum[3] = {0.0f};
float(*no)[3];
int j;
for (j = 0, no = &nos[mp->loopstart]; j < mp->totloop; j++, no++) {
for (j = 0, no = &nos[poly.loopstart]; j < poly.totloop; j++, no++) {
add_v3_v3(norsum, *no);
}
@@ -202,7 +200,7 @@ static bool polygons_check_flip(MLoop *mloop,
/* If average of new loop normals is opposed to polygon normal, flip polygon. */
if (dot_v3v3(poly_normals[i], norsum) < 0.0f) {
BKE_mesh_polygon_flip_ex(mp, mloop, ldata, nos, mdisp, true);
BKE_mesh_polygon_flip_ex(&poly, loops.data(), ldata, nos, mdisp, true);
negate_v3(poly_normals[i]);
flipped = true;
}
@@ -226,13 +224,10 @@ static void normalEditModifier_do_radial(NormalEditModifierData *enmd,
const bool use_invert_vgroup,
const float (*vert_positions)[3],
const int verts_num,
const MEdge *medge,
const int edges_num,
const blender::Span<MEdge> edges,
bool *sharp_edges,
MLoop *mloop,
const int loops_num,
const MPoly *mpoly,
const int polys_num)
blender::MutableSpan<MLoop> loops,
const blender::Span<MPoly> polys)
{
Object *ob_target = enmd->target;
@@ -242,7 +237,7 @@ static void normalEditModifier_do_radial(NormalEditModifierData *enmd,
float(*cos)[3] = static_cast<float(*)[3]>(
MEM_malloc_arrayN(size_t(verts_num), sizeof(*cos), __func__));
float(*nos)[3] = static_cast<float(*)[3]>(
MEM_malloc_arrayN(size_t(loops_num), sizeof(*nos), __func__));
MEM_malloc_arrayN(size_t(loops.size()), sizeof(*nos), __func__));
float size[3];
BLI_bitmap *done_verts = BLI_BITMAP_NEW(size_t(verts_num), __func__);
@@ -289,7 +284,7 @@ static void normalEditModifier_do_radial(NormalEditModifierData *enmd,
float(*no)[3];
/* We reuse cos to now store the ellipsoid-normal of the verts! */
for (i = loops_num, ml = mloop, no = nos; i--; ml++, no++) {
for (i = loops.size(), ml = loops.data(), no = nos; i--; ml++, no++) {
const int vidx = ml->v;
float *co = cos[vidx];
@@ -320,19 +315,14 @@ static void normalEditModifier_do_radial(NormalEditModifierData *enmd,
mix_limit,
mix_mode,
verts_num,
mloop,
loops,
loop_normals,
nos,
loops_num);
nos);
}
if (do_polynors_fix && polygons_check_flip(mloop,
nos,
&mesh->ldata,
mesh->totloop,
mpoly,
BKE_mesh_poly_normals_for_write(mesh),
polys_num)) {
if (do_polynors_fix &&
polygons_check_flip(
loops, nos, &mesh->ldata, polys, BKE_mesh_poly_normals_for_write(mesh))) {
/* We need to recompute vertex normals! */
BKE_mesh_normals_tag_dirty(mesh);
}
@@ -340,14 +330,14 @@ static void normalEditModifier_do_radial(NormalEditModifierData *enmd,
BKE_mesh_normals_loop_custom_set(vert_positions,
BKE_mesh_vert_normals_ensure(mesh),
verts_num,
medge,
edges_num,
mloop,
edges.data(),
edges.size(),
loops.data(),
nos,
loops_num,
mpoly,
loops.size(),
polys.data(),
poly_normals,
polys_num,
polys.size(),
sharp_edges,
clnors);
@@ -371,13 +361,10 @@ static void normalEditModifier_do_directional(NormalEditModifierData *enmd,
const bool use_invert_vgroup,
const float (*positions)[3],
const int verts_num,
const MEdge *medge,
const int edges_num,
const blender::Span<MEdge> edges,
bool *sharp_edges,
MLoop *mloop,
const int loops_num,
const MPoly *mpoly,
const int polys_num)
blender::MutableSpan<MLoop> loops,
const blender::Span<MPoly> polys)
{
Object *ob_target = enmd->target;
@@ -385,7 +372,7 @@ static void normalEditModifier_do_directional(NormalEditModifierData *enmd,
const bool use_parallel_normals = (enmd->flag & MOD_NORMALEDIT_USE_DIRECTION_PARALLEL) != 0;
float(*nos)[3] = static_cast<float(*)[3]>(
MEM_malloc_arrayN(size_t(loops_num), sizeof(*nos), __func__));
MEM_malloc_arrayN(loops.size(), sizeof(*nos), __func__));
float target_co[3];
int i;
@@ -403,7 +390,7 @@ static void normalEditModifier_do_directional(NormalEditModifierData *enmd,
sub_v3_v3v3(no, target_co, enmd->offset);
normalize_v3(no);
for (i = loops_num; i--;) {
for (i = loops.size(); i--;) {
copy_v3_v3(nos[i], no);
}
}
@@ -417,7 +404,7 @@ static void normalEditModifier_do_directional(NormalEditModifierData *enmd,
float(*no)[3];
/* We reuse cos to now store the 'to target' normal of the verts! */
for (i = loops_num, no = nos, ml = mloop; i--; no++, ml++) {
for (i = loops.size(), no = nos, ml = loops.data(); i--; no++, ml++) {
const int vidx = ml->v;
float *co = cos[vidx];
@@ -443,33 +430,28 @@ static void normalEditModifier_do_directional(NormalEditModifierData *enmd,
mix_limit,
mix_mode,
verts_num,
mloop,
loops,
loop_normals,
nos,
loops_num);
nos);
}
if (do_polynors_fix && polygons_check_flip(mloop,
nos,
&mesh->ldata,
mesh->totloop,
mpoly,
BKE_mesh_poly_normals_for_write(mesh),
polys_num)) {
if (do_polynors_fix &&
polygons_check_flip(
loops, nos, &mesh->ldata, polys, BKE_mesh_poly_normals_for_write(mesh))) {
BKE_mesh_normals_tag_dirty(mesh);
}
BKE_mesh_normals_loop_custom_set(positions,
BKE_mesh_vert_normals_ensure(mesh),
verts_num,
medge,
edges_num,
mloop,
edges.data(),
edges.size(),
loops.data(),
nos,
loops_num,
mpoly,
loops.size(),
polys.data(),
poly_normals,
polys_num,
polys.size(),
sharp_edges,
clnors);
@@ -609,13 +591,10 @@ static Mesh *normalEditModifier_do(NormalEditModifierData *enmd,
use_invert_vgroup,
positions,
verts_num,
edges.data(),
edges.size(),
edges,
sharp_edges.span.data(),
loops.data(),
loops.size(),
polys.data(),
polys.size());
loops,
polys);
}
else if (enmd->mode == MOD_NORMALEDIT_MODE_DIRECTIONAL) {
normalEditModifier_do_directional(enmd,
@@ -633,13 +612,10 @@ static Mesh *normalEditModifier_do(NormalEditModifierData *enmd,
use_invert_vgroup,
positions,
verts_num,
edges.data(),
edges.size(),
edges,
sharp_edges.span.data(),
loops.data(),
loops.size(),
polys.data(),
polys.size());
loops,
polys);
}
MEM_SAFE_FREE(loop_normals);

66
source/blender/modifiers/intern/MOD_skin.cc
View File

@@ -446,8 +446,11 @@ static void merge_frame_corners(Frame **frames, int totframe)
}
}
static Frame **collect_hull_frames(
int v, SkinNode *frames, const MeshElemMap *emap, const MEdge *medge, int *tothullframe)
static Frame **collect_hull_frames(int v,
SkinNode *frames,
const MeshElemMap *emap,
const blender::Span<MEdge> medge,
int *tothullframe)
{
SkinNode *f;
Frame **hull_frames;
@@ -714,7 +717,7 @@ static void build_emats_stack(BLI_Stack *stack,
BLI_bitmap *visited_e,
EMat *emat,
const MeshElemMap *emap,
const MEdge *medge,
const blender::Span<MEdge> medge,
const MVertSkin *vs,
const float (*vert_positions)[3])
{
@@ -769,9 +772,8 @@ static void build_emats_stack(BLI_Stack *stack,
static EMat *build_edge_mats(const MVertSkin *vs,
const float (*vert_positions)[3],
const int verts_num,
const MEdge *medge,
const blender::Span<MEdge> medge,
const MeshElemMap *emap,
const int edges_num,
bool *has_valid_root)
{
BLI_Stack *stack;
@@ -782,8 +784,8 @@ static EMat *build_edge_mats(const MVertSkin *vs,
stack = BLI_stack_new(sizeof(stack_elem), "build_edge_mats.stack");
visited_e = BLI_BITMAP_NEW(edges_num, "build_edge_mats.visited_e");
emat = MEM_cnew_array<EMat>(edges_num, __func__);
visited_e = BLI_BITMAP_NEW(medge.size(), "build_edge_mats.visited_e");
emat = MEM_cnew_array<EMat>(medge.size(), __func__);
/* Edge matrices are built from the root nodes, add all roots with
* children to the stack */
@@ -803,7 +805,7 @@ static EMat *build_edge_mats(const MVertSkin *vs,
*has_valid_root = true;
}
else if (edges_num == 0) {
else if (medge.size() == 0) {
/* Vertex-only mesh is valid, mark valid root as well (will display error otherwise). */
*has_valid_root = true;
break;
@@ -894,7 +896,7 @@ static Mesh *subdivide_base(const Mesh *orig)
const MVertSkin *orignode = static_cast<const MVertSkin *>(
CustomData_get_layer(&orig->vdata, CD_MVERT_SKIN));
const float(*orig_vert_positions)[3] = BKE_mesh_vert_positions(orig);
const MEdge *origedge = BKE_mesh_edges(orig);
const blender::Span<MEdge> origedge = orig->edges();
const MDeformVert *origdvert = BKE_mesh_deform_verts(orig);
int orig_vert_num = orig->totvert;
int orig_edge_num = orig->totedge;
@@ -921,7 +923,7 @@ static Mesh *subdivide_base(const Mesh *orig)
orig, orig_vert_num + subd_num, orig_edge_num + subd_num, 0, 0);
float(*out_vert_positions)[3] = BKE_mesh_vert_positions_for_write(result);
MEdge *outedge = BKE_mesh_edges_for_write(result);
blender::MutableSpan<MEdge> result_edges = result->edges_for_write();
MVertSkin *outnode = static_cast<MVertSkin *>(
CustomData_get_layer_for_write(&result->vdata, CD_MVERT_SKIN, result->totvert));
MDeformVert *outdvert = nullptr;
@@ -933,6 +935,7 @@ static Mesh *subdivide_base(const Mesh *orig)
CustomData_copy_data(&orig->vdata, &result->vdata, 0, 0, orig_vert_num);
/* Subdivide edges */
int result_edge_i = 0;
for (i = 0, v = orig_vert_num; i < orig_edge_num; i++) {
struct VGroupData {
/* Vertex group number */
@@ -979,7 +982,7 @@ static Mesh *subdivide_base(const Mesh *orig)
}
/* Add vertices and edge segments */
for (j = 0; j < edge_subd[i]; j++, v++, outedge++) {
for (j = 0; j < edge_subd[i]; j++, v++) {
float r = (j + 1) / float(edge_subd[i] + 1);
float t = powf(r, radrat);
@@ -1002,8 +1005,9 @@ static Mesh *subdivide_base(const Mesh *orig)
}
}
outedge->v1 = u;
outedge->v2 = v;
result_edges[result_edge_i].v1 = u;
result_edges[result_edge_i].v2 = v;
result_edge_i++;
u = v;
}
@@ -1012,9 +1016,9 @@ static Mesh *subdivide_base(const Mesh *orig)
}
/* Link up to final vertex */
outedge->v1 = u;
outedge->v2 = e->v2;
outedge++;
result_edges[result_edge_i].v1 = u;
result_edges[result_edge_i].v2 = e->v2;
result_edge_i++;
}
MEM_freeN(edge_subd);
@@ -1561,7 +1565,7 @@ static void hull_merge_triangles(SkinOutput *so, const SkinModifierData *smd)
static void skin_merge_close_frame_verts(SkinNode *skin_nodes,
int verts_num,
const MeshElemMap *emap,
const MEdge *medge)
const blender::Span<MEdge> medge)
{
Frame **hull_frames;
int v, tothullframe;
@@ -1673,12 +1677,9 @@ static void skin_output_end_nodes(SkinOutput *so, SkinNode *skin_nodes, int vert
static void skin_output_connections(SkinOutput *so,
SkinNode *skin_nodes,
const MEdge *medge,
int edges_num)
const blender::Span<MEdge> medge)
{
int e;
for (e = 0; e < edges_num; e++) {
for (const int e : medge.index_range()) {
SkinNode *a, *b;
a = &skin_nodes[medge[e].v1];
b = &skin_nodes[medge[e].v2];
@@ -1786,7 +1787,7 @@ static bool skin_output_branch_hulls(SkinOutput *so,
SkinNode *skin_nodes,
int verts_num,
const MeshElemMap *emap,
const MEdge *medge)
const blender::Span<MEdge> medge)
{
bool result = true;
int v;
@@ -1820,8 +1821,7 @@ ENUM_OPERATORS(eSkinErrorFlag, SKIN_ERROR_HULL);
static BMesh *build_skin(SkinNode *skin_nodes,
int verts_num,
const MeshElemMap *emap,
const MEdge *medge,
int edges_num,
const blender::Span<MEdge> medge,
const MDeformVert *input_dvert,
SkinModifierData *smd,
eSkinErrorFlag *r_error)
@@ -1881,7 +1881,7 @@ static BMesh *build_skin(SkinNode *skin_nodes,
skin_smooth_hulls(so.bm, skin_nodes, verts_num, smd);
skin_output_end_nodes(&so, skin_nodes, verts_num);
skin_output_connections(&so, skin_nodes, medge, edges_num);
skin_output_connections(&so, skin_nodes, medge);
hull_merge_triangles(&so, smd);
bmesh_edit_end(so.bm, BMOpTypeFlag(0));
@@ -1911,29 +1911,25 @@ static Mesh *base_skin(Mesh *origmesh, SkinModifierData *smd, eSkinErrorFlag *r_
SkinNode *skin_nodes;
MeshElemMap *emap;
int *emapmem;
const MEdge *medge;
const MDeformVert *dvert;
int verts_num, edges_num;
bool has_valid_root = false;
const MVertSkin *nodes = static_cast<const MVertSkin *>(
CustomData_get_layer(&origmesh->vdata, CD_MVERT_SKIN));
const float(*vert_positions)[3] = BKE_mesh_vert_positions(origmesh);
const blender::Span<MEdge> edges = origmesh->edges();
dvert = BKE_mesh_deform_verts(origmesh);
medge = BKE_mesh_edges(origmesh);
verts_num = origmesh->totvert;
edges_num = origmesh->totedge;
const int verts_num = origmesh->totvert;
BKE_mesh_vert_edge_map_create(&emap, &emapmem, medge, verts_num, edges_num);
BKE_mesh_vert_edge_map_create(&emap, &emapmem, edges.data(), verts_num, edges.size());
emat = build_edge_mats(
nodes, vert_positions, verts_num, medge, emap, edges_num, &has_valid_root);
emat = build_edge_mats(nodes, vert_positions, verts_num, edges, emap, &has_valid_root);
skin_nodes = build_frames(vert_positions, verts_num, nodes, emap, emat);
MEM_freeN(emat);
emat = nullptr;
bm = build_skin(skin_nodes, verts_num, emap, medge, edges_num, dvert, smd, r_error);
bm = build_skin(skin_nodes, verts_num, emap, edges, dvert, smd, r_error);
MEM_freeN(skin_nodes);
MEM_freeN(emap);

9
source/blender/modifiers/intern/MOD_smooth.cc
View File

@@ -95,8 +95,7 @@ static void smoothModifier_do(
const float fac_orig = 1.0f - fac_new;
const bool invert_vgroup = (smd->flag & MOD_SMOOTH_INVERT_VGROUP) != 0;
const MEdge *medges = BKE_mesh_edges(mesh);
const int edges_num = mesh->totedge;
const blender::Span<MEdge> edges = mesh->edges();
const MDeformVert *dvert;
int defgrp_index;
@@ -108,10 +107,10 @@ static void smoothModifier_do(
memset(accumulated_vecs_count, 0, sizeof(*accumulated_vecs_count) * (size_t)verts_num);
}
for (int i = 0; i < edges_num; i++) {
for (const int i : edges.index_range()) {
float fvec[3];
const uint idx1 = medges[i].v1;
const uint idx2 = medges[i].v2;
const uint idx1 = edges[i].v1;
const uint idx2 = edges[i].v2;
mid_v3_v3v3(fvec, vertexCos[idx1], vertexCos[idx2]);