Page MenuHome
Differential D15982 Diff 59259 source/blender/nodes/geometry/nodes/node_geo_dual_mesh.cc

Changeset View

Standalone View

View Options

source/blender/nodes/geometry/nodes/node_geo_dual_mesh.cc

Show First 20 Lines • Show All 92 Lines • ▼ Show 20 Lines
* - The faces are at the vertices of the input mesh. * - The faces are at the vertices of the input mesh.
* *
* Some special cases are needed for boundaries and non-manifold geometry. * Some special cases are needed for boundaries and non-manifold geometry.
*/ */
static Mesh *calc_dual_mesh(const Mesh &src_mesh, static Mesh *calc_dual_mesh(const Mesh &src_mesh,
const bool keep_boundaries, const bool keep_boundaries,
const AnonymousAttributePropagationInfo &propagation_info) const AnonymousAttributePropagationInfo &propagation_info)
{ {
const Span<MVert> src_verts = src_mesh.verts(); const Span<float3> src_positions = src_mesh.vert_positions();
const Span<MEdge> src_edges = src_mesh.edges(); const Span<MEdge> src_edges = src_mesh.edges();
const Span<MPoly> src_polys = src_mesh.polys(); const Span<MPoly> src_polys = src_mesh.polys();
const Span<MLoop> src_loops = src_mesh.loops(); const Span<MLoop> src_loops = src_mesh.loops();
Array<VertexType> vertex_types(src_mesh.totvert); Array<VertexType> vertex_types(src_mesh.totvert);
Array<EdgeType> edge_types(src_mesh.totedge); Array<EdgeType> edge_types(src_mesh.totedge);
calc_boundaries(src_mesh, vertex_types, edge_types); calc_boundaries(src_mesh, vertex_types, edge_types);
/* Stores the indices of the polygons connected to the vertex. Because the polygons are looped /* Stores the indices of the polygons connected to the vertex. Because the polygons are looped
* over in order of their indices, the polygon's indices will be sorted in ascending order. * over in order of their indices, the polygon's indices will be sorted in ascending order.
* (This can change once they are sorted using `sort_vertex_polys`). */ * (This can change once they are sorted using `sort_vertex_polys`). */
Array<Vector<int>> vert_to_poly_map = bke::mesh_topology::build_vert_to_poly_map( Array<Vector<int>> vert_to_poly_map = bke::mesh_topology::build_vert_to_poly_map(
src_polys, src_loops, src_verts.size()); src_polys, src_loops, src_positions.size());
Array<Array<int>> vertex_shared_edges(src_mesh.totvert); Array<Array<int>> vertex_shared_edges(src_mesh.totvert);
Array<Array<int>> vertex_corners(src_mesh.totvert); Array<Array<int>> vertex_corners(src_mesh.totvert);
threading::parallel_for(vert_to_poly_map.index_range(), 512, [&](IndexRange range) { threading::parallel_for(vert_to_poly_map.index_range(), 512, [&](IndexRange range) {
for (const int i : range) { for (const int i : range) {
if (vertex_types[i] == VertexType::Loose || vertex_types[i] >= VertexType::NonManifold || if (vertex_types[i] == VertexType::Loose || vertex_types[i] >= VertexType::NonManifold ||
(!keep_boundaries && vertex_types[i] == VertexType::Boundary)) { (!keep_boundaries && vertex_types[i] == VertexType::Boundary)) {
/* Bad vertex that we can't work with. */ /* Bad vertex that we can't work with. */
continue; continue;
Show All 35 Lines
} }
vertex_corners[i] = std::move(sorted_corners); vertex_corners[i] = std::move(sorted_corners);
} }
}); });
Vector<float3> vertex_positions(src_mesh.totpoly); Vector<float3> vertex_positions(src_mesh.totpoly);
for (const int i : IndexRange(src_mesh.totpoly)) { for (const int i : IndexRange(src_mesh.totpoly)) {
const MPoly &poly = src_polys[i]; const MPoly &poly = src_polys[i];
BKE_mesh_calc_poly_center( BKE_mesh_calc_poly_center(&poly,
&poly, &src_loops[poly.loopstart], src_verts.data(), vertex_positions[i]); &src_loops[poly.loopstart],
reinterpret_cast<const float(*)[3]>(src_positions.data()),
vertex_positions[i]);
} }
Array<int> boundary_edge_midpoint_index; Array<int> boundary_edge_midpoint_index;
if (keep_boundaries) { if (keep_boundaries) {
/* Only initialize when we actually need it. */ /* Only initialize when we actually need it. */
boundary_edge_midpoint_index.reinitialize(src_mesh.totedge); boundary_edge_midpoint_index.reinitialize(src_mesh.totedge);
/* We need to add vertices at the centers of boundary edges. */ /* We need to add vertices at the centers of boundary edges. */
for (const int i : IndexRange(src_mesh.totedge)) { for (const int i : IndexRange(src_mesh.totedge)) {
if (edge_types[i] == EdgeType::Boundary) { if (edge_types[i] == EdgeType::Boundary) {
float3 mid;
const MEdge &edge = src_edges[i]; const MEdge &edge = src_edges[i];
mid_v3_v3v3(mid, src_verts[edge.v1].co, src_verts[edge.v2].co); const float3 mid = math::midpoint(src_positions[edge.v1], src_positions[edge.v2]);
boundary_edge_midpoint_index[i] = vertex_positions.size(); boundary_edge_midpoint_index[i] = vertex_positions.size();
vertex_positions.append(mid); vertex_positions.append(mid);
} }
} }
} }
Vector<int> loop_lengths; Vector<int> loop_lengths;
Vector<int> loops; Vector<int> loops;
▲ Show 20 Lines • Show All 134 Lines • ▼ Show 20 Lines
else { else {
loop_edges.append(old_to_new_edges_map[edge1]); loop_edges.append(old_to_new_edges_map[edge1]);
} }
loop_indices.append(vertex_positions.size()); loop_indices.append(vertex_positions.size());
/* This is sort of arbitrary, but interpolating would be a lot harder to do. */ /* This is sort of arbitrary, but interpolating would be a lot harder to do. */
new_to_old_face_corners_map.append(sorted_corners.first()); new_to_old_face_corners_map.append(sorted_corners.first());
boundary_vertex_to_relevant_face_map.append( boundary_vertex_to_relevant_face_map.append(
std::pair(loop_indices.last(), last_face_center)); std::pair(loop_indices.last(), last_face_center));
vertex_positions.append(src_verts[i].co); vertex_positions.append(src_positions[i]);
const int boundary_vertex = loop_indices.last(); const int boundary_vertex = loop_indices.last();
add_edge(src_edges, add_edge(src_edges,
edge1, edge1,
first_midpoint, first_midpoint,
boundary_vertex, boundary_vertex,
new_to_old_edges_map, new_to_old_edges_map,
new_edges, new_edges,
loop_edges); loop_edges);
Show All 38 Lines
keep_boundaries, keep_boundaries,
new_to_old_edges_map, new_to_old_edges_map,
new_to_old_face_corners_map, new_to_old_face_corners_map,
boundary_vertex_to_relevant_face_map, boundary_vertex_to_relevant_face_map,
propagation_info, propagation_info,
src_mesh.attributes(), src_mesh.attributes(),
mesh_out->attributes_for_write()); mesh_out->attributes_for_write());
MutableSpan<MVert> dst_verts = mesh_out->verts_for_write(); mesh_out->vert_positions_for_write().copy_from(vertex_positions);
MutableSpan<MEdge> dst_edges = mesh_out->edges_for_write(); MutableSpan<MEdge> dst_edges = mesh_out->edges_for_write();
MutableSpan<MPoly> dst_polys = mesh_out->polys_for_write(); MutableSpan<MPoly> dst_polys = mesh_out->polys_for_write();
MutableSpan<MLoop> dst_loops = mesh_out->loops_for_write(); MutableSpan<MLoop> dst_loops = mesh_out->loops_for_write();
int loop_start = 0; int loop_start = 0;
for (const int i : IndexRange(mesh_out->totpoly)) { for (const int i : IndexRange(mesh_out->totpoly)) {
dst_polys[i].loopstart = loop_start; dst_polys[i].loopstart = loop_start;
dst_polys[i].totloop = loop_lengths[i]; dst_polys[i].totloop = loop_lengths[i];
loop_start += loop_lengths[i]; loop_start += loop_lengths[i];
} }
for (const int i : IndexRange(mesh_out->totloop)) { for (const int i : IndexRange(mesh_out->totloop)) {
dst_loops[i].v = loops[i]; dst_loops[i].v = loops[i];
dst_loops[i].e = loop_edges[i]; dst_loops[i].e = loop_edges[i];
} }
for (const int i : IndexRange(mesh_out->totvert)) {
copy_v3_v3(dst_verts[i].co, vertex_positions[i]);
}
dst_edges.copy_from(new_edges); dst_edges.copy_from(new_edges);
return mesh_out; return mesh_out;
} }
static void node_geo_exec(GeoNodeExecParams params) static void node_geo_exec(GeoNodeExecParams params)
{ {
GeometrySet geometry_set = params.extract_input<GeometrySet>("Mesh"); GeometrySet geometry_set = params.extract_input<GeometrySet>("Mesh");
const bool keep_boundaries = params.extract_input<bool>("Keep Boundaries"); const bool keep_boundaries = params.extract_input<bool>("Keep Boundaries");
Show All 22 Lines