enable easier modification of image samplers in image loaders (#22042)

# Objective

Previously, to modify a sampler when loading an image with settings it
was required to set all fields individually. Much of the time, these
settings are all the same so to enable repeating textures you have to
set the address_mode 3 times. To set filters you have to set them
another 3 times.

```rust
MeshMaterial3d(materials.add(
    StandardMaterial {
        base_color_texture:
            Some(
                asset_server.load_with_settings(
                    "floor_graph_base_color.png",
                    |settings: &mut ImageLoaderSettings| {
                        let  descriptor = settings.sampler.get_or_init_descriptor();
                        descriptor.address_mode_u = bevy::image::ImageAddressMode::Repeat;
                        descriptor.address_mode_v = bevy::image::ImageAddressMode::Repeat;
                        descriptor.address_mode_w = bevy::image::ImageAddressMode::Repeat;
                        descriptor.mag_filter = ImageFilterMode::Linear;
                        descriptor.min_filter = ImageFilterMode::Linear;
                        descriptor.mipmap_filter = ImageFilterMode::Linear;
                    }
                ),
            ),
        unlit: true,
        cull_mode: None,
        uv_transform: Affine2::from_scale(Vec2::new(30., 90.)),
        ..default()
    },
)),
```

## Solution

Add two new helpers, loosely modeled after the `Transform::with_<field>`
functions. Further modifications can still be made to the descriptor for
use cases which want to set one of the three fields differently, or
additionally set anisotropy_clamp, etc.

```rust
let descriptor = settings
    .sampler
    .get_or_init_descriptor()
    .set_address_mode(ImageAddressMode::Repeat)
    .set_filter(ImageFilterMode::Linear);
```

## Testing

New test in bevy_image

## Showcase

```rust
MeshMaterial3d(materials.add(
    StandardMaterial {
        base_color_texture:
            Some(
                asset_server.load_with_settings(
                    "floor_graph_base_color.png",
                    |settings: &mut ImageLoaderSettings| {
                        let descriptor = settings
                            .sampler
                            .get_or_init_descriptor()
                            .set_address_mode(ImageAddressMode::Repeat)
                            .set_filter(ImageFilterMode::Linear);
                    }
                ),
            ),
        unlit: true,
        cull_mode: None,
        uv_transform: Affine2::from_scale(Vec2::new(30., 90.)),
        ..default()
    },
)),
```

This PR now includes:

- `set_filter`
- `set_address_mode`
- `set_anisotropic_filter`

---------

Co-authored-by: Greeble <166992735+greeble-dev@users.noreply.github.com>

Author: ChristopherBiscardi

crates/bevy_image/src/image.rs

@@ -699,6 +699,36 @@ impl ImageSamplerDescriptor {
         }
     }
 
+    /// Returns this sampler descriptor with a new `ImageFilterMode` min, mag, and mipmap filters
+    #[inline]
+    pub fn set_filter(&mut self, filter: ImageFilterMode) -> &mut Self {
+        self.mag_filter = filter;
+        self.min_filter = filter;
+        self.mipmap_filter = filter;
+        self
+    }
+
+    /// Returns this sampler descriptor with a new `ImageAddressMode` for u, v, and w
+    #[inline]
+    pub fn set_address_mode(&mut self, address_mode: ImageAddressMode) -> &mut Self {
+        self.address_mode_u = address_mode;
+        self.address_mode_v = address_mode;
+        self.address_mode_w = address_mode;
+        self
+    }
+
+    /// Returns this sampler descriptor with an `anisotropy_clamp` value and also
+    /// set filters to `ImageFilterMode::Linear`, which is required to
+    /// use anisotropy.
+    #[inline]
+    pub fn set_anisotropic_filter(&mut self, anisotropy_clamp: u16) -> &mut Self {
+        self.mag_filter = ImageFilterMode::Linear;
+        self.min_filter = ImageFilterMode::Linear;
+        self.mipmap_filter = ImageFilterMode::Linear;
+        self.anisotropy_clamp = anisotropy_clamp;
+        self
+    }
+
     pub fn as_wgpu(&self) -> SamplerDescriptor<Option<&str>> {
         SamplerDescriptor {
             label: self.label.as_deref(),
@@ -2212,4 +2242,34 @@ mod test {
 
         assert!(image.data.as_ref().unwrap().iter().all(|&p| p == 255));
     }
+
+    #[test]
+    fn get_or_init_sampler_modifications() {
+        // given some sampler
+        let mut default_sampler = ImageSampler::Default;
+        // a load_with_settings call wants to customize the descriptor
+        let my_sampler_in_a_loader = default_sampler
+            .get_or_init_descriptor()
+            .set_filter(ImageFilterMode::Linear)
+            .set_address_mode(ImageAddressMode::Repeat);
+
+        assert_eq!(
+            my_sampler_in_a_loader.address_mode_u,
+            ImageAddressMode::Repeat
+        );
+        assert_eq!(my_sampler_in_a_loader.min_filter, ImageFilterMode::Linear);
+    }
+
+    #[test]
+    fn get_or_init_sampler_anisotropy() {
+        // given some sampler
+        let mut default_sampler = ImageSampler::Default;
+        // a load_with_settings call wants to customize the descriptor
+        let my_sampler_in_a_loader = default_sampler
+            .get_or_init_descriptor()
+            .set_anisotropic_filter(8);
+
+        assert_eq!(my_sampler_in_a_loader.min_filter, ImageFilterMode::Linear);
+        assert_eq!(my_sampler_in_a_loader.anisotropy_clamp, 8);
+    }
 }