migrate blit

ecoskey · ecoskey · commit bc858daca2e4 · 2025-07-13T13:33:07.000-07:00
diff --git a/crates/bevy_core_pipeline/src/blit/mod.rs b/crates/bevy_core_pipeline/src/blit/mod.rs
@@ -1,6 +1,8 @@
+use core::result::Result;
+
 use crate::FullscreenShader;
 use bevy_app::{App, Plugin};
-use bevy_asset::{embedded_asset, load_embedded_asset, Handle};
+use bevy_asset::{embedded_asset, load_embedded_asset};
 use bevy_ecs::prelude::*;
 use bevy_render::{
     render_resource::{
@@ -20,26 +22,23 @@ impl Plugin for BlitPlugin {
         embedded_asset!(app, "blit.wgsl");
 
         if let Some(render_app) = app.get_sub_app_mut(RenderApp) {
-            render_app.allow_ambiguous_resource::<SpecializedRenderPipelines<BlitPipeline>>();
+            render_app.allow_ambiguous_resource::<BlitPipeline>();
         }
     }
 
     fn finish(&self, app: &mut App) {
         let Some(render_app) = app.get_sub_app_mut(RenderApp) else {
             return;
         };
-        render_app
-            .init_resource::<BlitPipeline>()
-            .init_resource::<SpecializedRenderPipelines<BlitPipeline>>();
+        render_app.init_resource::<BlitPipeline>();
     }
 }
 
 #[derive(Resource)]
 pub struct BlitPipeline {
-    pub texture_bind_group: BindGroupLayout,
+    pub layout: BindGroupLayout,
     pub sampler: Sampler,
-    pub fullscreen_shader: FullscreenShader,
-    pub fragment_shader: Handle<Shader>,
+    pub specialized_cache: SpecializedCache<RenderPipeline, BlitSpecializer>,
 }
 
 impl FromWorld for BlitPipeline {
@@ -59,44 +58,59 @@ impl FromWorld for BlitPipeline {
 
         let sampler = render_device.create_sampler(&SamplerDescriptor::default());
 
+        let fullscreen_shader = render_world.resource::<FullscreenShader>().clone();
+        let fragment_shader = load_embedded_asset!(render_world, "blit.wgsl");
+
+        let base_descriptor = RenderPipelineDescriptor {
+            label: Some("blit pipeline".into()),
+            layout: vec![texture_bind_group.clone()],
+            vertex: fullscreen_shader.to_vertex_state(),
+            fragment: Some(FragmentState {
+                shader: fragment_shader,
+                targets: vec![],
+                ..default()
+            }),
+            ..default()
+        };
+
+        let specialized_cache = SpecializedCache::new(BlitSpecializer, None, base_descriptor);
+
         BlitPipeline {
-            texture_bind_group,
+            layout: texture_bind_group,
             sampler,
-            fullscreen_shader: render_world.resource::<FullscreenShader>().clone(),
-            fragment_shader: load_embedded_asset!(render_world, "blit.wgsl"),
+            specialized_cache,
         }
     }
 }
 
-#[derive(PartialEq, Eq, Hash, Clone, Copy)]
-pub struct BlitPipelineKey {
-    pub texture_format: TextureFormat,
-    pub blend_state: Option<BlendState>,
-    pub samples: u32,
-}
+pub struct BlitSpecializer;
 
-impl SpecializedRenderPipeline for BlitPipeline {
-    type Key = BlitPipelineKey;
+impl Specializer<RenderPipeline> for BlitSpecializer {
+    type Key = BlitKey;
 
-    fn specialize(&self, key: Self::Key) -> RenderPipelineDescriptor {
-        RenderPipelineDescriptor {
-            label: Some("blit pipeline".into()),
-            layout: vec![self.texture_bind_group.clone()],
-            vertex: self.fullscreen_shader.to_vertex_state(),
-            fragment: Some(FragmentState {
-                shader: self.fragment_shader.clone(),
-                targets: vec![Some(ColorTargetState {
-                    format: key.texture_format,
-                    blend: key.blend_state,
-                    write_mask: ColorWrites::ALL,
-                })],
-                ..default()
-            }),
-            multisample: MultisampleState {
-                count: key.samples,
-                ..default()
+    fn specialize(
+        &self,
+        key: Self::Key,
+        descriptor: &mut <RenderPipeline as Specializable>::Descriptor,
+    ) -> Result<Canonical<Self::Key>, BevyError> {
+        descriptor.multisample.count = key.samples;
+
+        descriptor.fragment_mut()?.set_target(
+            0,
+            ColorTargetState {
+                format: key.texture_format,
+                blend: key.blend_state,
+                write_mask: ColorWrites::ALL,
             },
-            ..default()
-        }
+        );
+
+        Ok(key)
     }
 }
+
+#[derive(PartialEq, Eq, Hash, Clone, Copy, SpecializerKey)]
+pub struct BlitKey {
+    pub texture_format: TextureFormat,
+    pub blend_state: Option<BlendState>,
+    pub samples: u32,
+}
diff --git a/crates/bevy_core_pipeline/src/msaa_writeback.rs b/crates/bevy_core_pipeline/src/msaa_writeback.rs
@@ -1,5 +1,5 @@
 use crate::{
-    blit::{BlitPipeline, BlitPipelineKey},
+    blit::{BlitKey, BlitPipeline},
     core_2d::graph::{Core2d, Node2d},
     core_3d::graph::{Core3d, Node3d},
 };
@@ -100,7 +100,7 @@ impl ViewNode for MsaaWritebackNode {
 
         let bind_group = render_context.render_device().create_bind_group(
             None,
-            &blit_pipeline.texture_bind_group,
+            &blit_pipeline.layout,
             &BindGroupEntries::sequential((post_process.source, &blit_pipeline.sampler)),
         );
 
@@ -122,22 +122,23 @@ pub struct MsaaWritebackBlitPipeline(CachedRenderPipelineId);
 fn prepare_msaa_writeback_pipelines(
     mut commands: Commands,
     pipeline_cache: Res<PipelineCache>,
-    mut pipelines: ResMut<SpecializedRenderPipelines<BlitPipeline>>,
-    blit_pipeline: Res<BlitPipeline>,
+    mut blit_pipeline: ResMut<BlitPipeline>,
     view_targets: Query<(Entity, &ViewTarget, &ExtractedCamera, &Msaa)>,
-) {
+) -> Result<(), BevyError> {
     for (entity, view_target, camera, msaa) in view_targets.iter() {
         // only do writeback if writeback is enabled for the camera and this isn't the first camera in the target,
         // as there is nothing to write back for the first camera.
         if msaa.samples() > 1 && camera.msaa_writeback && camera.sorted_camera_index_for_target > 0
         {
-            let key = BlitPipelineKey {
+            let key = BlitKey {
                 texture_format: view_target.main_texture_format(),
                 samples: msaa.samples(),
                 blend_state: None,
             };
 
-            let pipeline = pipelines.specialize(&pipeline_cache, &blit_pipeline, key);
+            let pipeline = blit_pipeline
+                .specialized_cache
+                .specialize(&pipeline_cache, key)?;
             commands
                 .entity(entity)
                 .insert(MsaaWritebackBlitPipeline(pipeline));
@@ -149,4 +150,5 @@ fn prepare_msaa_writeback_pipelines(
                 .remove::<MsaaWritebackBlitPipeline>();
         }
     }
+    Ok(())
 }
diff --git a/crates/bevy_core_pipeline/src/upscaling/mod.rs b/crates/bevy_core_pipeline/src/upscaling/mod.rs
@@ -1,4 +1,4 @@
-use crate::blit::{BlitPipeline, BlitPipelineKey};
+use crate::blit::{BlitKey, BlitPipeline};
 use bevy_app::prelude::*;
 use bevy_ecs::prelude::*;
 use bevy_platform::collections::HashSet;
@@ -39,10 +39,9 @@ pub struct ViewUpscalingPipeline(CachedRenderPipelineId);
 fn prepare_view_upscaling_pipelines(
     mut commands: Commands,
     mut pipeline_cache: ResMut<PipelineCache>,
-    mut pipelines: ResMut<SpecializedRenderPipelines<BlitPipeline>>,
-    blit_pipeline: Res<BlitPipeline>,
+    mut blit_pipeline: ResMut<BlitPipeline>,
     view_targets: Query<(Entity, &ViewTarget, Option<&ExtractedCamera>)>,
-) {
+) -> Result<(), BevyError> {
     let mut output_textures = <HashSet<_>>::default();
     for (entity, view_target, camera) in view_targets.iter() {
         let out_texture_id = view_target.out_texture().id();
@@ -73,12 +72,14 @@ fn prepare_view_upscaling_pipelines(
             None
         };
 
-        let key = BlitPipelineKey {
+        let key = BlitKey {
             texture_format: view_target.out_texture_format(),
             blend_state,
             samples: 1,
         };
-        let pipeline = pipelines.specialize(&pipeline_cache, &blit_pipeline, key);
+        let pipeline = blit_pipeline
+            .specialized_cache
+            .specialize(&pipeline_cache, key)?;
 
         // Ensure the pipeline is loaded before continuing the frame to prevent frames without any GPU work submitted
         pipeline_cache.block_on_render_pipeline(pipeline);
@@ -87,4 +88,6 @@ fn prepare_view_upscaling_pipelines(
             .entity(entity)
             .insert(ViewUpscalingPipeline(pipeline));
     }
+
+    Ok(())
 }
diff --git a/crates/bevy_core_pipeline/src/upscaling/node.rs b/crates/bevy_core_pipeline/src/upscaling/node.rs
@@ -56,7 +56,7 @@ impl ViewNode for UpscalingNode {
             cached_bind_group => {
                 let bind_group = render_context.render_device().create_bind_group(
                     None,
-                    &blit_pipeline.texture_bind_group,
+                    &blit_pipeline.layout,
                     &BindGroupEntries::sequential((upscaled_texture, &blit_pipeline.sampler)),
                 );
 
