Rename TangentCalculationStrategy to TangentAlgorithm

The variants have also been renamed to match their algorithm names.

Author: aloucks

crates/bevy_gltf/src/lib.rs

@@ -102,7 +102,7 @@ use bevy_platform_support::collections::HashMap;
 use bevy_app::prelude::*;
 use bevy_asset::AssetApp;
 use bevy_image::CompressedImageFormats;
-use bevy_mesh::{MeshVertexAttribute, TangentCalculationStrategy};
+use bevy_mesh::{MeshVertexAttribute, TangentAlgorithm};
 use bevy_render::renderer::RenderDevice;
 
 /// The glTF prelude.
@@ -119,8 +119,8 @@ pub use {assets::*, label::GltfAssetLabel, loader::*};
 #[derive(Default)]
 pub struct GltfPlugin {
     custom_vertex_attributes: HashMap<Box<str>, MeshVertexAttribute>,
-    /// The strategy to use when computing tangents for meshes without them.
-    pub tangent_calculation_strategy: TangentCalculationStrategy,
+    /// The algorithm to use when computing tangents for meshes without them.
+    pub tangent_calculation_algorithm: TangentAlgorithm,
 }
 
 impl GltfPlugin {
@@ -138,12 +138,12 @@ impl GltfPlugin {
         self
     }
 
-    /// The strategy to use when computing mesh tangents.
-    pub fn with_tangent_calculation_strategy(
+    /// The algorithm to use when computing mesh tangents.
+    pub fn with_tangent_calculation_algorithm(
         mut self,
-        tangent_strategy: TangentCalculationStrategy,
+        tangent_algorithm: TangentAlgorithm,
     ) -> Self {
-        self.tangent_calculation_strategy = tangent_strategy;
+        self.tangent_calculation_algorithm = tangent_algorithm;
         self
     }
 }
@@ -171,7 +171,7 @@ impl Plugin for GltfPlugin {
         app.register_asset_loader(GltfLoader {
             supported_compressed_formats,
             custom_vertex_attributes: self.custom_vertex_attributes.clone(),
-            tangent_calculation_strategy: self.tangent_calculation_strategy,
+            tangent_calculation_algorithm: self.tangent_calculation_algorithm,
         });
     }
 }

crates/bevy_gltf/src/loader/mod.rs

@@ -28,8 +28,7 @@ use bevy_math::{Mat4, Vec3};
 use bevy_mesh::{
     morph::{MeshMorphWeights, MorphAttributes, MorphTargetImage, MorphWeights},
     skinning::{SkinnedMesh, SkinnedMeshInverseBindposes},
-    Indices, Mesh, MeshVertexAttribute, PrimitiveTopology, TangentCalculationStrategy,
-    VertexAttributeValues,
+    Indices, Mesh, MeshVertexAttribute, PrimitiveTopology, TangentAlgorithm, VertexAttributeValues,
 };
 #[cfg(feature = "pbr_transmission_textures")]
 use bevy_pbr::UvChannel;
@@ -147,8 +146,8 @@ pub struct GltfLoader {
     /// See [this section of the glTF specification](https://registry.khronos.org/glTF/specs/2.0/glTF-2.0.html#meshes-overview)
     /// for additional details on custom attributes.
     pub custom_vertex_attributes: HashMap<Box<str>, MeshVertexAttribute>,
-    /// The strategy to use when computing mesh tangents.
-    pub tangent_calculation_strategy: TangentCalculationStrategy,
+    /// The algorithm to use when computing mesh tangents.
+    pub tangent_calculation_algorithm: TangentAlgorithm,
 }
 
 /// Specifies optional settings for processing gltfs at load time. By default, all recognized contents of
