Enable load_with_settings TextureFormats (#20788)

Previously, loading an image resulted in a hard-coded TextureFormat.
When loading images that are meant to be used as the
`StandardMaterial::depth_map`, the data can be stored in ways that
result in an `R16Uint` TextureFormat. This results in an error because
the `depth_map` must be a Float sampler and not a Uint sampler.

2025-08-29T17:15:03.081069Z ERROR bevy_render::erased_render_asset:
bevy_pbr::mesh_material::MeshMaterial3d<bevy_pbr::extended_material::ExtendedMaterial<bevy_pbr::pbr_material::StandardMaterial,
test_uv_transform::MyExtension>> Bind group construction failed: At
binding index 12, the provided image sampler `Uint` does not match the
required sampler type(s) `[Float { filterable: true }]`.

Setting the TextureFormat can adjust the way in which the same image
data shows up in the shader. For example, an image that would otherwise
be `TextureFormat::R16Uint` can be set to `TextureFormat::R16Unorm`,
with no other changes, which results in the 16-bit integer data being
converted to the 0-1 range for the shader.

```rust
asset_server.load_with_settings(
    "grass_height.png",
    |settings: &mut ImageLoaderSettings| {
        settings.texture_format = Some(TextureFormat::R16Unorm);
    }
),
```

This PR adds the ability to set the texture format with using
`load_with_settings`.

Software like Substance Designer outputs height data in what becomes
`R16Uint` format, but depth_map requires `R16Unorm`.

--

Additional notes:

- TextureFormat does not have a serde implementation, so is skipped in
this PR
- This PR tries to change as little as possible when it comes to Image
creation, so does not add a TextureFormat option to Image constructors
like `from_buffer` and `from_dynamic`, which is what is used by the
ImageLoader. It also ends up relying on a conversion from
[`DynamicImage`](https://docs.rs/image/0.25.6/image/enum.DynamicImage.html),
which doesn't have enough information to make this judgement afaict.
- Alternative strategies could include using a LoadTransformAndSave
sequence to correct the data, but this is not straightforward as the
tools to do this are not obvious (specifically the conversion from the
Vec<u8> image crate representation + filename guessing when loading the
processed image).

Author: ChristopherBiscardi

crates/bevy_image/src/compressed_image_saver.rs

@@ -69,6 +69,7 @@ impl AssetSaver for CompressedImageSaver {
             is_srgb,
             sampler: image.sampler.clone(),
             asset_usage: image.asset_usage,
+            texture_format: None,
         })
     }
 }

crates/bevy_image/src/image_loader.rs

@@ -99,8 +99,15 @@ pub enum ImageFormatSetting {
 /// Settings for loading an [`Image`] using an [`ImageLoader`].
 #[derive(Serialize, Deserialize, Debug, Clone)]
 pub struct ImageLoaderSettings {
-    /// How to determine the image's format.
+    /// How to determine the image's container format.
     pub format: ImageFormatSetting,
+    /// Forcibly use a specific [`wgpu_types::TextureFormat`].
+    /// Useful to control how data is handled when used
+    /// in a shader.
+    /// Ex: data that would be `R16Uint` that needs to
+    /// be sampled as a float using `R16Snorm`.
+    #[serde(skip)]
+    pub texture_format: Option<wgpu_types::TextureFormat>,
     /// Specifies whether image data is linear
     /// or in sRGB space when this is not determined by
     /// the image format.
@@ -117,6 +124,7 @@ impl Default for ImageLoaderSettings {
     fn default() -> Self {
         Self {
             format: ImageFormatSetting::default(),
+            texture_format: None,
             is_srgb: true,
             sampler: ImageSampler::Default,
             asset_usage: RenderAssetUsages::default(),
@@ -176,6 +184,12 @@ impl AssetLoader for ImageLoader {
             settings.sampler.clone(),
             settings.asset_usage,
         )
+        .map(|mut image| {
+            if let Some(format) = settings.texture_format {
+                image.texture_descriptor.format = format;
+            }
+            image
+        })
         .map_err(|err| FileTextureError {
             error: err,
             path: format!("{}", load_context.path().display()),