Support non-sRGB image formats for RenderTarget::Image (bevyengine#22031)

# Objective

- Fixes bevyengine#15201 

## Solution

- It seems there was some confusion where
`OutputColorAttachment::format` could be different from the actual
underlying texture format (of `OutputColorAttachment::view`). This would
eventually lead to a texture format mismatch on the `BlitPipeline`. I
removed the `OutputColorAttachment::format` field to resolve this
conflict.
- Sim. for `ManualTextureView`.

## Testing

- The repro steps provided by bevyengine#15201 no longer cause a WGPU validation
error.
- I tested the `pbr` example on native and WebGPU and it still works as
before.

## Future Work

Although the WGPU validation error is fixed, when using a non-sRGB
texture format for the GPU image in the `headless_renderer` example, the
output image seems to have incorrect gamma. I think this is because the
example does a byte-for-byte copy from the GPU image to the CPU image
without any gamma correction; and the `image` crate saves the image
assuming a nonlinear color space.

I don't think we need to fix this as part of this PR, but it might be
nice for `bevy_image::Image::try_into_dynamic` to eventually handle the
gamma correction when saving linear color images.

<details>
<summary>Here you can see a comparison</summary>
With sRGB
<img width="1920" height="1080" alt="with_srgb"
src="https://github.com/user-attachments/assets/b6d96072-2754-4fc3-bb5a-fc2994e65dc0"
/>

No sRGB
<img width="1920" height="1080" alt="no_srgb"
src="https://github.com/user-attachments/assets/46f83f85-2202-40f6-9a68-85bdf4631494"
/>
</details>

Author: bonsairobo

crates/bevy_render/src/camera.rs

@@ -213,9 +213,9 @@ impl NormalizedRenderTargetExt for NormalizedRenderTarget {
             NormalizedRenderTarget::Image(image_target) => images
                 .get(&image_target.handle)
                 .map(|image| image.texture_format),
-            NormalizedRenderTarget::TextureView(id) => {
-                manual_texture_views.get(id).map(|tex| tex.format)
-            }
+            NormalizedRenderTarget::TextureView(id) => manual_texture_views
+                .get(id)
+                .map(|view| view.texture_view.texture().format()),
             NormalizedRenderTarget::None { .. } => None,
         }
     }

crates/bevy_render/src/texture/manual_texture_view.rs

@@ -1,10 +1,8 @@
 use bevy_camera::ManualTextureViewHandle;
 use bevy_ecs::{prelude::Component, resource::Resource};
-use bevy_image::BevyDefault;
 use bevy_math::UVec2;
 use bevy_platform::collections::HashMap;
 use bevy_render_macros::ExtractResource;
-use wgpu::TextureFormat;
 
 use crate::render_resource::TextureView;
 
