spec_v2: migrate CAS

crates/bevy_anti_alias/src/contrast_adaptive_sharpening/mod.rs

@@ -1,5 +1,5 @@
 use bevy_app::prelude::*;
-use bevy_asset::{embedded_asset, load_embedded_asset, AssetServer, Handle};
+use bevy_asset::{embedded_asset, load_embedded_asset, AssetServer};
 use bevy_camera::Camera;
 use bevy_core_pipeline::{
     core_2d::graph::{Core2d, Node2d},
@@ -20,8 +20,6 @@ use bevy_render::{
     view::{ExtractedView, ViewTarget},
     Render, RenderApp, RenderStartup, RenderSystems,
 };
-use bevy_shader::Shader;
-use bevy_utils::default;
 
 mod node;
 
@@ -114,7 +112,6 @@ impl Plugin for CasPlugin {
             return;
         };
         render_app
-            .init_resource::<SpecializedRenderPipelines<CasPipeline>>()
             .add_systems(RenderStartup, init_cas_pipeline)
             .add_systems(Render, prepare_cas_pipelines.in_set(RenderSystems::Prepare));
 
@@ -157,10 +154,9 @@ impl Plugin for CasPlugin {
 
 #[derive(Resource)]
 pub struct CasPipeline {
-    texture_bind_group: BindGroupLayoutDescriptor,
+    layout: BindGroupLayoutDescriptor,
     sampler: Sampler,
-    fullscreen_shader: FullscreenShader,
-    fragment_shader: Handle<Shader>,
+    variants: Variants<RenderPipeline, CasPipelineSpecializer>,
 }
 
 pub fn init_cas_pipeline(
@@ -169,7 +165,7 @@ pub fn init_cas_pipeline(
     fullscreen_shader: Res<FullscreenShader>,
     asset_server: Res<AssetServer>,
 ) {
-    let texture_bind_group = BindGroupLayoutDescriptor::new(
+    let layout = BindGroupLayoutDescriptor::new(
         "sharpening_texture_bind_group_layout",
         &BindGroupLayoutEntries::sequential(
             ShaderStages::FRAGMENT,
@@ -184,69 +180,84 @@ pub fn init_cas_pipeline(
 
     let sampler = render_device.create_sampler(&SamplerDescriptor::default());
 
+    let fragment_shader = load_embedded_asset!(
+        asset_server.as_ref(),
+        "robust_contrast_adaptive_sharpening.wgsl"
+    );
+
+    let variants = Variants::new(
+        CasPipelineSpecializer,
+        RenderPipelineDescriptor {
+            label: Some("contrast_adaptive_sharpening".into()),
+            layout: vec![layout.clone()],
+            vertex: fullscreen_shader.to_vertex_state(),
+            fragment: Some(FragmentState {
+                shader: fragment_shader,
+                ..Default::default()
+            }),
+            ..Default::default()
+        },
+    );
+
     commands.insert_resource(CasPipeline {
-        texture_bind_group,
+        layout,
         sampler,
-        fullscreen_shader: fullscreen_shader.clone(),
-        fragment_shader: load_embedded_asset!(
-            asset_server.as_ref(),
-            "robust_contrast_adaptive_sharpening.wgsl"
-        ),
+        variants,
     });
 }
 
-#[derive(PartialEq, Eq, Hash, Clone, Copy)]
+#[derive(PartialEq, Eq, Hash, Clone, Copy, SpecializerKey)]
 pub struct CasPipelineKey {
     texture_format: TextureFormat,
     denoise: bool,
 }
 
-impl SpecializedRenderPipeline for CasPipeline {
+pub struct CasPipelineSpecializer;
+
+impl Specializer<RenderPipeline> for CasPipelineSpecializer {
     type Key = CasPipelineKey;
 
-    fn specialize(&self, key: Self::Key) -> RenderPipelineDescriptor {
-        let mut shader_defs = vec![];
+    fn specialize(
+        &self,
+        key: Self::Key,
+        descriptor: &mut <RenderPipeline as Specializable>::Descriptor,
+    ) -> Result<Canonical<Self::Key>, BevyError> {
+        let fragment = descriptor.fragment_mut()?;
+
         if key.denoise {
-            shader_defs.push("RCAS_DENOISE".into());
-        }
-        RenderPipelineDescriptor {
-            label: Some("contrast_adaptive_sharpening".into()),
-            layout: vec![self.texture_bind_group.clone()],
-            vertex: self.fullscreen_shader.to_vertex_state(),
-            fragment: Some(FragmentState {
-                shader: self.fragment_shader.clone(),
-                shader_defs,
-                targets: vec![Some(ColorTargetState {
-                    format: key.texture_format,
-                    blend: None,
-                    write_mask: ColorWrites::ALL,
-                })],
-                ..default()
-            }),
-            ..default()
+            fragment.shader_defs.push("RCAS_DENOISE".into());
         }
+
+        fragment.set_target(
+            0,
+            ColorTargetState {
+                format: key.texture_format,
+                blend: None,
+                write_mask: ColorWrites::ALL,
+            },
+        );
+
+        Ok(key)
     }
 }
 
 fn prepare_cas_pipelines(
     mut commands: Commands,
     pipeline_cache: Res<PipelineCache>,
-    mut pipelines: ResMut<SpecializedRenderPipelines<CasPipeline>>,
-    sharpening_pipeline: Res<CasPipeline>,
+    mut sharpening_pipeline: ResMut<CasPipeline>,
     views: Query<
         (Entity, &ExtractedView, &DenoiseCas),
         Or<(Added<CasUniform>, Changed<DenoiseCas>)>,
     >,
     mut removals: RemovedComponents<CasUniform>,
-) {
+) -> Result<(), BevyError> {
     for entity in removals.read() {
         commands.entity(entity).remove::<ViewCasPipeline>();
     }
 
     for (entity, view, denoise_cas) in &views {
-        let pipeline_id = pipelines.specialize(
+        let pipeline_id = sharpening_pipeline.variants.specialize(
             &pipeline_cache,
-            &sharpening_pipeline,
             CasPipelineKey {
                 denoise: denoise_cas.0,
                 texture_format: if view.hdr {
@@ -255,10 +266,12 @@ fn prepare_cas_pipelines(
                     TextureFormat::bevy_default()
                 },
             },
-        );
+        )?;
 
         commands.entity(entity).insert(ViewCasPipeline(pipeline_id));
     }
+
+    Ok(())
 }
 
 #[derive(Component)]

crates/bevy_anti_alias/src/contrast_adaptive_sharpening/node.rs

@@ -83,7 +83,7 @@ impl Node for CasNode {
             cached_bind_group => {
                 let bind_group = render_context.render_device().create_bind_group(
                     "cas_bind_group",
-                    &pipeline_cache.get_bind_group_layout(&sharpening_pipeline.texture_bind_group),
+                    &pipeline_cache.get_bind_group_layout(&sharpening_pipeline.layout),
                     &BindGroupEntries::sequential((
                         view_target.source,
                         &sharpening_pipeline.sampler,