blender
/
blender
136
404
Fork 586
Code Issues 6.2k Pull Requests 753 Projects 19 Wiki Activity

68 Remaining uses of MLoop

This commit is contained in:
Hans Goudey 2022-12-05 23:42:26 -06:00
parent dd18757314
commit a495b782db
28 changed files with 309 additions and 276 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
source/blender/blenkernel/BKE_mesh.h
View File

@ -771,8 +771,6 @@ void BKE_mesh_mdisp_flip(struct MDisps *md, bool use_loop_mdisp_flip);
* (keeping the same vertex as 'start point').
*
* \param mpoly: the polygon to flip.
* \param mloop: the full loops array.
* \param ldata: the loops custom data.
*/
void BKE_mesh_polygon_flip_ex(const struct MPoly *mpoly,
int *corner_verts,

2
source/blender/blenkernel/BKE_mesh_types.h
View File

@ -47,7 +47,7 @@ typedef enum eMeshBatchDirtyMode {
/** #MeshRuntime.wrapper_type */
typedef enum eMeshWrapperType {
/** Use mesh data (#Mesh.positions(), #Mesh.medge, #Mesh.mloop, #Mesh.mpoly). */
/** Use mesh data (#Mesh.positions(), #Mesh.medge, #Mesh.corner_verts, #Mesh.mpoly). */
ME_WRAPPER_TYPE_MDATA = 0,
/** Use edit-mesh data (#Mesh.edit_mesh, #MeshRuntime.edit_data). */
ME_WRAPPER_TYPE_BMESH = 1,

2
source/blender/blenkernel/BKE_pbvh.h
View File

@ -258,7 +258,7 @@ PBVH *BKE_pbvh_new(PBVHType type);
/**
* Do a full rebuild with on Mesh data structure.
*
* \note Unlike mpoly/mloop/verts, looptri is *totally owned* by PBVH
* \note Unlike mpoly/corner_verts/verts, looptri is *totally owned* by PBVH
* (which means it may rewrite it if needed, see #BKE_pbvh_vert_coords_apply().
*/
void BKE_pbvh_build_mesh(PBVH *pbvh,

1
source/blender/blenkernel/BKE_shrinkwrap.h
View File

@ -75,6 +75,7 @@ typedef struct ShrinkwrapTreeData {
const struct MPoly *polys;
const float (*vert_normals)[3];
const int *corner_edges;
const float (*pnors)[3];
const float (*clnors)[3];
ShrinkwrapBoundaryData *boundary;

12
source/blender/blenkernel/intern/mesh_fair.cc
View File

@ -200,11 +200,12 @@ class MeshFairingContext : public FairingContext {
MutableSpan<float3> positions = mesh->positions_for_write();
medge_ = mesh->edges();
mpoly_ = mesh->polys();
mloop_ = mesh->loops();
corner_verts_ = mesh->corner_verts();
corner_edges_ = mesh->corner_edges();
BKE_mesh_vert_loop_map_create(&vlmap_,
&vlmap_mem_,
mpoly_.data(),
mloop_.data(),
corner_verts_.data(),
mesh->totvert,
mesh->totpoly,
mesh->totloop);
@ -222,7 +223,8 @@ class MeshFairingContext : public FairingContext {
}
}
loop_to_poly_map_ = blender::bke::mesh_topology::build_loop_to_poly_map(mpoly_, mloop_.size());
loop_to_poly_map_ = blender::bke::mesh_topology::build_loop_to_poly_map(mpoly_,
corner_verts_.size());
}
~MeshFairingContext() override
@ -238,8 +240,8 @@ class MeshFairingContext : public FairingContext {
const int vert = corner_verts_[loop];
const MPoly *p = &mpoly_[loop_to_poly_map_[loop]];
const int corner = poly_find_loop_from_vert(p, &corner_verts_[p->loopstart], vert);
copy_v3_v3(r_adj_next, co_[ME_POLY_LOOP_NEXT(mloop_, p, corner)->v]);
copy_v3_v3(r_adj_prev, co_[ME_POLY_LOOP_PREV(mloop_, p, corner)->v]);
copy_v3_v3(r_adj_next, co_[corner_verts_[ME_POLY_LOOP_NEXT(p, corner)]]);
copy_v3_v3(r_adj_prev, co_[corner_verts_[ME_POLY_LOOP_PREV(p, corner)]]);
}
int other_vertex_index_from_loop(const int loop, const uint v) override

4
source/blender/blenkernel/intern/mesh_remesh_voxel.cc
View File

@ -423,7 +423,7 @@ void BKE_remesh_reproject_vertex_paint(Mesh *target, const Mesh *source)
BKE_mesh_vert_loop_map_create(&source_lmap,
&source_lmap_mem,
source->polys().data(),
source->loops().data(),
source->corner_verts().data(),
source->totvert,
source->totpoly,
source->totloop);
@ -431,7 +431,7 @@ void BKE_remesh_reproject_vertex_paint(Mesh *target, const Mesh *source)
BKE_mesh_vert_loop_map_create(&target_lmap,
&target_lmap_mem,
target->polys().data(),
target->loops().data(),
target->corner_verts().data(),
target->totvert,
target->totpoly,
target->totloop);

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

@ -1595,7 +1595,7 @@ int mdisp_rot_face_to_crn(
float mindist = FLT_MAX;
for (i = 0; i < mpoly->totloop; i++) {
float len = len_v3v3(nullptr, positions[mloop[mpoly->loopstart + i].v].co);
float len = len_v3v3(nullptr, positions[corner_verts[mpoly->loopstart + i]].co);
if (len < mindist) {
mindist = len;
minS = i;

4
source/blender/blenkernel/intern/pbvh.cc
View File

@ -96,7 +96,7 @@ static void pbvh_vertex_color_get(const PBVH &pbvh, PBVHVertRef vertex, float r_
for (const int i_poly : Span(melem.indices, melem.count)) {
const MPoly &mp = pbvh.mpoly[i_poly];
Span<T> colors{static_cast<const T *>(pbvh.color_layer->data) + mp.loopstart, mp.totloop};
Span<int> poly_verts{pbvh.mloop + mp.loopstart, mp.totloop};
Span<int> poly_verts{pbvh.corner_verts + mp.loopstart, mp.totloop};
for (const int i : IndexRange(mp.totloop)) {
if (poly_verts[i] == index) {
@ -129,7 +129,7 @@ static void pbvh_vertex_color_set(PBVH &pbvh, PBVHVertRef vertex, const float co
for (const int i_poly : Span(melem.indices, melem.count)) {
const MPoly &mp = pbvh.mpoly[i_poly];
MutableSpan<T> colors{static_cast<T *>(pbvh.color_layer->data) + mp.loopstart, mp.totloop};
Span<int> poly_verts{pbvh.mloop + mp.loopstart, mp.totloop};
Span<int> poly_verts{pbvh.corner_verts + mp.loopstart, mp.totloop};
for (const int i : IndexRange(mp.totloop)) {
if (poly_verts[i] == index) {

7
source/blender/blenkernel/intern/shrinkwrap.cc
View File

@ -115,6 +115,7 @@ bool BKE_shrinkwrap_init_tree(
data->mesh = mesh;
data->polys = BKE_mesh_polys(mesh);
data->corner_edges = mesh->corner_edges().data();
data->vert_normals = BKE_mesh_vertex_normals_ensure(mesh);
if (shrinkType == MOD_SHRINKWRAP_NEAREST_VERTEX) {
@ -191,6 +192,7 @@ static ShrinkwrapBoundaryData *shrinkwrap_build_boundary_data(Mesh *mesh)
using namespace blender;
const float(*positions)[3] = BKE_mesh_positions(mesh);
const MEdge *medge = BKE_mesh_edges(mesh);
const Span<int> corner_verts = mesh->corner_verts();
const Span<int> corner_edges = mesh->corner_edges();
/* Count faces per edge (up to 2). */
@ -240,7 +242,8 @@ static ShrinkwrapBoundaryData *shrinkwrap_build_boundary_data(Mesh *mesh)
for (int i = 0; i < totlooptri; i++) {
int edges[3];
BKE_mesh_looptri_get_real_edges(medge, mloop, &mlooptri[i], edges);
BKE_mesh_looptri_get_real_edges(
medge, corner_verts.data(), corner_edges.data(), &mlooptri[i], edges);
for (int j = 0; j < 3; j++) {
if (edges[j] >= 0 && edge_mode[edges[j]]) {
@ -1050,7 +1053,7 @@ static void mesh_looptri_target_project(void *userdata,
const BLI_bitmap *is_boundary = tree->boundary->edge_is_boundary;
int edges[3];
BKE_mesh_looptri_get_real_edges(data->edge, data->loop, lt, edges);
BKE_mesh_looptri_get_real_edges(data->edge, data->corner_verts, tree->corner_edges, lt, edges);
for (int i = 0; i < 3; i++) {
if (edges[i] >= 0 && BLI_BITMAP_TEST(is_boundary, edges[i])) {

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

@ -177,7 +177,7 @@ Mesh *volume_to_mesh(const openvdb::GridBase &grid,
0,
mesh->positions_for_write(),
mesh->polys_for_write(),
mesh->loops_for_write());
mesh->corner_verts_for_write());
BKE_mesh_calc_edges(mesh, false, false);

6
source/blender/draw/intern/draw_pbvh.cc
View File

@ -975,7 +975,8 @@ struct PBVHBatches {
}
int r_edges[3];
BKE_mesh_looptri_get_real_edges(edges.data(), args->mloop, lt, r_edges);
BKE_mesh_looptri_get_real_edges(
edges.data(), args->corner_verts, args->corner_edges, lt, r_edges);
if (r_edges[0] != -1) {
edge_count++;
@ -1000,7 +1001,8 @@ struct PBVHBatches {
}
int r_edges[3];
BKE_mesh_looptri_get_real_edges(edges.data(), args->mloop, lt, r_edges);
BKE_mesh_looptri_get_real_edges(
edges.data(), args->corner_verts, args->corner_edges, lt, r_edges);
if (r_edges[0] != -1) {
GPU_indexbuf_add_line_verts(&elb_lines, vertex_i, vertex_i + 1);

6
source/blender/draw/intern/mesh_extractors/extract_mesh_ibo_lines_adjacency.cc
View File

@ -123,9 +123,9 @@ static void extract_lines_adjacency_iter_looptri_mesh(const MeshRenderData *mr,
if (hidden) {
return;
}
lines_adjacency_triangle(mr->mloop[mlt->tri[0]].v,
mr->mloop[mlt->tri[1]].v,
mr->mloop[mlt->tri[2]].v,
lines_adjacency_triangle(mr->corner_verts[mlt->tri[0]],
mr->corner_verts[mlt->tri[1]],
mr->corner_verts[mlt->tri[2]],
mlt->tri[0],
mlt->tri[1],
mlt->tri[2],

8
source/blender/draw/intern/mesh_extractors/extract_mesh_vbo_edituv_stretch_angle.cc
View File

@ -175,8 +175,8 @@ static void extract_edituv_stretch_angle_iter_poly_mesh(const MeshRenderData *mr
av,
data->luv[ml_index_last].uv,
data->luv[l_next_tmp].uv,
mr->positions[mr->mloop[ml_index_last].v],
mr->positions[mr->mloop[l_next_tmp].v]);
mr->positions[mr->corner_verts[ml_index_last]],
mr->positions[mr->corner_verts[l_next_tmp]]);
/* Save last edge. */
copy_v2_v2(last_auv, auv[1]);
copy_v3_v3(last_av, av[1]);
@ -195,8 +195,8 @@ static void extract_edituv_stretch_angle_iter_poly_mesh(const MeshRenderData *mr
av,
data->luv[ml_index].uv,
data->luv[l_next].uv,
mr->positions[mr->mloop[ml_index].v],
mr->positions[mr->mloop[l_next].v]);
mr->positions[mr->corner_verts[ml_index]],
mr->positions[mr->corner_verts[l_next]]);
}
edituv_get_edituv_stretch_angle(auv, av, &data->vbo_data[ml_index]);
}

5
source/blender/draw/intern/mesh_extractors/extract_mesh_vbo_edituv_stretch_area.cc
View File

@ -75,8 +75,9 @@ static void compute_area_ratio(const MeshRenderData *mr,
const MLoopUV *uv_data = (const MLoopUV *)CustomData_get_layer(&mr->me->ldata, CD_MLOOPUV);
const MPoly *mp = mr->mpoly;
for (int mp_index = 0; mp_index < mr->poly_len; mp_index++, mp++) {
float area = BKE_mesh_calc_poly_area(
mp, &mr->mloop[mp->loopstart], reinterpret_cast<const float(*)[3]>(mr->positions));
float area = BKE_mesh_calc_poly_area(mp,
&mr->corner_verts[mp->loopstart],
reinterpret_cast<const float(*)[3]>(mr->positions));
float uvarea = BKE_mesh_calc_poly_uv_area(mp, uv_data);
tot_area += area;
tot_uv_area += uvarea;

2
source/blender/draw/intern/mesh_extractors/extract_mesh_vbo_tan.cc
View File

@ -116,7 +116,7 @@ static void extract_tan_init_common(const MeshRenderData *mr,
BKE_mesh_calc_loop_tangent_ex(reinterpret_cast<const float(*)[3]>(mr->positions),
mr->mpoly,
mr->poly_len,
mr->mloop,
mr->corner_verts,
mr->mlooptri,
mr->tri_len,
cd_ldata,

22
source/blender/editors/sculpt_paint/paint_vertex.cc
View File

@ -3006,7 +3006,7 @@ static void do_vpaint_brush_blur_loops(bContext *C,
if (sculpt_brush_test_sq_fn(&test, vd.co)) {
/* For grid based pbvh, take the vert whose loop corresponds to the current grid.
* Otherwise, take the current vert. */
const int v_index = has_grids ? ss->mloop[vd.grid_indices[vd.g]].v :
const int v_index = has_grids ? ss->corner_verts[vd.grid_indices[vd.g]] :
vd.vert_indices[vd.i];
const float grid_alpha = has_grids ? 1.0f / vd.gridsize : 1.0f;
@ -3065,7 +3065,7 @@ static void do_vpaint_brush_blur_loops(bContext *C,
for (int j = 0; j < gmap->vert_to_poly[v_index].count; j++) {
const int p_index = gmap->vert_to_poly[v_index].indices[j];
const int l_index = gmap->vert_to_loop[v_index].indices[j];
BLI_assert(ss->mloop[l_index].v == v_index);
BLI_assert(ss->corner_verts[l_index] == v_index);
if (!use_face_sel || select_poly[p_index]) {
Color color_orig(0, 0, 0, 0); /* unused when array is nullptr */
@ -3151,7 +3151,7 @@ static void do_vpaint_brush_blur_verts(bContext *C,
if (sculpt_brush_test_sq_fn(&test, vd.co)) {
/* For grid based pbvh, take the vert whose loop corresponds to the current grid.
* Otherwise, take the current vert. */
const int v_index = has_grids ? ss->mloop[vd.grid_indices[vd.g]].v :
const int v_index = has_grids ? ss->corner_verts[vd.grid_indices[vd.g]] :
vd.vert_indices[vd.i];
const float grid_alpha = has_grids ? 1.0f / vd.gridsize : 1.0f;
@ -3181,7 +3181,7 @@ static void do_vpaint_brush_blur_verts(bContext *C,
total_hit_loops += mp->totloop;
for (int k = 0; k < mp->totloop; k++) {
const uint l_index = mp->loopstart + k;
const uint v_index = ss->mloop[l_index].v;
const uint v_index = ss->corner_verts[l_index];
Color *col = lcol + v_index;
@ -3212,7 +3212,7 @@ static void do_vpaint_brush_blur_verts(bContext *C,
for (int j = 0; j < gmap->vert_to_poly[v_index].count; j++) {
const int p_index = gmap->vert_to_poly[v_index].indices[j];
BLI_assert(ss->mloop[gmap->vert_to_loop[v_index].indices[j]].v == v_index);
BLI_assert(ss->corner_verts[gmap->vert_to_loop[v_index].indices[j]] == v_index);
if (!use_face_sel || select_poly[p_index]) {
Color color_orig(0, 0, 0, 0); /* unused when array is nullptr */
@ -3305,7 +3305,7 @@ static void do_vpaint_brush_smear(bContext *C,
if (sculpt_brush_test_sq_fn(&test, vd.co)) {
/* For grid based pbvh, take the vert whose loop corresponds to the current grid.
* Otherwise, take the current vert. */
const int v_index = has_grids ? ss->mloop[vd.grid_indices[vd.g]].v :
const int v_index = has_grids ? ss->corner_verts[vd.grid_indices[vd.g]] :
vd.vert_indices[vd.i];
const float grid_alpha = has_grids ? 1.0f / vd.gridsize : 1.0f;
const float3 &mv_curr = &ss->positions[v_index];
@ -3337,7 +3337,7 @@ static void do_vpaint_brush_smear(bContext *C,
for (int j = 0; j < gmap->vert_to_poly[v_index].count; j++) {
const int p_index = gmap->vert_to_poly[v_index].indices[j];
const int l_index = gmap->vert_to_loop[v_index].indices[j];
BLI_assert(ss->mloop[l_index].v == v_index);
BLI_assert(ss->corner_verts[l_index] == v_index);
UNUSED_VARS_NDEBUG(l_index);
const MPoly *mp = &ss->mpoly[p_index];
if (!use_face_sel || select_poly[p_index]) {
@ -3391,7 +3391,7 @@ static void do_vpaint_brush_smear(bContext *C,
else {
const int l_index = gmap->vert_to_loop[v_index].indices[j];
elem_index = l_index;
BLI_assert(ss->mloop[l_index].v == v_index);
BLI_assert(ss->corner_verts[l_index] == v_index);
}
if (!use_face_sel || select_poly[p_index]) {
@ -3469,7 +3469,7 @@ static void calculate_average_color(VPaintData<Color, Traits, domain> *vpd,
BKE_pbvh_vertex_iter_begin (ss->pbvh, nodes[n], vd, PBVH_ITER_UNIQUE) {
/* Test to see if the vertex coordinates are within the spherical brush region. */
if (sculpt_brush_test_sq_fn(&test, vd.co)) {
const int v_index = has_grids ? ss->mloop[vd.grid_indices[vd.g]].v :
const int v_index = has_grids ? ss->corner_verts[vd.grid_indices[vd.g]] :
vd.vert_indices[vd.i];
if (BKE_brush_curve_strength(brush, 0.0, cache->radius) > 0.0) {
/* If the vertex is selected for painting. */
@ -3593,7 +3593,7 @@ static void vpaint_do_draw(bContext *C,
/* NOTE: Grids are 1:1 with corners (aka loops).
* For grid based pbvh, take the vert whose loop corresponds to the current grid.
* Otherwise, take the current vert. */
const int v_index = has_grids ? ss->mloop[vd.grid_indices[vd.g]].v :
const int v_index = has_grids ? ss->corner_verts[vd.grid_indices[vd.g]] :
vd.vert_indices[vd.i];
const float grid_alpha = has_grids ? 1.0f / vd.gridsize : 1.0f;
@ -3649,7 +3649,7 @@ static void vpaint_do_draw(bContext *C,
for (int j = 0; j < gmap->vert_to_poly[v_index].count; j++) {
const int p_index = gmap->vert_to_poly[v_index].indices[j];
const int l_index = gmap->vert_to_loop[v_index].indices[j];
BLI_assert(ss->mloop[l_index].v == v_index);
BLI_assert(ss->corner_verts[l_index] == v_index);
if (!use_face_sel || select_poly[p_index]) {
Color color_orig = Color(0, 0, 0, 0); /* unused when array is nullptr */

6
source/blender/editors/sculpt_paint/sculpt.cc
View File

@ -727,7 +727,7 @@ bool SCULPT_vertex_has_unique_face_set(SculptSession *ss, PBVHVertRef vertex)
coord.y = vertex_index / key->grid_size;
int v1, v2;
const SubdivCCGAdjacencyType adjacency = BKE_subdiv_ccg_coarse_mesh_adjacency_info_get(
ss->subdiv_ccg, &coord, ss->mloop, ss->mpoly, &v1, &v2);
ss->subdiv_ccg, &coord, ss->corner_verts, ss->mpoly, &v1, &v2);
switch (adjacency) {
case SUBDIV_CCG_ADJACENT_VERTEX:
return sculpt_check_unique_face_set_in_base_mesh(ss, v1);
@ -848,7 +848,7 @@ static void sculpt_vertex_neighbors_get_faces(SculptSession *ss,
}
const MPoly *p = &ss->mpoly[vert_map->indices[i]];
int f_adj_v[2];
if (poly_get_adj_loops_from_vert(p, ss->mloop, vertex.i, f_adj_v) != -1) {
if (poly_get_adj_loops_from_vert(p, ss->corner_verts, vertex.i, f_adj_v) != -1) {
for (int j = 0; j < ARRAY_SIZE(f_adj_v); j += 1) {
if (f_adj_v[j] != vertex.i) {
sculpt_vertex_neighbor_add(iter, BKE_pbvh_make_vref(f_adj_v[j]), f_adj_v[j]);
@ -962,7 +962,7 @@ bool SCULPT_vertex_is_boundary(const SculptSession *ss, const PBVHVertRef vertex
coord.y = vertex_index / key->grid_size;
int v1, v2;
const SubdivCCGAdjacencyType adjacency = BKE_subdiv_ccg_coarse_mesh_adjacency_info_get(
ss->subdiv_ccg, &coord, ss->mloop, ss->mpoly, &v1, &v2);
ss->subdiv_ccg, &coord, ss->corner_verts, ss->mpoly, &v1, &v2);
switch (adjacency) {
case SUBDIV_CCG_ADJACENT_VERTEX:
return sculpt_check_boundary_vertex_in_base_mesh(ss, v1);

2
source/blender/editors/sculpt_paint/sculpt_face_set.cc
View File

@ -135,7 +135,7 @@ static void do_draw_face_sets_brush_task_cb_ex(void *__restrict userdata,
const MPoly *p = &ss->mpoly[vert_map->indices[j]];
float poly_center[3];
BKE_mesh_calc_poly_center(p, &ss->mloop[p->loopstart], positions, poly_center);
BKE_mesh_calc_poly_center(p, &ss->corner_verts[p->loopstart], positions, poly_center);
if (!sculpt_brush_test_sq_fn(&test, poly_center)) {
continue;

12
source/blender/geometry/intern/mesh_merge_by_distance.cc
View File

@ -959,7 +959,8 @@ static void weld_poly_split_recursive(Span<int> vert_dest_map,
*r_loop_kill += loop_kill;
#ifdef USE_WELD_DEBUG
weld_assert_poly_no_vert_repetition(*r_wp, wloop, mloop, r_weld_mesh->loop_map);
weld_assert_poly_no_vert_repetition(
*r_wp, wloop, corner_verts, corner_edges, r_weld_mesh->loop_map);
#endif
}
@ -1026,7 +1027,8 @@ static void weld_poly_loop_ctx_setup(const Span<int> corner_verts,
weld_poly_split_recursive(vert_dest_map,
#ifdef USE_WELD_DEBUG
mloop,
corner_verts,
corner_edges,
#endif
ctx_verts_len,
&wp,
@ -1037,7 +1039,8 @@ static void weld_poly_loop_ctx_setup(const Span<int> corner_verts,
}
#ifdef USE_WELD_DEBUG
weld_assert_poly_and_loop_kill_len(r_weld_mesh, mloop, mpoly, poly_kill_len, loop_kill_len);
weld_assert_poly_and_loop_kill_len(
r_weld_mesh, corner_verts, corner_edges, mpoly, poly_kill_len, loop_kill_len);
#endif
/* Setup Polygon Overlap. */
@ -1165,7 +1168,8 @@ static void weld_poly_loop_ctx_setup(const Span<int> corner_verts,
}
#ifdef USE_WELD_DEBUG
weld_assert_poly_and_loop_kill_len(r_weld_mesh, mloop, mpoly, poly_kill_len, loop_kill_len);
weld_assert_poly_and_loop_kill_len(
r_weld_mesh, corner_verts, corner_edges, mpoly, poly_kill_len, loop_kill_len);
#endif
r_weld_mesh->poly_kill_len = poly_kill_len;

2
source/blender/geometry/intern/mesh_to_volume.cc
View File

@ -31,7 +31,7 @@ class OpenVDBMeshAdapter {
OpenVDBMeshAdapter::OpenVDBMeshAdapter(const Mesh &mesh, float4x4 transform)
: positions_(mesh.positions()),
loops_(mesh.loops()),
corner_verts_(mesh.corner_verts()),
looptris_(mesh.looptris()),
transform_(transform)
{

2
source/blender/io/alembic/intern/abc_customdata.h
View File

@ -71,7 +71,7 @@ struct CDStreamConfig {
std::map<std::string, Alembic::AbcGeom::OC4fGeomParam> abc_vertex_colors;
CDStreamConfig()
: mloop(NULL),
: corner_verts(NULL),
totloop(0),
mpoly(NULL),
totpoly(0),

2
source/blender/io/wavefront_obj/importer/obj_import_objects.hh
View File

@ -41,7 +41,7 @@ struct GlobalVertices {
};
/**
* A face's corner in an OBJ file. In Blender, it translates to a mloop vertex.
* A face's corner in an OBJ file. In Blender, it translates to a corner vertex.
*/
struct PolyCorner {
/* These indices range from zero to total vertices in the OBJ file. */

47
source/blender/makesdna/DNA_meshdata_types.h
View File

@ -105,21 +105,6 @@ enum {
/* ME_HIDE = (1 << 4), */
};
/**
* Mesh Face Corners.
* "Loop" is an internal name for the corner of a polygon (#MPoly).
*
* Typically accessed with #Mesh.loops().
*/
#ifdef DNA_DEPRECATED_ALLOW
typedef struct MLoop {
/** Vertex index. */
unsigned int v;
/** Edge index into an #MEdge array. */
unsigned int e;
} MLoop;
#endif
/** \} */
/* -------------------------------------------------------------------- */
@ -182,9 +167,9 @@ enum {
*
* // access vertex locations.
* float *vtri_co[3] = {
* positions[mloop[lt->tri[0]].v],
* positions[mloop[lt->tri[1]].v],
* positions[mloop[lt->tri[2]].v],
* positions[corner_verts[lt->tri[0]]],
* positions[corner_verts[lt->tri[1]]],
* positions[corner_verts[lt->tri[2]]],
* };
*
* // access UV coordinates (works for all loop data, vertex colors... etc).
@ -208,10 +193,10 @@ enum {
* int j, lt_tot = ME_POLY_TRI_TOT(mp);
*
* for (j = 0; j < lt_tot; j++, lt++) {
* unsigned int vtri[3] = {
* mloop[lt->tri[0]].v,
* mloop[lt->tri[1]].v,
* mloop[lt->tri[2]].v,
* int vtri[3] = {
* corner_verts[lt->tri[0]],
* corner_verts[lt->tri[1]],
* corner_verts[lt->tri[2]],
* };
* printf("tri %u %u %u\n", vtri[0], vtri[1], vtri[2]);
* };
@ -228,8 +213,8 @@ enum {
* // print real edges from an MLoopTri: lt
* int j, j_next;
* for (j = 2, j_next = 0; j_next < 3; j = j_next++) {
* MEdge *ed = &medge[mloop[lt->tri[j]].e];
* unsigned int tri_edge[2] = {mloop[lt->tri[j]].v, mloop[lt->tri[j_next]].v};
* MEdge *ed = &medge[corner_edges[lt->tri[j]]];
* unsigned int tri_edge[2] = {corner_verts[lt->tri[j]], corner_verts[lt->tri[j_next]]};
*
* if (((ed->v1 == tri_edge[0]) && (ed->v2 == tri_edge[1])) ||
* ((ed->v1 == tri_edge[1]) && (ed->v2 == tri_edge[0])))
@ -476,6 +461,20 @@ enum {
/** \name Deprecated Structs
* \{ */
/**
* Mesh Face Corners.
* Deprecated storage for the vertex of a face corner and the following edge.
* Replaced by the "corner_verts" and "corner_edges" arrays.
*/
#ifdef DNA_DEPRECATED_ALLOW
typedef struct MLoop {
/** Vertex index. */
unsigned int v;
/** Edge index into an #MEdge array. */
unsigned int e;
} MLoop;
#endif
/**
* Used in Blender pre 2.63, See #Mesh::corner_verts(), #MPoly for face data stored in the blend
* file. Use for reading old files and in a handful of cases which should be removed eventually.

126
source/blender/modifiers/intern/MOD_laplaciansmooth.c
View File

@ -151,14 +151,16 @@ static float compute_volume(const float center[3],
for (i = 0; i < polys_num; i++) {
const MPoly *mp = &mpoly[i];
const MLoop *l_first = &mloop[mp->loopstart];
const MLoop *l_prev = l_first + 1;
const MLoop *l_curr = l_first + 2;
const MLoop *l_term = l_first + mp->totloop;
int corner_first = mp->loopstart;
int corner_prev = corner_first + 1;
int corner_curr = corner_first + 2;
int corner_term = corner_first + mp->totloop;
for (; l_curr != l_term; l_prev = l_curr, l_curr++) {
vol += volume_tetrahedron_signed_v3(
center, vertexCos[l_first->v], vertexCos[l_prev->v], vertexCos[l_curr->v]);
for (; corner_curr != corner_term; corner_prev = corner_curr, corner_curr++) {
vol += volume_tetrahedron_signed_v3(center,
vertexCos[corner_verts[corner_first]],
vertexCos[corner_verts[corner_prev]],
vertexCos[corner_verts[corner_curr]]);
}
}
@ -218,42 +220,44 @@ static void init_laplacian_matrix(LaplacianSystem *sys)
sys->eweights[i] = w1;
}
const int *corner_verts = sys->corner_verts;
for (i = 0; i < sys->polys_num; i++) {
const MPoly *mp = &sys->mpoly[i];
const MLoop *l_next = &sys->mloop[mp->loopstart];
const MLoop *l_term = l_next + mp->totloop;
const MLoop *l_prev = l_term - 2;
const MLoop *l_curr = l_term - 1;
int corner_next = mp->loopstart;
int corner_term = corner_next + mp->totloop;
int corner_prev = corner_term - 2;
int corner_curr = corner_term - 1;
for (; l_next != l_term; l_prev = l_curr, l_curr = l_next, l_next++) {
const float *v_prev = sys->vertexCos[l_prev->v];
const float *v_curr = sys->vertexCos[l_curr->v];
const float *v_next = sys->vertexCos[l_next->v];
const uint l_curr_index = l_curr - sys->mloop;
for (; corner_next != corner_term;
corner_prev = corner_curr, corner_curr = corner_next, corner_next++) {
const float *v_prev = sys->vertexCos[corner_verts[corner_prev]];
const float *v_curr = sys->vertexCos[corner_verts[corner_curr]];
const float *v_next = sys->vertexCos[corner_verts[corner_next]];
sys->ne_fa_num[l_curr->v] += 1;
sys->ne_fa_num[corner_verts[corner_curr]] += 1;
areaf = area_tri_v3(v_prev, v_curr, v_next);
if (areaf < sys->min_area) {
sys->zerola[l_curr->v] = true;
sys->zerola[corner_verts[corner_curr]] = true;
}
sys->ring_areas[l_prev->v] += areaf;
sys->ring_areas[l_curr->v] += areaf;
sys->ring_areas[l_next->v] += areaf;
sys->ring_areas[corner_verts[corner_prev]] += areaf;
sys->ring_areas[corner_verts[corner_curr]] += areaf;
sys->ring_areas[corner_verts[corner_next]] += areaf;
w1 = cotangent_tri_weight_v3(v_curr, v_next, v_prev) / 2.0f;
w2 = cotangent_tri_weight_v3(v_next, v_prev, v_curr) / 2.0f;
w3 = cotangent_tri_weight_v3(v_prev, v_curr, v_next) / 2.0f;
sys->fweights[l_curr_index][0] += w1;
sys->fweights[l_curr_index][1] += w2;
sys->fweights[l_curr_index][2] += w3;
sys->fweights[corner_curr][0] += w1;
sys->fweights[corner_curr][1] += w2;
sys->fweights[corner_curr][2] += w3;
sys->vweights[l_curr->v] += w2 + w3;
sys->vweights[l_next->v] += w1 + w3;
sys->vweights[l_prev->v] += w1 + w2;
sys->vweights[corner_verts[corner_curr]] += w2 + w3;
sys->vweights[corner_verts[corner_next]] += w1 + w3;
sys->vweights[corner_verts[corner_prev]] += w1 + w2;
}
}
for (i = 0; i < sys->edges_num; i++) {
@ -273,49 +277,57 @@ static void fill_laplacian_matrix(LaplacianSystem *sys)
int i;
uint idv1, idv2;
const int *corner_verts = sys->corner_verts;
for (i = 0; i < sys->polys_num; i++) {
const MPoly *mp = &sys->mpoly[i];
const MLoop *l_next = &sys->mloop[mp->loopstart];
const MLoop *l_term = l_next + mp->totloop;
const MLoop *l_prev = l_term - 2;
const MLoop *l_curr = l_term - 1;
int corner_next = mp->loopstart;
int corner_term = corner_next + mp->totloop;
int corner_prev = corner_term - 2;
int corner_curr = corner_term - 1;
for (; l_next != l_term; l_prev = l_curr, l_curr = l_next, l_next++) {
const uint l_curr_index = l_curr - sys->mloop;
for (; corner_next != corner_term;
corner_prev = corner_curr, corner_curr = corner_next, corner_next++) {
/* Is ring if number of faces == number of edges around vertex. */
if (sys->ne_ed_num[l_curr->v] == sys->ne_fa_num[l_curr->v] &&
sys->zerola[l_curr->v] == false) {
if (sys->ne_ed_num[corner_verts[corner_curr]] == sys->ne_fa_num[corner_verts[corner_curr]] &&
sys->zerola[corner_verts[corner_curr]] == false) {
EIG_linear_solver_matrix_add(sys->context,
l_curr->v,
l_next->v,
sys->fweights[l_curr_index][2] * sys->vweights[l_curr->v]);
corner_verts[corner_curr],
corner_verts[corner_next],
sys->fweights[corner_curr][2] *
sys->vweights[corner_verts[corner_curr]]);
EIG_linear_solver_matrix_add(sys->context,
l_curr->v,
l_prev->v,
sys->fweights[l_curr_index][1] * sys->vweights[l_curr->v]);
corner_verts[corner_curr],
corner_verts[corner_prev],
sys->fweights[corner_curr][1] *
sys->vweights[corner_verts[corner_curr]]);
}
if (sys->ne_ed_num[l_next->v] == sys->ne_fa_num[l_next->v] &&
sys->zerola[l_next->v] == false) {
if (sys->ne_ed_num[corner_verts[corner_next]] == sys->ne_fa_num[corner_verts[corner_next]] &&
sys->zerola[corner_verts[corner_next]] == false) {
EIG_linear_solver_matrix_add(sys->context,
l_next->v,
l_curr->v,
sys->fweights[l_curr_index][2] * sys->vweights[l_next->v]);
corner_verts[corner_next],
corner_verts[corner_curr],
sys->fweights[corner_curr][2] *
sys->vweights[corner_verts[corner_next]]);
EIG_linear_solver_matrix_add(sys->context,
l_next->v,
l_prev->v,
sys->fweights[l_curr_index][0] * sys->vweights[l_next->v]);
corner_verts[corner_next],
corner_verts[corner_prev],
sys->fweights[corner_curr][0] *
sys->vweights[corner_verts[corner_next]]);
}
if (sys->ne_ed_num[l_prev->v] == sys->ne_fa_num[l_prev->v] &&
sys->zerola[l_prev->v] == false) {
if (sys->ne_ed_num[corner_verts[corner_prev]] == sys->ne_fa_num[corner_verts[corner_prev]] &&
sys->zerola[corner_verts[corner_prev]] == false) {
EIG_linear_solver_matrix_add(sys->context,
l_prev->v,
l_curr->v,
sys->fweights[l_curr_index][1] * sys->vweights[l_prev->v]);
corner_verts[corner_prev],
corner_verts[corner_curr],
sys->fweights[corner_curr][1] *
sys->vweights[corner_verts[corner_prev]]);
EIG_linear_solver_matrix_add(sys->context,
l_prev->v,
l_next->v,
sys->fweights[l_curr_index][0] * sys->vweights[l_prev->v]);
corner_verts[corner_prev],
corner_verts[corner_next],
sys->fweights[corner_curr][0] *
sys->vweights[corner_verts[corner_prev]]);
}
}
}

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

@ -246,7 +246,7 @@ static Mesh *modifyMesh(ModifierData *md, const ModifierEvalContext *ctx, Mesh *
sculpt_session->totpoly = mesh->totpoly;
sculpt_session->positions = nullptr;
sculpt_session->mpoly = nullptr;
sculpt_session->mloop = nullptr;
sculpt_session->corner_verts = nullptr;
}
// BKE_subdiv_stats_print(&subdiv->stats);
}

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

@ -267,7 +267,7 @@ static Mesh *generate_ocean_geometry(OceanModifierData *omd, Mesh *mesh_orig, co
gogd.positions = BKE_mesh_positions_for_write(result);
gogd.mpolys = BKE_mesh_polys_for_write(result);
gogd.mloops = BKE_mesh_loops_for_write(result);
gogd.corner_verts = BKE_mesh_corner_verts_for_write(result);
TaskParallelSettings settings;
BLI_parallel_range_settings_defaults(&settings);
@ -384,7 +384,7 @@ static Mesh *doOcean(ModifierData *md, const ModifierEvalContext *ctx, Mesh *mes
const MPoly *mp;
for (i = 0, mp = polys; i < polys_num; i++, mp++) {
const int *corner_vert = &mloops[mp->loopstart];
const int *corner_vert = &corner_verts[mp->loopstart];
MLoopCol *mlcol = &mloopcols[mp->loopstart];
MLoopCol *mlcolspray = NULL;

131
source/blender/modifiers/intern/MOD_solidify_extrude.c
View File

@ -258,22 +258,24 @@ Mesh *MOD_solidify_extrude_modifyMesh(ModifierData *md, const ModifierEvalContex
for (i = 0, mp = orig_mpoly; i < polys_num; i++, mp++) {
int j;
const MLoop *ml = orig_mloop + mp->loopstart;
const MLoop *ml_prev = ml + (mp->totloop - 1);
int corner_i_prev = mp->loopstart + (mp->totloop - 1);
for (j = 0; j < mp->totloop; j++, ml++) {
for (j = 0; j < mp->totloop; j++) {
const int corner_i = mp->loopstart + j;
const int vert_i = orig_corner_verts[corner_i];
const int prev_vert_i = orig_corner_verts[corner_i_prev];
/* add edge user */
eidx = ml_prev->e;
eidx = orig_corner_edges[corner_i_prev];
if (edge_users[eidx] == INVALID_UNUSED) {
ed = orig_medge + eidx;
BLI_assert(ELEM(ml_prev->v, ed->v1, ed->v2) && ELEM(ml->v, ed->v1, ed->v2));
edge_users[eidx] = (ml_prev->v > ml->v) == (ed->v1 < ed->v2) ? i : (i + polys_num);
BLI_assert(ELEM(prev_vert_i, ed->v1, ed->v2) && ELEM(vert_i, ed->v1, ed->v2));
edge_users[eidx] = (prev_vert_i > vert_i) == (ed->v1 < ed->v2) ? i : (i + polys_num);
edge_order[eidx] = j;
}
else {
edge_users[eidx] = INVALID_PAIR;
}
ml_prev = ml;
corner_i_prev = corner_i;
}
}
@ -339,7 +341,8 @@ Mesh *MOD_solidify_extrude_modifyMesh(ModifierData *md, const ModifierEvalContex
float(*positions)[3] = BKE_mesh_positions_for_write(result);
MEdge *medge = BKE_mesh_edges_for_write(result);
MPoly *mpoly = BKE_mesh_polys_for_write(result);
MLoop *mloop = BKE_mesh_loops_for_write(result);
int *corner_verts = BKE_mesh_corner_verts_for_write(result);
int *corner_edges = BKE_mesh_corner_edges_for_write(result);
if (do_shell) {
CustomData_copy_data(&mesh->vdata, &result->vdata, 0, 0, (int)verts_num);
@ -424,13 +427,12 @@ Mesh *MOD_solidify_extrude_modifyMesh(ModifierData *md, const ModifierEvalContex
MPoly *mp = mpoly + polys_num;
for (i = 0; i < mesh->totpoly; i++, mp++) {
const int loop_end = mp->totloop - 1;
MLoop *ml2;
uint e;
int e;
int j;
/* reverses the loop direction (MLoop.v as well as custom-data)
* MLoop.e also needs to be corrected too, done in a separate loop below. */
ml2 = mloop + mp->loopstart + mesh->totloop;
/* reverses the loop direction (corner verts as well as custom-data)
* Corner edges also need to be corrected too, done in a separate loop below. */
const int corner_2 = mp->loopstart + mesh->totloop;
#if 0
for (j = 0; j < mp->totloop; j++) {
CustomData_copy_data(&mesh->ldata,
@ -457,17 +459,17 @@ Mesh *MOD_solidify_extrude_modifyMesh(ModifierData *md, const ModifierEvalContex
CLAMP(dst_material_index[mp - mpoly], 0, mat_nr_max);
}
e = ml2[0].e;
e = corner_edges[corner_2 + 0];
for (j = 0; j < loop_end; j++) {
ml2[j].e = ml2[j + 1].e;
corner_edges[corner_2 + j] = corner_edges[corner_2 + j + 1];
}
ml2[loop_end].e = e;
corner_edges[corner_2 + loop_end] = e;
mp->loopstart += mesh->totloop;
for (j = 0; j < mp->totloop; j++) {
ml2[j].e += edges_num;
ml2[j].v += verts_num;
corner_verts[corner_2 + j] += verts_num;
corner_edges[corner_2 + j] += edges_num;
}
}
@ -522,15 +524,16 @@ Mesh *MOD_solidify_extrude_modifyMesh(ModifierData *md, const ModifierEvalContex
}
const MPoly *mp = orig_mpoly;
for (uint i = 0; i < polys_num; i++, mp++) {
const MLoop *ml = orig_mloop + mp->loopstart;
const MLoop *ml_prev = ml + (mp->totloop - 1);
for (uint j = 0; j < mp->totloop; j++, ml++) {
int prev_corner_i = mp->loopstart + mp->totloop - 1;
for (int j = 0; j < mp->totloop; j++) {
const int corner_i = mp->loopstart + j;
const int vert_i = orig_corner_verts[corner_i];
const int prev_vert_i = orig_corner_verts[prev_corner_i];
/* add edge user */
eidx = ml_prev->e;
eidx = orig_corner_edges[prev_corner_i];
const MEdge *ed = orig_medge + eidx;
BLI_assert(ELEM(ml_prev->v, ed->v1, ed->v2) && ELEM(ml->v, ed->v1, ed->v2));
char flip = (char)((ml_prev->v > ml->v) == (ed->v1 < ed->v2));
BLI_assert(ELEM(prev_vert_i, ed->v1, ed->v2) && ELEM(vert_i, ed->v1, ed->v2));
char flip = (char)((prev_vert_i > vert_i) == (ed->v1 < ed->v2));
if (edge_user_pairs[eidx][flip] == INVALID_UNUSED) {
edge_user_pairs[eidx][flip] = i;
}
@ -538,7 +541,7 @@ Mesh *MOD_solidify_extrude_modifyMesh(ModifierData *md, const ModifierEvalContex
edge_user_pairs[eidx][0] = INVALID_PAIR;
edge_user_pairs[eidx][1] = INVALID_PAIR;
}
ml_prev = ml;
prev_corner_i = corner_i;
}
}
const MEdge *ed = orig_medge;
@ -728,14 +731,15 @@ Mesh *MOD_solidify_extrude_modifyMesh(ModifierData *md, const ModifierEvalContex
int i_curr = mp->totloop - 1;
int i_next = 0;
const MLoop *ml = &mloop[mp->loopstart];
const int *poly_verts = &corner_verts[mp->loopstart];
const int *poly_edges = &corner_edges[mp->loopstart];
sub_v3_v3v3(nor_prev, positions[ml[i_curr - 1].v], positions[ml[i_curr].v]);
sub_v3_v3v3(nor_prev, positions[poly_verts[i_curr - 1]], positions[poly_verts[i_curr]]);
normalize_v3(nor_prev);
while (i_next < mp->totloop) {
float angle;
sub_v3_v3v3(nor_next, positions[ml[i_curr].v], positions[ml[i_next].v]);
sub_v3_v3v3(nor_next, positions[poly_verts[i_curr]], positions[poly_verts[i_next]]);
normalize_v3(nor_next);
angle = angle_normalized_v3v3(nor_prev, nor_next);
@ -744,14 +748,14 @@ Mesh *MOD_solidify_extrude_modifyMesh(ModifierData *md, const ModifierEvalContex
angle = FLT_EPSILON;
}
vidx = ml[i_curr].v;
vidx = poly_verts[i_curr];
vert_accum[vidx] += angle;
#ifdef USE_NONMANIFOLD_WORKAROUND
/* skip 3+ face user edges */
if ((check_non_manifold == false) ||
LIKELY(!BLI_BITMAP_TEST(edge_tmp_tag, ml[i_curr].e) &&
!BLI_BITMAP_TEST(edge_tmp_tag, ml[i_next].e))) {
LIKELY(!BLI_BITMAP_TEST(edge_tmp_tag, poly_edges[i_curr]) &&
!BLI_BITMAP_TEST(edge_tmp_tag, poly_edges[i_next]))) {
vert_angles[vidx] += shell_v3v3_normalized_to_dist(vert_nors[vidx], poly_nors[i]) *
angle;
}
@ -815,15 +819,17 @@ Mesh *MOD_solidify_extrude_modifyMesh(ModifierData *md, const ModifierEvalContex
edge_user_pairs[eidx][1] = INVALID_UNUSED;
}
for (i = 0, mp = orig_mpoly; i < polys_num; i++, mp++) {
const MLoop *ml = orig_mloop + mp->loopstart;
const MLoop *ml_prev = ml + (mp->totloop - 1);
int prev_corner_i = mp->loopstart + mp->totloop - 1;
for (int j = 0; j < mp->totloop; j++) {
const int corner_i = mp->loopstart + j;
const int vert_i = orig_corner_verts[corner_i];
const int prev_vert_i = orig_corner_verts[prev_corner_i];
for (int j = 0; j < mp->totloop; j++, ml++) {
/* add edge user */
eidx = ml_prev->e;
eidx = orig_corner_edges[prev_corner_i];
const MEdge *ed = orig_medge + eidx;
BLI_assert(ELEM(ml_prev->v, ed->v1, ed->v2) && ELEM(ml->v, ed->v1, ed->v2));
char flip = (char)((ml_prev->v > ml->v) == (ed->v1 < ed->v2));
BLI_assert(ELEM(prev_vert_i, ed->v1, ed->v2) && ELEM(vert_i, ed->v1, ed->v2));
char flip = (char)((prev_vert_i > vert_i) == (ed->v1 < ed->v2));
if (edge_user_pairs[eidx][flip] == INVALID_UNUSED) {
edge_user_pairs[eidx][flip] = i;
}
@ -831,7 +837,7 @@ Mesh *MOD_solidify_extrude_modifyMesh(ModifierData *md, const ModifierEvalContex
edge_user_pairs[eidx][0] = INVALID_PAIR;
edge_user_pairs[eidx][1] = INVALID_PAIR;
}
ml_prev = ml;
prev_corner_i = corner_i;
}
}
const MEdge *ed = orig_medge;
@ -1061,7 +1067,8 @@ Mesh *MOD_solidify_extrude_modifyMesh(ModifierData *md, const ModifierEvalContex
/* faces */
MPoly *mp = mpoly + (polys_num * stride);
MLoop *ml = mloop + (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];
@ -1106,35 +1113,35 @@ Mesh *MOD_solidify_extrude_modifyMesh(ModifierData *md, const ModifierEvalContex
&mesh->ldata, &result->ldata, k2, (int)((loops_num * stride) + j + 3), 1);
if (flip == false) {
ml[j].v = ed->v1;
ml[j++].e = eidx;
new_corner_verts[j] = ed->v1;
new_corner_edges[j++] = eidx;
ml[j].v = ed->v2;
ml[j++].e = (edges_num * stride) + old_vert_arr[ed->v2] + newEdges;
new_corner_verts[j] = ed->v2;
new_corner_edges[j++] = (edges_num * stride) + old_vert_arr[ed->v2] + newEdges;
ml[j].v = (do_shell ? ed->v2 : old_vert_arr[ed->v2]) + verts_num;
ml[j++].e = (do_shell ? eidx : i) + edges_num;
new_corner_verts[j] = (do_shell ? ed->v2 : old_vert_arr[ed->v2]) + verts_num;
new_corner_edges[j++] = (do_shell ? eidx : i) + edges_num;
ml[j].v = (do_shell ? ed->v1 : old_vert_arr[ed->v1]) + verts_num;
ml[j++].e = (edges_num * stride) + old_vert_arr[ed->v1] + newEdges;
new_corner_verts[j] = (do_shell ? ed->v1 : old_vert_arr[ed->v1]) + verts_num;
new_corner_edges[j++] = (edges_num * stride) + old_vert_arr[ed->v1] + newEdges;
}
else {
ml[j].v = ed->v2;
ml[j++].e = eidx;
new_corner_verts[j] = ed->v2;
new_corner_edges[j++] = eidx;
ml[j].v = ed->v1;
ml[j++].e = (edges_num * stride) + old_vert_arr[ed->v1] + newEdges;
new_corner_verts[j] = ed->v1;
new_corner_edges[j++] = (edges_num * stride) + old_vert_arr[ed->v1] + newEdges;
ml[j].v = (do_shell ? ed->v1 : old_vert_arr[ed->v1]) + verts_num;
ml[j++].e = (do_shell ? eidx : i) + edges_num;
new_corner_verts[j] = (do_shell ? ed->v1 : old_vert_arr[ed->v1]) + verts_num;
new_corner_edges[j++] = (do_shell ? eidx : i) + edges_num;
ml[j].v = (do_shell ? ed->v2 : old_vert_arr[ed->v2]) + verts_num;
ml[j++].e = (edges_num * stride) + old_vert_arr[ed->v2] + newEdges;
new_corner_verts[j] = (do_shell ? ed->v2 : old_vert_arr[ed->v2]) + verts_num;
new_corner_edges[j++] = (edges_num * stride) + old_vert_arr[ed->v2] + newEdges;
}
if (origindex_edge) {
origindex_edge[ml[j - 3].e] = ORIGINDEX_NONE;
origindex_edge[ml[j - 1].e] = ORIGINDEX_NONE;
origindex_edge[new_corner_edges[j - 3]] = ORIGINDEX_NONE;
origindex_edge[new_corner_edges[j - 1]] = ORIGINDEX_NONE;
}
/* use the next material index if option enabled */
@ -1159,10 +1166,10 @@ Mesh *MOD_solidify_extrude_modifyMesh(ModifierData *md, const ModifierEvalContex
#ifdef SOLIDIFY_SIDE_NORMALS
if (do_side_normals) {
normal_quad_v3(nor,
positions[ml[j - 4].v],
positions[ml[j - 3].v],
positions[ml[j - 2].v],
positions[ml[j - 1].v]);
positions[new_corner_verts[j - 4]],
positions[new_corner_verts[j - 3]],
positions[new_corner_verts[j - 2]],
positions[new_corner_verts[j - 1]]);
add_v3_v3(edge_vert_nos[ed->v1], nor);
add_v3_v3(edge_vert_nos[ed->v2], nor);

162
source/blender/modifiers/intern/MOD_solidify_nonmanifold.c
View File

@ -187,7 +187,8 @@ Mesh *MOD_solidify_nonmanifold_modifyMesh(ModifierData *md,
const float(*orig_positions)[3] = BKE_mesh_positions(mesh);
const MEdge *orig_medge = BKE_mesh_edges(mesh);
const MPoly *orig_mpoly = BKE_mesh_polys(mesh);
const MLoop *orig_mloop = BKE_mesh_corner_verts(mesh);
const int *orig_corner_verts = BKE_mesh_corner_verts(mesh);
const int *orig_corner_edges = BKE_mesh_corner_edges(mesh);
/* These might be null. */
const float *orig_vert_bweight = CustomData_get_layer(&mesh->vdata, CD_BWEIGHT);
@ -218,7 +219,7 @@ Mesh *MOD_solidify_nonmanifold_modifyMesh(ModifierData *md,
for (uint i = 0; i < polys_num; i++, mp++) {
/* Make normals for faces without area (should really be avoided though). */
if (len_squared_v3(poly_nors[i]) < 0.5f) {
const MEdge *e = orig_medge + orig_mloop[mp->loopstart].e;
const MEdge *e = orig_medge + orig_corner_edges[mp->loopstart];
float edgedir[3];
sub_v3_v3v3(edgedir, orig_positions[e->v2], orig_positions[e->v1]);
if (fabsf(edgedir[2]) < fabsf(edgedir[1])) {
@ -257,9 +258,8 @@ Mesh *MOD_solidify_nonmanifold_modifyMesh(ModifierData *md,
{
const MPoly *mp = orig_mpoly;
for (uint i = 0; i < polys_num; i++, mp++) {
const MLoop *ml = orig_mloop + mp->loopstart;
for (uint j = 0; j < mp->totloop; j++, ml++) {
edge_adj_faces_len[ml->e]++;
for (uint j = 0; j < mp->totloop; j++) {
edge_adj_faces_len[orig_corner_edges[mp->loopstart + j]]++;
}
}
}
@ -307,10 +307,10 @@ Mesh *MOD_solidify_nonmanifold_modifyMesh(ModifierData *md,
{
const MPoly *mp = orig_mpoly;
for (uint i = 0; i < polys_num; i++, mp++) {
const MLoop *ml = orig_mloop + mp->loopstart;
for (uint j = 0; j < mp->totloop; j++, ml++) {
const uint edge = ml->e;
const bool reversed = orig_medge[edge].v2 != ml->v;
for (uint j = 0; j < mp->totloop; j++) {
const int vert = orig_corner_verts[mp->loopstart + j];
const int edge = orig_corner_edges[mp->loopstart + j];
const bool reversed = orig_medge[edge].v2 != vert;
OldEdgeFaceRef *old_face_edge_ref = edge_adj_faces[edge];
if (old_face_edge_ref == NULL) {
const uint len = edge_adj_faces_len[edge];
@ -382,8 +382,8 @@ Mesh *MOD_solidify_nonmanifold_modifyMesh(ModifierData *md,
uint changes = 0;
int cur = mp->totloop - 1;
for (int next = 0; next < mp->totloop && changes <= 2; next++) {
uint cur_v = vm[orig_mloop[mp->loopstart + cur].v];
uint next_v = vm[orig_mloop[mp->loopstart + next].v];
uint cur_v = vm[orig_corner_verts[mp->loopstart + cur]];
uint next_v = vm[orig_corner_verts[mp->loopstart + next]];
changes += (ELEM(cur_v, v1, v2) != ELEM(next_v, v1, v2));
cur = next;
}
@ -441,7 +441,7 @@ Mesh *MOD_solidify_nonmanifold_modifyMesh(ModifierData *md,
if (!face_singularity[face]) {
bool is_singularity = true;
for (uint k = 0; k < orig_mpoly[face].totloop; k++) {
if (vm[orig_mloop[((uint)orig_mpoly[face].loopstart) + k].v] != v1) {
if (vm[orig_corner_verts[((uint)orig_mpoly[face].loopstart) + k]] != v1) {
is_singularity = false;
break;
}
@ -608,7 +608,7 @@ Mesh *MOD_solidify_nonmanifold_modifyMesh(ModifierData *md,
const uint face = adj_faces->faces[j];
const int j_loopstart = orig_mpoly[face].loopstart;
const int totloop = orig_mpoly[face].totloop;
const uint j_first_v = vm[orig_mloop[j_loopstart].v];
const uint j_first_v = vm[orig_corner_verts[j_loopstart]];
for (uint k = j + 1; k < adj_len; k++) {
if (orig_mpoly[adj_faces->faces[k]].totloop != totloop) {
continue;
@ -616,9 +616,11 @@ Mesh *MOD_solidify_nonmanifold_modifyMesh(ModifierData *md,
/* Find first face first loop vert in second face loops. */
const int k_loopstart = orig_mpoly[adj_faces->faces[k]].loopstart;
int l;
const MLoop *ml = orig_mloop + k_loopstart;
for (l = 0; l < totloop && vm[ml->v] != j_first_v; l++, ml++) {
/* Pass. */
{
const int *corner_vert = &orig_corner_verts[k_loopstart];
for (l = 0; l < totloop && vm[*corner_vert] != j_first_v; l++, corner_vert++) {
/* Pass. */
}
}
if (l == totloop) {
continue;
@ -627,17 +629,16 @@ Mesh *MOD_solidify_nonmanifold_modifyMesh(ModifierData *md,
const bool reversed = adj_faces->faces_reversed[j] != adj_faces->faces_reversed[k];
const int count_dir = reversed ? -1 : 1;
bool has_diff = false;
ml = orig_mloop + j_loopstart;
for (int m = 0, n = l + totloop; m < totloop && !has_diff;
m++, n += count_dir, ml++) {
has_diff = has_diff || vm[ml->v] != vm[orig_mloop[k_loopstart + n % totloop].v];
for (int m = 0, n = l + totloop; m < totloop && !has_diff; m++, n += count_dir) {
const int vert = orig_corner_verts[j_loopstart + m];
has_diff = has_diff ||
vm[vert] != vm[orig_corner_verts[k_loopstart + n % totloop]];
}
/* If the faces are equal, discard one (j). */
if (!has_diff) {
ml = orig_mloop + j_loopstart;
uint del_loops = 0;
for (uint m = 0; m < totloop; m++, ml++) {
const uint e = ml->e;
for (uint m = 0; m < totloop; m++) {
const int e = orig_corner_edges[j_loopstart + m];
OldEdgeFaceRef *e_adj_faces = edge_adj_faces[e];
if (e_adj_faces) {
uint face_index = j;
@ -849,11 +850,11 @@ Mesh *MOD_solidify_nonmanifold_modifyMesh(ModifierData *md,
new_edges[j] = edge_data;
for (uint k = 0; k < 2; k++) {
if (faces[k] != NULL) {
const MLoop *ml = orig_mloop + faces[k]->face->loopstart;
for (int l = 0; l < faces[k]->face->totloop; l++, ml++) {
if (edge_adj_faces[ml->e] == edge_adj_faces[i]) {
if (ml->e != i && orig_edge_data_arr[ml->e] == NULL) {
orig_edge_data_arr[ml->e] = new_edges;
for (int l = 0; l < faces[k]->face->totloop; l++) {
const int edge = orig_corner_edges[faces[k]->face->loopstart + l];
if (edge_adj_faces[edge] == edge_adj_faces[i]) {
if (edge != i && orig_edge_data_arr[edge] == NULL) {
orig_edge_data_arr[edge] = new_edges;
}
faces[k]->link_edges[l] = edge_data;
break;
@ -1382,9 +1383,9 @@ Mesh *MOD_solidify_nonmanifold_modifyMesh(ModifierData *md,
for (uint i = 0; i < polys_num; i++, mp++) {
float scalar_vgroup = 1.0f;
int loopend = mp->loopstart + mp->totloop;
const MLoop *ml = orig_mloop + mp->loopstart;
for (int j = mp->loopstart; j < loopend; j++, ml++) {
const MDeformVert *dv = &dvert[ml->v];
for (int j = mp->loopstart; j < loopend; j++) {
const int vert = orig_corner_verts[mp->loopstart + j];
const MDeformVert *dv = &dvert[vert];
if (defgrp_invert) {
scalar_vgroup = min_ff(1.0f - BKE_defvert_find_weight(dv, defgrp_index),
scalar_vgroup);
@ -1655,17 +1656,19 @@ Mesh *MOD_solidify_nonmanifold_modifyMesh(ModifierData *md,
if (smd->nonmanifold_offset_mode ==
MOD_SOLIDIFY_NONMANIFOLD_OFFSET_MODE_EVEN) {
const MLoop *ml_next = orig_mloop + face->face->loopstart;
const MLoop *ml = ml_next + (face->face->totloop - 1);
const MLoop *ml_prev = ml - 1;
for (int m = 0; m < face->face->totloop && vm[ml->v] != i;
m++, ml_next++) {
ml_prev = ml;
ml = ml_next;
int corner_next = face->face->loopstart;
int corner = corner_next + (face->face->totloop - 1);
int corner_prev = corner - 1;
for (int m = 0;
m < face->face->totloop && vm[orig_corner_verts[corner]] != i;
m++, corner_next++) {
corner_prev = corner;
corner = corner_next;
}
angle = angle_v3v3v3(orig_mvert_co[vm[ml_prev->v]],
angle = angle_v3v3v3(orig_mvert_co[vm[orig_corner_verts[corner_prev]]],
orig_mvert_co[i],
orig_mvert_co[vm[ml_next->v]]);
orig_mvert_co[vm[orig_corner_verts[corner_next]]]);
if (face->reversed) {
total_angle_back += angle * ofs * ofs;
}
@ -1964,7 +1967,8 @@ Mesh *MOD_solidify_nonmanifold_modifyMesh(ModifierData *md,
float(*positions)[3] = BKE_mesh_positions_for_write(result);
MEdge *medge = BKE_mesh_edges_for_write(result);
MPoly *mpoly = BKE_mesh_polys_for_write(result);
MLoop *mloop = BKE_mesh_loops_for_write(result);
int *corner_verts = BKE_mesh_corner_verts_for_write(result);
int *corner_edges = BKE_mesh_corner_edges_for_write(result);
int *origindex_edge = CustomData_get_layer(&result->edata, CD_ORIGINDEX);
int *origindex_poly = CustomData_get_layer(&result->pdata, CD_ORIGINDEX);
@ -2304,9 +2308,9 @@ Mesh *MOD_solidify_nonmanifold_modifyMesh(ModifierData *md,
for (uint k = 0; g2->valid && k < j; g2++) {
if ((do_rim && !g2->is_orig_closed) || (do_shell && g2->split)) {
const MPoly *face = g2->edges[0]->faces[0]->face;
const MLoop *ml = orig_mloop + face->loopstart;
for (int l = 0; l < face->totloop; l++, ml++) {
if (vm[ml->v] == i) {
for (int l = 0; l < face->totloop; l++) {
const int vert = orig_corner_verts[face->loopstart + l];
if (vm[vert] == i) {
loops[k] = face->loopstart + l;
break;
}
@ -2318,16 +2322,16 @@ Mesh *MOD_solidify_nonmanifold_modifyMesh(ModifierData *md,
if (!do_flip) {
for (uint k = 0; k < j; k++) {
CustomData_copy_data(&mesh->ldata, &result->ldata, loops[k], (int)loop_index, 1);
mloop[loop_index].v = medge[edge_index - j + k].v1;
mloop[loop_index++].e = edge_index - j + k;
corner_verts[loop_index] = medge[edge_index - j + k].v1;
corner_edges[loop_index++] = edge_index - j + k;
}
}
else {
for (uint k = 1; k <= j; k++) {
CustomData_copy_data(
&mesh->ldata, &result->ldata, loops[j - k], (int)loop_index, 1);
mloop[loop_index].v = medge[edge_index - k].v2;
mloop[loop_index++].e = edge_index - k;
corner_verts[loop_index] = medge[edge_index - k].v2;
corner_edges[loop_index++] = edge_index - k;
}
}
MEM_freeN(loops);
@ -2379,14 +2383,14 @@ Mesh *MOD_solidify_nonmanifold_modifyMesh(ModifierData *md,
int loop1 = -1;
int loop2 = -1;
const MLoop *ml = orig_mloop + face->loopstart;
const uint old_v1 = vm[orig_medge[edge1->old_edge].v1];
const uint old_v2 = vm[orig_medge[edge1->old_edge].v2];
for (uint j = 0; j < face->totloop; j++, ml++) {
if (vm[ml->v] == old_v1) {
for (uint j = 0; j < face->totloop; j++) {
const int vert = orig_corner_verts[face->loopstart + j];
if (vm[vert] == old_v1) {
loop1 = face->loopstart + (int)j;
}
else if (vm[ml->v] == old_v2) {
else if (vm[vert] == old_v2) {
loop2 = face->loopstart + (int)j;
}
}
@ -2399,8 +2403,8 @@ Mesh *MOD_solidify_nonmanifold_modifyMesh(ModifierData *md,
->weight = 1.0f;
}
CustomData_copy_data(&mesh->ldata, &result->ldata, loop1, (int)loop_index, 1);
mloop[loop_index].v = medge[edge1->new_edge].v1;
mloop[loop_index++].e = edge1->new_edge;
corner_verts[loop_index] = medge[edge1->new_edge].v1;
corner_edges[loop_index++] = edge1->new_edge;
if (!v2_singularity) {
open_face_edge_index = edge1->link_edge_groups[1]->open_face_edge;
@ -2409,13 +2413,13 @@ Mesh *MOD_solidify_nonmanifold_modifyMesh(ModifierData *md,
->weight = 1.0f;
}
CustomData_copy_data(&mesh->ldata, &result->ldata, loop2, (int)loop_index, 1);
mloop[loop_index].v = medge[edge1->new_edge].v2;
corner_verts[loop_index] = medge[edge1->new_edge].v2;
open_face_edge = medge + open_face_edge_index;
if (ELEM(medge[edge2->new_edge].v2, open_face_edge->v1, open_face_edge->v2)) {
mloop[loop_index++].e = open_face_edge_index;
corner_edges[loop_index++] = open_face_edge_index;
}
else {
mloop[loop_index++].e = edge2->link_edge_groups[1]->open_face_edge;
corner_edges[loop_index++] = edge2->link_edge_groups[1]->open_face_edge;
}
}
@ -2424,8 +2428,8 @@ Mesh *MOD_solidify_nonmanifold_modifyMesh(ModifierData *md,
->weight = 1.0f;
}
CustomData_copy_data(&mesh->ldata, &result->ldata, loop2, (int)loop_index, 1);
mloop[loop_index].v = medge[edge2->new_edge].v2;
mloop[loop_index++].e = edge2->new_edge;
corner_verts[loop_index] = medge[edge2->new_edge].v2;
corner_edges[loop_index++] = edge2->new_edge;
if (!v1_singularity) {
open_face_edge_index = edge2->link_edge_groups[0]->open_face_edge;
@ -2434,13 +2438,13 @@ Mesh *MOD_solidify_nonmanifold_modifyMesh(ModifierData *md,
->weight = 1.0f;
}
CustomData_copy_data(&mesh->ldata, &result->ldata, loop1, (int)loop_index, 1);
mloop[loop_index].v = medge[edge2->new_edge].v1;
corner_verts[loop_index] = medge[edge2->new_edge].v1;
open_face_edge = medge + open_face_edge_index;
if (ELEM(medge[edge1->new_edge].v1, open_face_edge->v1, open_face_edge->v2)) {
mloop[loop_index++].e = open_face_edge_index;
corner_edges[loop_index++] = open_face_edge_index;
}
else {
mloop[loop_index++].e = edge1->link_edge_groups[0]->open_face_edge;
corner_edges[loop_index++] = edge1->link_edge_groups[0]->open_face_edge;
}
}
}
@ -2452,13 +2456,13 @@ Mesh *MOD_solidify_nonmanifold_modifyMesh(ModifierData *md,
->weight = 1.0f;
}
CustomData_copy_data(&mesh->ldata, &result->ldata, loop1, (int)loop_index, 1);
mloop[loop_index].v = medge[edge1->new_edge].v1;
corner_verts[loop_index] = medge[edge1->new_edge].v1;
open_face_edge = medge + open_face_edge_index;
if (ELEM(medge[edge2->new_edge].v1, open_face_edge->v1, open_face_edge->v2)) {
mloop[loop_index++].e = open_face_edge_index;
corner_edges[loop_index++] = open_face_edge_index;
}
else {
mloop[loop_index++].e = edge2->link_edge_groups[0]->open_face_edge;
corner_edges[loop_index++] = edge2->link_edge_groups[0]->open_face_edge;
}
}
@ -2467,8 +2471,8 @@ Mesh *MOD_solidify_nonmanifold_modifyMesh(ModifierData *md,
->weight = 1.0f;
}
CustomData_copy_data(&mesh->ldata, &result->ldata, loop1, (int)loop_index, 1);
mloop[loop_index].v = medge[edge2->new_edge].v1;
mloop[loop_index++].e = edge2->new_edge;
corner_verts[loop_index] = medge[edge2->new_edge].v1;
corner_edges[loop_index++] = edge2->new_edge;
if (!v2_singularity) {
open_face_edge_index = edge2->link_edge_groups[1]->open_face_edge;
@ -2477,13 +2481,13 @@ Mesh *MOD_solidify_nonmanifold_modifyMesh(ModifierData *md,
->weight = 1.0f;
}
CustomData_copy_data(&mesh->ldata, &result->ldata, loop2, (int)loop_index, 1);
mloop[loop_index].v = medge[edge2->new_edge].v2;
corner_verts[loop_index] = medge[edge2->new_edge].v2;
open_face_edge = medge + open_face_edge_index;
if (ELEM(medge[edge1->new_edge].v2, open_face_edge->v1, open_face_edge->v2)) {
mloop[loop_index++].e = open_face_edge_index;
corner_edges[loop_index++] = open_face_edge_index;
}
else {
mloop[loop_index++].e = edge1->link_edge_groups[1]->open_face_edge;
corner_edges[loop_index++] = edge1->link_edge_groups[1]->open_face_edge;
}
}
@ -2492,8 +2496,8 @@ Mesh *MOD_solidify_nonmanifold_modifyMesh(ModifierData *md,
->weight = 1.0f;
}
CustomData_copy_data(&mesh->ldata, &result->ldata, loop2, (int)loop_index, 1);
mloop[loop_index].v = medge[edge1->new_edge].v2;
mloop[loop_index++].e = edge1->new_edge;
corner_verts[loop_index] = medge[edge1->new_edge].v2;
corner_edges[loop_index++] = edge1->new_edge;
}
}
}
@ -2520,15 +2524,15 @@ Mesh *MOD_solidify_nonmanifold_modifyMesh(ModifierData *md,
if (totloop > 0) {
NewEdgeRef *prior_edge = fr->link_edges[totloop - 1];
uint prior_flip = (uint)(vm[orig_medge[prior_edge->old_edge].v1] ==
vm[orig_mloop[loopstart + (totloop - 1)].v]);
vm[orig_corner_verts[loopstart + (totloop - 1)]]);
for (uint j = 0; j < totloop; j++) {
NewEdgeRef *new_edge = fr->link_edges[j];
if (new_edge && new_edge->new_edge != MOD_SOLIDIFY_EMPTY_TAG) {
valid_edges++;
const uint flip = (uint)(vm[orig_medge[new_edge->old_edge].v2] ==
vm[orig_mloop[loopstart + j].v]);
vm[orig_corner_verts[loopstart + j]]);
BLI_assert(flip ||
vm[orig_medge[new_edge->old_edge].v1] == vm[orig_mloop[loopstart + j].v]);
vm[orig_medge[new_edge->old_edge].v1] == vm[orig_corner_verts[loopstart + j]]);
/* The vert that's in the current loop. */
const uint new_v1 = new_edge->link_edge_groups[flip]->new_vert;
/* The vert that's in the next loop. */
@ -2576,8 +2580,8 @@ Mesh *MOD_solidify_nonmanifold_modifyMesh(ModifierData *md,
}
CustomData_copy_data(
&mesh->ldata, &result->ldata, (int)face_loops[l], (int)loop_index, 1);
mloop[loop_index].v = face_verts[l];
mloop[loop_index++].e = face_edges[l];
corner_verts[loop_index] = face_verts[l];
corner_edges[loop_index++] = face_edges[l];
}
}
else {
@ -2585,8 +2589,8 @@ Mesh *MOD_solidify_nonmanifold_modifyMesh(ModifierData *md,
for (uint next_l = 0; next_l < k; next_l++) {
CustomData_copy_data(
&mesh->ldata, &result->ldata, (int)face_loops[l], (int)loop_index, 1);
mloop[loop_index].v = face_verts[l];
mloop[loop_index++].e = face_edges[next_l];
corner_verts[loop_index] = face_verts[l];
corner_edges[loop_index++] = face_edges[next_l];
l = next_l;
}
}