Fix unit tests

bevy_asset_loader/examples/full_collection.rs

@@ -122,10 +122,7 @@ fn expectations(
     let image = images
         .get(&assets.array_texture)
         .expect("Image should be added to its asset resource");
-    assert_eq!(
-        image.texture_descriptor.array_layer_count(),
-        4
-    );
+    assert_eq!(image.texture_descriptor.array_layer_count(), 4);
 
     assert_eq!(assets.folder_untyped.len(), 7);
     for handle in assets.folder_untyped.iter() {

bevy_asset_loader/examples/full_dynamic_collection.rs

@@ -9,7 +9,7 @@ use bevy_asset_loader::prelude::*;
 /// and the `2d` and `3d` features for `TextureAtlas` and `StandardMaterial` dynamic assets.
 /// It showcases all possible configurations for dynamic assets.
 
-const FOLDER_SIZE : usize= 8;
+const FOLDER_SIZE: usize = 8;
 
 fn main() {
     App::new()
@@ -154,10 +154,7 @@ fn expectations(
     let image = images
         .get(&assets.array_texture)
         .expect("Image should be added to its asset resource");
-    assert_eq!(
-        image.texture_descriptor.array_layer_count(),
-        4
-    );
+    assert_eq!(image.texture_descriptor.array_layer_count(), 4);
 
     assert_eq!(assets.folder_untyped.len(), FOLDER_SIZE);
     for handle in assets.folder_untyped.iter() {

bevy_asset_loader/src/standard_dynamic_asset.rs

@@ -176,7 +176,11 @@ impl DynamicAsset for StandardDynamicAsset {
                 ))
             }
             #[cfg(any(feature = "3d", feature = "2d"))]
-            StandardDynamicAsset::Image { path, sampler, array_texture_layers } => {
+            StandardDynamicAsset::Image {
+                path,
+                sampler,
+                array_texture_layers,
+            } => {
                 let mut system_state =
                     SystemState::<(ResMut<Assets<Image>>, Res<AssetServer>)>::new(world);
                 let (mut images, asset_server) = system_state.get_mut(world);
@@ -185,7 +189,9 @@ impl DynamicAsset for StandardDynamicAsset {
                     Self::update_image_sampler(&mut handle, &mut images, sampler);
                 }
                 if let Some(layers) = array_texture_layers {
-                    let image = images.get_mut(&handle).expect("Failed to find loaded image");
+                    let image = images
+                        .get_mut(&handle)
+                        .expect("Failed to find loaded image");
                     image.reinterpret_stacked_2d_as_array(*layers);
                 }
 

bevy_asset_loader_derive/src/assets.rs

@@ -148,7 +148,7 @@ impl AssetField {
                     if (#layers > 0) {
                         image.reinterpret_stacked_2d_as_array(#layers);
                     }
-                    
+
                     if (#is_sampler_set) {
                         let is_different_sampler = if let ImageSampler::Descriptor(descriptor) = &image.sampler {
                             !descriptor.as_wgpu().eq(&#descriptor.as_wgpu())
@@ -670,7 +670,7 @@ impl AssetBuilder {
                 field_ident: self.field_ident.unwrap(),
                 asset_path: self.asset_path.unwrap(),
                 sampler: self.sampler,
-                array_texture_layers: self.array_texture_layers
+                array_texture_layers: self.array_texture_layers,
             }));
         }
         let asset = BasicAssetField {
@@ -940,27 +940,46 @@ mod test {
             ..Default::default()
         };
 
+        let builder_layers = AssetBuilder {
+            field_ident: Some(Ident::new("test", Span::call_site())),
+            asset_path: Some("some/image.png".to_owned()),
+            array_texture_layers: Some(42),
+            ..Default::default()
+        };
+
         let asset_linear = builder_linear
             .build()
             .expect("This should be a valid ImageAsset");
         let asset_nearest = builder_nearest
             .build()
             .expect("This should be a valid ImageAsset");
+        let asset_layers = builder_layers.build().expect("Failed to build asset");
 
         assert_eq!(
             asset_linear,
             AssetField::Image(ImageAssetField {
                 field_ident: Ident::new("test", Span::call_site()),
                 asset_path: "some/image.png".to_owned(),
-                sampler: SamplerType::Linear
+                sampler: Some(SamplerType::Linear),
+                array_texture_layers: None
             })
         );
         assert_eq!(
             asset_nearest,
             AssetField::Image(ImageAssetField {
                 field_ident: Ident::new("test", Span::call_site()),
                 asset_path: "some/image.png".to_owned(),
-                sampler: SamplerType::Nearest
+                sampler: Some(SamplerType::Nearest),
+                array_texture_layers: None
+            })
+        );
+        assert_eq!(
+            asset_layers,
+            AssetField::Image(ImageAssetField {
+                field_ident: Ident::new("test", Span::call_site()),
+                asset_path: "some/image.png".to_owned(),
+                sampler: None,
+                array_texture_layers: Some(42)
             })
         );
     }

bevy_asset_loader_derive/src/lib.rs

@@ -480,9 +480,9 @@ fn parse_field(field: &Field) -> Result<AssetField, Vec<ParseFieldError>> {
                                         }
                                     } else if path == ImageAttribute::LAYERS {
                                         if let Expr::Lit(ExprLit {
-                                                             lit: Lit::Int(layers),
-                                                             ..
-                                                         }) = &named_value.value
+                                            lit: Lit::Int(layers),
+                                            ..
+                                        }) = &named_value.value
                                         {
                                             builder.array_texture_layers =
                                                 Some(layers.base10_parse::<u32>().unwrap());