Reuse gpu textures when possible (#22552)

# Objective

when an image's data is modified, we currently always create a new gpu
texture. if the size and format haven't changed, we could instead reuse
the existing texture.

this is more efficient for cpu image data modifications, and also means
we don't need to `get_mut` materials using these textures to propagate
the changes, unless the descriptor has changed.

## Solution

- put the full texture descriptor and view descriptor into the GpuImage
so we can compare fully
- reuse the existing texture and view when the descriptors are unchanged

Author: robtfm

crates/bevy_core_pipeline/src/mip_generation/mod.rs

@@ -426,7 +426,7 @@ impl Node for MipGenerationNode {
             };
             let Some(mip_generation_pipelines) = mip_generation_bind_groups
                 .pipelines
-                .get(&gpu_image.texture_format)
+                .get(&gpu_image.texture_descriptor.format)
             else {
                 continue;
             };
@@ -458,8 +458,8 @@ impl Node for MipGenerationNode {
                     &[],
                 );
                 compute_pass_1.dispatch_workgroups(
-                    gpu_image.size.width.div_ceil(64),
-                    gpu_image.size.height.div_ceil(64),
+                    gpu_image.texture_descriptor.size.width.div_ceil(64),
+                    gpu_image.texture_descriptor.size.height.div_ceil(64),
                     1,
                 );
                 pass_span.end(&mut compute_pass_1);
@@ -482,8 +482,8 @@ impl Node for MipGenerationNode {
                     &[],
                 );
                 compute_pass_2.dispatch_workgroups(
-                    gpu_image.size.width.div_ceil(256),
-                    gpu_image.size.height.div_ceil(256),
+                    gpu_image.texture_descriptor.size.width.div_ceil(256),
+                    gpu_image.texture_descriptor.size.height.div_ceil(256),
                     1,
                 );
                 pass_span.end(&mut compute_pass_2);
@@ -538,7 +538,7 @@ fn prepare_mip_generator_pipelines(
                 &pipeline_cache,
                 &downsample_shaders,
                 &mut mip_generation_pipelines.pipelines,
-                gpu_image.texture_format,
+                gpu_image.texture_descriptor.format,
                 mip_generation_job,
                 combine_downsampling_bind_groups,
             ) else {
@@ -786,7 +786,7 @@ fn create_downsampling_bind_groups(
         label: Some("mip generation input texture view, pass 2"),
         format: Some(gpu_image.texture.format()),
         dimension: Some(TextureViewDimension::D2),
-        base_mip_level: gpu_image.mip_level_count.min(6),
+        base_mip_level: gpu_image.texture_descriptor.mip_level_count.min(6),
         mip_level_count: Some(1),
         ..default()
     });
@@ -892,10 +892,10 @@ fn create_downsampling_constants_buffer(
     gpu_image: &GpuImage,
 ) -> UniformBuffer<DownsamplingConstants> {
     let downsampling_constants = DownsamplingConstants {
-        mips: gpu_image.mip_level_count,
+        mips: gpu_image.texture_descriptor.mip_level_count,
         inverse_input_size: vec2(
-            1.0 / gpu_image.size.width as f32,
-            1.0 / gpu_image.size.height as f32,
+            1.0 / gpu_image.texture_descriptor.size.width as f32,
+            1.0 / gpu_image.texture_descriptor.size.height as f32,
         ),
         _padding: 0,
     };
@@ -914,13 +914,13 @@ fn get_mip_storage_view(
 ) -> TextureView {
     // If `level` represents an actual mip level of the image, return a view to
     // it.
-    if level < gpu_image.mip_level_count {
+    if level < gpu_image.texture_descriptor.mip_level_count {
         return gpu_image.texture.create_view(&TextureViewDescriptor {
             label: Some(&*format!(
                 "mip downsampling storage view {}/{}",
-                level, gpu_image.mip_level_count
+                level, gpu_image.texture_descriptor.mip_level_count
             )),
-            format: Some(gpu_image.texture_format),
+            format: Some(gpu_image.texture_descriptor.format),
             dimension: Some(TextureViewDimension::D2),
             aspect: TextureAspect::All,
             base_mip_level: level,
@@ -936,7 +936,7 @@ fn get_mip_storage_view(
     let dummy_texture = render_device.create_texture(&TextureDescriptor {
         label: Some(&*format!(
             "mip downsampling dummy storage view {}/{}",
-            level, gpu_image.mip_level_count
+            level, gpu_image.texture_descriptor.mip_level_count
         )),
         size: Extent3d {
             width: 1,
@@ -946,7 +946,7 @@ fn get_mip_storage_view(
         mip_level_count: 1,
         sample_count: 1,
         dimension: TextureDimension::D2,
-        format: gpu_image.texture_format,
+        format: gpu_image.texture_descriptor.format,
         usage: TextureUsages::STORAGE_BINDING | TextureUsages::TEXTURE_BINDING,
         view_formats: &[],
     });

crates/bevy_pbr/src/light_probe/environment_map.rs

@@ -288,7 +288,7 @@ impl LightProbeComponent for EnvironmentMapLight {
                     diffuse: diffuse_map_handle.id(),
                     specular: specular_map_handle.id(),
                 }) as i32,
-                smallest_specular_mip_level: specular_map.mip_level_count - 1,
+                smallest_specular_mip_level: specular_map.texture_descriptor.mip_level_count - 1,
                 intensity: *intensity,
                 affects_lightmapped_mesh_diffuse: *affects_lightmapped_mesh_diffuse,
             };

crates/bevy_pbr/src/light_probe/generate.rs

@@ -526,7 +526,7 @@ pub fn prepare_generated_environment_map_intermediate_textures(
     mut commands: Commands,
 ) {
     for (entity, env_map_light) in &light_probes {
-        let base_size = env_map_light.environment_map.size.width;
+        let base_size = env_map_light.environment_map.texture_descriptor.size.width;
         let mip_level_count = compute_mip_count(base_size);
 
         let environment_map = texture_cache.get(
@@ -597,16 +597,20 @@ pub fn prepare_generated_environment_map_bind_groups(
         return;
     };
 
-    assert!(stbn_texture.size.width.is_power_of_two());
-    assert!(stbn_texture.size.height.is_power_of_two());
+    assert!(stbn_texture.texture_descriptor.size.width.is_power_of_two());
+    assert!(stbn_texture
+        .texture_descriptor
+        .size
+        .height
+        .is_power_of_two());
     let noise_size_bits = UVec2::new(
-        stbn_texture.size.width.trailing_zeros(),
-        stbn_texture.size.height.trailing_zeros(),
+        stbn_texture.texture_descriptor.size.width.trailing_zeros(),
+        stbn_texture.texture_descriptor.size.height.trailing_zeros(),
     );
 
     for (entity, textures, env_map_light) in &light_probes {
         // Determine mip chain based on input size
-        let base_size = env_map_light.environment_map.size.width;
+        let base_size = env_map_light.environment_map.texture_descriptor.size.width;
         let mip_count = compute_mip_count(base_size);
         let last_mip = mip_count - 1;
         let env_map_texture = env_map_light.environment_map.texture.clone();
@@ -923,7 +927,7 @@ impl Node for DownsamplingNode {
                 compute_pass.set_pipeline(copy_pipeline);
                 compute_pass.set_bind_group(0, &bind_groups.copy, &[]);
 
-                let tex_size = env_map_light.environment_map.size;
+                let tex_size = env_map_light.environment_map.texture_descriptor.size;
                 let wg_x = tex_size.width.div_ceil(8);
                 let wg_y = tex_size.height.div_ceil(8);
                 compute_pass.dispatch_workgroups(wg_x, wg_y, 6);
@@ -947,7 +951,7 @@ impl Node for DownsamplingNode {
                 compute_pass.set_pipeline(downsample_first_pipeline);
                 compute_pass.set_bind_group(0, &bind_groups.downsampling_first, &[]);
 
-                let tex_size = env_map_light.environment_map.size;
+                let tex_size = env_map_light.environment_map.texture_descriptor.size;
                 let wg_x = tex_size.width.div_ceil(64);
                 let wg_y = tex_size.height.div_ceil(64);
                 compute_pass.dispatch_workgroups(wg_x, wg_y, 6); // 6 faces
@@ -971,7 +975,7 @@ impl Node for DownsamplingNode {
                 compute_pass.set_pipeline(downsample_second_pipeline);
                 compute_pass.set_bind_group(0, &bind_groups.downsampling_second, &[]);
 
-                let tex_size = env_map_light.environment_map.size;
+                let tex_size = env_map_light.environment_map.texture_descriptor.size;
                 let wg_x = tex_size.width.div_ceil(256);
                 let wg_y = tex_size.height.div_ceil(256);
                 compute_pass.dispatch_workgroups(wg_x, wg_y, 6);
@@ -1039,7 +1043,7 @@ impl Node for FilteringNode {
 
             compute_pass.set_pipeline(radiance_pipeline);
 
-            let base_size = env_map_light.specular_map.size.width;
+            let base_size = env_map_light.specular_map.texture_descriptor.size.width;
 
             // Radiance convolution pass
             // Process each mip at different roughness levels

crates/bevy_pbr/src/pbr_material.rs

@@ -1145,7 +1145,7 @@ impl AsBindGroupShaderType<StandardMaterialUniform> for StandardMaterial {
         if has_normal_map {
             let normal_map_id = self.normal_map_texture.as_ref().map(Handle::id).unwrap();
             if let Some(texture) = images.get(normal_map_id) {
-                match texture.texture_format {
+                match texture.texture_descriptor.format {
                     // All 2-component unorm formats
                     TextureFormat::Rg8Unorm
                     | TextureFormat::Rg16Unorm

crates/bevy_pbr/src/render/mesh.rs

@@ -2065,11 +2065,9 @@ pub fn build_dummy_white_gpu_image(
     GpuImage {
         texture,
         texture_view,
-        texture_format: image.texture_descriptor.format,
-        texture_view_format: image.texture_view_descriptor.and_then(|v| v.format),
         sampler,
-        size: image.texture_descriptor.size,
-        mip_level_count: image.texture_descriptor.mip_level_count,
+        texture_descriptor: image.texture_descriptor,
+        texture_view_descriptor: image.texture_view_descriptor,
         had_data: true,
     }
 }

crates/bevy_render/Cargo.toml

@@ -95,6 +95,7 @@ wgpu = { version = "27", default-features = false, features = [
   "naga-ir",
   "fragile-send-sync-non-atomic-wasm",
 ] }
+wgpu-types = { version = "27", default-features = false }
 naga = { version = "27", features = ["wgsl-in"] }
 bytemuck = { version = "1.5", features = ["derive", "must_cast"] }
 downcast-rs = { version = "2", default-features = false, features = ["std"] }

crates/bevy_render/macros/src/as_bind_group.rs

@@ -722,7 +722,7 @@ pub fn derive_as_bind_group(ast: syn::DeriveInput) -> Result<TokenStream> {
                                 if let Some(handle) = handle {
                                     let image = images.get(handle).ok_or_else(|| #render_path::render_resource::AsBindGroupError::RetryNextUpdate)?;
 
-                                    let Some(sample_type) = image.texture_format.sample_type(None, Some(render_device.features())) else {
+                                    let Some(sample_type) = image.texture_descriptor.format.sample_type(None, Some(render_device.features())) else {
                                         return Err(#render_path::render_resource::AsBindGroupError::InvalidSamplerType(
                                             #binding_index,
                                             "None".to_string(),

crates/bevy_render/src/camera.rs

@@ -210,9 +210,9 @@ impl NormalizedRenderTargetExt for NormalizedRenderTarget {
             NormalizedRenderTarget::Window(window_ref) => windows
                 .get(&window_ref.entity())
                 .and_then(|window| window.swap_chain_texture_view_format),
-            NormalizedRenderTarget::Image(image_target) => images
-                .get(&image_target.handle)
-                .map(|image| image.texture_view_format.unwrap_or(image.texture_format)),
+            NormalizedRenderTarget::Image(image_target) => {
+                images.get(&image_target.handle).map(GpuImage::view_format)
+            }
             NormalizedRenderTarget::TextureView(id) => {
                 manual_texture_views.get(id).map(|tex| tex.view_format)
             }

crates/bevy_render/src/gpu_readback.rs

@@ -262,20 +262,24 @@ fn prepare_buffers(
         match readback {
             Readback::Texture(image) => {
                 if let Some(gpu_image) = gpu_images.get(image)
-                    && let Ok(pixel_size) = gpu_image.texture_format.pixel_size()
+                    && let Ok(pixel_size) = gpu_image.texture_descriptor.format.pixel_size()
                 {
-                    let layout = layout_data(gpu_image.size, gpu_image.texture_format);
+                    let layout = layout_data(
+                        gpu_image.texture_descriptor.size,
+                        gpu_image.texture_descriptor.format,
+                    );
                     let buffer = buffer_pool.get(
                         &render_device,
-                        get_aligned_size(gpu_image.size, pixel_size as u32) as u64,
+                        get_aligned_size(gpu_image.texture_descriptor.size, pixel_size as u32)
+                            as u64,
                     );
                     let (tx, rx) = async_channel::bounded(1);
                     readbacks.requested.push(GpuReadback {
                         entity: entity.id(),
                         src: ReadbackSource::Texture {
                             texture: gpu_image.texture.clone(),
                             layout,
-                            size: gpu_image.size,
+                            size: gpu_image.texture_descriptor.size,
                         },
                         buffer,
                         rx,

crates/bevy_render/src/texture/fallback_image.rs

@@ -134,11 +134,9 @@ fn fallback_image_new(
     GpuImage {
         texture,
         texture_view,
-        texture_format: image.texture_descriptor.format,
-        texture_view_format: image.texture_view_descriptor.and_then(|v| v.format),
         sampler,
-        size: image.texture_descriptor.size,
-        mip_level_count: image.texture_descriptor.mip_level_count,
+        texture_descriptor: image.texture_descriptor,
+        texture_view_descriptor: image.texture_view_descriptor,
         had_data: true,
     }
 }