griefith/test2
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity

Cleanup: Modernize mesh variable naming in some cases

Browse Source 
Simplify naming of vertex and corner indices, and replace "loop".
This commit is contained in:
Hans Goudey
2025-03-05 23:16:05 -05:00
parent edd041e230
commit d88d6331fd
13 changed files with 193 additions and 197 deletions
Download Patch File Download Diff File Expand all files Collapse all files

13
source/blender/blenkernel/BKE_mesh_iterators.hh
View File

@@ -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]),

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

@@ -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;
}

32
source/blender/blenkernel/intern/geometry_compare.cc
View File

@@ -370,15 +370,15 @@ static void update_set_sizes(const Span<int> set_ids, MutableSpan<int> set_sizes
}
}
static void edges_from_vertex_sets(const Span<int2> edges,
const Span<int> verts_to_sorted,
const Span<int> vertex_set_ids,
MutableSpan<OrderedEdge> r_edges)
static void edges_from_vert_sets(const Span<int2> edges,
const Span<int> verts_to_sorted,
const Span<int> vert_set_ids,
MutableSpan<OrderedEdge> 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<int2> edges1,
/* Need `NoInitialization()` because OrderedEdge is not default constructible. */
Array<OrderedEdge> ordered_edges1(edges1.size(), NoInitialization());
Array<OrderedEdge> 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<int> set_sizes)
*
* \returns the type of mismatch that occurred if the mapping couldn't be constructed.
*/
static std::optional<GeoMismatch> construct_vertex_mapping(const Mesh &mesh1,
const Mesh &mesh2,
IndexMapping &verts,
IndexMapping &edges)
static std::optional<GeoMismatch> 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<GeoMismatch> 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<GeoMismatch> 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<GeoMismatch> 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;
}

30
source/blender/blenkernel/intern/mesh_attributes.cc
View File

@@ -113,8 +113,8 @@ static GVArray adapt_mesh_domain_corner_to_face(const Mesh &mesh, const GVArray
new_varray = VArray<T>::ForFunc(
faces.size(), [faces, varray = varray.typed<bool>()](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<T>()](const int face_index) {
T return_value;
attribute_math::DefaultMixer<T> 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;
}
}
}

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

@@ -474,7 +474,7 @@ GroupedSpan<int> build_edge_to_face_map(const OffsetIndices<int> faces,
*/
using MeshRemap_CheckIslandBoundary =
blender::FunctionRef<bool(int face_index,
int loop_index,
int corner,
int edge_index,
int edge_user_count,
const blender::Span<int> 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<int> edge_face_map_elem) {
@@ -854,12 +854,12 @@ static bool mesh_calc_islands_loop_face_uv(const int totedge,
const GroupedSpan<int> 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<int> edge_to_loop_offsets;
Array<int> edge_to_loop_indices;
GroupedSpan<int> edge_to_loop_map;
Array<int> edge_to_corner_offsets;
Array<int> edge_to_corner_indices;
GroupedSpan<int> 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<int> /*edge_face_map_elem*/) -> bool {
if (luvs) {
const Span<int> edge_to_loops = edge_to_loop_map[corner_edges[loop_index]];
const Span<int> 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;
}

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

@@ -1259,7 +1259,7 @@ void BKE_mesh_remap_calc_loops_from_mesh(const int mode,
blender::Array<blender::float3> face_cents_src;
GroupedSpan<int> vert_to_loop_map_src;
GroupedSpan<int> vert_to_corner_map_src;
GroupedSpan<int> vert_to_face_map_src;
Array<int> 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;

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

@@ -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()) {

42
source/blender/editors/sculpt_paint/sculpt_trim.cc
View File

@@ -452,53 +452,53 @@ static void generate_geometry(gesture::GestureData &gesture_data)
MutableSpan<int> face_offsets = trim_operation->mesh->face_offsets_for_write();
MutableSpan<int> 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);

86
source/blender/geometry/intern/mesh_primitive_cuboid.cc
View File

@@ -104,21 +104,21 @@ static void calculate_positions(const CuboidConfig &config, MutableSpan<float3>
* anti-clockwise.
*/
static void define_quad(MutableSpan<int> 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<int> 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<int>
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<int>
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<int>
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<int>
}
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<int>
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<int>
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<float2> 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);
}
}

56
source/blender/geometry/intern/mesh_primitive_cylinder_cone.cc
View File

@@ -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;
}
}
}

38
source/blender/geometry/intern/mesh_primitive_grid.cc
View File

@@ -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;
}
});
}

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

@@ -54,7 +54,7 @@ class CornersOfEdgeInput final : public bke::MeshFieldInput {
Array<int> map_offsets;
Array<int> map_indices;
const Span<int> corner_edges = mesh.corner_edges();
const GroupedSpan<int> edge_to_loop_map = bke::mesh::build_edge_to_corner_map(
const GroupedSpan<int> 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<int> corners = edge_to_loop_map[edge_i];
const Span<int> corners = edge_to_corner_map[edge_i];
if (corners.is_empty()) {
corner_of_edge[selection_i] = 0;
continue;

18
source/blender/nodes/geometry/nodes/node_geo_sample_nearest.cc
View File

@@ -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;