blender
/
blender
136
406
Fork 590
Code Issues 6.2k Pull Requests 760 Projects 19 Wiki Activity

Cleanup: Make naming more consistent 

Avoid _i prefix which doesn't really help
This commit is contained in:
Hans Goudey 2023-01-18 19:33:14 -06:00
parent 2a98a1c133
commit d300fe01ac
40 changed files with 303 additions and 306 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
source/blender/blenkernel/intern/curve_to_mesh_convert.cc
View File

@ -144,7 +144,6 @@ static void fill_mesh_topology(const int vert_offset,
corner_edges[cap_loop_offset + i] = profile_edges_start + ((i == (profile_segment_num - 1)) ?
(profile_segment_num - 1) :
(i_inv - 1));
corner_verts[cap_loop_offset + profile_segment_num + i] = last_ring_vert_offset + i;
corner_edges[cap_loop_offset + profile_segment_num + i] = last_ring_edge_offset + i;
}

64
source/blender/blenkernel/intern/geometry_component_mesh.cc
View File

@ -177,8 +177,8 @@ static void adapt_mesh_domain_corner_to_point_impl(const Mesh &mesh,
const Span<int> corner_verts = mesh.corner_verts();
attribute_math::DefaultMixer<T> mixer(r_values);
for (const int corner_i : IndexRange(mesh.totloop)) {
mixer.mix_in(corner_verts[corner_i], old_values[corner_i]);
for (const int corner : IndexRange(mesh.totloop)) {
mixer.mix_in(corner_verts[corner], old_values[corner]);
}
mixer.finalize();
}
@ -195,11 +195,11 @@ void adapt_mesh_domain_corner_to_point_impl(const Mesh &mesh,
Array<bool> loose_verts(mesh.totvert, true);
r_values.fill(true);
for (const int corner_i : IndexRange(mesh.totloop)) {
const int point_index = corner_verts[corner_i];
for (const int corner : IndexRange(mesh.totloop)) {
const int point_index = corner_verts[corner];
loose_verts[point_index] = false;
if (!old_values[corner_i]) {
if (!old_values[corner]) {
r_values[point_index] = false;
}
}
@ -242,8 +242,8 @@ static GVArray adapt_mesh_domain_point_to_corner(const Mesh &mesh, const GVArray
attribute_math::convert_to_static_type(varray.type(), [&](auto dummy) {
using T = decltype(dummy);
new_varray = VArray<T>::ForFunc(
mesh.totloop, [corner_verts, varray = varray.typed<T>()](const int64_t corner_i) {
return varray[corner_verts[corner_i]];
mesh.totloop, [corner_verts, varray = varray.typed<T>()](const int64_t corner) {
return varray[corner_verts[corner]];
});
});
return new_varray;
@ -383,8 +383,8 @@ void adapt_mesh_domain_face_to_point_impl(const Mesh &mesh,
for (const int poly_index : polys.index_range()) {
const MPoly &poly = polys[poly_index];
const T value = old_values[poly_index];
for (const int vert_i : corner_verts.slice(poly.loopstart, poly.totloop)) {
mixer.mix_in(vert_i, value);
for (const int vert : corner_verts.slice(poly.loopstart, poly.totloop)) {
mixer.mix_in(vert, value);
}
}
@ -406,8 +406,8 @@ void adapt_mesh_domain_face_to_point_impl(const Mesh &mesh,
for (const int poly_index : range) {
if (old_values[poly_index]) {
const MPoly &poly = polys[poly_index];
for (const int vert_i : corner_verts.slice(poly.loopstart, poly.totloop)) {
r_values[vert_i] = true;
for (const int vert : corner_verts.slice(poly.loopstart, poly.totloop)) {
r_values[vert] = true;
}
}
}
@ -472,8 +472,8 @@ void adapt_mesh_domain_face_to_edge_impl(const Mesh &mesh,
for (const int poly_index : polys.index_range()) {
const MPoly &poly = polys[poly_index];
const T value = old_values[poly_index];
for (const int edge_i : corner_edges.slice(poly.loopstart, poly.totloop)) {
mixer.mix_in(edge_i, value);
for (const int edge : corner_edges.slice(poly.loopstart, poly.totloop)) {
mixer.mix_in(edge, value);
}
}
mixer.finalize();
@ -494,8 +494,8 @@ void adapt_mesh_domain_face_to_edge_impl(const Mesh &mesh,
for (const int poly_index : range) {
if (old_values[poly_index]) {
const MPoly &poly = polys[poly_index];
for (const int edge_i : corner_edges.slice(poly.loopstart, poly.totloop)) {
r_values[edge_i] = true;
for (const int edge : corner_edges.slice(poly.loopstart, poly.totloop)) {
r_values[edge] = true;
}
}
}
@ -530,8 +530,8 @@ static GVArray adapt_mesh_domain_point_to_face(const Mesh &mesh, const GVArray &
[corner_verts, polys, varray = varray.typed<bool>()](const int face_index) {
/* A face is selected if all of its vertices were selected. */
const MPoly &poly = polys[face_index];
for (const int vert_i : corner_verts.slice(poly.loopstart, poly.totloop)) {
if (!varray[vert_i]) {
for (const int vert : corner_verts.slice(poly.loopstart, poly.totloop)) {
if (!varray[vert]) {
return false;
}
}
@ -544,8 +544,8 @@ static GVArray adapt_mesh_domain_point_to_face(const Mesh &mesh, const GVArray &
T return_value;
attribute_math::DefaultMixer<T> mixer({&return_value, 1});
const MPoly &poly = polys[face_index];
for (const int vert_i : corner_verts.slice(poly.loopstart, poly.totloop)) {
mixer.mix_in(0, varray[vert_i]);
for (const int vert : corner_verts.slice(poly.loopstart, poly.totloop)) {
mixer.mix_in(0, varray[vert]);
}
mixer.finalize();
return return_value;
@ -606,10 +606,10 @@ void adapt_mesh_domain_edge_to_corner_impl(const Mesh &mesh,
/* For every corner, mix the values from the adjacent edges on the face. */
for (const int loop_index : IndexRange(poly.loopstart, poly.totloop)) {
const int loop_index_prev = mesh_topology::poly_loop_prev(poly, loop_index);
const int edge_i = corner_edges[loop_index];
const int edge_i_prev = corner_edges[loop_index_prev];
mixer.mix_in(loop_index, old_values[edge_i]);
mixer.mix_in(loop_index, old_values[edge_i_prev]);
const int edge = corner_edges[loop_index];
const int edge_prev = corner_edges[loop_index_prev];
mixer.mix_in(loop_index, old_values[edge]);
mixer.mix_in(loop_index, old_values[edge_prev]);
}
}
@ -633,9 +633,9 @@ void adapt_mesh_domain_edge_to_corner_impl(const Mesh &mesh,
const MPoly &poly = polys[poly_index];
for (const int loop_index : IndexRange(poly.loopstart, poly.totloop)) {
const int loop_index_prev = mesh_topology::poly_loop_prev(poly, loop_index);
const int edge_i = corner_edges[loop_index];
const int edge_i_prev = corner_edges[loop_index_prev];
if (old_values[edge_i] && old_values[edge_i_prev]) {
const int edge = corner_edges[loop_index];
const int edge_prev = corner_edges[loop_index_prev];
if (old_values[edge] && old_values[edge_prev]) {
r_values[loop_index] = true;
}
}
@ -726,8 +726,8 @@ static GVArray adapt_mesh_domain_edge_to_face(const Mesh &mesh, const GVArray &v
new_varray = VArray<bool>::ForFunc(
polys.size(), [corner_edges, polys, varray = varray.typed<T>()](const int face_index) {
const MPoly &poly = polys[face_index];
for (const int edge_i : corner_edges.slice(poly.loopstart, poly.totloop)) {
if (!varray[edge_i]) {
for (const int edge : corner_edges.slice(poly.loopstart, poly.totloop)) {
if (!varray[edge]) {
return false;
}
}
@ -740,8 +740,8 @@ static GVArray adapt_mesh_domain_edge_to_face(const Mesh &mesh, const GVArray &v
T return_value;
attribute_math::DefaultMixer<T> mixer({&return_value, 1});
const MPoly &poly = polys[face_index];
for (const int edge_i : corner_edges.slice(poly.loopstart, poly.totloop)) {
mixer.mix_in(0, varray[edge_i]);
for (const int edge : corner_edges.slice(poly.loopstart, poly.totloop)) {
mixer.mix_in(0, varray[edge]);
}
mixer.finalize();
return return_value;
@ -1247,9 +1247,11 @@ static ComponentAttributeProviders create_attribute_providers_for_mesh()
nullptr,
AttributeValidator{&material_index_clamp});
/* Note: This clamping is more of a last resort, since it's quite easy to make an
* invalid mesh that will crash Blender by arbitrarily editing this attribute. */
static const auto int_index_clamp = mf::build::SI1_SO<int, int>(
"Index Validate",
[](int value) { return std::clamp<int>(value, 0, std::numeric_limits<int>::max()); },
[](int value) { return std::max(value, 0); },
mf::build::exec_presets::AllSpanOrSingle());
static BuiltinCustomDataLayerProvider corner_vert(".corner_vert",
ATTR_DOMAIN_CORNER,

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

@ -570,7 +570,7 @@ static int customdata_compare(
if (StringRef(l1->name) == ".corner_edge") {
/* TODO(Hans): This attribute wasn't tested before loops were refactored into separate
* corner edges and corner verts arrays. Remove after updating tests. */
* corner edges and corner verts attributes. Remove after updating tests. */
continue;
}

26
source/blender/blenkernel/intern/mesh_iterators.cc
View File

@ -202,24 +202,24 @@ void BKE_mesh_foreach_mapped_loop(Mesh *mesh,
if (v_index || f_index) {
for (p_idx = 0; p_idx < mesh->totpoly; p_idx++, mp++) {
for (i = 0; i < mp->totloop; i++) {
const int vert_i = corner_verts[i];
const int v_idx = v_index ? v_index[vert_i] : vert_i;
const int vert = corner_verts[i];
const int v_idx = v_index ? v_index[vert] : vert;
const int f_idx = f_index ? f_index[p_idx] : p_idx;
const float *no = loop_normals ? *loop_normals++ : nullptr;
if (ELEM(ORIGINDEX_NONE, v_idx, f_idx)) {
continue;
}
func(userData, v_idx, f_idx, positions[vert_i], no);
func(userData, v_idx, f_idx, positions[vert], no);
}
}
}
else {
for (p_idx = 0; p_idx < mesh->totpoly; p_idx++, mp++) {
for (i = 0; i < mp->totloop; i++) {
const int vert_i = corner_verts[i];
const int vert = corner_verts[i];
const int f_idx = p_idx;
const float *no = loop_normals ? *loop_normals++ : nullptr;
func(userData, vert_i, f_idx, positions[vert_i], no);
func(userData, vert, f_idx, positions[vert], no);
}
}
}
@ -324,12 +324,12 @@ void BKE_mesh_foreach_mapped_subdiv_face_center(
continue;
}
for (int j = 0; j < mp->totloop; j++) {
const int vert_i = corner_verts[mp->loopstart + j];
if (BLI_BITMAP_TEST(facedot_tags, vert_i)) {
const int vert = corner_verts[mp->loopstart + j];
if (BLI_BITMAP_TEST(facedot_tags, vert)) {
func(userData,
orig,
positions[vert_i],
(flag & MESH_FOREACH_USE_NORMAL) ? vert_normals[vert_i] : nullptr);
positions[vert],
(flag & MESH_FOREACH_USE_NORMAL) ? vert_normals[vert] : nullptr);
}
}
}
@ -337,12 +337,12 @@ void BKE_mesh_foreach_mapped_subdiv_face_center(
else {
for (int i = 0; i < mesh->totpoly; i++, mp++) {
for (int j = 0; j < mp->totloop; j++) {
const int vert_i = corner_verts[mp->loopstart + j];
if (BLI_BITMAP_TEST(facedot_tags, vert_i)) {
const int vert = corner_verts[mp->loopstart + j];
if (BLI_BITMAP_TEST(facedot_tags, vert)) {
func(userData,
i,
positions[vert_i],
(flag & MESH_FOREACH_USE_NORMAL) ? vert_normals[vert_i] : nullptr);
positions[vert],
(flag & MESH_FOREACH_USE_NORMAL) ? vert_normals[vert] : nullptr);
}
}
}

14
source/blender/blenkernel/intern/mesh_mapping.cc
View File

@ -624,7 +624,7 @@ Vector<Vector<int>> build_edge_to_loop_map_resizable(const Span<int> corner_edge
* Callback deciding whether the given poly/loop/edge define an island boundary or not.
*/
using MeshRemap_CheckIslandBoundary = bool (*)(const MPoly *mpoly,
const int corner_i,
const int corner,
const MEdge *medge,
const int edge_index,
const bool *sharp_edges,
@ -722,15 +722,15 @@ static void poly_edge_loop_islands_calc(const MEdge *medge,
BLI_assert(poly_groups[poly] == poly_group_id);
mp = &mpoly[poly];
for (const int64_t corner_i : blender::IndexRange(mp->loopstart, mp->totloop)) {
for (const int64_t corner : blender::IndexRange(mp->loopstart, mp->totloop)) {
/* loop over poly users */
const int me_idx = corner_edges[corner_i];
const int me_idx = corner_edges[corner];
const MEdge *me = &medge[me_idx];
const MeshElemMap *map_ele = &edge_poly_map[me_idx];
const int *p = map_ele->indices;
int i = map_ele->count;
if (!edge_boundary_check(mp,
int(corner_i),
int(corner),
me,
me_idx,
sharp_edges,
@ -836,7 +836,7 @@ static void poly_edge_loop_islands_calc(const MEdge *medge,
}
static bool poly_is_island_boundary_smooth_cb(const MPoly *mp,
const int /*corner_i*/,
const int /*corner*/,
const MEdge * /*me*/,
const int edge_index,
const bool *sharp_edges,
@ -1018,7 +1018,7 @@ struct MeshCheckIslandBoundaryUv {
};
static bool mesh_check_island_boundary_uv(const MPoly * /*mp*/,
const int corner_i,
const int corner,
const MEdge *me,
const int /*edge_index*/,
const bool * /*sharp_edges*/,
@ -1032,7 +1032,7 @@ static bool mesh_check_island_boundary_uv(const MPoly * /*mp*/,
user_data);
const int *corner_verts = data->corner_verts;
const float(*luvs)[2] = data->luvs;
const MeshElemMap *edge_to_loops = &data->edge_loop_map[data->corner_edges[corner_i]];
const MeshElemMap *edge_to_loops = &data->edge_loop_map[data->corner_edges[corner]];
BLI_assert(edge_to_loops->count >= 2 && (edge_to_loops->count % 2) == 0);

8
source/blender/blenkernel/intern/mesh_normals.cc
View File

@ -1550,7 +1550,7 @@ void BKE_mesh_normals_loop_split(const float (*vert_positions)[3],
common_data.clnors_data = {reinterpret_cast<short2 *>(clnors_data), clnors_data ? numLoops : 0};
common_data.positions = {reinterpret_cast<const float3 *>(vert_positions), numVerts};
common_data.edges = {medges, numEdges};
common_data.polys = {mpolys, numPolys};
common_data.polys = polys;
common_data.corner_verts = {corner_verts, numLoops};
common_data.corner_edges = {corner_edges, numLoops};
common_data.edge_to_loops = edge_to_loops;
@ -1989,9 +1989,9 @@ void BKE_mesh_normals_loop_to_vertex(const int numVerts,
int i;
for (i = 0; i < numLoops; i++) {
const int vert_i = corner_verts[i];
add_v3_v3(r_vert_clnors[vert_i], clnors[i]);
vert_loops_count[vert_i]++;
const int vert = corner_verts[i];
add_v3_v3(r_vert_clnors[vert], clnors[i]);
vert_loops_count[vert]++;
}
for (i = 0; i < numVerts; i++) {

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

@ -399,9 +399,9 @@ static int mesh_remap_interp_poly_data_get(const MPoly *mp,
}
for (i = 0, vco = *vcos, index = *indices; i < sources_num; i++, vco++, index++) {
const int vert_i = corner_verts[mp->loopstart + i];
*index = use_loops ? int(mp->loopstart) + i : vert_i;
copy_v3_v3(*vco, vcos_src[vert_i]);
const int vert = corner_verts[mp->loopstart + i];
*index = use_loops ? int(mp->loopstart) + i : vert;
copy_v3_v3(*vco, vcos_src[vert]);
if (r_closest_index) {
/* Find closest vert/loop in this case. */
const float dist_sq = len_squared_v3v3(point, *vco);
@ -1168,9 +1168,9 @@ static void mesh_island_to_astar_graph(MeshIslandStore *islands,
}
for (pl_idx = 0, l_idx = mp->loopstart; pl_idx < mp->totloop; pl_idx++, l_idx++) {
const int edge_i = corner_edges[l_idx];
const int edge = corner_edges[l_idx];
if (BLI_BITMAP_TEST(done_edges, edge_i)) {
if (BLI_BITMAP_TEST(done_edges, edge)) {
continue;
}
@ -1180,7 +1180,7 @@ static void mesh_island_to_astar_graph(MeshIslandStore *islands,
positions,
polys,
corner_verts,
edge_i,
edge,
done_edges,
edge_to_poly_map,
false,
@ -1613,11 +1613,11 @@ void BKE_mesh_remap_calc_loops_from_mesh(const int mode,
BVHTreeFromMesh *tdata = &treedata[tindex];
for (plidx_dst = 0; plidx_dst < mp_dst->totloop; plidx_dst++) {
const int vert_dst_i = corner_verts_dst[mp_dst->loopstart + plidx_dst];
const int vert_dst = corner_verts_dst[mp_dst->loopstart + plidx_dst];
if (use_from_vert) {
MeshElemMap *vert_to_refelem_map_src = nullptr;
copy_v3_v3(tmp_co, vert_positions_dst[vert_dst_i]);
copy_v3_v3(tmp_co, vert_positions_dst[vert_dst]);
nearest.index = -1;
/* Convert the vertex to tree coordinates, if needed. */
@ -1704,8 +1704,8 @@ void BKE_mesh_remap_calc_loops_from_mesh(const int mode,
* Have to find its loop matching our closest vertex. */
mp_src = &polys_src[best_index_src];
for (plidx_src = 0; plidx_src < mp_src->totloop; plidx_src++) {
const int vert_src_i = corner_verts_src[mp_src->loopstart + plidx_src];
if (vert_src_i == nearest.index) {
const int vert_src = corner_verts_src[mp_src->loopstart + plidx_src];
if (vert_src == nearest.index) {
best_index_src = plidx_src + mp_src->loopstart;
break;
}
@ -1727,7 +1727,7 @@ void BKE_mesh_remap_calc_loops_from_mesh(const int mode,
int n = (ray_radius > 0.0f) ? MREMAP_RAYCAST_APPROXIMATE_NR : 1;
float w = 1.0f;
copy_v3_v3(tmp_co, vert_positions_dst[vert_dst_i]);
copy_v3_v3(tmp_co, vert_positions_dst[vert_dst]);
copy_v3_v3(tmp_no, loop_nors_dst[plidx_dst + mp_dst->loopstart]);
/* We do our transform here, since we may do several raycast/nearest queries. */
@ -1755,7 +1755,7 @@ void BKE_mesh_remap_calc_loops_from_mesh(const int mode,
* is null, it means none of its loop mapped to this source island,
* hence we can skip it later.
*/
copy_v3_v3(tmp_co, vert_positions_dst[vert_dst_i]);
copy_v3_v3(tmp_co, vert_positions_dst[vert_dst]);
nearest.index = -1;
/* Convert the vertex to tree coordinates, if needed. */
@ -1781,7 +1781,7 @@ void BKE_mesh_remap_calc_loops_from_mesh(const int mode,
}
}
else { /* Nearest poly either to use all its loops/verts or just closest one. */
copy_v3_v3(tmp_co, vert_positions_dst[vert_dst_i]);
copy_v3_v3(tmp_co, vert_positions_dst[vert_dst]);
nearest.index = -1;
/* Convert the vertex to tree coordinates, if needed. */
@ -1922,8 +1922,8 @@ void BKE_mesh_remap_calc_loops_from_mesh(const int mode,
last_valid_pidx_isld_src);
mp_src = &polys_src[pidx_src];
for (j = 0; j < mp_src->totloop; j++) {
const int vert_src_i = corner_verts_src[mp_src->loopstart + j];
const float dist_sq = len_squared_v3v3(positions_src[vert_src_i], tmp_co);
const int vert_src = corner_verts_src[mp_src->loopstart + j];
const float dist_sq = len_squared_v3v3(positions_src[vert_src], tmp_co);
if (dist_sq < best_dist_sq) {
best_dist_sq = dist_sq;
lidx_src = mp_src->loopstart + j;
@ -2002,8 +2002,8 @@ void BKE_mesh_remap_calc_loops_from_mesh(const int mode,
float best_dist_sq = FLT_MAX;
int j;
const int vert_dst_i = corner_verts_dst[lidx_dst];
copy_v3_v3(tmp_co, vert_positions_dst[vert_dst_i]);
const int vert_dst = corner_verts_dst[lidx_dst];
copy_v3_v3(tmp_co, vert_positions_dst[vert_dst]);
/* We do our transform here,
* since we may do several raycast/nearest queries. */
@ -2329,8 +2329,8 @@ void BKE_mesh_remap_calc_polys_from_mesh(const int mode,
INIT_MINMAX2(poly_dst_2d_min, poly_dst_2d_max);
for (j = 0; j < mp->totloop; j++) {
const int vert_i = corner_verts[j + mp->loopstart];
copy_v3_v3(tmp_co, vert_positions_dst[vert_i]);
const int vert = corner_verts[mp->loopstart + j];
copy_v3_v3(tmp_co, vert_positions_dst[vert]);
if (space_transform) {
BLI_space_transform_apply(space_transform, tmp_co);
}

20
source/blender/blenkernel/intern/mesh_sample.cc
View File

@ -164,14 +164,10 @@ Span<float3> MeshAttributeInterpolator::ensure_barycentric_coords()
const int looptri_index = looptri_indices_[i];
const MLoopTri &looptri = looptris[looptri_index];
const int v0_index = corner_verts[looptri.tri[0]];
const int v1_index = corner_verts[looptri.tri[1]];
const int v2_index = corner_verts[looptri.tri[2]];
interp_weights_tri_v3(bary_coords_[i],
positions[v0_index],
positions[v1_index],
positions[v2_index],
positions[corner_verts[looptri.tri[0]]],
positions[corner_verts[looptri.tri[1]]],
positions[corner_verts[looptri.tri[2]]],
positions_[i]);
}
return bary_coords_;
@ -193,13 +189,9 @@ Span<float3> MeshAttributeInterpolator::ensure_nearest_weights()
const int looptri_index = looptri_indices_[i];
const MLoopTri &looptri = looptris[looptri_index];
const int v0_index = corner_verts[looptri.tri[0]];
const int v1_index = corner_verts[looptri.tri[1]];
const int v2_index = corner_verts[looptri.tri[2]];
const float d0 = len_squared_v3v3(positions_[i], positions[v0_index]);
const float d1 = len_squared_v3v3(positions_[i], positions[v1_index]);
const float d2 = len_squared_v3v3(positions_[i], positions[v2_index]);
const float d0 = len_squared_v3v3(positions_[i], positions[corner_verts[looptri.tri[0]]]);
const float d1 = len_squared_v3v3(positions_[i], positions[corner_verts[looptri.tri[1]]]);
const float d2 = len_squared_v3v3(positions_[i], positions[corner_verts[looptri.tri[2]]]);
nearest_weights_[i] = MIN3_PAIR(d0, d1, d2, float3(1, 0, 0), float3(0, 1, 0), float3(0, 0, 1));
}

70
source/blender/blenkernel/intern/mesh_validate.cc
View File

@ -231,9 +231,9 @@ bool BKE_mesh_validate_arrays(Mesh *mesh,
(void)0
#define IS_REMOVED_EDGE(_me) (_me->v2 == _me->v1)
#define REMOVE_LOOP_TAG(corner_i) \
#define REMOVE_LOOP_TAG(corner) \
{ \
corner_edges[corner_i] = INVALID_LOOP_EDGE_MARKER; \
corner_edges[corner] = INVALID_LOOP_EDGE_MARKER; \
free_flag.polyloops = do_fixes; \
} \
(void)0
@ -604,28 +604,28 @@ bool BKE_mesh_validate_arrays(Mesh *mesh,
* before we start checking each poly, but several polys can use same vert,
* so we have to ensure here all verts of current poly are cleared. */
for (j = 0; j < mp->totloop; j++) {
const int vert_i = corner_verts[sp->loopstart + j];
if (vert_i < totvert) {
BLI_BITMAP_DISABLE(vert_tag, vert_i);
const int vert = corner_verts[sp->loopstart + j];
if (vert < totvert) {
BLI_BITMAP_DISABLE(vert_tag, vert);
}
}
/* Test all poly's loops' vert idx. */
for (j = 0; j < mp->totloop; j++, v++) {
const int vert_i = corner_verts[sp->loopstart + j];
if (vert_i >= totvert) {
const int vert = corner_verts[sp->loopstart + j];
if (vert >= totvert) {
/* Invalid vert idx. */
PRINT_ERR("\tLoop %u has invalid vert reference (%d)", sp->loopstart + j, vert_i);
PRINT_ERR("\tLoop %u has invalid vert reference (%d)", sp->loopstart + j, vert);
sp->invalid = true;
}
else if (BLI_BITMAP_TEST(vert_tag, vert_i)) {
else if (BLI_BITMAP_TEST(vert_tag, vert)) {
PRINT_ERR("\tPoly %u has duplicated vert reference at corner (%u)", i, j);
sp->invalid = true;
}
else {
BLI_BITMAP_ENABLE(vert_tag, vert_i);
BLI_BITMAP_ENABLE(vert_tag, vert);
}
*v = vert_i;
*v = vert;
}
if (sp->invalid) {
@ -634,10 +634,10 @@ bool BKE_mesh_validate_arrays(Mesh *mesh,
/* Test all poly's loops. */
for (j = 0; j < mp->totloop; j++) {
const int corner_i = sp->loopstart + j;
const int vert_i = corner_verts[corner_i];
const int edge_i = corner_edges[corner_i];
v1 = vert_i;
const int corner = sp->loopstart + j;
const int vert = corner_verts[corner];
const int edge = corner_edges[corner];
v1 = vert;
v2 = corner_verts[sp->loopstart + (j + 1) % mp->totloop];
if (!BLI_edgehash_haskey(edge_hash, v1, v2)) {
/* Edge not existing. */
@ -649,33 +649,33 @@ bool BKE_mesh_validate_arrays(Mesh *mesh,
sp->invalid = true;
}
}
else if (edge_i >= totedge) {
else if (edge >= totedge) {
/* Invalid edge idx.
* We already know from previous text that a valid edge exists, use it (if allowed)! */
if (do_fixes) {
int prev_e = edge_i;
corner_edges[corner_i] = POINTER_AS_INT(BLI_edgehash_lookup(edge_hash, v1, v2));
int prev_e = edge;
corner_edges[corner] = POINTER_AS_INT(BLI_edgehash_lookup(edge_hash, v1, v2));
fix_flag.loops_edge = true;
PRINT_ERR("\tLoop %d has invalid edge reference (%d), fixed using edge %d",
corner_i,
corner,
prev_e,
corner_edges[corner_i]);
corner_edges[corner]);
}
else {
PRINT_ERR("\tLoop %d has invalid edge reference (%d)", corner_i, edge_i);
PRINT_ERR("\tLoop %d has invalid edge reference (%d)", corner, edge);
sp->invalid = true;
}
}
else {
me = &medges[edge_i];
me = &medges[edge];
if (IS_REMOVED_EDGE(me) ||
!((me->v1 == v1 && me->v2 == v2) || (me->v1 == v2 && me->v2 == v1))) {
/* The pointed edge is invalid (tagged as removed, or vert idx mismatch),
* and we already know from previous test that a valid one exists,
* use it (if allowed)! */
if (do_fixes) {
int prev_e = edge_i;
corner_edges[corner_i] = POINTER_AS_INT(BLI_edgehash_lookup(edge_hash, v1, v2));
int prev_e = edge;
corner_edges[corner] = POINTER_AS_INT(BLI_edgehash_lookup(edge_hash, v1, v2));
fix_flag.loops_edge = true;
PRINT_ERR(
"\tPoly %u has invalid edge reference (%d, is_removed: %d), fixed using edge "
@ -683,10 +683,10 @@ bool BKE_mesh_validate_arrays(Mesh *mesh,
sp->index,
prev_e,
IS_REMOVED_EDGE(me),
corner_edges[corner_i]);
corner_edges[corner]);
}
else {
PRINT_ERR("\tPoly %u has invalid edge reference (%d)", sp->index, edge_i);
PRINT_ERR("\tPoly %u has invalid edge reference (%d)", sp->index, edge);
sp->invalid = true;
}
}
@ -764,11 +764,11 @@ bool BKE_mesh_validate_arrays(Mesh *mesh,
else {
/* Unused loops. */
if (prev_end < sp->loopstart) {
int corner_i;
for (j = prev_end, corner_i = prev_end; j < sp->loopstart; j++, corner_i++) {
int corner;
for (j = prev_end, corner = prev_end; j < sp->loopstart; j++, corner++) {
PRINT_ERR("\tLoop %u is unused.", j);
if (do_fixes) {
REMOVE_LOOP_TAG(corner_i);
REMOVE_LOOP_TAG(corner);
}
}
prev_end = sp->loopstart + sp->numverts;
@ -798,11 +798,11 @@ bool BKE_mesh_validate_arrays(Mesh *mesh,
}
/* We may have some remaining unused loops to get rid of! */
if (prev_end < totloop) {
int corner_i;
for (j = prev_end, corner_i = prev_end; j < totloop; j++, corner_i++) {
int corner;
for (j = prev_end, corner = prev_end; j < totloop; j++, corner++) {
PRINT_ERR("\tLoop %u is unused.", j);
if (do_fixes) {
REMOVE_LOOP_TAG(corner_i);
REMOVE_LOOP_TAG(corner);
}
}
}
@ -1253,9 +1253,9 @@ void BKE_mesh_strip_loose_polysloops(Mesh *me)
}
/* And now, get rid of invalid loops. */
int corner_i = 0;
for (a = b = 0; a < me->totloop; a++, corner_i++) {
if (corner_edges[corner_i] != INVALID_LOOP_EDGE_MARKER) {
int corner = 0;
for (a = b = 0; a < me->totloop; a++, corner++) {
if (corner_edges[corner] != INVALID_LOOP_EDGE_MARKER) {
if (a != b) {
CustomData_copy_data(&me->ldata, &me->ldata, a, b, 1);
}

4
source/blender/blenkernel/intern/subdiv_converter_mesh.c
View File

@ -135,8 +135,8 @@ static void get_face_vertices(const OpenSubdiv_Converter *converter,
ConverterStorage *storage = converter->user_data;
const MPoly *poly = &storage->polys[manifold_face_index];
for (int i = 0; i < poly->totloop; i++) {
const int vert_i = storage->corner_verts[poly->loopstart + i];
manifold_face_vertices[i] = storage->manifold_vertex_index[vert_i];
const int vert = storage->corner_verts[poly->loopstart + i];
manifold_face_vertices[i] = storage->manifold_vertex_index[vert];
}
}

123
source/blender/blenkernel/intern/subdiv_foreach.c
View File

@ -169,11 +169,11 @@ static void subdiv_foreach_ctx_count(SubdivForeachTaskContext *ctx)
const MPoly *coarse_poly = &ctx->coarse_polys[poly_index];
const int num_ptex_faces_per_poly = num_ptex_faces_per_poly_get(coarse_poly);
for (int corner = 0; corner < coarse_poly->totloop; corner++) {
const int coarse_edge_i = ctx->coarse_corner_edges[coarse_poly->loopstart + corner];
const bool is_edge_used = BLI_BITMAP_TEST_BOOL(ctx->coarse_edges_used_map, coarse_edge_i);
const int coarse_edge = ctx->coarse_corner_edges[coarse_poly->loopstart + corner];
const bool is_edge_used = BLI_BITMAP_TEST_BOOL(ctx->coarse_edges_used_map, coarse_edge);
/* Edges which aren't counted yet. */
if (!is_edge_used) {
BLI_BITMAP_ENABLE(ctx->coarse_edges_used_map, coarse_edge_i);
BLI_BITMAP_ENABLE(ctx->coarse_edges_used_map, coarse_edge);
ctx->num_subdiv_vertices += num_subdiv_vertices_per_coarse_edge;
}
}
@ -304,12 +304,12 @@ static void subdiv_foreach_corner_vertices_regular_do(
const int coarse_poly_index = coarse_poly - ctx->coarse_polys;
const int ptex_face_index = ctx->face_ptex_offset[coarse_poly_index];
for (int corner = 0; corner < coarse_poly->totloop; corner++) {
const int coarse_vert_index = ctx->coarse_corner_verts[coarse_poly->loopstart + corner];
const int coarse_vert = ctx->coarse_corner_verts[coarse_poly->loopstart + corner];
if (check_usage &&
BLI_BITMAP_TEST_AND_SET_ATOMIC(ctx->coarse_vertices_used_map, coarse_vert_index)) {
BLI_BITMAP_TEST_AND_SET_ATOMIC(ctx->coarse_vertices_used_map, coarse_vert)) {
continue;
}
const int coarse_vertex_index = coarse_vert_index;
const int coarse_vertex_index = coarse_vert;
const int subdiv_vertex_index = ctx->vertices_corner_offset + coarse_vertex_index;
const float u = weights[corner][0];
const float v = weights[corner][1];
@ -343,12 +343,12 @@ static void subdiv_foreach_corner_vertices_special_do(
const int coarse_poly_index = coarse_poly - ctx->coarse_polys;
int ptex_face_index = ctx->face_ptex_offset[coarse_poly_index];
for (int corner = 0; corner < coarse_poly->totloop; corner++, ptex_face_index++) {
const int coarse_vert_index = ctx->coarse_corner_verts[coarse_poly->loopstart + corner];
const int coarse_vert = ctx->coarse_corner_verts[coarse_poly->loopstart + corner];
if (check_usage &&
BLI_BITMAP_TEST_AND_SET_ATOMIC(ctx->coarse_vertices_used_map, coarse_vert_index)) {
BLI_BITMAP_TEST_AND_SET_ATOMIC(ctx->coarse_vertices_used_map, coarse_vert)) {
continue;
}
const int coarse_vertex_index = coarse_vert_index;
const int coarse_vertex_index = coarse_vert;
const int subdiv_vertex_index = ctx->vertices_corner_offset + coarse_vertex_index;
vertex_corner(ctx->foreach_context,
tls,
@ -430,14 +430,14 @@ static void subdiv_foreach_edge_vertices_regular_do(SubdivForeachTaskContext *ct
const int coarse_poly_index = coarse_poly - ctx->coarse_polys;
const int ptex_face_index = ctx->face_ptex_offset[coarse_poly_index];
for (int corner = 0; corner < coarse_poly->totloop; corner++) {
const int coarse_vert_index = ctx->coarse_corner_verts[coarse_poly->loopstart + corner];
const int coarse_vert = ctx->coarse_corner_verts[coarse_poly->loopstart + corner];
const int coarse_edge_index = ctx->coarse_corner_edges[coarse_poly->loopstart + corner];
if (check_usage &&
BLI_BITMAP_TEST_AND_SET_ATOMIC(ctx->coarse_edges_used_map, coarse_edge_index)) {
continue;
}
const MEdge *coarse_edge = &ctx->coarse_edges[coarse_edge_index];
const bool flip = (coarse_edge->v2 == coarse_vert_index);
const bool flip = (coarse_edge->v2 == coarse_vert);
int subdiv_vertex_index = ctx->vertices_edge_offset +
coarse_edge_index * num_subdiv_vertices_per_coarse_edge;
for (int vertex_index = 0; vertex_index < num_subdiv_vertices_per_coarse_edge;
@ -493,14 +493,14 @@ static void subdiv_foreach_edge_vertices_special_do(SubdivForeachTaskContext *ct
const int ptex_face_start_index = ctx->face_ptex_offset[coarse_poly_index];
int ptex_face_index = ptex_face_start_index;
for (int corner = 0; corner < coarse_poly->totloop; corner++, ptex_face_index++) {
const int coarse_vert_index = ctx->coarse_corner_verts[coarse_poly->loopstart + corner];
const int coarse_vert = ctx->coarse_corner_verts[coarse_poly->loopstart + corner];
const int coarse_edge_index = ctx->coarse_corner_edges[coarse_poly->loopstart + corner];
if (check_usage &&
BLI_BITMAP_TEST_AND_SET_ATOMIC(ctx->coarse_edges_used_map, coarse_edge_index)) {
continue;
}
const MEdge *coarse_edge = &ctx->coarse_edges[coarse_edge_index];
const bool flip = (coarse_edge->v2 == coarse_vert_index);
const bool flip = (coarse_edge->v2 == coarse_vert);
int subdiv_vertex_index = ctx->vertices_edge_offset +
coarse_edge_index * num_subdiv_vertices_per_coarse_edge;
int vertex_delta = 1;
@ -903,14 +903,14 @@ static void subdiv_foreach_edges_all_patches_special(SubdivForeachTaskContext *c
/* Connect inner path of patch to boundary. */
int prev_corner = coarse_poly->totloop - 1;
for (int corner = 0; corner < coarse_poly->totloop; corner++) {
const int vert_i = ctx->coarse_corner_verts[coarse_poly->loopstart + corner];
const int edge_i = ctx->coarse_corner_edges[coarse_poly->loopstart + corner];
const int prev_edge_i = ctx->coarse_corner_edges[coarse_poly->loopstart + prev_corner];
const int coarse_vert = ctx->coarse_corner_verts[coarse_poly->loopstart + corner];
const int coarse_edge_i = ctx->coarse_corner_edges[coarse_poly->loopstart + corner];
const int coarse_prev_edge = ctx->coarse_corner_edges[coarse_poly->loopstart + prev_corner];
{
const MEdge *coarse_edge = &ctx->coarse_edges[edge_i];
const MEdge *coarse_edge = &ctx->coarse_edges[coarse_edge_i];
const int start_edge_vertex = ctx->vertices_edge_offset +
edge_i * num_subdiv_vertices_per_coarse_edge;
const bool flip = (coarse_edge->v2 == vert_i);
coarse_edge_i * num_subdiv_vertices_per_coarse_edge;
const bool flip = (coarse_edge->v2 == coarse_vert);
int side_start_index;
if (ptex_face_resolution >= 3) {
side_start_index = start_vertex_index + num_inner_vertices_per_ptex * corner;
@ -927,10 +927,10 @@ static void subdiv_foreach_edges_all_patches_special(SubdivForeachTaskContext *c
}
}
if (ptex_face_resolution >= 3) {
const MEdge *coarse_edge = &ctx->coarse_edges[prev_edge_i];
const MEdge *coarse_edge = &ctx->coarse_edges[coarse_prev_edge];
const int start_edge_vertex = ctx->vertices_edge_offset +
prev_edge_i * num_subdiv_vertices_per_coarse_edge;
const bool flip = (coarse_edge->v2 == vert_i);
coarse_prev_edge * num_subdiv_vertices_per_coarse_edge;
const bool flip = (coarse_edge->v2 == coarse_vert);
int side_start_index = start_vertex_index + num_inner_vertices_per_ptex * corner;
for (int i = 0; i < ptex_face_resolution - 2; i++, subdiv_edge_index++) {
const int v1 = (flip) ? (start_edge_vertex + (resolution - i - 3)) :
@ -1152,31 +1152,33 @@ static void subdiv_foreach_loops_regular(SubdivForeachTaskContext *ctx,
/* Loops for faces connecting inner ptex part with boundary. */
int prev_corner_index = coarse_poly->totloop - 1;
for (int corner = 0; corner < coarse_poly->totloop; corner++) {
const int vert_i = ctx->coarse_corner_verts[coarse_poly->loopstart + corner];
const int edge_i = ctx->coarse_corner_edges[coarse_poly->loopstart + corner];
const int prev_vert_i = ctx->coarse_corner_verts[coarse_poly->loopstart + prev_corner_index];
const int prev_edge_i = ctx->coarse_corner_edges[coarse_poly->loopstart + prev_corner_index];
const int coarse_vert = ctx->coarse_corner_verts[coarse_poly->loopstart + corner];
const int coarse_edge_i = ctx->coarse_corner_edges[coarse_poly->loopstart + corner];
const int coase_prev_vert =
ctx->coarse_corner_verts[coarse_poly->loopstart + prev_corner_index];
const int coarse_prev_edge =
ctx->coarse_corner_edges[coarse_poly->loopstart + prev_corner_index];
const MEdge *coarse_edge = &ctx->coarse_edges[edge_i];
const MEdge *prev_coarse_edge = &ctx->coarse_edges[prev_edge_i];
const MEdge *coarse_edge = &ctx->coarse_edges[coarse_edge_i];
const MEdge *prev_coarse_edge = &ctx->coarse_edges[coarse_prev_edge];
const int start_edge_vertex = ctx->vertices_edge_offset +
edge_i * num_subdiv_vertices_per_coarse_edge;
const bool flip = (coarse_edge->v2 == vert_i);
coarse_edge_i * num_subdiv_vertices_per_coarse_edge;
const bool flip = (coarse_edge->v2 == coarse_vert);
int side_start_index = start_vertex_index;
int side_stride = 0;
int v0 = ctx->vertices_corner_offset + vert_i;
int v0 = ctx->vertices_corner_offset + coarse_vert;
int v3, e3;
int e2_offset, e2_stride;
float u, v, delta_u, delta_v;
if (prev_vert_i == prev_coarse_edge->v1) {
v3 = ctx->vertices_edge_offset + prev_edge_i * num_subdiv_vertices_per_coarse_edge +
if (coase_prev_vert == prev_coarse_edge->v1) {
v3 = ctx->vertices_edge_offset + coarse_prev_edge * num_subdiv_vertices_per_coarse_edge +
num_subdiv_vertices_per_coarse_edge - 1;
e3 = ctx->edge_boundary_offset + prev_edge_i * num_subdiv_edges_per_coarse_edge +
e3 = ctx->edge_boundary_offset + coarse_prev_edge * num_subdiv_edges_per_coarse_edge +
num_subdiv_edges_per_coarse_edge - 1;
}
else {
v3 = ctx->vertices_edge_offset + prev_edge_i * num_subdiv_vertices_per_coarse_edge;
e3 = ctx->edge_boundary_offset + prev_edge_i * num_subdiv_edges_per_coarse_edge;
v3 = ctx->vertices_edge_offset + coarse_prev_edge * num_subdiv_vertices_per_coarse_edge;
e3 = ctx->edge_boundary_offset + coarse_prev_edge * num_subdiv_edges_per_coarse_edge;
}
/* Calculate starting vertex of corresponding inner part of ptex. */
if (corner == 0) {
@ -1233,11 +1235,11 @@ static void subdiv_foreach_loops_regular(SubdivForeachTaskContext *ctx,
const int v2 = side_start_index + side_stride * i;
int e0;
if (flip) {
e0 = ctx->edge_boundary_offset + edge_i * num_subdiv_edges_per_coarse_edge +
e0 = ctx->edge_boundary_offset + coarse_edge_i * num_subdiv_edges_per_coarse_edge +
num_subdiv_edges_per_coarse_edge - i - 1;
}
else {
e0 = ctx->edge_boundary_offset + edge_i * num_subdiv_edges_per_coarse_edge + i;
e0 = ctx->edge_boundary_offset + coarse_edge_i * num_subdiv_edges_per_coarse_edge + i;
}
int e1 = start_edge_index + num_edges_per_ptex_face_get(resolution - 2) +
corner * num_subdiv_vertices_per_coarse_edge + i;
@ -1457,30 +1459,30 @@ static void subdiv_foreach_loops_special(SubdivForeachTaskContext *ctx,
/* Loops for faces connecting inner ptex part with boundary. */
for (int prev_corner = coarse_poly->totloop - 1, corner = 0; corner < coarse_poly->totloop;
prev_corner = corner, corner++) {
const int vert_i = ctx->coarse_corner_verts[coarse_poly->loopstart + corner];
const int edge_i = ctx->coarse_corner_edges[coarse_poly->loopstart + corner];
const int prev_vert_i = ctx->coarse_corner_verts[coarse_poly->loopstart + prev_corner];
const int prev_edge_i = ctx->coarse_corner_edges[coarse_poly->loopstart + prev_corner];
const int coarse_vert = ctx->coarse_corner_verts[coarse_poly->loopstart + corner];
const int coarse_edge_i = ctx->coarse_corner_edges[coarse_poly->loopstart + corner];
const int coase_prev_vert = ctx->coarse_corner_verts[coarse_poly->loopstart + prev_corner];
const int coarse_prev_edge = ctx->coarse_corner_edges[coarse_poly->loopstart + prev_corner];
const MEdge *coarse_edge = &ctx->coarse_edges[edge_i];
const MEdge *prev_coarse_edge = &ctx->coarse_edges[prev_edge_i];
const bool flip = (coarse_edge->v2 == vert_i);
const MEdge *coarse_edge = &ctx->coarse_edges[coarse_edge_i];
const MEdge *prev_coarse_edge = &ctx->coarse_edges[coarse_prev_edge];
const bool flip = (coarse_edge->v2 == coarse_vert);
const int start_edge_vertex = ctx->vertices_edge_offset +
edge_i * num_subdiv_vertices_per_coarse_edge;
coarse_edge_i * num_subdiv_vertices_per_coarse_edge;
const int corner_vertex_index = start_vertex_index + corner * num_inner_vertices_per_ptex;
const int corner_edge_index = start_edge_index + corner * num_inner_edges_per_ptex_face;
/* Create loops for polygons along U axis. */
int v0 = ctx->vertices_corner_offset + vert_i;
int v0 = ctx->vertices_corner_offset + coarse_vert;
int v3, e3;
if (prev_vert_i == prev_coarse_edge->v1) {
v3 = ctx->vertices_edge_offset + prev_edge_i * num_subdiv_vertices_per_coarse_edge +
if (coase_prev_vert == prev_coarse_edge->v1) {
v3 = ctx->vertices_edge_offset + coarse_prev_edge * num_subdiv_vertices_per_coarse_edge +
num_subdiv_vertices_per_coarse_edge - 1;
e3 = ctx->edge_boundary_offset + prev_edge_i * num_subdiv_edges_per_coarse_edge +
e3 = ctx->edge_boundary_offset + coarse_prev_edge * num_subdiv_edges_per_coarse_edge +
num_subdiv_edges_per_coarse_edge - 1;
}
else {
v3 = ctx->vertices_edge_offset + prev_edge_i * num_subdiv_vertices_per_coarse_edge;
e3 = ctx->edge_boundary_offset + prev_edge_i * num_subdiv_edges_per_coarse_edge;
v3 = ctx->vertices_edge_offset + coarse_prev_edge * num_subdiv_vertices_per_coarse_edge;
e3 = ctx->edge_boundary_offset + coarse_prev_edge * num_subdiv_edges_per_coarse_edge;
}
for (int i = 0; i <= ptex_face_inner_resolution; i++, subdiv_loop_index += 4) {
int v1;
@ -1499,11 +1501,11 @@ static void subdiv_foreach_loops_special(SubdivForeachTaskContext *ctx,
}
int e0;
if (flip) {
e0 = ctx->edge_boundary_offset + edge_i * num_subdiv_edges_per_coarse_edge +
e0 = ctx->edge_boundary_offset + coarse_edge_i * num_subdiv_edges_per_coarse_edge +
num_subdiv_edges_per_coarse_edge - i - 1;
}
else {
e0 = ctx->edge_boundary_offset + edge_i * num_subdiv_edges_per_coarse_edge + i;
e0 = ctx->edge_boundary_offset + coarse_edge_i * num_subdiv_edges_per_coarse_edge + i;
}
int e1 = start_edge_index + corner * (2 * ptex_face_inner_resolution + 1);
if (ptex_face_resolution >= 3) {
@ -1550,14 +1552,14 @@ static void subdiv_foreach_loops_special(SubdivForeachTaskContext *ctx,
e3 = e1;
}
/* Create loops for polygons along V axis. */
const bool flip_prev = (prev_coarse_edge->v2 == vert_i);
const bool flip_prev = (prev_coarse_edge->v2 == coarse_vert);
v0 = corner_vertex_index;
if (prev_vert_i == prev_coarse_edge->v1) {
v3 = ctx->vertices_edge_offset + prev_edge_i * num_subdiv_vertices_per_coarse_edge +
if (coase_prev_vert == prev_coarse_edge->v1) {
v3 = ctx->vertices_edge_offset + coarse_prev_edge * num_subdiv_vertices_per_coarse_edge +
num_subdiv_vertices_per_coarse_edge - 1;
}
else {
v3 = ctx->vertices_edge_offset + prev_edge_i * num_subdiv_vertices_per_coarse_edge;
v3 = ctx->vertices_edge_offset + coarse_prev_edge * num_subdiv_vertices_per_coarse_edge;
}
e3 = start_edge_index +
coarse_poly->totloop * (num_inner_edges_per_ptex_face + ptex_face_inner_resolution + 1) +
@ -1584,11 +1586,12 @@ static void subdiv_foreach_loops_special(SubdivForeachTaskContext *ctx,
int v2 = flip_prev ? v3 - 1 : v3 + 1;
int e2;
if (flip_prev) {
e2 = ctx->edge_boundary_offset + prev_edge_i * num_subdiv_edges_per_coarse_edge +
e2 = ctx->edge_boundary_offset + coarse_prev_edge * num_subdiv_edges_per_coarse_edge +
num_subdiv_edges_per_coarse_edge - 2 - i;
}
else {
e2 = ctx->edge_boundary_offset + prev_edge_i * num_subdiv_edges_per_coarse_edge + 1 + i;
e2 = ctx->edge_boundary_offset + coarse_prev_edge * num_subdiv_edges_per_coarse_edge + 1 +
i;
}
const float u = 0.0f;
const float v = du * (i + 1);

16
source/blender/draw/intern/mesh_extractors/extract_mesh_vbo_edge_fac.cc
View File

@ -112,27 +112,27 @@ static void extract_edge_fac_iter_poly_mesh(const MeshRenderData *mr,
const int ml_index_end = mp->loopstart + mp->totloop;
for (int ml_index = mp->loopstart; ml_index < ml_index_end; ml_index += 1) {
const int vert_i = mr->corner_verts[ml_index];
const int edge_i = mr->corner_edges[ml_index];
const int vert = mr->corner_verts[ml_index];
const int edge = mr->corner_edges[ml_index];
if (data->use_edge_render) {
const MEdge *med = &mr->medge[edge_i];
const MEdge *med = &mr->medge[edge];
data->vbo_data[ml_index] = (med->flag & ME_EDGEDRAW) ? 255 : 0;
}
else {
/* Count loop per edge to detect non-manifold. */
if (data->edge_loop_count[edge_i] < 3) {
data->edge_loop_count[edge_i]++;
if (data->edge_loop_count[edge] < 3) {
data->edge_loop_count[edge]++;
}
if (data->edge_loop_count[edge_i] == 2) {
if (data->edge_loop_count[edge] == 2) {
/* Manifold */
const int ml_index_last = mp->totloop + mp->loopstart - 1;
const int ml_index_other = (ml_index == ml_index_last) ? mp->loopstart : (ml_index + 1);
const int vert_next = mr->corner_verts[ml_index_other];
float ratio = loop_edge_factor_get(mr->poly_normals[mp_index],
mr->vert_positions[vert_i],
mr->vert_normals[vert_i],
mr->vert_positions[vert],
mr->vert_normals[vert],
mr->vert_positions[vert_next]);
data->vbo_data[ml_index] = ratio * 253 + 1;
}

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

@ -79,15 +79,15 @@ static void extract_fdots_pos_iter_poly_mesh(const MeshRenderData *mr,
const int ml_index_end = mp->loopstart + mp->totloop;
for (int ml_index = mp->loopstart; ml_index < ml_index_end; ml_index += 1) {
const int vert_i = mr->corner_verts[ml_index];
const int vert = mr->corner_verts[ml_index];
if (mr->use_subsurf_fdots) {
if (BLI_BITMAP_TEST(facedot_tags, vert_i)) {
copy_v3_v3(center[mp_index], mr->vert_positions[vert_i]);
if (BLI_BITMAP_TEST(facedot_tags, vert)) {
copy_v3_v3(center[mp_index], mr->vert_positions[vert]);
break;
}
}
else {
add_v3_v3(center[mp_index], mr->vert_positions[vert_i]);
add_v3_v3(center[mp_index], mr->vert_positions[vert]);
}
}

4
source/blender/draw/intern/mesh_extractors/extract_mesh_vbo_fdots_uv.cc
View File

@ -78,9 +78,9 @@ static void extract_fdots_uv_iter_poly_mesh(const MeshRenderData *mr,
const int ml_index_end = mp->loopstart + mp->totloop;
for (int ml_index = mp->loopstart; ml_index < ml_index_end; ml_index += 1) {
const int vert_i = mr->corner_verts[ml_index];
const int vert = mr->corner_verts[ml_index];
if (mr->use_subsurf_fdots) {
if (BLI_BITMAP_TEST(facedot_tags, vert_i)) {
if (BLI_BITMAP_TEST(facedot_tags, vert)) {
copy_v2_v2(data->vbo_data[mp_index], data->uv_data[ml_index]);
}
}

12
source/blender/draw/intern/mesh_extractors/extract_mesh_vbo_lnor.cc
View File

@ -66,13 +66,13 @@ static void extract_lnor_iter_poly_mesh(const MeshRenderData *mr,
const int ml_index_end = mp->loopstart + mp->totloop;
for (int ml_index = mp->loopstart; ml_index < ml_index_end; ml_index += 1) {
const int vert_i = mr->corner_verts[ml_index];
const int vert = mr->corner_verts[ml_index];
GPUPackedNormal *lnor_data = &(*(GPUPackedNormal **)data)[ml_index];
if (mr->loop_normals) {
*lnor_data = GPU_normal_convert_i10_v3(mr->loop_normals[ml_index]);
}
else if (mp->flag & ME_SMOOTH) {
*lnor_data = GPU_normal_convert_i10_v3(mr->vert_normals[vert_i]);
*lnor_data = GPU_normal_convert_i10_v3(mr->vert_normals[vert]);
}
else {
*lnor_data = GPU_normal_convert_i10_v3(mr->poly_normals[mp_index]);
@ -82,7 +82,7 @@ static void extract_lnor_iter_poly_mesh(const MeshRenderData *mr,
* Only use origindex in edit mode where it is used to display the edge-normals.
* In paint mode it will use the un-mapped data to draw the wire-frame. */
if (hidden ||
(mr->edit_bmesh && (mr->v_origindex) && mr->v_origindex[vert_i] == ORIGINDEX_NONE)) {
(mr->edit_bmesh && (mr->v_origindex) && mr->v_origindex[vert] == ORIGINDEX_NONE)) {
lnor_data->w = -1;
}
else if (mr->select_poly && mr->select_poly[mp_index]) {
@ -190,13 +190,13 @@ static void extract_lnor_hq_iter_poly_mesh(const MeshRenderData *mr,
const int ml_index_end = mp->loopstart + mp->totloop;
for (int ml_index = mp->loopstart; ml_index < ml_index_end; ml_index += 1) {
const int vert_i = mr->corner_verts[ml_index];
const int vert = mr->corner_verts[ml_index];
gpuHQNor *lnor_data = &(*(gpuHQNor **)data)[ml_index];
if (mr->loop_normals) {
normal_float_to_short_v3(&lnor_data->x, mr->loop_normals[ml_index]);
}
else if (mp->flag & ME_SMOOTH) {
normal_float_to_short_v3(&lnor_data->x, mr->vert_normals[vert_i]);
normal_float_to_short_v3(&lnor_data->x, mr->vert_normals[vert]);
}
else {
normal_float_to_short_v3(&lnor_data->x, mr->poly_normals[mp_index]);
@ -206,7 +206,7 @@ static void extract_lnor_hq_iter_poly_mesh(const MeshRenderData *mr,
* Only use origindex in edit mode where it is used to display the edge-normals.
* In paint mode it will use the un-mapped data to draw the wire-frame. */
if (hidden ||
(mr->edit_bmesh && (mr->v_origindex) && mr->v_origindex[vert_i] == ORIGINDEX_NONE)) {
(mr->edit_bmesh && (mr->v_origindex) && mr->v_origindex[vert] == ORIGINDEX_NONE)) {
lnor_data->w = -1;
}
else if (mr->select_poly && mr->select_poly[mp_index]) {

4
source/blender/draw/intern/mesh_extractors/extract_mesh_vbo_mesh_analysis.cc
View File

@ -580,8 +580,8 @@ static void statvis_calc_sharp(const MeshRenderData *mr, float *r_sharp)
BLI_edgehash_free(eh, nullptr);
for (int l_index = 0; l_index < mr->loop_len; l_index++) {
const int vert_i = mr->corner_verts[l_index];
r_sharp[l_index] = sharp_remap(vert_angles[vert_i], min, max, minmax_irange);
const int vert = mr->corner_verts[l_index];
r_sharp[l_index] = sharp_remap(vert_angles[vert], min, max, minmax_irange);
}
}

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

@ -127,8 +127,8 @@ static void extract_edge_idx_iter_poly_mesh(const MeshRenderData *mr,
{
const int ml_index_end = mp->loopstart + mp->totloop;
for (int ml_index = mp->loopstart; ml_index < ml_index_end; ml_index += 1) {
const int edge_i = mr->corner_edges[ml_index];
(*(int32_t **)data)[ml_index] = (mr->e_origindex) ? mr->e_origindex[edge_i] : edge_i;
const int edge = mr->corner_edges[ml_index];
(*(int32_t **)data)[ml_index] = (mr->e_origindex) ? mr->e_origindex[edge] : edge;
}
}
@ -139,8 +139,8 @@ static void extract_vert_idx_iter_poly_mesh(const MeshRenderData *mr,
{
const int ml_index_end = mp->loopstart + mp->totloop;
for (int ml_index = mp->loopstart; ml_index < ml_index_end; ml_index += 1) {
const int vert_i = mr->corner_verts[ml_index];
(*(int32_t **)data)[ml_index] = (mr->v_origindex) ? mr->v_origindex[vert_i] : vert_i;
const int vert = mr->corner_verts[ml_index];
(*(int32_t **)data)[ml_index] = (mr->v_origindex) ? mr->v_origindex[vert] : vert;
}
}

4
source/blender/draw/intern/mesh_extractors/extract_mesh_vbo_weights.cc
View File

@ -140,9 +140,9 @@ static void extract_weights_iter_poly_mesh(const MeshRenderData *mr,
MeshExtract_Weight_Data *data = static_cast<MeshExtract_Weight_Data *>(_data);
const int ml_index_end = mp->loopstart + mp->totloop;
for (int ml_index = mp->loopstart; ml_index < ml_index_end; ml_index += 1) {
const int vert_i = mr->corner_verts[ml_index];
const int vert = mr->corner_verts[ml_index];
if (data->dvert != nullptr) {
const MDeformVert *dvert = &data->dvert[vert_i];
const MDeformVert *dvert = &data->dvert[vert];
data->vbo_data[ml_index] = evaluate_vertex_weight(dvert, data->wstate);
}
else {

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

@ -1111,8 +1111,8 @@ static void sculpt_face_set_grow(Object *ob,
continue;
}
const MPoly *c_poly = &polys[p];
for (const int vert_i : corner_verts.slice(c_poly->loopstart, c_poly->totloop)) {
const MeshElemMap *vert_map = &ss->pmap[vert_i];
for (const int vert : corner_verts.slice(c_poly->loopstart, c_poly->totloop)) {
const MeshElemMap *vert_map = &ss->pmap[vert];
for (int i = 0; i < vert_map->count; i++) {
const int neighbor_face_index = vert_map->indices[i];
if (neighbor_face_index == p) {

3
source/blender/editors/transform/transform_snap_object.cc
View File

@ -254,7 +254,8 @@ static void snap_object_data_mesh_get(SnapObjectContext *sctx,
BKE_bvhtree_from_mesh_get(
r_treedata, me_eval, use_hide ? BVHTREE_FROM_LOOPTRI_NO_HIDDEN : BVHTREE_FROM_LOOPTRI, 4);
BLI_assert(reinterpret_cast<const float3 *>(r_treedata->vert_positions) == positions.data());
BLI_assert(reinterpret_cast<const float3 *>(r_treedata->vert_positions) ==
vert_positions.data());
BLI_assert(r_treedata->corner_verts == corner_verts.data());
BLI_assert(!polys.data() || r_treedata->looptri);
BLI_assert(!r_treedata->tree || r_treedata->looptri);

16
source/blender/geometry/intern/realize_instances.cc
View File

@ -95,7 +95,7 @@ struct MeshElementStartIndices {
int vertex = 0;
int edge = 0;
int poly = 0;
int corner = 0;
int loop = 0;
};
struct MeshRealizeInfo {
@ -548,7 +548,7 @@ static void gather_realize_tasks_recursive(GatherTasksInfo &gather_info,
base_instance_context.id});
gather_info.r_offsets.mesh_offsets.vertex += mesh->totvert;
gather_info.r_offsets.mesh_offsets.edge += mesh->totedge;
gather_info.r_offsets.mesh_offsets.corner += mesh->totloop;
gather_info.r_offsets.mesh_offsets.loop += mesh->totloop;
gather_info.r_offsets.mesh_offsets.poly += mesh->totpoly;
}
break;
@ -960,13 +960,13 @@ static void execute_realize_mesh_task(const RealizeInstancesOptions &options,
const IndexRange dst_vert_range(task.start_indices.vertex, src_positions.size());
const IndexRange dst_edge_range(task.start_indices.edge, src_edges.size());
const IndexRange dst_poly_range(task.start_indices.poly, src_polys.size());
const IndexRange dst_corner_range(task.start_indices.corner, src_corner_verts.size());
const IndexRange dst_loop_range(task.start_indices.loop, src_corner_verts.size());
MutableSpan<float3> dst_positions = all_dst_positions.slice(dst_vert_range);
MutableSpan<MEdge> dst_edges = all_dst_edges.slice(dst_edge_range);
MutableSpan<MPoly> dst_polys = all_dst_polys.slice(dst_poly_range);
MutableSpan<int> dst_corner_verts = all_dst_corner_verts.slice(dst_corner_range);
MutableSpan<int> dst_corner_edges = all_dst_corner_edges.slice(dst_corner_range);
MutableSpan<int> dst_corner_verts = all_dst_corner_verts.slice(dst_loop_range);
MutableSpan<int> dst_corner_edges = all_dst_corner_edges.slice(dst_loop_range);
threading::parallel_for(src_positions.index_range(), 1024, [&](const IndexRange vert_range) {
for (const int i : vert_range) {
@ -993,7 +993,7 @@ static void execute_realize_mesh_task(const RealizeInstancesOptions &options,
const MPoly &src_poly = src_polys[i];
MPoly &dst_poly = dst_polys[i];
dst_poly = src_poly;
dst_poly.loopstart += task.start_indices.corner;
dst_poly.loopstart += task.start_indices.loop;
}
});
if (!all_dst_material_indices.is_empty()) {
@ -1042,7 +1042,7 @@ static void execute_realize_mesh_task(const RealizeInstancesOptions &options,
case ATTR_DOMAIN_FACE:
return dst_poly_range;
case ATTR_DOMAIN_CORNER:
return dst_corner_range;
return dst_loop_range;
default:
BLI_assert_unreachable();
return IndexRange();
@ -1066,7 +1066,7 @@ static void execute_realize_mesh_tasks(const RealizeInstancesOptions &options,
const Mesh &last_mesh = *last_task.mesh_info->mesh;
const int tot_vertices = last_task.start_indices.vertex + last_mesh.totvert;
const int tot_edges = last_task.start_indices.edge + last_mesh.totedge;
const int tot_loops = last_task.start_indices.corner + last_mesh.totloop;
const int tot_loops = last_task.start_indices.loop + last_mesh.totloop;
const int tot_poly = last_task.start_indices.poly + last_mesh.totpoly;
Mesh *dst_mesh = BKE_mesh_new_nomain(tot_vertices, tot_edges, 0, tot_loops, tot_poly);

6
source/blender/io/alembic/exporter/abc_writer_mesh.cc
View File

@ -465,9 +465,9 @@ static void get_topology(struct Mesh *mesh,
r_has_flat_shaded_poly |= (poly.flag & ME_SMOOTH) == 0;
int corner_i = poly.loopstart + (poly.totloop - 1);
for (int j = 0; j < poly.totloop; j++, corner_i--) {
poly_verts.push_back(corner_verts[corner_i]);
int corner = poly.loopstart + (poly.totloop - 1);
for (int j = 0; j < poly.totloop; j++, corner--) {
poly_verts.push_back(corner_verts[corner]);
}
}
}

8
source/blender/io/alembic/intern/abc_reader_mesh.cc
View File

@ -210,15 +210,15 @@ static void read_mpolys(CDStreamConfig &config, const AbcMeshData &mesh_data)
uint last_vertex_index = 0;
for (int f = 0; f < face_size; f++, loop_index++, rev_loop_index--) {
const int vert_i = (*face_indices)[loop_index];
corner_verts[rev_loop_index] = vert_i;
const int vert = (*face_indices)[loop_index];
corner_verts[rev_loop_index] = vert;
if (f > 0 && vert_i == last_vertex_index) {
if (f > 0 && vert == last_vertex_index) {
/* This face is invalid, as it has consecutive loops from the same vertex. This is caused
* by invalid geometry in the Alembic file, such as in T76514. */
seen_invalid_geometry = true;
}
last_vertex_index = vert_i;
last_vertex_index = vert;
if (do_uvs) {
uv_index = (*uvs_indices)[do_uvs_per_loop ? loop_index : last_vertex_index];

8
source/blender/io/usd/intern/usd_writer_mesh.cc
View File

@ -283,8 +283,8 @@ static void get_loops_polys(const Mesh *mesh, USDMeshData &usd_mesh_data)
for (const int i : polys.index_range()) {
const MPoly &poly = polys[i];
usd_mesh_data.face_vertex_counts.push_back(poly.totloop);
for (const int vert_i : corner_verts.slice(poly.loopstart, poly.totloop)) {
usd_mesh_data.face_indices.push_back(vert_i);
for (const int vert : corner_verts.slice(poly.loopstart, poly.totloop)) {
usd_mesh_data.face_indices.push_back(vert);
}
}
}
@ -433,8 +433,8 @@ void USDGenericMeshWriter::write_normals(const Mesh *mesh, pxr::UsdGeomMesh usd_
}
else {
/* Smooth shaded, use individual vert normals. */
for (const int vert_i : corner_verts.slice(poly.loopstart, poly.totloop)) {
loop_normals.push_back(pxr::GfVec3f(vert_normals[vert_i]));
for (const int vert : corner_verts.slice(poly.loopstart, poly.totloop)) {
loop_normals.push_back(pxr::GfVec3f(vert_normals[vert]));
}
}
}

4
source/blender/io/wavefront_obj/exporter/obj_export_mesh.cc
View File

@ -468,8 +468,8 @@ int16_t OBJMesh::get_poly_deform_group_index(const int poly_index,
group_weights.fill(0);
bool found_any_group = false;
const MPoly &mpoly = mesh_polys_[poly_index];
for (const int vert_i : mesh_corner_verts_.slice(mpoly.loopstart, mpoly.totloop)) {
const MDeformVert &dv = dverts[vert_i];
for (const int vert : mesh_corner_verts_.slice(mpoly.loopstart, mpoly.totloop)) {
const MDeformVert &dv = dverts[vert];
for (int weight_i = 0; weight_i < dv.totweight; ++weight_i) {
const auto group = dv.dw[weight_i].def_nr;
if (group < group_weights.size()) {

1
source/blender/io/wavefront_obj/importer/obj_import_mesh.cc
View File

@ -215,6 +215,7 @@ void MeshFromGeometry::create_polys_loops(Mesh *mesh, bool use_vertex_groups)
const PolyCorner &curr_corner = mesh_geometry_.face_corners_[curr_face.start_index_ + idx];
corner_verts[tot_loop_idx] = mesh_geometry_.global_to_local_vertices_.lookup_default(
curr_corner.vert_index, 0);
tot_loop_idx++;
/* Setup vertex group data, if needed. */
if (dverts.is_empty()) {

3
source/blender/nodes/geometry/nodes/node_geo_blur_attribute.cc
View File

@ -222,9 +222,8 @@ static Array<Vector<int>> create_mesh_map(const Mesh &mesh,
}
case ATTR_DOMAIN_FACE: {
const Span<MPoly> polys = mesh.polys();
const Span<int> corner_edges = mesh.corner_edges();
const int edges_num = mesh.totedge;
return build_face_to_face_by_edge_map(polys, corner_edges, edges_num, mask);
return build_face_to_face_by_edge_map(polys, mesh.corner_edges(), edges_num, mask);
}
case ATTR_DOMAIN_CORNER: {
return {};

8
source/blender/nodes/geometry/nodes/node_geo_convex_hull.cc
View File

@ -110,7 +110,7 @@ static Mesh *hull_from_bullet(const Mesh *mesh, Span<float3> coords)
MutableSpan<MPoly> polys = result->polys_for_write();
MutableSpan<int> mesh_corner_verts = result->corner_verts_for_write();
MutableSpan<int> mesh_corner_edges = result->corner_edges_for_write();
int dst_corner_i = 0;
int dst_corner = 0;
for (const int i : IndexRange(faces_num)) {
const int len = plConvexHullGetFaceSize(hull, i);
@ -125,9 +125,9 @@ static Mesh *hull_from_bullet(const Mesh *mesh, Span<float3> coords)
face.loopstart = j;
face.totloop = len;
for (const int k : IndexRange(len)) {
mesh_corner_verts[dst_corner_i] = corner_verts[loops[k]];
mesh_corner_edges[dst_corner_i] = corner_edges[loops[k]];
dst_corner_i++;
mesh_corner_verts[dst_corner] = corner_verts[loops[k]];
mesh_corner_edges[dst_corner] = corner_edges[loops[k]];
dst_corner++;
}
j += len;
}

26
source/blender/nodes/geometry/nodes/node_geo_delete_geometry.cc
View File

@ -445,8 +445,8 @@ static void compute_selected_polys_from_vertex_selection(const Mesh &mesh,
const MPoly &poly_src = polys[i];
bool all_verts_in_selection = true;
for (const int vert_i : corner_verts.slice(poly_src.loopstart, poly_src.totloop)) {
if (!vertex_selection[vert_i]) {
for (const int vert : corner_verts.slice(poly_src.loopstart, poly_src.totloop)) {
if (!vertex_selection[vert]) {
all_verts_in_selection = false;
break;
}
@ -548,8 +548,8 @@ static void compute_selected_polys_from_edge_selection(const Mesh &mesh,
const MPoly &poly_src = polys[i];
bool all_edges_in_selection = true;
for (const int edge_i : corner_edges.slice(poly_src.loopstart, poly_src.totloop)) {
if (!edge_selection[edge_i]) {
for (const int edge : corner_edges.slice(poly_src.loopstart, poly_src.totloop)) {
if (!edge_selection[edge]) {
all_edges_in_selection = false;
break;
}
@ -734,10 +734,10 @@ static void compute_selected_mesh_data_from_poly_selection_edge_face(
selected_loops_num += poly_src.totloop;
/* Add the vertices and the edges. */
for (const int edge_i : corner_edges.slice(poly_src.loopstart, poly_src.totloop)) {
for (const int edge : corner_edges.slice(poly_src.loopstart, poly_src.totloop)) {
/* Check first if it has not yet been added. */
if (r_edge_map[edge_i] == -1) {
r_edge_map[edge_i] = selected_edges_num;
if (r_edge_map[edge] == -1) {
r_edge_map[edge] = selected_edges_num;
selected_edges_num++;
}
}
@ -788,15 +788,15 @@ static void compute_selected_mesh_data_from_poly_selection(const Mesh &mesh,
/* Add the vertices and the edges. */
for (const int corner : IndexRange(poly_src.loopstart, poly_src.totloop)) {
const int vert_i = corner_verts[corner];
const int edge_i = corner_edges[corner];
const int vert = corner_verts[corner];
const int edge = corner_edges[corner];
/* Check first if it has not yet been added. */
if (r_vertex_map[vert_i] == -1) {
r_vertex_map[vert_i] = selected_verts_num;
if (r_vertex_map[vert] == -1) {
r_vertex_map[vert] = selected_verts_num;
selected_verts_num++;
}
if (r_edge_map[edge_i] == -1) {
r_edge_map[edge_i] = selected_edges_num;
if (r_edge_map[edge] == -1) {
r_edge_map[edge] = selected_edges_num;
selected_edges_num++;
}
}

4
source/blender/nodes/geometry/nodes/node_geo_dual_mesh.cc
View File

@ -331,8 +331,8 @@ static bool sort_vertex_polys(const Span<MEdge> edges,
const MPoly &poly = polys[connected_polys[i]];
bool first_edge_done = false;
for (const int corner : IndexRange(poly.loopstart, poly.totloop)) {
const int edge_i = corner_edges[corner];
if (edges[edge_i].v1 == vertex_index || edges[edge_i].v2 == vertex_index) {
const int edge = corner_edges[corner];
if (edges[edge].v1 == vertex_index || edges[edge].v2 == vertex_index) {
if (!first_edge_done) {
poly_vertex_corners[i].first = corner;
first_edge_done = true;

10
source/blender/nodes/geometry/nodes/node_geo_duplicate_elements.cc
View File

@ -578,11 +578,11 @@ static void duplicate_faces(GeometrySet &geometry_set,
new_polys[poly_index] = source;
new_polys[poly_index].loopstart = loop_index;
for (const int i_loops : IndexRange(source.totloop)) {
const int src_corner_i = source.loopstart + i_loops;
corner_mapping[loop_index] = src_corner_i;
vert_mapping[loop_index] = corner_verts[src_corner_i];
new_edges[loop_index] = edges[corner_edges[src_corner_i]];
edge_mapping[loop_index] = corner_edges[src_corner_i];
const int src_corner = source.loopstart + i_loops;
corner_mapping[loop_index] = src_corner;
vert_mapping[loop_index] = corner_verts[src_corner];
new_edges[loop_index] = edges[corner_edges[src_corner]];
edge_mapping[loop_index] = corner_edges[src_corner];
new_edges[loop_index].v1 = loop_index;
if (i_loops + 1 != source.totloop) {
new_edges[loop_index].v2 = loop_index + 1;

26
source/blender/nodes/geometry/nodes/node_geo_extrude_mesh.cc
View File

@ -299,8 +299,8 @@ static Array<Vector<int, 2>> mesh_calculate_polys_of_edge(const Mesh &mesh)
for (const int i_poly : polys.index_range()) {
const MPoly &poly = polys[i_poly];
for (const int edge_i : corner_edges.slice(poly.loopstart, poly.totloop)) {
polys_of_edge[edge_i].append(i_poly);
for (const int edge : corner_edges.slice(poly.loopstart, poly.totloop)) {
polys_of_edge[edge].append(i_poly);
}
}
@ -689,8 +689,8 @@ static void extrude_mesh_face_regions(Mesh &mesh,
for (const int i_poly : poly_selection) {
const MPoly &poly = orig_polys[i_poly];
const float3 offset = poly_offsets[i_poly];
for (const int vert_i : orig_corner_verts.slice(poly.loopstart, poly.totloop)) {
mixer.mix_in(vert_i, offset);
for (const int vert : orig_corner_verts.slice(poly.loopstart, poly.totloop)) {
mixer.mix_in(vert, offset);
}
}
mixer.finalize();
@ -705,8 +705,8 @@ static void extrude_mesh_face_regions(Mesh &mesh,
all_selected_verts.reserve(orig_polys.size());
for (const int i_poly : poly_selection) {
const MPoly &poly = orig_polys[i_poly];
for (const int vert_i : orig_corner_verts.slice(poly.loopstart, poly.totloop)) {
all_selected_verts.add(vert_i);
for (const int vert : orig_corner_verts.slice(poly.loopstart, poly.totloop)) {
all_selected_verts.add(vert);
}
}
@ -841,20 +841,20 @@ static void extrude_mesh_face_regions(Mesh &mesh,
/* Connect the selected faces to the extruded or duplicated edges and the new vertices. */
for (const int i_poly : poly_selection) {
const MPoly &poly = polys[i_poly];
for (const int corner_i : IndexRange(poly.loopstart, poly.totloop)) {
const int i_new_vert = new_vert_indices.index_of_try(corner_verts[corner_i]);
for (const int corner : IndexRange(poly.loopstart, poly.totloop)) {
const int i_new_vert = new_vert_indices.index_of_try(corner_verts[corner]);
if (i_new_vert != -1) {
corner_verts[corner_i] = new_vert_range[i_new_vert];
corner_verts[corner] = new_vert_range[i_new_vert];
}
const int i_boundary_edge = boundary_edge_indices.index_of_try(corner_edges[corner_i]);
const int i_boundary_edge = boundary_edge_indices.index_of_try(corner_edges[corner]);
if (i_boundary_edge != -1) {
corner_edges[corner_i] = boundary_edge_range[i_boundary_edge];
corner_edges[corner] = boundary_edge_range[i_boundary_edge];
/* Skip the next check, an edge cannot be both a boundary edge and an inner edge. */
continue;
}
const int i_new_inner_edge = new_inner_edge_indices.index_of_try(corner_edges[corner_i]);
const int i_new_inner_edge = new_inner_edge_indices.index_of_try(corner_edges[corner]);
if (i_new_inner_edge != -1) {
corner_edges[corner_i] = new_inner_edge_range[i_new_inner_edge];
corner_edges[corner] = new_inner_edge_range[i_new_inner_edge];
}
}
}

4
source/blender/nodes/geometry/nodes/node_geo_input_mesh_edge_angle.cc
View File

@ -39,8 +39,8 @@ static Array<EdgeMapEntry> create_edge_map(const Span<MPoly> polys,
for (const int i_poly : polys.index_range()) {
const MPoly &mpoly = polys[i_poly];
for (const int edge_i : corner_edges.slice(mpoly.loopstart, mpoly.totloop)) {
EdgeMapEntry &entry = edge_map[edge_i];
for (const int edge : corner_edges.slice(mpoly.loopstart, mpoly.totloop)) {
EdgeMapEntry &entry = edge_map[edge];
if (entry.face_count == 0) {
entry.face_index_1 = i_poly;
}

4
source/blender/nodes/geometry/nodes/node_geo_input_mesh_edge_neighbors.cc
View File

@ -30,8 +30,8 @@ class EdgeNeighborCountFieldInput final : public bke::MeshFieldInput {
{
const Span<int> corner_edges = mesh.corner_edges();
Array<int> face_count(mesh.totedge, 0);
for (const int edge_i:corner_edges) {
face_count[edge_i]++;
for (const int edge : corner_edges) {
face_count[edge]++;
}
return mesh.attributes().adapt_domain<int>(

4
source/blender/nodes/geometry/nodes/node_geo_input_mesh_face_is_planar.cc
View File

@ -59,8 +59,8 @@ class PlanarFieldInput final : public bke::MeshFieldInput {
float min = FLT_MAX;
float max = -FLT_MAX;
for (const int vert_i : corner_verts.slice(poly.loopstart, poly.totloop)) {
float dot = math::dot(reference_normal, positions[vert_i]);
for (const int vert : corner_verts.slice(poly.loopstart, poly.totloop)) {
float dot = math::dot(reference_normal, positions[vert]);
if (dot > max) {
max = dot;
}

8
source/blender/nodes/geometry/nodes/node_geo_input_mesh_face_neighbors.cc
View File

@ -25,15 +25,15 @@ static VArray<int> construct_neighbor_count_varray(const Mesh &mesh, const eAttr
const Span<int> corner_edges = mesh.corner_edges();
Array<int> edge_count(mesh.totedge, 0);
for (const int edge_i : corner_edges) {
edge_count[edge_i]++;
for (const int edge : corner_edges) {
edge_count[edge]++;
}
Array<int> poly_count(polys.size(), 0);
for (const int poly_index : polys.index_range()) {
const MPoly &poly = polys[poly_index];
for (const int edge_i : corner_edges.slice(poly.loopstart, poly.totloop)) {
poly_count[poly_index] += edge_count[edge_i] - 1;
for (const int edge : corner_edges.slice(poly.loopstart, poly.totloop)) {
poly_count[poly_index] += edge_count[edge] - 1;
}
}

4
source/blender/nodes/geometry/nodes/node_geo_input_mesh_vertex_neighbors.cc
View File

@ -70,8 +70,8 @@ static VArray<int> construct_face_count_gvarray(const Mesh &mesh, const eAttrDom
const Span<int> corner_verts = mesh.corner_verts();
if (domain == ATTR_DOMAIN_POINT) {
Array<int> vertices(mesh.totvert, 0);
for (const int vert_i : corner_verts) {
vertices[vert_i]++;
for (const int vert : corner_verts) {
vertices[vert]++;
}
return VArray<int>::ForContainer(std::move(vertices));
}

12
source/blender/nodes/geometry/nodes/node_geo_scale_elements.cc
View File

@ -245,13 +245,13 @@ static Vector<ElementIsland> prepare_face_islands(const Mesh &mesh, const IndexM
DisjointSet<int> disjoint_set(mesh.totvert);
for (const int poly_index : face_selection) {
const MPoly &poly = polys[poly_index];
const Span<int> poly_corner_verts = corner_verts.slice(poly.loopstart, poly.totloop);
const Span<int> poly_verts = corner_verts.slice(poly.loopstart, poly.totloop);
for (const int loop_index : IndexRange(poly.totloop - 1)) {
const int v1 = poly_corner_verts[loop_index];
const int v2 = poly_corner_verts[loop_index + 1];
const int v1 = poly_verts[loop_index];
const int v2 = poly_verts[loop_index + 1];
disjoint_set.join(v1, v2);
}
disjoint_set.join(poly_corner_verts.first(), poly_corner_verts.last());
disjoint_set.join(poly_verts.first(), poly_verts.last());
}
VectorSet<int> island_ids;
@ -262,8 +262,8 @@ static Vector<ElementIsland> prepare_face_islands(const Mesh &mesh, const IndexM
/* Gather all of the face indices in each island into separate vectors. */
for (const int poly_index : face_selection) {
const MPoly &poly = polys[poly_index];
const Span<int> poly_corner_verts = corner_verts.slice(poly.loopstart, poly.totloop);
const int island_id = disjoint_set.find_root(poly_corner_verts[0]);
const Span<int> poly_verts = corner_verts.slice(poly.loopstart, poly.totloop);
const int island_id = disjoint_set.find_root(poly_verts[0]);
const int island_index = island_ids.index_of_or_add(island_id);
if (island_index == islands.size()) {
islands.append_as();

10
source/blender/nodes/geometry/nodes/node_geo_uv_pack_islands.cc
View File

@ -65,11 +65,11 @@ static VArray<float3> construct_uv_gvarray(const Mesh &mesh,
Array<const float *, 16> mp_co(mp.totloop);
Array<float *, 16> mp_uv(mp.totloop);
for (const int i : IndexRange(mp.totloop)) {
const int corner_i = corner_i;
const int vert_i = corner_verts[corner_i];
mp_vkeys[i] = vert_i;
mp_co[i] = positions[vert_i];
mp_uv[i] = uv[corner_i];
const int corner = mp.loopstart + i;
const int vert = corner_verts[corner];
mp_vkeys[i] = vert;
mp_co[i] = positions[vert];
mp_uv[i] = uv[corner];
mp_pin[i] = false;
mp_select[i] = false;
}

10
source/blender/nodes/geometry/nodes/node_geo_uv_unwrap.cc
View File

@ -93,11 +93,11 @@ static VArray<float3> construct_uv_gvarray(const Mesh &mesh,
Array<const float *, 16> mp_co(mp.totloop);
Array<float *, 16> mp_uv(mp.totloop);
for (const int i : IndexRange(mp.totloop)) {
const int corner_i = corner_i;
const int vert_i = corner_verts[corner_i];
mp_vkeys[i] = vert_i;
mp_co[i] = positions[vert_i];
mp_uv[i] = uv[corner_i];
const int corner = mp.loopstart + i;
const int vert = corner_verts[corner];
mp_vkeys[i] = vert;
mp_co[i] = positions[vert];
mp_uv[i] = uv[corner];
mp_pin[i] = false;
mp_select[i] = false;
}