From 65e62ba5eb5b08bbd1cb94b4b48a5d55c152c59b Mon Sep 17 00:00:00 2001 From: Adith Ramachandran <59206213+adithramachandran@users.noreply.github.com> Date: Thu, 16 May 2024 10:54:35 -0400 Subject: [PATCH] Revert "Support calculating normals for indexed meshes" (#12716) and add support for calculating smooth normals (#13333) # Objective - Refactor the changes merged in #11654 to compute flat normals for indexed meshes instead of smooth normals. - Fixes #12716 ## Solution - Partially revert the changes in #11654 to compute flat normals for both indexed and unindexed meshes in `compute_flat_normals` - Create a new method, `compute_smooth_normals`, that computes smooth normals for indexed meshes - Create a new method, `compute_normals`, that computes smooth normals for indexed meshes and flat normals for unindexed meshes by default. Use this new method instead of `compute_flat_normals`. ## Testing - Run the example with and without the changes to ensure that the results are identical. --- crates/bevy_render/src/mesh/mesh/mod.rs | 164 +++++++++++++++++------- 1 file changed, 120 insertions(+), 44 deletions(-) diff --git a/crates/bevy_render/src/mesh/mesh/mod.rs b/crates/bevy_render/src/mesh/mesh/mod.rs index 90e23fbcd8..a58556d827 100644 --- a/crates/bevy_render/src/mesh/mesh/mod.rs +++ b/crates/bevy_render/src/mesh/mesh/mod.rs @@ -544,15 +544,44 @@ impl Mesh { } /// Calculates the [`Mesh::ATTRIBUTE_NORMAL`] of a mesh. + /// If the mesh is indexed, this defaults to smooth normals. Otherwise, it defaults to flat + /// normals. /// /// # Panics /// Panics if [`Mesh::ATTRIBUTE_POSITION`] is not of type `float3`. /// Panics if the mesh has any other topology than [`PrimitiveTopology::TriangleList`]. /// - /// FIXME: The should handle more cases since this is called as a part of gltf + /// FIXME: This should handle more cases since this is called as a part of gltf + /// mesh loading where we can't really blame users for loading meshes that might + /// not conform to the limitations here! + pub fn compute_normals(&mut self) { + assert!( + matches!(self.primitive_topology, PrimitiveTopology::TriangleList), + "`compute_normals` can only work on `TriangleList`s" + ); + if self.indices().is_none() { + self.compute_flat_normals(); + } else { + self.compute_smooth_normals(); + } + } + + /// Calculates the [`Mesh::ATTRIBUTE_NORMAL`] of a mesh. + /// + /// # Panics + /// Panics if [`Indices`] are set or [`Mesh::ATTRIBUTE_POSITION`] is not of type `float3`. + /// Panics if the mesh has any other topology than [`PrimitiveTopology::TriangleList`]. + /// Consider calling [`Mesh::duplicate_vertices`] or exporting your mesh with normal + /// attributes. + /// + /// FIXME: This should handle more cases since this is called as a part of gltf /// mesh loading where we can't really blame users for loading meshes that might /// not conform to the limitations here! pub fn compute_flat_normals(&mut self) { + assert!( + self.indices().is_none(), + "`compute_flat_normals` can't work on indexed geometry. Consider calling either `Mesh::compute_smooth_normals` or `Mesh::duplicate_vertices` followed by `Mesh::compute_flat_normals`." + ); assert!( matches!(self.primitive_topology, PrimitiveTopology::TriangleList), "`compute_flat_normals` can only work on `TriangleList`s" @@ -564,67 +593,114 @@ impl Mesh { .as_float3() .expect("`Mesh::ATTRIBUTE_POSITION` vertex attributes should be of type `float3`"); - match self.indices() { - Some(indices) => { - let mut count: usize = 0; - let mut corners = [0_usize; 3]; - let mut normals = vec![[0.0f32; 3]; positions.len()]; - let mut adjacency_counts = vec![0_usize; positions.len()]; + let normals: Vec<_> = positions + .chunks_exact(3) + .map(|p| face_normal(p[0], p[1], p[2])) + .flat_map(|normal| [normal; 3]) + .collect(); - for i in indices.iter() { - corners[count % 3] = i; - count += 1; - if count % 3 == 0 { - let normal = face_normal( - positions[corners[0]], - positions[corners[1]], - positions[corners[2]], - ); - for corner in corners { - normals[corner] = - (Vec3::from(normal) + Vec3::from(normals[corner])).into(); - adjacency_counts[corner] += 1; - } - } - } + self.insert_attribute(Mesh::ATTRIBUTE_NORMAL, normals); + } - // average (smooth) normals for shared vertices... - // TODO: support different methods of weighting the average - for i in 0..normals.len() { - let count = adjacency_counts[i]; - if count > 0 { - normals[i] = (Vec3::from(normals[i]) / (count as f32)).normalize().into(); - } - } + /// Calculates the [`Mesh::ATTRIBUTE_NORMAL`] of an indexed mesh, smoothing normals for shared + /// vertices. + /// + /// # Panics + /// Panics if [`Mesh::ATTRIBUTE_POSITION`] is not of type `float3`. + /// Panics if the mesh has any other topology than [`PrimitiveTopology::TriangleList`]. + /// Panics if the mesh does not have indices defined. + /// + /// FIXME: This should handle more cases since this is called as a part of gltf + /// mesh loading where we can't really blame users for loading meshes that might + /// not conform to the limitations here! + pub fn compute_smooth_normals(&mut self) { + assert!( + matches!(self.primitive_topology, PrimitiveTopology::TriangleList), + "`compute_smooth_normals` can only work on `TriangleList`s" + ); + assert!( + self.indices().is_some(), + "`compute_smooth_normals` can only work on indexed meshes" + ); - self.insert_attribute(Mesh::ATTRIBUTE_NORMAL, normals); - } - None => { - let normals: Vec<_> = positions - .chunks_exact(3) - .map(|p| face_normal(p[0], p[1], p[2])) - .flat_map(|normal| [normal; 3]) - .collect(); + let positions = self + .attribute(Mesh::ATTRIBUTE_POSITION) + .unwrap() + .as_float3() + .expect("`Mesh::ATTRIBUTE_POSITION` vertex attributes should be of type `float3`"); - self.insert_attribute(Mesh::ATTRIBUTE_NORMAL, normals); + let mut normals = vec![Vec3::ZERO; positions.len()]; + let mut adjacency_counts = vec![0_usize; positions.len()]; + + self.indices() + .unwrap() + .iter() + .collect::>() + .chunks_exact(3) + .for_each(|face| { + let [a, b, c] = [face[0], face[1], face[2]]; + let normal = Vec3::from(face_normal(positions[a], positions[b], positions[c])); + [a, b, c].iter().for_each(|pos| { + normals[*pos] += normal; + adjacency_counts[*pos] += 1; + }); + }); + + // average (smooth) normals for shared vertices... + // TODO: support different methods of weighting the average + for i in 0..normals.len() { + let count = adjacency_counts[i]; + if count > 0 { + normals[i] = (normals[i] / (count as f32)).normalize(); } } + + self.insert_attribute(Mesh::ATTRIBUTE_NORMAL, normals); + } + + /// Consumes the mesh and returns a mesh with calculated [`Mesh::ATTRIBUTE_NORMAL`]. + /// If the mesh is indexed, this defaults to smooth normals. Otherwise, it defaults to flat + /// normals. + /// + /// (Alternatively, you can use [`Mesh::compute_normals`] to mutate an existing mesh in-place) + /// + /// # Panics + /// Panics if [`Mesh::ATTRIBUTE_POSITION`] is not of type `float3`. + /// Panics if the mesh has any other topology than [`PrimitiveTopology::TriangleList`]. + #[must_use] + pub fn with_computed_normals(mut self) -> Self { + self.compute_normals(); + self } /// Consumes the mesh and returns a mesh with calculated [`Mesh::ATTRIBUTE_NORMAL`]. /// - /// (Alternatively, you can use [`Mesh::with_computed_flat_normals`] to mutate an existing mesh in-place) + /// (Alternatively, you can use [`Mesh::compute_flat_normals`] to mutate an existing mesh in-place) /// /// # Panics - /// Panics if [`Indices`] are set or [`Mesh::ATTRIBUTE_POSITION`] is not of type `float3` or - /// if the mesh has any other topology than [`PrimitiveTopology::TriangleList`]. - /// Consider calling [`Mesh::with_duplicated_vertices`] or export your mesh with normal attributes. + /// Panics if [`Mesh::ATTRIBUTE_POSITION`] is not of type `float3`. + /// Panics if the mesh has any other topology than [`PrimitiveTopology::TriangleList`]. + /// Panics if the mesh has indices defined #[must_use] pub fn with_computed_flat_normals(mut self) -> Self { self.compute_flat_normals(); self } + /// Consumes the mesh and returns a mesh with calculated [`Mesh::ATTRIBUTE_NORMAL`]. + /// + /// (Alternatively, you can use [`Mesh::compute_smooth_normals`] to mutate an existing mesh in-place) + /// + /// # Panics + /// Panics if [`Mesh::ATTRIBUTE_POSITION`] is not of type `float3`. + /// Panics if the mesh has any other topology than [`PrimitiveTopology::TriangleList`]. + /// Panics if the mesh does not have indices defined. + #[must_use] + pub fn with_computed_smooth_normals(mut self) -> Self { + self.compute_smooth_normals(); + self + } + /// Generate tangents for the mesh using the `mikktspace` algorithm. /// /// Sets the [`Mesh::ATTRIBUTE_TANGENT`] attribute if successful.