From d88d6331fd49cca6ccff9c76c4962998d21be72e Mon Sep 17 00:00:00 2001 From: Hans Goudey Date: Wed, 5 Mar 2025 23:16:05 -0500 Subject: [PATCH] Cleanup: Modernize mesh variable naming in some cases Simplify naming of vertex and corner indices, and replace "loop". --- .../blender/blenkernel/BKE_mesh_iterators.hh | 13 ++- .../blender/blenkernel/intern/crazyspace.cc | 19 ++-- .../blenkernel/intern/geometry_compare.cc | 32 +++---- .../blenkernel/intern/mesh_attributes.cc | 30 +++---- .../blender/blenkernel/intern/mesh_mapping.cc | 42 ++++----- .../blender/blenkernel/intern/mesh_remap.cc | 6 +- .../mesh_extractors/extract_mesh_ibo_tris.cc | 4 +- .../editors/sculpt_paint/sculpt_trim.cc | 42 ++++----- .../geometry/intern/mesh_primitive_cuboid.cc | 86 +++++++++---------- .../intern/mesh_primitive_cylinder_cone.cc | 56 ++++++------ .../geometry/intern/mesh_primitive_grid.cc | 38 ++++---- .../node_geo_mesh_topology_corners_of_edge.cc | 4 +- .../geometry/nodes/node_geo_sample_nearest.cc | 18 ++-- 13 files changed, 193 insertions(+), 197 deletions(-) diff --git a/source/blender/blenkernel/BKE_mesh_iterators.hh b/source/blender/blenkernel/BKE_mesh_iterators.hh index 0e7a2909ba3..1a411c18f11 100644 --- a/source/blender/blenkernel/BKE_mesh_iterators.hh +++ b/source/blender/blenkernel/BKE_mesh_iterators.hh @@ -30,14 +30,11 @@ void BKE_mesh_foreach_mapped_edge( int tot_edges, void (*func)(void *user_data, int index, const float v0co[3], const float v1co[3]), void *user_data); -void BKE_mesh_foreach_mapped_loop(Mesh *mesh, - void (*func)(void *user_data, - int vertex_index, - int face_index, - const float co[3], - const float no[3]), - void *user_data, - MeshForeachFlag flag); +void BKE_mesh_foreach_mapped_loop( + Mesh *mesh, + void (*func)(void *user_data, int vert, int face_index, const float co[3], const float no[3]), + void *user_data, + MeshForeachFlag flag); void BKE_mesh_foreach_mapped_face_center( Mesh *mesh, void (*func)(void *user_data, int index, const float cent[3], const float no[3]), diff --git a/source/blender/blenkernel/intern/crazyspace.cc b/source/blender/blenkernel/intern/crazyspace.cc index 382b0110ff4..ddadc5fe94d 100644 --- a/source/blender/blenkernel/intern/crazyspace.cc +++ b/source/blender/blenkernel/intern/crazyspace.cc @@ -513,41 +513,40 @@ void BKE_crazyspace_api_eval(Depsgraph *depsgraph, void BKE_crazyspace_api_displacement_to_deformed(Object *object, ReportList *reports, - int vertex_index, + int vert, const float displacement[3], float r_displacement_deformed[3]) { - if (vertex_index < 0 || vertex_index >= object->runtime->crazyspace_deform_imats.size()) { + if (vert < 0 || vert >= object->runtime->crazyspace_deform_imats.size()) { BKE_reportf(reports, RPT_ERROR, "Invalid vertex index %d (expected to be within 0 to %d range)", - vertex_index, + vert, int(object->runtime->crazyspace_deform_imats.size())); return; } - mul_v3_m3v3(r_displacement_deformed, - object->runtime->crazyspace_deform_imats[vertex_index].ptr(), - displacement); + mul_v3_m3v3( + r_displacement_deformed, object->runtime->crazyspace_deform_imats[vert].ptr(), displacement); } void BKE_crazyspace_api_displacement_to_original(Object *object, ReportList *reports, - int vertex_index, + int vert, const float displacement_deformed[3], float r_displacement[3]) { - if (vertex_index < 0 || vertex_index >= object->runtime->crazyspace_deform_imats.size()) { + if (vert < 0 || vert >= object->runtime->crazyspace_deform_imats.size()) { BKE_reportf(reports, RPT_ERROR, "Invalid vertex index %d (expected to be within 0 to %d range)", - vertex_index, + vert, int(object->runtime->crazyspace_deform_imats.size())); return; } float mat[3][3]; - if (!invert_m3_m3(mat, object->runtime->crazyspace_deform_imats[vertex_index].ptr())) { + if (!invert_m3_m3(mat, object->runtime->crazyspace_deform_imats[vert].ptr())) { copy_v3_v3(r_displacement, displacement_deformed); return; } diff --git a/source/blender/blenkernel/intern/geometry_compare.cc b/source/blender/blenkernel/intern/geometry_compare.cc index 285e3f7d4a6..24088e57614 100644 --- a/source/blender/blenkernel/intern/geometry_compare.cc +++ b/source/blender/blenkernel/intern/geometry_compare.cc @@ -370,15 +370,15 @@ static void update_set_sizes(const Span set_ids, MutableSpan set_sizes } } -static void edges_from_vertex_sets(const Span edges, - const Span verts_to_sorted, - const Span vertex_set_ids, - MutableSpan r_edges) +static void edges_from_vert_sets(const Span edges, + const Span verts_to_sorted, + const Span vert_set_ids, + MutableSpan r_edges) { for (const int i : r_edges.index_range()) { const int2 e = edges[i]; - r_edges[i] = OrderedEdge(vertex_set_ids[verts_to_sorted[e.x]], - vertex_set_ids[verts_to_sorted[e.y]]); + r_edges[i] = OrderedEdge(vert_set_ids[verts_to_sorted[e.x]], + vert_set_ids[verts_to_sorted[e.y]]); } } @@ -393,8 +393,8 @@ static bool sort_edges(const Span edges1, /* Need `NoInitialization()` because OrderedEdge is not default constructible. */ Array ordered_edges1(edges1.size(), NoInitialization()); Array ordered_edges2(edges2.size(), NoInitialization()); - edges_from_vertex_sets(edges1, verts.to_sorted1, verts.set_ids, ordered_edges1); - edges_from_vertex_sets(edges2, verts.to_sorted2, verts.set_ids, ordered_edges2); + edges_from_vert_sets(edges1, verts.to_sorted1, verts.set_ids, ordered_edges1); + edges_from_vert_sets(edges2, verts.to_sorted2, verts.set_ids, ordered_edges2); sort_per_set_based_on_attributes(edges.set_sizes, edges.from_sorted1, edges.from_sorted2, @@ -699,10 +699,10 @@ static bool all_set_sizes_one(const Span set_sizes) * * \returns the type of mismatch that occurred if the mapping couldn't be constructed. */ -static std::optional construct_vertex_mapping(const Mesh &mesh1, - const Mesh &mesh2, - IndexMapping &verts, - IndexMapping &edges) +static std::optional construct_vert_mapping(const Mesh &mesh1, + const Mesh &mesh2, + IndexMapping &verts, + IndexMapping &edges) { if (all_set_sizes_one(verts.set_sizes)) { /* The vertices are already in one-to-one correspondence. */ @@ -733,7 +733,7 @@ static std::optional construct_vertex_mapping(const Mesh &mesh1, if (edges1.size() != edges2.size()) { continue; } - bool vertex_matches = true; + bool vert_matches = true; for (const int edge1 : edges1) { bool found_matching_edge = false; for (const int edge2 : edges2) { @@ -743,11 +743,11 @@ static std::optional construct_vertex_mapping(const Mesh &mesh1, } } if (!found_matching_edge) { - vertex_matches = false; + vert_matches = false; break; } } - if (vertex_matches) { + if (vert_matches) { matching_verts.append(index_in_set); } } @@ -877,7 +877,7 @@ std::optional compare_meshes(const Mesh &mesh1, return mismatch; }; - mismatch = construct_vertex_mapping(mesh1, mesh2, verts, edges); + mismatch = construct_vert_mapping(mesh1, mesh2, verts, edges); if (mismatch) { return mismatch; } diff --git a/source/blender/blenkernel/intern/mesh_attributes.cc b/source/blender/blenkernel/intern/mesh_attributes.cc index fb46bf2ee65..c752716408d 100644 --- a/source/blender/blenkernel/intern/mesh_attributes.cc +++ b/source/blender/blenkernel/intern/mesh_attributes.cc @@ -113,8 +113,8 @@ static GVArray adapt_mesh_domain_corner_to_face(const Mesh &mesh, const GVArray new_varray = VArray::ForFunc( faces.size(), [faces, varray = varray.typed()](const int face_index) { /* A face is selected if all of its corners were selected. */ - for (const int loop_index : faces[face_index]) { - if (!varray[loop_index]) { + for (const int corner : faces[face_index]) { + if (!varray[corner]) { return false; } } @@ -126,8 +126,8 @@ static GVArray adapt_mesh_domain_corner_to_face(const Mesh &mesh, const GVArray faces.size(), [faces, varray = varray.typed()](const int face_index) { T return_value; attribute_math::DefaultMixer mixer({&return_value, 1}); - for (const int loop_index : faces[face_index]) { - const T value = varray[loop_index]; + for (const int corner : faces[face_index]) { + const T value = varray[corner]; mixer.mix_in(0, value); } mixer.finalize(); @@ -438,12 +438,12 @@ void adapt_mesh_domain_edge_to_corner_impl(const Mesh &mesh, const IndexRange face = faces[face_index]; /* For every corner, mix the values from the adjacent edges on the face. */ - for (const int loop_index : face) { - const int loop_index_prev = mesh::face_corner_prev(face, loop_index); - 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]); + for (const int corner : face) { + const int corner_prev = mesh::face_corner_prev(face, corner); + const int edge = corner_edges[corner]; + const int edge_prev = corner_edges[corner_prev]; + mixer.mix_in(corner, old_values[edge]); + mixer.mix_in(corner, old_values[edge_prev]); } } @@ -465,12 +465,12 @@ void adapt_mesh_domain_edge_to_corner_impl(const Mesh &mesh, threading::parallel_for(faces.index_range(), 2048, [&](const IndexRange range) { for (const int face_index : range) { const IndexRange face = faces[face_index]; - for (const int loop_index : face) { - const int loop_index_prev = mesh::face_corner_prev(face, loop_index); - const int edge = corner_edges[loop_index]; - const int edge_prev = corner_edges[loop_index_prev]; + for (const int corner : face) { + const int corner_prev = mesh::face_corner_prev(face, corner); + const int edge = corner_edges[corner]; + const int edge_prev = corner_edges[corner_prev]; if (old_values[edge] && old_values[edge_prev]) { - r_values[loop_index] = true; + r_values[corner] = true; } } } diff --git a/source/blender/blenkernel/intern/mesh_mapping.cc b/source/blender/blenkernel/intern/mesh_mapping.cc index 4cff067265b..d9a6c9ae44d 100644 --- a/source/blender/blenkernel/intern/mesh_mapping.cc +++ b/source/blender/blenkernel/intern/mesh_mapping.cc @@ -474,7 +474,7 @@ GroupedSpan build_edge_to_face_map(const OffsetIndices faces, */ using MeshRemap_CheckIslandBoundary = blender::FunctionRef edge_face_map_elem)>; @@ -671,7 +671,7 @@ int *BKE_mesh_calc_smoothgroups(int edges_num, auto face_is_smooth = [&](const int i) { return sharp_faces.is_empty() || !sharp_faces[i]; }; auto face_is_island_boundary_smooth = [&](const int face_index, - const int /*loop_index*/, + const int /*corner*/, const int edge_index, const int edge_user_count, const blender::Span edge_face_map_elem) { @@ -854,12 +854,12 @@ static bool mesh_calc_islands_loop_face_uv(const int totedge, const GroupedSpan edge_to_face_map = bke::mesh::build_edge_to_face_map( faces, {corner_edges, corners_num}, totedge, edge_to_face_offsets, edge_to_face_indices); - Array edge_to_loop_offsets; - Array edge_to_loop_indices; - GroupedSpan edge_to_loop_map; + Array edge_to_corner_offsets; + Array edge_to_corner_indices; + GroupedSpan edge_to_corner_map; if (luvs) { - edge_to_loop_map = bke::mesh::build_edge_to_corner_map( - {corner_edges, corners_num}, totedge, edge_to_loop_offsets, edge_to_loop_indices); + edge_to_corner_map = bke::mesh::build_edge_to_corner_map( + {corner_edges, corners_num}, totedge, edge_to_corner_offsets, edge_to_corner_indices); } /* TODO: I'm not sure edge seam flag is enough to define UV islands? @@ -869,32 +869,32 @@ static bool mesh_calc_islands_loop_face_uv(const int totedge, * and each UVMap would then need its own mesh mapping, not sure we want that at all! */ auto mesh_check_island_boundary_uv = [&](const int /*face_index*/, - const int loop_index, + const int corner, const int edge_index, const int /*edge_user_count*/, const Span /*edge_face_map_elem*/) -> bool { if (luvs) { - const Span edge_to_loops = edge_to_loop_map[corner_edges[loop_index]]; + const Span edge_to_corners = edge_to_corner_map[corner_edges[corner]]; - BLI_assert(edge_to_loops.size() >= 2 && (edge_to_loops.size() % 2) == 0); + BLI_assert(edge_to_corners.size() >= 2 && (edge_to_corners.size() % 2) == 0); - const int v1 = corner_verts[edge_to_loops[0]]; - const int v2 = corner_verts[edge_to_loops[1]]; - const float *uvco_v1 = luvs[edge_to_loops[0]]; - const float *uvco_v2 = luvs[edge_to_loops[1]]; - for (int i = 2; i < edge_to_loops.size(); i += 2) { - if (corner_verts[edge_to_loops[i]] == v1) { - if (!equals_v2v2(uvco_v1, luvs[edge_to_loops[i]]) || - !equals_v2v2(uvco_v2, luvs[edge_to_loops[i + 1]])) + const int v1 = corner_verts[edge_to_corners[0]]; + const int v2 = corner_verts[edge_to_corners[1]]; + const float *uvco_v1 = luvs[edge_to_corners[0]]; + const float *uvco_v2 = luvs[edge_to_corners[1]]; + for (int i = 2; i < edge_to_corners.size(); i += 2) { + if (corner_verts[edge_to_corners[i]] == v1) { + if (!equals_v2v2(uvco_v1, luvs[edge_to_corners[i]]) || + !equals_v2v2(uvco_v2, luvs[edge_to_corners[i + 1]])) { return true; } } else { - BLI_assert(corner_verts[edge_to_loops[i]] == v2); + BLI_assert(corner_verts[edge_to_corners[i]] == v2); UNUSED_VARS_NDEBUG(v2); - if (!equals_v2v2(uvco_v2, luvs[edge_to_loops[i]]) || - !equals_v2v2(uvco_v1, luvs[edge_to_loops[i + 1]])) + if (!equals_v2v2(uvco_v2, luvs[edge_to_corners[i]]) || + !equals_v2v2(uvco_v1, luvs[edge_to_corners[i + 1]])) { return true; } diff --git a/source/blender/blenkernel/intern/mesh_remap.cc b/source/blender/blenkernel/intern/mesh_remap.cc index f7d99fca422..e77ef8af995 100644 --- a/source/blender/blenkernel/intern/mesh_remap.cc +++ b/source/blender/blenkernel/intern/mesh_remap.cc @@ -1259,7 +1259,7 @@ void BKE_mesh_remap_calc_loops_from_mesh(const int mode, blender::Array face_cents_src; - GroupedSpan vert_to_loop_map_src; + GroupedSpan vert_to_corner_map_src; GroupedSpan vert_to_face_map_src; Array edge_to_face_src_offsets; @@ -1322,7 +1322,7 @@ void BKE_mesh_remap_calc_loops_from_mesh(const int mode, } if (use_from_vert) { - vert_to_loop_map_src = me_src->vert_to_corner_map(); + vert_to_corner_map_src = me_src->vert_to_corner_map(); if (mode & MREMAP_USE_POLY) { vert_to_face_map_src = me_src->vert_to_face_map(); } @@ -1523,7 +1523,7 @@ void BKE_mesh_remap_calc_loops_from_mesh(const int mode, } nor_dst = &tmp_no; nors_src = loop_normals_src; - vert_to_refelem_map_src = vert_to_loop_map_src[nearest.index]; + vert_to_refelem_map_src = vert_to_corner_map_src[nearest.index]; } else { /* if (mode == MREMAP_MODE_LOOP_NEAREST_POLYNOR) { */ nor_dst = &pnor_dst; diff --git a/source/blender/draw/intern/mesh_extractors/extract_mesh_ibo_tris.cc b/source/blender/draw/intern/mesh_extractors/extract_mesh_ibo_tris.cc index 78b6cb51f98..00b3e360ffe 100644 --- a/source/blender/draw/intern/mesh_extractors/extract_mesh_ibo_tris.cc +++ b/source/blender/draw/intern/mesh_extractors/extract_mesh_ibo_tris.cc @@ -77,8 +77,8 @@ static void extract_tris_bmesh(const MeshRenderData &mr, if (BM_elem_flag_test(&face, BM_ELEM_HIDDEN)) { continue; } - const int loop_index = BM_elem_index_get(BM_FACE_FIRST_LOOP(&face)); - const IndexRange bm_tris(poly_to_tri_count(face_index, loop_index), + const int corner_index = BM_elem_index_get(BM_FACE_FIRST_LOOP(&face)); + const IndexRange bm_tris(poly_to_tri_count(face_index, corner_index), bke::mesh::face_triangles_num(face.len)); const IndexRange ibo_tris(face_tri_offsets[face_index], bm_tris.size()); for (const int i : bm_tris.index_range()) { diff --git a/source/blender/editors/sculpt_paint/sculpt_trim.cc b/source/blender/editors/sculpt_paint/sculpt_trim.cc index 46b21b32931..686981991cc 100644 --- a/source/blender/editors/sculpt_paint/sculpt_trim.cc +++ b/source/blender/editors/sculpt_paint/sculpt_trim.cc @@ -452,53 +452,53 @@ static void generate_geometry(gesture::GestureData &gesture_data) MutableSpan face_offsets = trim_operation->mesh->face_offsets_for_write(); MutableSpan corner_verts = trim_operation->mesh->corner_verts_for_write(); int face_index = 0; - int loop_index = 0; + int corner = 0; for (const int i : tris.index_range()) { - face_offsets[face_index] = loop_index; - corner_verts[loop_index + 0] = tris[i][0]; - corner_verts[loop_index + 1] = tris[i][1]; - corner_verts[loop_index + 2] = tris[i][2]; + face_offsets[face_index] = corner; + corner_verts[corner + 0] = tris[i][0]; + corner_verts[corner + 1] = tris[i][1]; + corner_verts[corner + 2] = tris[i][2]; face_index++; - loop_index += 3; + corner += 3; } /* Write the back face triangle indices. */ for (const int i : tris.index_range()) { - face_offsets[face_index] = loop_index; - corner_verts[loop_index + 0] = tris[i][0] + screen_points.size(); - corner_verts[loop_index + 1] = tris[i][1] + screen_points.size(); - corner_verts[loop_index + 2] = tris[i][2] + screen_points.size(); + face_offsets[face_index] = corner; + corner_verts[corner + 0] = tris[i][0] + screen_points.size(); + corner_verts[corner + 1] = tris[i][1] + screen_points.size(); + corner_verts[corner + 2] = tris[i][2] + screen_points.size(); face_index++; - loop_index += 3; + corner += 3; } /* Write the indices for the lateral triangles. */ for (const int i : screen_points.index_range()) { - face_offsets[face_index] = loop_index; + face_offsets[face_index] = corner; int current_index = i; int next_index = current_index + 1; if (next_index >= screen_points.size()) { next_index = 0; } - corner_verts[loop_index + 0] = next_index + screen_points.size(); - corner_verts[loop_index + 1] = next_index; - corner_verts[loop_index + 2] = current_index; + corner_verts[corner + 0] = next_index + screen_points.size(); + corner_verts[corner + 1] = next_index; + corner_verts[corner + 2] = current_index; face_index++; - loop_index += 3; + corner += 3; } for (const int i : screen_points.index_range()) { - face_offsets[face_index] = loop_index; + face_offsets[face_index] = corner; int current_index = i; int next_index = current_index + 1; if (next_index >= screen_points.size()) { next_index = 0; } - corner_verts[loop_index + 0] = current_index; - corner_verts[loop_index + 1] = current_index + screen_points.size(); - corner_verts[loop_index + 2] = next_index + screen_points.size(); + corner_verts[corner + 0] = current_index; + corner_verts[corner + 1] = current_index + screen_points.size(); + corner_verts[corner + 2] = next_index + screen_points.size(); face_index++; - loop_index += 3; + corner += 3; } bke::mesh_smooth_set(*trim_operation->mesh, false); diff --git a/source/blender/geometry/intern/mesh_primitive_cuboid.cc b/source/blender/geometry/intern/mesh_primitive_cuboid.cc index 82c98375759..9ba8590c882 100644 --- a/source/blender/geometry/intern/mesh_primitive_cuboid.cc +++ b/source/blender/geometry/intern/mesh_primitive_cuboid.cc @@ -104,21 +104,21 @@ static void calculate_positions(const CuboidConfig &config, MutableSpan * anti-clockwise. */ static void define_quad(MutableSpan corner_verts, - const int loop_index, + const int corner, const int vert_1, const int vert_2, const int vert_3, const int vert_4) { - corner_verts[loop_index] = vert_1; - corner_verts[loop_index + 1] = vert_2; - corner_verts[loop_index + 2] = vert_3; - corner_verts[loop_index + 3] = vert_4; + corner_verts[corner] = vert_1; + corner_verts[corner + 1] = vert_2; + corner_verts[corner + 2] = vert_3; + corner_verts[corner + 3] = vert_4; } static void calculate_corner_verts(const CuboidConfig &config, MutableSpan corner_verts) { - int loop_index = 0; + int corner = 0; /* Number of vertices in an XY cross-section of the cube (barring top and bottom faces). */ const int xy_cross_section_vert_count = config.verts_x * config.verts_y - @@ -134,8 +134,8 @@ static void calculate_corner_verts(const CuboidConfig &config, MutableSpan const int vert_3 = vert_2 + 1; const int vert_4 = vert_1 + 1; - define_quad(corner_verts, loop_index, vert_1, vert_2, vert_3, vert_4); - loop_index += 4; + define_quad(corner_verts, corner, vert_1, vert_2, vert_3, vert_4); + corner += 4; } vert_1_start += config.verts_x; } @@ -147,12 +147,12 @@ static void calculate_corner_verts(const CuboidConfig &config, MutableSpan for ([[maybe_unused]] const int z : IndexRange(config.edges_z)) { for (const int x : IndexRange(config.edges_x)) { define_quad(corner_verts, - loop_index, + corner, vert_1_start + x, vert_1_start + x + 1, vert_2_start + x + 1, vert_2_start + x); - loop_index += 4; + corner += 4; } vert_1_start = vert_2_start; vert_2_start += config.verts_x * config.verts_y - (config.verts_x - 2) * (config.verts_y - 2); @@ -167,12 +167,12 @@ static void calculate_corner_verts(const CuboidConfig &config, MutableSpan for ([[maybe_unused]] const int y : IndexRange(config.edges_y)) { for (const int x : IndexRange(config.edges_x)) { define_quad(corner_verts, - loop_index, + corner, vert_1_start + x, vert_1_start + x + 1, vert_2_start + x + 1, vert_2_start + x); - loop_index += 4; + corner += 4; } vert_2_start += config.verts_x; vert_1_start += config.verts_x; @@ -188,12 +188,12 @@ static void calculate_corner_verts(const CuboidConfig &config, MutableSpan } for (const int x : IndexRange(config.edges_x)) { define_quad(corner_verts, - loop_index, + corner, vert_1_start + x, vert_2_start + x, vert_2_start + x + 1, vert_1_start + x + 1); - loop_index += 4; + corner += 4; } vert_2_start += xy_cross_section_vert_count; vert_1_start += xy_cross_section_vert_count; @@ -230,8 +230,8 @@ static void calculate_corner_verts(const CuboidConfig &config, MutableSpan vert_3 = vert_2 + 2; } - define_quad(corner_verts, loop_index, vert_1, vert_2, vert_3, vert_4); - loop_index += 4; + define_quad(corner_verts, corner, vert_1, vert_2, vert_3, vert_4); + corner += 4; } if (z == 0) { vert_1_start += config.verts_x * config.verts_y; @@ -276,8 +276,8 @@ static void calculate_corner_verts(const CuboidConfig &config, MutableSpan vert_4 = vert_1 + config.verts_x; } - define_quad(corner_verts, loop_index, vert_1, vert_4, vert_3, vert_2); - loop_index += 4; + define_quad(corner_verts, corner, vert_1, vert_4, vert_3, vert_2); + corner += 4; } if (z == 0) { vert_1_start += config.verts_x * config.verts_y; @@ -296,7 +296,7 @@ static void calculate_uvs(const CuboidConfig &config, Mesh *mesh, const StringRe uv_id, bke::AttrDomain::Corner); MutableSpan uvs = uv_attribute.span; - int loop_index = 0; + int corner = 0; const float x_delta = 0.25f / float(config.edges_x); const float y_delta = 0.25f / float(config.edges_y); @@ -305,60 +305,60 @@ static void calculate_uvs(const CuboidConfig &config, Mesh *mesh, const StringRe /* Calculate bottom face UVs. */ for (const int y : IndexRange(config.edges_y)) { for (const int x : IndexRange(config.edges_x)) { - uvs[loop_index++] = float2(0.25f + x * x_delta, 0.375f - y * y_delta); - uvs[loop_index++] = float2(0.25f + x * x_delta, 0.375f - (y + 1) * y_delta); - uvs[loop_index++] = float2(0.25f + (x + 1) * x_delta, 0.375f - (y + 1) * y_delta); - uvs[loop_index++] = float2(0.25f + (x + 1) * x_delta, 0.375f - y * y_delta); + uvs[corner++] = float2(0.25f + x * x_delta, 0.375f - y * y_delta); + uvs[corner++] = float2(0.25f + x * x_delta, 0.375f - (y + 1) * y_delta); + uvs[corner++] = float2(0.25f + (x + 1) * x_delta, 0.375f - (y + 1) * y_delta); + uvs[corner++] = float2(0.25f + (x + 1) * x_delta, 0.375f - y * y_delta); } } /* Calculate front face UVs. */ for (const int z : IndexRange(config.edges_z)) { for (const int x : IndexRange(config.edges_x)) { - uvs[loop_index++] = float2(0.25f + x * x_delta, 0.375f + z * z_delta); - uvs[loop_index++] = float2(0.25f + (x + 1) * x_delta, 0.375f + z * z_delta); - uvs[loop_index++] = float2(0.25f + (x + 1) * x_delta, 0.375f + (z + 1) * z_delta); - uvs[loop_index++] = float2(0.25f + x * x_delta, 0.375f + (z + 1) * z_delta); + uvs[corner++] = float2(0.25f + x * x_delta, 0.375f + z * z_delta); + uvs[corner++] = float2(0.25f + (x + 1) * x_delta, 0.375f + z * z_delta); + uvs[corner++] = float2(0.25f + (x + 1) * x_delta, 0.375f + (z + 1) * z_delta); + uvs[corner++] = float2(0.25f + x * x_delta, 0.375f + (z + 1) * z_delta); } } /* Calculate top face UVs. */ for (const int y : IndexRange(config.edges_y)) { for (const int x : IndexRange(config.edges_x)) { - uvs[loop_index++] = float2(0.25f + x * x_delta, 0.625f + y * y_delta); - uvs[loop_index++] = float2(0.25f + (x + 1) * x_delta, 0.625f + y * y_delta); - uvs[loop_index++] = float2(0.25f + (x + 1) * x_delta, 0.625f + (y + 1) * y_delta); - uvs[loop_index++] = float2(0.25f + x * x_delta, 0.625f + (y + 1) * y_delta); + uvs[corner++] = float2(0.25f + x * x_delta, 0.625f + y * y_delta); + uvs[corner++] = float2(0.25f + (x + 1) * x_delta, 0.625f + y * y_delta); + uvs[corner++] = float2(0.25f + (x + 1) * x_delta, 0.625f + (y + 1) * y_delta); + uvs[corner++] = float2(0.25f + x * x_delta, 0.625f + (y + 1) * y_delta); } } /* Calculate back face UVs. */ for (const int z : IndexRange(config.edges_z)) { for (const int x : IndexRange(config.edges_x)) { - uvs[loop_index++] = float2(1.0f - x * x_delta, 0.375f + z * z_delta); - uvs[loop_index++] = float2(1.0f - x * x_delta, 0.375f + (z + 1) * z_delta); - uvs[loop_index++] = float2(1.0f - (x + 1) * x_delta, 0.375f + (z + 1) * z_delta); - uvs[loop_index++] = float2(1.0f - (x + 1) * x_delta, 0.375f + z * z_delta); + uvs[corner++] = float2(1.0f - x * x_delta, 0.375f + z * z_delta); + uvs[corner++] = float2(1.0f - x * x_delta, 0.375f + (z + 1) * z_delta); + uvs[corner++] = float2(1.0f - (x + 1) * x_delta, 0.375f + (z + 1) * z_delta); + uvs[corner++] = float2(1.0f - (x + 1) * x_delta, 0.375f + z * z_delta); } } /* Calculate left face UVs. */ for (const int z : IndexRange(config.edges_z)) { for (const int y : IndexRange(config.edges_y)) { - uvs[loop_index++] = float2(0.25f - y * y_delta, 0.375f + z * z_delta); - uvs[loop_index++] = float2(0.25f - y * y_delta, 0.375f + (z + 1) * z_delta); - uvs[loop_index++] = float2(0.25f - (y + 1) * y_delta, 0.375f + (z + 1) * z_delta); - uvs[loop_index++] = float2(0.25f - (y + 1) * y_delta, 0.375f + z * z_delta); + uvs[corner++] = float2(0.25f - y * y_delta, 0.375f + z * z_delta); + uvs[corner++] = float2(0.25f - y * y_delta, 0.375f + (z + 1) * z_delta); + uvs[corner++] = float2(0.25f - (y + 1) * y_delta, 0.375f + (z + 1) * z_delta); + uvs[corner++] = float2(0.25f - (y + 1) * y_delta, 0.375f + z * z_delta); } } /* Calculate right face UVs. */ for (const int z : IndexRange(config.edges_z)) { for (const int y : IndexRange(config.edges_y)) { - uvs[loop_index++] = float2(0.50f + y * y_delta, 0.375f + z * z_delta); - uvs[loop_index++] = float2(0.50f + (y + 1) * y_delta, 0.375f + z * z_delta); - uvs[loop_index++] = float2(0.50f + (y + 1) * y_delta, 0.375f + (z + 1) * z_delta); - uvs[loop_index++] = float2(0.50f + y * y_delta, 0.375f + (z + 1) * z_delta); + uvs[corner++] = float2(0.50f + y * y_delta, 0.375f + z * z_delta); + uvs[corner++] = float2(0.50f + (y + 1) * y_delta, 0.375f + z * z_delta); + uvs[corner++] = float2(0.50f + (y + 1) * y_delta, 0.375f + (z + 1) * z_delta); + uvs[corner++] = float2(0.50f + y * y_delta, 0.375f + (z + 1) * z_delta); } } diff --git a/source/blender/geometry/intern/mesh_primitive_cylinder_cone.cc b/source/blender/geometry/intern/mesh_primitive_cylinder_cone.cc index db4f40a5c63..197b8a5ee2c 100644 --- a/source/blender/geometry/intern/mesh_primitive_cylinder_cone.cc +++ b/source/blender/geometry/intern/mesh_primitive_cylinder_cone.cc @@ -541,7 +541,7 @@ static void calculate_cone_uvs(const ConeConfig &config, Mesh *mesh, const Strin angle += angle_delta; } - int loop_index = 0; + int corner = 0; /* Left circle of the UV representing the top fill or top cone tip. */ if (config.top_is_point || config.fill_type != ConeFillType::None) { @@ -554,16 +554,16 @@ static void calculate_cone_uvs(const ConeConfig &config, Mesh *mesh, const Strin if (config.top_has_center_vert) { /* Cone tip itself or triangle fan center of the fill. */ for (const int i : IndexRange(config.circle_segments)) { - uvs[loop_index++] = radius_factor_delta * circle[i] + center_left; - uvs[loop_index++] = radius_factor_delta * circle[(i + 1) % config.circle_segments] + - center_left; - uvs[loop_index++] = center_left; + uvs[corner++] = radius_factor_delta * circle[i] + center_left; + uvs[corner++] = radius_factor_delta * circle[(i + 1) % config.circle_segments] + + center_left; + uvs[corner++] = center_left; } } else if (!config.top_is_point && config.fill_type == ConeFillType::NGon) { /* N-gon at the center of the fill. */ for (const int i : IndexRange(config.circle_segments)) { - uvs[loop_index++] = radius_factor_delta * circle[i] + center_left; + uvs[corner++] = radius_factor_delta * circle[i] + center_left; } } /* The rest of the top fill is made out of quad rings. */ @@ -571,12 +571,12 @@ static void calculate_cone_uvs(const ConeConfig &config, Mesh *mesh, const Strin const float inner_radius_factor = i * radius_factor_delta; const float outer_radius_factor = (i + 1) * radius_factor_delta; for (const int j : IndexRange(config.circle_segments)) { - uvs[loop_index++] = inner_radius_factor * circle[j] + center_left; - uvs[loop_index++] = outer_radius_factor * circle[j] + center_left; - uvs[loop_index++] = outer_radius_factor * circle[(j + 1) % config.circle_segments] + - center_left; - uvs[loop_index++] = inner_radius_factor * circle[(j + 1) % config.circle_segments] + - center_left; + uvs[corner++] = inner_radius_factor * circle[j] + center_left; + uvs[corner++] = outer_radius_factor * circle[j] + center_left; + uvs[corner++] = outer_radius_factor * circle[(j + 1) % config.circle_segments] + + center_left; + uvs[corner++] = inner_radius_factor * circle[(j + 1) % config.circle_segments] + + center_left; } } } @@ -589,10 +589,10 @@ static void calculate_cone_uvs(const ConeConfig &config, Mesh *mesh, const Strin for (const int i : IndexRange(config.side_segments)) { for (const int j : IndexRange(config.circle_segments)) { - uvs[loop_index++] = float2(j * x_delta, i * y_delta + bottom); - uvs[loop_index++] = float2(j * x_delta, (i + 1) * y_delta + bottom); - uvs[loop_index++] = float2((j + 1) * x_delta, (i + 1) * y_delta + bottom); - uvs[loop_index++] = float2((j + 1) * x_delta, i * y_delta + bottom); + uvs[corner++] = float2(j * x_delta, i * y_delta + bottom); + uvs[corner++] = float2(j * x_delta, (i + 1) * y_delta + bottom); + uvs[corner++] = float2((j + 1) * x_delta, (i + 1) * y_delta + bottom); + uvs[corner++] = float2((j + 1) * x_delta, i * y_delta + bottom); } } } @@ -611,30 +611,30 @@ static void calculate_cone_uvs(const ConeConfig &config, Mesh *mesh, const Strin const float outer_radius_factor = 1.0f - i * radius_factor_delta; const float inner_radius_factor = 1.0f - (i + 1) * radius_factor_delta; for (const int j : IndexRange(config.circle_segments)) { - uvs[loop_index++] = outer_radius_factor * circle[j] + center_right; - uvs[loop_index++] = inner_radius_factor * circle[j] + center_right; - uvs[loop_index++] = inner_radius_factor * circle[(j + 1) % config.circle_segments] + - center_right; - uvs[loop_index++] = outer_radius_factor * circle[(j + 1) % config.circle_segments] + - center_right; + uvs[corner++] = outer_radius_factor * circle[j] + center_right; + uvs[corner++] = inner_radius_factor * circle[j] + center_right; + uvs[corner++] = inner_radius_factor * circle[(j + 1) % config.circle_segments] + + center_right; + uvs[corner++] = outer_radius_factor * circle[(j + 1) % config.circle_segments] + + center_right; } } if (config.bottom_has_center_vert) { /* Cone tip itself or triangle fan center of the fill. */ for (const int i : IndexRange(config.circle_segments)) { - uvs[loop_index++] = radius_factor_delta * circle[i] + center_right; - uvs[loop_index++] = center_right; - uvs[loop_index++] = radius_factor_delta * circle[(i + 1) % config.circle_segments] + - center_right; + uvs[corner++] = radius_factor_delta * circle[i] + center_right; + uvs[corner++] = center_right; + uvs[corner++] = radius_factor_delta * circle[(i + 1) % config.circle_segments] + + center_right; } } else if (!config.bottom_is_point && config.fill_type == ConeFillType::NGon) { /* N-gon at the center of the fill. */ for (const int i : IndexRange(config.circle_segments)) { /* Go backwards because of reversed face normal. */ - uvs[loop_index++] = radius_factor_delta * circle[config.circle_segments - 1 - i] + - center_right; + uvs[corner++] = radius_factor_delta * circle[config.circle_segments - 1 - i] + + center_right; } } } diff --git a/source/blender/geometry/intern/mesh_primitive_grid.cc b/source/blender/geometry/intern/mesh_primitive_grid.cc index 559aaafba6a..e0597e03a6c 100644 --- a/source/blender/geometry/intern/mesh_primitive_grid.cc +++ b/source/blender/geometry/intern/mesh_primitive_grid.cc @@ -69,10 +69,10 @@ Mesh *create_grid_mesh(const int verts_x, const int y_offset = x * verts_y; threading::parallel_for(IndexRange(verts_y), 512, [&](IndexRange y_range) { for (const int y : y_range) { - const int vert_index = y_offset + y; - positions[vert_index].x = (x - x_shift) * dx; - positions[vert_index].y = (y - y_shift) * dy; - positions[vert_index].z = 0.0f; + const int vert = y_offset + y; + positions[vert].x = (x - x_shift) * dx; + positions[vert].y = (y - y_shift) * dy; + positions[vert].z = 0.0f; } }); } @@ -91,8 +91,8 @@ Mesh *create_grid_mesh(const int verts_x, const int y_edge_offset = y_edges_start + x * edges_y; threading::parallel_for(IndexRange(edges_y), 512, [&](IndexRange y_range) { for (const int y : y_range) { - const int vert_index = y_vert_offset + y; - edges[y_edge_offset + y] = int2(vert_index, vert_index + 1); + const int vert = y_vert_offset + y; + edges[y_edge_offset + y] = int2(vert, vert + 1); } }); } @@ -106,8 +106,8 @@ Mesh *create_grid_mesh(const int verts_x, const int x_edge_offset = x_edges_start + y * edges_x; threading::parallel_for(IndexRange(edges_x), 512, [&](IndexRange x_range) { for (const int x : x_range) { - const int vert_index = x * verts_y + y; - edges[x_edge_offset + x] = int2(vert_index, vert_index + verts_y); + const int vert = x * verts_y + y; + edges[x_edge_offset + x] = int2(vert, vert + verts_y); } }); } @@ -121,21 +121,21 @@ Mesh *create_grid_mesh(const int verts_x, const int y_offset = x * edges_y; threading::parallel_for(IndexRange(edges_y), 512, [&](IndexRange y_range) { for (const int y : y_range) { - const int face_index = y_offset + y; - const int loop_index = face_index * 4; - const int vert_index = x * verts_y + y; + const int face = y_offset + y; + const int corner = face * 4; + const int vert = x * verts_y + y; - corner_verts[loop_index] = vert_index; - corner_edges[loop_index] = x_edges_start + edges_x * y + x; + corner_verts[corner] = vert; + corner_edges[corner] = x_edges_start + edges_x * y + x; - corner_verts[loop_index + 1] = vert_index + verts_y; - corner_edges[loop_index + 1] = y_edges_start + edges_y * (x + 1) + y; + corner_verts[corner + 1] = vert + verts_y; + corner_edges[corner + 1] = y_edges_start + edges_y * (x + 1) + y; - corner_verts[loop_index + 2] = vert_index + verts_y + 1; - corner_edges[loop_index + 2] = x_edges_start + edges_x * (y + 1) + x; + corner_verts[corner + 2] = vert + verts_y + 1; + corner_edges[corner + 2] = x_edges_start + edges_x * (y + 1) + x; - corner_verts[loop_index + 3] = vert_index + 1; - corner_edges[loop_index + 3] = y_edges_start + edges_y * x + y; + corner_verts[corner + 3] = vert + 1; + corner_edges[corner + 3] = y_edges_start + edges_y * x + y; } }); } diff --git a/source/blender/nodes/geometry/nodes/node_geo_mesh_topology_corners_of_edge.cc b/source/blender/nodes/geometry/nodes/node_geo_mesh_topology_corners_of_edge.cc index e4a8399c2b8..b9503d0c76f 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_mesh_topology_corners_of_edge.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_mesh_topology_corners_of_edge.cc @@ -54,7 +54,7 @@ class CornersOfEdgeInput final : public bke::MeshFieldInput { Array map_offsets; Array map_indices; const Span corner_edges = mesh.corner_edges(); - const GroupedSpan edge_to_loop_map = bke::mesh::build_edge_to_corner_map( + const GroupedSpan edge_to_corner_map = bke::mesh::build_edge_to_corner_map( mesh.corner_edges(), mesh.edges_num, map_offsets, map_indices); const bke::MeshFieldContext context{mesh, domain}; @@ -87,7 +87,7 @@ class CornersOfEdgeInput final : public bke::MeshFieldInput { continue; } - const Span corners = edge_to_loop_map[edge_i]; + const Span corners = edge_to_corner_map[edge_i]; if (corners.is_empty()) { corner_of_edge[selection_i] = 0; continue; diff --git a/source/blender/nodes/geometry/nodes/node_geo_sample_nearest.cc b/source/blender/nodes/geometry/nodes/node_geo_sample_nearest.cc index 079ca2ed093..7f37fb65798 100644 --- a/source/blender/nodes/geometry/nodes/node_geo_sample_nearest.cc +++ b/source/blender/nodes/geometry/nodes/node_geo_sample_nearest.cc @@ -178,22 +178,22 @@ static void get_closest_mesh_corners(const Mesh &mesh, /* Find the closest vertex in the face. */ float min_distance_sq = FLT_MAX; - int closest_vert_index = 0; - int closest_loop_index = 0; - for (const int loop_index : faces[face_index]) { - const int vertex_index = corner_verts[loop_index]; - const float distance_sq = math::distance_squared(position, vert_positions[vertex_index]); + int closest_vert = 0; + int closest_corner = 0; + for (const int corner : faces[face_index]) { + const int vert = corner_verts[corner]; + const float distance_sq = math::distance_squared(position, vert_positions[vert]); if (distance_sq < min_distance_sq) { min_distance_sq = distance_sq; - closest_loop_index = loop_index; - closest_vert_index = vertex_index; + closest_corner = corner; + closest_vert = vert; } } if (!r_corner_indices.is_empty()) { - r_corner_indices[i] = closest_loop_index; + r_corner_indices[i] = closest_corner; } if (!r_positions.is_empty()) { - r_positions[i] = vert_positions[closest_vert_index]; + r_positions[i] = vert_positions[closest_vert]; } if (!r_distances_sq.is_empty()) { r_distances_sq[i] = min_distance_sq;