blender
/
blender
136
405
Fork 586
Code Issues 6.2k Pull Requests 757 Projects 19 Wiki Activity

Fix several failing tests

This commit is contained in:
Hans Goudey 2022-12-11 00:36:31 -06:00
parent f645faace9
commit d90281c725
7 changed files with 39 additions and 32 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -512,6 +512,12 @@ static int customdata_compare(
}
/* At this point `l1` and `l2` have the same name and type, so they should be compared. */
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. */
continue;
}
switch (l1->type) {
/* We're order-agnostic for edges here. */
case CD_MEDGE: {

24
source/blender/blenkernel/intern/mesh_calc_edges.cc
View File

@ -104,9 +104,9 @@ static void add_polygon_edges_to_hash_maps(Mesh *mesh,
for (const MPoly &poly : polys) {
const IndexRange corners(poly.loopstart, poly.totloop);
int corner_prev = corners.last();
for (const int corner : corners) {
for (const int next_corner : corners) {
/* Can only be the same when the mesh data is invalid. */
const int vert = corner_verts[corner];
const int vert = corner_verts[next_corner];
const int vert_prev = corner_verts[corner_prev];
if (vert_prev != vert) {
OrderedEdge ordered_edge{vert_prev, vert};
@ -115,7 +115,7 @@ static void add_polygon_edges_to_hash_maps(Mesh *mesh,
edge_map.lookup_or_add(ordered_edge, {nullptr});
}
}
corner_prev = corner;
corner_prev = next_corner;
}
}
});
@ -161,17 +161,17 @@ static void update_edge_indices_in_poly_loops(Mesh *mesh,
uint32_t parallel_mask)
{
const Span<MPoly> polys = mesh->polys();
MutableSpan<int> corner_verts = mesh->corner_verts_for_write();
const Span<int> corner_verts = mesh->corner_verts();
MutableSpan<int> corner_edges = mesh->corner_edges_for_write();
threading::parallel_for(IndexRange(mesh->totpoly), 100, [&](IndexRange range) {
for (const int poly_index : range) {
const MPoly &poly = polys[poly_index];
const IndexRange corners(poly.loopstart, poly.totloop);
int corner_prev = corners.last();
for (const int corner : corners) {
const int vert = corner_verts[corner];
const int vert_prev = corner_verts[corner_prev];
int prev_corner = corners.last();
for (const int next_corner : corners) {
const int vert = corner_verts[next_corner];
const int vert_prev = corner_verts[prev_corner];
int edge_index;
if (vert_prev != vert) {
@ -186,8 +186,8 @@ static void update_edge_indices_in_poly_loops(Mesh *mesh,
* T76514. */
edge_index = 0;
}
corner_edges[corner_prev] = edge_index;
corner_prev = corner;
corner_edges[prev_corner] = edge_index;
prev_corner = next_corner;
}
}
});
@ -239,6 +239,10 @@ void BKE_mesh_calc_edges(Mesh *mesh, bool keep_existing_edges, const bool select
}
/* Create new edges. */
if (!CustomData_get_layer_named(&mesh->ldata, CD_PROP_INT32, ".corner_edge")) {
CustomData_add_layer_named(
&mesh->ldata, CD_PROP_INT32, CD_CONSTRUCT, nullptr, mesh->totloop, ".corner_edge");
}
MutableSpan<MEdge> new_edges{
static_cast<MEdge *>(MEM_calloc_arrayN(new_totedge, sizeof(MEdge), __func__)), new_totedge};
calc_edges::serialize_and_initialize_deduplicated_edges(edge_maps, new_edges);

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

@ -714,21 +714,20 @@ static void poly_edge_loop_islands_calc(const MEdge *medge,
while (ps_curr_idx != ps_end_idx) {
const MPoly *mp;
int corner_i;
int j;
poly = poly_stack[ps_curr_idx++];
BLI_assert(poly_groups[poly] == poly_group_id);
mp = &mpoly[poly];
for (corner_i = mp->loopstart, j = mp->totloop; j--;) {
for (const int64_t corner_i : blender::IndexRange(mp->loopstart, mp->totloop)) {
/* loop over poly users */
const int me_idx = corner_edges[corner_i];
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, corner_i, me, i, mpoly, map_ele, edge_boundary_check_data)) {
if (!edge_boundary_check(
mp, int(corner_i), me, i, mpoly, map_ele, edge_boundary_check_data)) {
for (; i--; p++) {
/* if we meet other non initialized its a bug */
BLI_assert(ELEM(poly_groups[*p], 0, poly_group_id));

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

@ -315,7 +315,7 @@ static void calculate_normals_poly_and_vert(const Span<float3> positions,
const float fac = saacos(-dot_v3v3(edvec_prev, edvec_next));
const float vnor_add[3] = {pnor[0] * fac, pnor[1] * fac, pnor[2] * fac};
float *vnor = vert_normals[corner_verts[i_curr]];
float *vnor = vert_normals[poly_verts[i_curr]];
add_v3_v3_atomic(vnor, vnor_add);
v_curr = v_next;
copy_v3_v3(edvec_prev, edvec_next);

8
source/blender/modifiers/intern/MOD_array.c
View File

@ -425,8 +425,6 @@ static Mesh *arrayModifier_doArray(ArrayModifierData *amd,
unit_m4(offset);
const MEdge *src_edges = BKE_mesh_edges(mesh);
const MPoly *src_polys = BKE_mesh_polys(mesh);
const int *src_corner_verts = BKE_mesh_corner_verts(mesh);
const int *src_corner_edges = BKE_mesh_corner_edges(mesh);
if (amd->offset_type & MOD_ARR_OFF_CONST) {
add_v3_v3(offset[3], amd->offset);
@ -556,8 +554,6 @@ static Mesh *arrayModifier_doArray(ArrayModifierData *amd,
memcpy(result_edges, src_edges, sizeof(MEdge) * mesh->totedge);
}
if (!CustomData_has_layer(&mesh->pdata, CD_MPOLY)) {
memcpy(result_corner_verts, src_corner_verts, sizeof(int) * mesh->totloop);
memcpy(result_corner_edges, src_corner_edges, sizeof(int) * mesh->totloop);
memcpy(result_polys, src_polys, sizeof(MPoly) * mesh->totpoly);
}
@ -614,8 +610,8 @@ static Mesh *arrayModifier_doArray(ArrayModifierData *amd,
/* adjust loop vertex and edge indices */
const int chunk_corner_start = c * chunk_nloops;
for (i = 0; i < chunk_nloops; i++) {
result_corner_verts[chunk_corner_start] += c * chunk_nverts;
result_corner_edges[chunk_corner_start] += c * chunk_nedges;
result_corner_verts[chunk_corner_start + i] += c * chunk_nverts;
result_corner_edges[chunk_corner_start + i] += c * chunk_nedges;
}
/* Handle merge between chunk n and n-1 */

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

@ -125,8 +125,8 @@ 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] = mesh_corner_verts[loops[k]];
mesh_corner_edges[dst_corner_i] = mesh_corner_edges[loops[k]];
mesh_corner_verts[dst_corner_i] = corner_verts[loops[k]];
mesh_corner_edges[dst_corner_i] = corner_edges[loops[k]];
dst_corner_i++;
}
j += len;

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

@ -325,7 +325,7 @@ static void fill_quad_consistent_direction(const Span<int> other_poly_verts,
{
/* Find the loop on the polygon connected to the new quad that uses the duplicate edge. */
bool start_with_connecting_edge = true;
for (const int i : other_poly_verts.index_range()) {
for (const int i : other_poly_edges.index_range()) {
if (other_poly_edges[i] == edge_connected_to_poly) {
start_with_connecting_edge = other_poly_verts[i] == vert_connected_to_poly_1;
break;
@ -464,8 +464,8 @@ static void extrude_mesh_edges(Mesh &mesh,
/* When there was a single polygon connected to the new polygon, we can use the old one to keep
* the face direction consistent. When there is more than one connected edge, the new face
* direction is totally arbitrary and the only goal for the behavior is to be deterministic. */
Span<int> connected_poly_verts;
Span<int> connected_poly_edges;
Span<int> connected_poly_verts = {};
Span<int> connected_poly_edges = {};
if (connected_polys.size() == 1) {
const MPoly &connected_poly = polys[connected_polys.first()];
connected_poly_verts = corner_verts.slice(connected_poly.loopstart, connected_poly.totloop);
@ -568,14 +568,13 @@ static void extrude_mesh_edges(Mesh &mesh,
* polygons that share an edge with the extruded edge. */
for (const int i_connected_poly : connected_polys.index_range()) {
const MPoly &connected_poly = polys[connected_polys[i_connected_poly]];
for (const int corner_i :
for (const int i_loop :
IndexRange(connected_poly.loopstart, connected_poly.totloop)) {
const int vert_i = corner_verts[corner_i];
if (vert_i == orig_vert_1) {
mixer.mix_in(0, data[corner_i]);
if (corner_verts[i_loop] == orig_vert_1) {
mixer.mix_in(0, data[i_loop]);
}
if (vert_i == orig_vert_2) {
mixer.mix_in(1, data[corner_i]);
if (corner_verts[i_loop] == orig_vert_2) {
mixer.mix_in(1, data[i_loop]);
}
}
}
@ -1197,6 +1196,9 @@ static void extrude_individual_mesh_faces(Mesh &mesh,
if (meta_data.data_type == CD_PROP_STRING) {
return true;
}
if (id.is_named() && ELEM(id.name(), ".corner_vert", ".corner_edge")) {
return true;
}
GSpanAttributeWriter attribute = attributes.lookup_or_add_for_write_span(
id, meta_data.domain, meta_data.data_type);
if (!attribute) {