Clean up several miscellaneous uses of weak_handle. (#19408)

# Objective

- Related to #19024.

## Solution

- This is a mix of several ways to get rid of weak handles. The primary
strategy is putting strong asset handles in resources that the rendering
code clones into its pipelines (or whatever).
- This does not handle every remaining case, but we are slowly clearing
them out.

## Testing

- `anti_aliasing` example still works.
- `fog_volumes` example still works.

Author: andriyDev

crates/bevy_anti_aliasing/src/smaa/mod.rs

@@ -30,9 +30,7 @@
 //!
 //! [SMAA]: https://www.iryoku.com/smaa/
 use bevy_app::{App, Plugin};
-#[cfg(feature = "smaa_luts")]
-use bevy_asset::load_internal_binary_asset;
-use bevy_asset::{embedded_asset, load_embedded_asset, uuid_handle, AssetServer, Handle};
+use bevy_asset::{embedded_asset, load_embedded_asset, AssetServer, Handle};
 #[cfg(not(feature = "smaa_luts"))]
 use bevy_core_pipeline::tonemapping::lut_placeholder;
 use bevy_core_pipeline::{
@@ -79,13 +77,6 @@ use bevy_render::{
 };
 use bevy_utils::prelude::default;
 
-/// The handle of the area LUT, a KTX2 format texture that SMAA uses internally.
-const SMAA_AREA_LUT_TEXTURE_HANDLE: Handle<Image> =
-    uuid_handle!("569c4d67-c7fa-4958-b1af-0836023603c0");
-/// The handle of the search LUT, a KTX2 format texture that SMAA uses internally.
-const SMAA_SEARCH_LUT_TEXTURE_HANDLE: Handle<Image> =
-    uuid_handle!("43b97515-252e-4c8a-b9af-f2fc528a1c27");
-
 /// Adds support for subpixel morphological antialiasing, or SMAA.
 pub struct SmaaPlugin;
 
@@ -125,6 +116,14 @@ pub enum SmaaPreset {
     Ultra,
 }
 
+#[derive(Resource)]
+struct SmaaLuts {
+    /// The handle of the area LUT, a KTX2 format texture that SMAA uses internally.
+    area_lut: Handle<Image>,
+    /// The handle of the search LUT, a KTX2 format texture that SMAA uses internally.
+    search_lut: Handle<Image>,
+}
+
 /// A render world resource that holds all render pipeline data needed for SMAA.
 ///
 /// There are three separate passes, so we need three separate pipelines.
@@ -292,49 +291,26 @@ impl Plugin for SmaaPlugin {
         // Load the shader.
         embedded_asset!(app, "smaa.wgsl");
 
-        // Load the two lookup textures. These are compressed textures in KTX2
-        // format.
-        #[cfg(feature = "smaa_luts")]
-        load_internal_binary_asset!(
-            app,
-            SMAA_AREA_LUT_TEXTURE_HANDLE,
-            "SMAAAreaLUT.ktx2",
-            |bytes, _: String| Image::from_buffer(
-                bytes,
-                bevy_image::ImageType::Format(bevy_image::ImageFormat::Ktx2),
-                bevy_image::CompressedImageFormats::NONE,
-                false,
-                bevy_image::ImageSampler::Default,
-                bevy_asset::RenderAssetUsages::RENDER_WORLD,
-            )
-            .expect("Failed to load SMAA area LUT")
-        );
-
         #[cfg(feature = "smaa_luts")]
-        load_internal_binary_asset!(
-            app,
-            SMAA_SEARCH_LUT_TEXTURE_HANDLE,
-            "SMAASearchLUT.ktx2",
-            |bytes, _: String| Image::from_buffer(
-                bytes,
-                bevy_image::ImageType::Format(bevy_image::ImageFormat::Ktx2),
-                bevy_image::CompressedImageFormats::NONE,
-                false,
-                bevy_image::ImageSampler::Default,
-                bevy_asset::RenderAssetUsages::RENDER_WORLD,
-            )
-            .expect("Failed to load SMAA search LUT")
-        );
-
-        #[cfg(not(feature = "smaa_luts"))]
-        app.world_mut()
-            .resource_mut::<bevy_asset::Assets<Image>>()
-            .insert(SMAA_AREA_LUT_TEXTURE_HANDLE.id(), lut_placeholder());
-
+        let smaa_luts = {
+            // Load the two lookup textures. These are compressed textures in KTX2 format.
+            embedded_asset!(app, "SMAAAreaLUT.ktx2");
+            embedded_asset!(app, "SMAASearchLUT.ktx2");
+
+            SmaaLuts {
+                area_lut: load_embedded_asset!(app, "SMAAAreaLUT.ktx2"),
+                search_lut: load_embedded_asset!(app, "SMAASearchLUT.ktx2"),
+            }
+        };
         #[cfg(not(feature = "smaa_luts"))]
-        app.world_mut()
-            .resource_mut::<bevy_asset::Assets<Image>>()
-            .insert(SMAA_SEARCH_LUT_TEXTURE_HANDLE.id(), lut_placeholder());
+        let smaa_luts = {
+            let mut images = app.world_mut().resource_mut::<bevy_asset::Assets<Image>>();
+            let handle = images.add(lut_placeholder());
+            SmaaLuts {
+                area_lut: handle.clone(),
+                search_lut: handle.clone(),
+            }
+        };
 
         app.add_plugins(ExtractComponentPlugin::<Smaa>::default())
             .register_type::<Smaa>();
@@ -344,6 +320,7 @@ impl Plugin for SmaaPlugin {
         };
 
         render_app
+            .insert_resource(smaa_luts)
             .init_resource::<SmaaSpecializedRenderPipelines>()
             .init_resource::<SmaaInfoUniformBuffer>()
             .add_systems(RenderStartup, init_smaa_pipelines)
@@ -747,13 +724,14 @@ fn prepare_smaa_bind_groups(
     mut commands: Commands,
     render_device: Res<RenderDevice>,
     smaa_pipelines: Res<SmaaPipelines>,
+    smaa_luts: Res<SmaaLuts>,
     images: Res<RenderAssets<GpuImage>>,
     view_targets: Query<(Entity, &SmaaTextures), (With<ExtractedView>, With<Smaa>)>,
 ) {
     // Fetch the two lookup textures. These are bundled in this library.
     let (Some(search_texture), Some(area_texture)) = (
-        images.get(&SMAA_SEARCH_LUT_TEXTURE_HANDLE),
-        images.get(&SMAA_AREA_LUT_TEXTURE_HANDLE),
+        images.get(&smaa_luts.search_lut),
+        images.get(&smaa_luts.area_lut),
     ) else {
         return;
     };

crates/bevy_asset/src/handle.rs

@@ -492,8 +492,8 @@ impl<A: Asset> TryFrom<UntypedHandle> for Handle<A> {
 ///
 /// ```
 /// # use bevy_asset::{Handle, uuid_handle};
-/// # type Shader = ();
-/// const SHADER: Handle<Shader> = uuid_handle!("1347c9b7-c46a-48e7-b7b8-023a354b7cac");
+/// # type Image = ();
+/// const IMAGE: Handle<Image> = uuid_handle!("1347c9b7-c46a-48e7-b7b8-023a354b7cac");
 /// ```
 #[macro_export]
 macro_rules! uuid_handle {

crates/bevy_core_pipeline/src/experimental/mip_generation/mod.rs

@@ -12,7 +12,7 @@ use crate::core_3d::{
     prepare_core_3d_depth_textures,
 };
 use bevy_app::{App, Plugin};
-use bevy_asset::{load_internal_asset, uuid_handle, Handle};
+use bevy_asset::{embedded_asset, load_embedded_asset, Handle};
 use bevy_derive::{Deref, DerefMut};
 use bevy_ecs::{
     component::Component,
@@ -51,8 +51,8 @@ use bitflags::bitflags;
 use tracing::debug;
 
 /// Identifies the `downsample_depth.wgsl` shader.
-pub const DOWNSAMPLE_DEPTH_SHADER_HANDLE: Handle<Shader> =
-    uuid_handle!("a09a149e-5922-4fa4-9170-3c1a13065364");
+#[derive(Resource, Deref)]
+pub struct DownsampleDepthShader(Handle<Shader>);
 
 /// The maximum number of mip levels that we can produce.
 ///
@@ -69,18 +69,16 @@ pub struct MipGenerationPlugin;
 
 impl Plugin for MipGenerationPlugin {
     fn build(&self, app: &mut App) {
-        load_internal_asset!(
-            app,
-            DOWNSAMPLE_DEPTH_SHADER_HANDLE,
-            "downsample_depth.wgsl",
-            Shader::from_wgsl
-        );
+        embedded_asset!(app, "downsample_depth.wgsl");
+
+        let downsample_depth_shader = load_embedded_asset!(app, "downsample_depth.wgsl");
 
         let Some(render_app) = app.get_sub_app_mut(RenderApp) else {
             return;
         };
 
         render_app
+            .insert_resource(DownsampleDepthShader(downsample_depth_shader))
             .init_resource::<SpecializedComputePipelines<DownsampleDepthPipeline>>()
             .add_render_graph_node::<DownsampleDepthNode>(Core3d, Node3d::EarlyDownsampleDepth)
             .add_render_graph_node::<DownsampleDepthNode>(Core3d, Node3d::LateDownsampleDepth)
@@ -294,17 +292,21 @@ pub struct DownsampleDepthPipeline {
     bind_group_layout: BindGroupLayout,
     /// A handle that identifies the compiled shader.
     pipeline_id: Option<CachedComputePipelineId>,
+    /// The shader asset handle.
+    shader: Handle<Shader>,
 }
 
 impl DownsampleDepthPipeline {
-    /// Creates a new [`DownsampleDepthPipeline`] from a bind group layout.
+    /// Creates a new [`DownsampleDepthPipeline`] from a bind group layout and the downsample
+    /// shader.
     ///
     /// This doesn't actually specialize the pipeline; that must be done
     /// afterward.
-    fn new(bind_group_layout: BindGroupLayout) -> DownsampleDepthPipeline {
+    fn new(bind_group_layout: BindGroupLayout, shader: Handle<Shader>) -> DownsampleDepthPipeline {
         DownsampleDepthPipeline {
             bind_group_layout,
             pipeline_id: None,
+            shader,
         }
     }
 }
@@ -335,6 +337,7 @@ fn create_downsample_depth_pipelines(
     pipeline_cache: Res<PipelineCache>,
     mut specialized_compute_pipelines: ResMut<SpecializedComputePipelines<DownsampleDepthPipeline>>,
     gpu_preprocessing_support: Res<GpuPreprocessingSupport>,
+    downsample_depth_shader: Res<DownsampleDepthShader>,
     mut has_run: Local<bool>,
 ) {
     // Only run once.
@@ -368,10 +371,22 @@ fn create_downsample_depth_pipelines(
 
     // Initialize the pipelines.
     let mut downsample_depth_pipelines = DownsampleDepthPipelines {
-        first: DownsampleDepthPipeline::new(standard_bind_group_layout.clone()),
-        second: DownsampleDepthPipeline::new(standard_bind_group_layout.clone()),
-        first_multisample: DownsampleDepthPipeline::new(multisampled_bind_group_layout.clone()),
-        second_multisample: DownsampleDepthPipeline::new(multisampled_bind_group_layout.clone()),
+        first: DownsampleDepthPipeline::new(
+            standard_bind_group_layout.clone(),
+            downsample_depth_shader.0.clone(),
+        ),
+        second: DownsampleDepthPipeline::new(
+            standard_bind_group_layout.clone(),
+            downsample_depth_shader.0.clone(),
+        ),
+        first_multisample: DownsampleDepthPipeline::new(
+            multisampled_bind_group_layout.clone(),
+            downsample_depth_shader.0.clone(),
+        ),
+        second_multisample: DownsampleDepthPipeline::new(
+            multisampled_bind_group_layout.clone(),
+            downsample_depth_shader.0.clone(),
+        ),
         sampler,
     };
 
@@ -491,7 +506,7 @@ impl SpecializedComputePipeline for DownsampleDepthPipeline {
                 stages: ShaderStages::COMPUTE,
                 range: 0..4,
             }],
-            shader: DOWNSAMPLE_DEPTH_SHADER_HANDLE,
+            shader: self.shader.clone(),
             shader_defs,
             entry_point: Some(if key.contains(DownsampleDepthPipelineKey::SECOND_PHASE) {
                 "downsample_depth_second".into()

crates/bevy_core_pipeline/src/post_process/mod.rs

@@ -3,7 +3,7 @@
 //! Currently, this consists only of chromatic aberration.
 
 use bevy_app::{App, Plugin};
-use bevy_asset::{embedded_asset, load_embedded_asset, uuid_handle, Assets, Handle};
+use bevy_asset::{embedded_asset, load_embedded_asset, Assets, Handle};
 use bevy_derive::{Deref, DerefMut};
 use bevy_ecs::{
     component::Component,
@@ -47,13 +47,6 @@ use crate::{
     FullscreenShader,
 };
 
-/// The handle to the default chromatic aberration lookup texture.
-///
-/// This is just a 3x1 image consisting of one red pixel, one green pixel, and
-/// one blue pixel, in that order.
-const DEFAULT_CHROMATIC_ABERRATION_LUT_HANDLE: Handle<Image> =
-    uuid_handle!("dc3e3307-40a1-49bb-be6d-e0634e8836b2");
-
 /// The default chromatic aberration intensity amount, in a fraction of the
 /// window size.
 const DEFAULT_CHROMATIC_ABERRATION_INTENSITY: f32 = 0.02;
@@ -68,6 +61,9 @@ const DEFAULT_CHROMATIC_ABERRATION_MAX_SAMPLES: u32 = 8;
 static DEFAULT_CHROMATIC_ABERRATION_LUT_DATA: [u8; 12] =
     [255, 0, 0, 255, 0, 255, 0, 255, 0, 0, 255, 255];
 
+#[derive(Resource)]
+struct DefaultChromaticAberrationLut(Handle<Image>);
+
 /// A plugin that implements a built-in postprocessing stack with some common
 /// effects.
 ///
@@ -96,14 +92,14 @@ pub struct PostProcessingPlugin;
 pub struct ChromaticAberration {
     /// The lookup texture that determines the color gradient.
     ///
-    /// By default, this is a 3×1 texel texture consisting of one red pixel, one
-    /// green pixel, and one blue texel, in that order. This recreates the most
-    /// typical chromatic aberration pattern. However, you can change it to
-    /// achieve different artistic effects.
+    /// By default (if None), this is a 3×1 texel texture consisting of one red
+    /// pixel, one green pixel, and one blue texel, in that order. This
+    /// recreates the most typical chromatic aberration pattern. However, you
+    /// can change it to achieve different artistic effects.
     ///
     /// The texture is always sampled in its vertical center, so it should
     /// ordinarily have a height of 1 texel.
-    pub color_lut: Handle<Image>,
+    pub color_lut: Option<Handle<Image>>,
 
     /// The size of the streaks around the edges of objects, as a fraction of
     /// the window size.
@@ -192,20 +188,17 @@ impl Plugin for PostProcessingPlugin {
 
         // Load the default chromatic aberration LUT.
         let mut assets = app.world_mut().resource_mut::<Assets<_>>();
-        assets.insert(
-            DEFAULT_CHROMATIC_ABERRATION_LUT_HANDLE.id(),
-            Image::new(
-                Extent3d {
-                    width: 3,
-                    height: 1,
-                    depth_or_array_layers: 1,
-                },
-                TextureDimension::D2,
-                DEFAULT_CHROMATIC_ABERRATION_LUT_DATA.to_vec(),
-                TextureFormat::Rgba8UnormSrgb,
-                RenderAssetUsages::RENDER_WORLD,
-            ),
-        );
+        let default_lut = assets.add(Image::new(
+            Extent3d {
+                width: 3,
+                height: 1,
+                depth_or_array_layers: 1,
+            },
+            TextureDimension::D2,
+            DEFAULT_CHROMATIC_ABERRATION_LUT_DATA.to_vec(),
+            TextureFormat::Rgba8UnormSrgb,
+            RenderAssetUsages::RENDER_WORLD,
+        ));
 
         app.register_type::<ChromaticAberration>();
         app.add_plugins(ExtractComponentPlugin::<ChromaticAberration>::default());
@@ -215,6 +208,7 @@ impl Plugin for PostProcessingPlugin {
         };
 
         render_app
+            .insert_resource(DefaultChromaticAberrationLut(default_lut))
             .init_resource::<SpecializedRenderPipelines<PostProcessingPipeline>>()
             .init_resource::<PostProcessingUniformBuffers>()
             .add_systems(
@@ -258,7 +252,7 @@ impl Plugin for PostProcessingPlugin {
 impl Default for ChromaticAberration {
     fn default() -> Self {
         Self {
-            color_lut: DEFAULT_CHROMATIC_ABERRATION_LUT_HANDLE,
+            color_lut: None,
             intensity: DEFAULT_CHROMATIC_ABERRATION_INTENSITY,
             max_samples: DEFAULT_CHROMATIC_ABERRATION_MAX_SAMPLES,
         }
@@ -357,15 +351,20 @@ impl ViewNode for PostProcessingNode {
         let post_processing_pipeline = world.resource::<PostProcessingPipeline>();
         let post_processing_uniform_buffers = world.resource::<PostProcessingUniformBuffers>();
         let gpu_image_assets = world.resource::<RenderAssets<GpuImage>>();
+        let default_lut = world.resource::<DefaultChromaticAberrationLut>();
 
         // We need a render pipeline to be prepared.
         let Some(pipeline) = pipeline_cache.get_render_pipeline(**pipeline_id) else {
             return Ok(());
         };
 
         // We need the chromatic aberration LUT to be present.
-        let Some(chromatic_aberration_lut) = gpu_image_assets.get(&chromatic_aberration.color_lut)
-        else {
+        let Some(chromatic_aberration_lut) = gpu_image_assets.get(
+            chromatic_aberration
+                .color_lut
+                .as_ref()
+                .unwrap_or(&default_lut.0),
+        ) else {
             return Ok(());
         };