@@ -13,16 +11,11 @@ use crate::render_resource::TextureView;
 pub struct ManualTextureView {
     pub texture_view: TextureView,
     pub size: UVec2,
-    pub format: TextureFormat,
 }
 
 impl ManualTextureView {
-    pub fn with_default_format(texture_view: TextureView, size: UVec2) -> Self {
-        Self {
-            texture_view,
-            size,
-            format: TextureFormat::bevy_default(),
-        }
+    pub fn new(texture_view: TextureView, size: UVec2) -> Self {
+        Self { texture_view, size }
     }
 }
 
@@ -36,7 +29,7 @@ impl ManualTextureView {
 /// # world.insert_resource(ManualTextureViews::default());
 /// # let texture_view = todo!();
 /// let manual_views = world.resource_mut::<ManualTextureViews>();
-/// let manual_view = ManualTextureView::with_default_format(texture_view, UVec2::new(1024, 1024));
+/// let manual_view = ManualTextureView::new(texture_view, UVec2::new(1024, 1024));
 ///
 /// // Choose an unused handle value; it's likely only you are inserting manual views.
 /// const MANUAL_VIEW_HANDLE: ManualTextureViewHandle = ManualTextureViewHandle::new(42);

crates/bevy_render/src/texture/texture_attachment.rs

@@ -1,5 +1,5 @@
 use super::CachedTexture;
-use crate::render_resource::{TextureFormat, TextureView};
+use crate::render_resource::TextureView;
 use alloc::sync::Arc;
 use bevy_color::LinearRgba;
 use core::sync::atomic::{AtomicBool, Ordering};
@@ -127,15 +127,13 @@ impl DepthAttachment {
 #[derive(Clone)]
 pub struct OutputColorAttachment {
     pub view: TextureView,
-    pub format: TextureFormat,
     is_first_call: Arc<AtomicBool>,
 }
 
 impl OutputColorAttachment {
-    pub fn new(view: TextureView, format: TextureFormat) -> Self {
+    pub fn new(view: TextureView) -> Self {
         Self {
             view,
-            format,
             is_first_call: Arc::new(AtomicBool::new(true)),
         }
     }

crates/bevy_render/src/view/mod.rs

@@ -838,7 +838,7 @@ impl ViewTarget {
     /// The format of the final texture this view will render to
     #[inline]
     pub fn out_texture_format(&self) -> TextureFormat {
-        self.out_texture.format
+        self.out_texture.view.texture().format()
     }
 
     /// This will start a new "post process write", which assumes that the caller
@@ -1014,10 +1014,7 @@ pub fn prepare_view_attachments(
                 let Some(attachment) = target
                     .get_texture_view(&windows, &images, &manual_texture_views)
                     .cloned()
-                    .zip(target.get_texture_format(&windows, &images, &manual_texture_views))
-                    .map(|(view, format)| {
-                        OutputColorAttachment::new(view.clone(), format.add_srgb_suffix())
-                    })
+                    .map(OutputColorAttachment::new)
                 else {
                     continue;
                 };
@@ -1086,11 +1083,7 @@ pub fn prepare_view_targets(
                     dimension: TextureDimension::D2,
                     format: main_texture_format,
                     usage: texture_usage.0,
-                    view_formats: match main_texture_format {
-                        TextureFormat::Bgra8Unorm => &[TextureFormat::Bgra8UnormSrgb],
-                        TextureFormat::Rgba8Unorm => &[TextureFormat::Rgba8UnormSrgb],
-                        _ => &[],
-                    },
+                    view_formats: &[],
                 };
                 let a = texture_cache.get(
                     &render_device,

crates/bevy_render/src/view/window/screenshot.rs

@@ -295,7 +295,7 @@ fn prepare_screenshots(
                 prepared.insert(*entity, state);
                 view_target_attachments.insert(
                     target.clone(),
-                    OutputColorAttachment::new(texture_view.clone(), format.add_srgb_suffix()),
+                    OutputColorAttachment::new(texture_view.clone()),
                 );
             }
             NormalizedRenderTarget::Image(image) => {
@@ -315,7 +315,7 @@ fn prepare_screenshots(
                 prepared.insert(*entity, state);
                 view_target_attachments.insert(
                     target.clone(),
-                    OutputColorAttachment::new(texture_view.clone(), format.add_srgb_suffix()),
+                    OutputColorAttachment::new(texture_view.clone()),
                 );
             }
             NormalizedRenderTarget::TextureView(texture_view) => {
@@ -326,7 +326,7 @@ fn prepare_screenshots(
                     );
                     continue;
                 };
-                let format = manual_texture_view.format;
+                let format = manual_texture_view.texture_view.texture().format();
                 let size = manual_texture_view.size.to_extents();
                 let (texture_view, state) = prepare_screenshot_state(
                     size,
@@ -339,7 +339,7 @@ fn prepare_screenshots(
                 prepared.insert(*entity, state);
                 view_target_attachments.insert(
                     target.clone(),
-                    OutputColorAttachment::new(texture_view.clone(), format.add_srgb_suffix()),
+                    OutputColorAttachment::new(texture_view.clone()),
                 );
             }
             NormalizedRenderTarget::None { .. } => {
@@ -550,7 +550,7 @@ pub(crate) fn submit_screenshot_commands(world: &World, encoder: &mut CommandEnc
                 };
                 let width = texture_view.size.x;
                 let height = texture_view.size.y;
-                let texture_format = texture_view.format;
+                let texture_format = texture_view.texture_view.texture().format();
                 let texture_view = texture_view.texture_view.deref();
                 render_screenshot(
                     encoder,