@@ -688,17 +687,17 @@ async fn load_gltf<'a, 'b, 'c>(
                 && needs_tangents(&primitive.material())
             {
                 tracing::debug!(
-                    "Missing vertex tangents for {}, computing them using the {:?} strategy. Consider using a tool such as Blender to pre-compute the tangents.",
-                    file_name, loader.tangent_calculation_strategy
+                    "Missing vertex tangents for {}, computing them using the {:?} algorithm. Consider using a tool such as Blender to pre-compute the tangents.",
+                    file_name, loader.tangent_calculation_algorithm
                 );
 
                 let generate_tangents_span = info_span!("compute_tangents", name = file_name);
 
                 generate_tangents_span.in_scope(|| {
-                    if let Err(err) = mesh.compute_tangents(loader.tangent_calculation_strategy) {
+                    if let Err(err) = mesh.compute_tangents(loader.tangent_calculation_algorithm) {
                         warn!(
                             "Failed to generate vertex tangents using {:?}: {}",
-                            loader.tangent_calculation_strategy, err
+                            loader.tangent_calculation_algorithm, err
                         );
                     }
                 });

crates/bevy_mesh/src/gramschmidt.rs

@@ -136,14 +136,14 @@ pub(crate) fn generate_tangents_for_mesh(
 mod tests {
     use bevy_math::{primitives::*, Vec2, Vec3, Vec3A};
 
-    use crate::{Mesh, TangentCalculationStrategy};
+    use crate::{Mesh, TangentAlgorithm};
 
     // The tangents should be very close for simple shapes
     fn compare_tangents(mut mesh: Mesh) {
         let hq_tangents: Vec<[f32; 4]> = {
             mesh.remove_attribute(Mesh::ATTRIBUTE_TANGENT);
-            mesh.compute_tangents(TangentCalculationStrategy::HighQuality)
-                .expect("compute_tangents(HighQuality)");
+            mesh.compute_tangents(TangentAlgorithm::Mikktspace)
+                .expect("compute_tangents(Mikktspace)");
             mesh.attribute(Mesh::ATTRIBUTE_TANGENT)
                 .expect("hq_tangents.attribute(tangent)")
                 .as_float4()
@@ -153,8 +153,8 @@ mod tests {
 
         let fa_tangents: Vec<[f32; 4]> = {
             mesh.remove_attribute(Mesh::ATTRIBUTE_TANGENT);
-            mesh.compute_tangents(TangentCalculationStrategy::FastApproximation)
-                .expect("compute_tangents(FastApproximation)");
+            mesh.compute_tangents(TangentAlgorithm::GramSchmidt)
+                .expect("compute_tangents(GramSchmidt)");
             mesh.attribute(Mesh::ATTRIBUTE_TANGENT)
                 .expect("fa_tangents.attribute(tangent)")
                 .as_float4()

crates/bevy_mesh/src/mesh.rs

@@ -777,26 +777,22 @@ impl Mesh {
     /// Requires a [`PrimitiveTopology::TriangleList`] topology and the [`Mesh::ATTRIBUTE_POSITION`], [`Mesh::ATTRIBUTE_NORMAL`] and [`Mesh::ATTRIBUTE_UV_0`] attributes set.
     #[deprecated(since = "0.16.0", note = "use compute_tangents")]
     pub fn generate_tangents(&mut self) -> Result<(), GenerateTangentsError> {
-        self.compute_tangents(TangentCalculationStrategy::HighQuality)?;
+        self.compute_tangents(TangentAlgorithm::Mikktspace)?;
         Ok(())
     }
 
     /// Generate tangents for the mesh using the given algorithm.
     ///
     /// Sets the [`Mesh::ATTRIBUTE_TANGENT`] attribute if successful.
     ///
-    /// See [`TangentCalculationStrategy`] for mesh topology and attribute requirements.
+    /// See [`TangentAlgorithm`] for mesh topology and attribute requirements.
     pub fn compute_tangents(
         &mut self,
-        strategy: TangentCalculationStrategy,
+        algorithm: TangentAlgorithm,
     ) -> Result<(), GenerateTangentsError> {
-        let tangents = match strategy {
-            TangentCalculationStrategy::HighQuality => {
-                mikktspace::generate_tangents_for_mesh(self)?
-            }
-            TangentCalculationStrategy::FastApproximation => {
-                gramschmidt::generate_tangents_for_mesh(self)?
-            }
+        let tangents = match algorithm {
+            TangentAlgorithm::Mikktspace => mikktspace::generate_tangents_for_mesh(self)?,
+            TangentAlgorithm::GramSchmidt => gramschmidt::generate_tangents_for_mesh(self)?,
         };
         self.insert_attribute(Mesh::ATTRIBUTE_TANGENT, tangents);
         Ok(())
@@ -822,12 +818,12 @@ impl Mesh {
     ///
     /// (Alternatively, you can use [`Mesh::compute_tangents`] to mutate an existing mesh in-place)
     ///
-    /// See [`TangentCalculationStrategy`] for mesh topology and attribute requirements.
+    /// See [`TangentAlgorithm`] for mesh topology and attribute requirements.
     pub fn with_computed_tangents(
         mut self,
-        strategy: TangentCalculationStrategy,
+        algorithm: TangentAlgorithm,
     ) -> Result<Mesh, GenerateTangentsError> {
-        self.compute_tangents(strategy)?;
+        self.compute_tangents(algorithm)?;
         Ok(self)
     }
 
@@ -1275,18 +1271,18 @@ impl core::ops::Mul<Mesh> for Transform {
     }
 }
 
-#[derive(Debug, Copy, Clone, PartialEq, Eq, Default)]
-/// The strategy to use when computing mesh tangents. Defaults to `HighQuality`.
-pub enum TangentCalculationStrategy {
+#[derive(Debug, Copy, Clone, PartialEq, Eq, Default, Hash)]
+/// The algorithm to use when computing mesh tangents. Defaults to `Mikktspace`.
+pub enum TangentAlgorithm {
     /// Uses the Morten S. Mikkelsen "mikktspace" algorithm. Produces potentially higher quality tangents, but much slower.
     ///
     /// Requires a [`PrimitiveTopology::TriangleList`] topology and the [`Mesh::ATTRIBUTE_POSITION`], [`Mesh::ATTRIBUTE_NORMAL`] and [`Mesh::ATTRIBUTE_UV_0`] attributes set.
     #[default]
-    HighQuality,
+    Mikktspace,
     /// Uses the Gram-Schmidt fast approximation algorithm. Produces potentially lower quality tangents, but very fast.
     ///
     /// Requires a [`PrimitiveTopology::TriangleList`] topology and the [`Mesh::ATTRIBUTE_POSITION`], [`Mesh::ATTRIBUTE_NORMAL`] and [`Mesh::ATTRIBUTE_UV_0`] attributes set.
-    FastApproximation,
+    GramSchmidt,
 }
 
 #[derive(Error, Debug)]

crates/bevy_pbr/src/decal/forward.rs

@@ -9,9 +9,7 @@ use bevy_math::{prelude::Rectangle, Quat, Vec2, Vec3};
 use bevy_reflect::{Reflect, TypePath};
 use bevy_render::{
     alpha::AlphaMode,
-    mesh::{
-        Mesh, Mesh3d, MeshBuilder, MeshVertexBufferLayoutRef, Meshable, TangentCalculationStrategy,
-    },
+    mesh::{Mesh, Mesh3d, MeshBuilder, MeshVertexBufferLayoutRef, Meshable, TangentAlgorithm},
     render_resource::{
         AsBindGroup, CompareFunction, RenderPipelineDescriptor, Shader,
         SpecializedMeshPipelineError,
@@ -44,7 +42,7 @@ impl Plugin for ForwardDecalPlugin {
                 .mesh()
                 .build()
                 .rotated_by(Quat::from_rotation_arc(Vec3::Z, Vec3::Y))
-                .with_computed_tangents(TangentCalculationStrategy::HighQuality)
+                .with_computed_tangents(TangentAlgorithm::Mikktspace)
                 .unwrap(),
         );
 

examples/3d/anisotropy.rs

@@ -7,7 +7,7 @@ use bevy::{
     core_pipeline::Skybox,
     math::vec3,
     prelude::*,
-    render::mesh::TangentCalculationStrategy,
+    render::mesh::TangentAlgorithm,
     time::Stopwatch,
 };
 
@@ -116,7 +116,7 @@ fn setup(mut commands: Commands, asset_server: Res<AssetServer>, app_status: Res
         Mesh3d(
             asset_server.add(
                 Mesh::from(Sphere::new(0.1))
-                    .with_computed_tangents(TangentCalculationStrategy::HighQuality)
+                    .with_computed_tangents(TangentAlgorithm::Mikktspace)
                     .unwrap(),
             ),
         ),

examples/3d/clearcoat.rs

@@ -25,7 +25,7 @@ use bevy::{
     image::ImageLoaderSettings,
     math::vec3,
     prelude::*,
-    render::mesh::TangentCalculationStrategy,
+    render::mesh::TangentAlgorithm,
 };
 
 /// The size of each sphere.
@@ -84,7 +84,7 @@ fn create_sphere_mesh(meshes: &mut Assets<Mesh>) -> Handle<Mesh> {
 
     let mut sphere_mesh = Sphere::new(1.0).mesh().build();
     sphere_mesh
-        .compute_tangents(TangentCalculationStrategy::HighQuality)
+        .compute_tangents(TangentAlgorithm::Mikktspace)
         .expect("Failed to generate tangents");
     meshes.add(sphere_mesh)
 }

examples/3d/deferred_rendering.rs

@@ -12,7 +12,7 @@ use bevy::{
         NotShadowCaster, NotShadowReceiver, OpaqueRendererMethod,
     },
     prelude::*,
-    render::mesh::TangentCalculationStrategy,
+    render::mesh::TangentAlgorithm,
 };
 
 fn main() {
@@ -234,7 +234,7 @@ fn setup_parallax(
 
     // NOTE: for normal maps and depth maps to work, the mesh
     // needs tangents generated.
-    cube.compute_tangents(TangentCalculationStrategy::FastApproximation)
+    cube.compute_tangents(TangentAlgorithm::GramSchmidt)
         .unwrap();
 
     let parallax_material = materials.add(StandardMaterial {

examples/3d/parallax_mapping.rs

@@ -3,9 +3,7 @@
 
 use std::fmt;
 
-use bevy::{
-    image::ImageLoaderSettings, math::ops, prelude::*, render::mesh::TangentCalculationStrategy,
-};
+use bevy::{image::ImageLoaderSettings, math::ops, prelude::*, render::mesh::TangentAlgorithm};
 
 fn main() {
     App::new()
@@ -269,7 +267,7 @@ fn setup(
                 // NOTE: for normal maps and depth maps to work, the mesh
                 // needs tangents generated.
                 Mesh::from(Cuboid::default())
-                    .with_computed_tangents(TangentCalculationStrategy::HighQuality)
+                    .with_computed_tangents(TangentAlgorithm::Mikktspace)
                     .unwrap(),
             ),
         ),
@@ -279,7 +277,7 @@ fn setup(
 
     let background_cube = meshes.add(
         Mesh::from(Cuboid::new(40.0, 40.0, 40.0))
-            .with_computed_tangents(TangentCalculationStrategy::HighQuality)
+            .with_computed_tangents(TangentAlgorithm::Mikktspace)
             .unwrap(),
     );
 

examples/3d/rotate_environment_map.rs

@@ -7,7 +7,7 @@ use bevy::{
     core_pipeline::{tonemapping::Tonemapping::AcesFitted, Skybox},
     image::ImageLoaderSettings,
     prelude::*,
-    render::mesh::TangentCalculationStrategy,
+    render::mesh::TangentAlgorithm,
 };
 
 /// Entry point.
@@ -52,7 +52,7 @@ fn create_sphere_mesh(meshes: &mut Assets<Mesh>) -> Handle<Mesh> {
 
     let mut sphere_mesh = Sphere::new(1.0).mesh().build();
     sphere_mesh
-        .compute_tangents(TangentCalculationStrategy::HighQuality)
+        .compute_tangents(TangentAlgorithm::Mikktspace)
         .expect("Failed to generate tangents");
     meshes.add(sphere_mesh)
 }

examples/ecs/error_handling.rs

@@ -11,7 +11,7 @@ use bevy::ecs::{
 use bevy::math::sampling::UniformMeshSampler;
 use bevy::prelude::*;
 
-use bevy::render::mesh::TangentCalculationStrategy;
+use bevy::render::mesh::TangentAlgorithm;
 use rand::distributions::Distribution;
 use rand::SeedableRng;
 use rand_chacha::ChaCha8Rng;
@@ -96,7 +96,7 @@ fn setup(
 
     // Create a new sphere mesh:
     let mut sphere_mesh = Sphere::new(1.0).mesh().ico(7)?;
-    sphere_mesh.compute_tangents(TangentCalculationStrategy::HighQuality)?;
+    sphere_mesh.compute_tangents(TangentAlgorithm::Mikktspace)?;
 
     // Spawn the mesh into the scene:
     let mut sphere = commands.spawn((