src/components.rs

@@ -1,9 +1,13 @@
 use bevy::{
     core_pipeline::prepass::{DeferredPrepass, DepthPrepass, NormalPrepass},
     prelude::*,
-    render::{extract_component::ExtractComponent, render_resource::ShaderType},
+    render::{extract_component::ExtractComponent, render_resource::{CachedRenderPipelineId, ShaderType}},
 };
 
+/// Stores the cached pipeline ID for the post processing pass for this camera
+#[derive(Component, Deref, DerefMut)]
+pub struct OutlinePostProcessPipelineId(pub CachedRenderPipelineId);
+
 /// Component which, when inserted into an entity with a camera and normal prepass, enables an outline effect for that
 /// camera.
 #[derive(Component, ShaderType, ExtractComponent, PartialEq, Clone)]

src/lib.rs

@@ -11,12 +11,15 @@ use bevy::{
     render::{
         extract_component::{ExtractComponentPlugin, UniformComponentPlugin},
         render_graph::{RenderGraphApp, ViewNodeRunner},
-        RenderApp,
+        render_resource::{PipelineCache, SpecializedRenderPipelines, TextureFormat},
+        view::{ExtractedView, ViewTarget},
+        Render, RenderApp, RenderSet,
     },
 };
 
-use components::OutlinePostProcessSettings;
+use components::{OutlinePostProcessPipelineId, OutlinePostProcessSettings};
 pub use nodes::OutlineRenderLabel;
+use resources::{OutlinePostProcessPipeline, OutlinePostProcessingPipelineKey};
 
 /// Components used by this plugin.
 pub mod components;
@@ -41,6 +44,11 @@ impl Plugin for OutlinePostProcessPlugin {
         };
 
         render_app
+            .add_systems(
+                Render,
+                prepare_post_processing_pipelines.in_set(RenderSet::Prepare),
+            )
+            .init_resource::<SpecializedRenderPipelines<OutlinePostProcessPipeline>>()
             .add_render_graph_node::<ViewNodeRunner<nodes::OutlineRenderNode>>(
                 Core3d,
                 nodes::OutlineRenderLabel,
@@ -64,6 +72,32 @@ impl Plugin for OutlinePostProcessPlugin {
     }
 }
 
+fn prepare_post_processing_pipelines(
+    mut commands: Commands,
+    pipeline_cache: Res<PipelineCache>,
+    mut pipelines: ResMut<SpecializedRenderPipelines<OutlinePostProcessPipeline>>,
+    post_processing_pipeline: Res<OutlinePostProcessPipeline>,
+    views: Query<(Entity, &ExtractedView), With<OutlinePostProcessSettings>>,
+) {
+    for (entity, view) in views.iter() {
+        let pipeline_id = pipelines.specialize(
+            &pipeline_cache,
+            &post_processing_pipeline,
+            OutlinePostProcessingPipelineKey {
+                texture_format: if view.hdr {
+                    ViewTarget::TEXTURE_FORMAT_HDR
+                } else {
+                    TextureFormat::bevy_default()
+                },
+            },
+        );
+
+        commands
+            .entity(entity)
+            .insert(OutlinePostProcessPipelineId(pipeline_id));
+    }
+}
+
 fn update_shader_clip_planes(
     mut settings_query: Query<(Ref<Projection>, &mut OutlinePostProcessSettings)>,
 ) {

src/nodes.rs

@@ -1,6 +1,6 @@
 use bevy::{
     core_pipeline::prepass::ViewPrepassTextures,
-    ecs::query::QueryItem,
+    ecs::{query::QueryItem, system::lifetimeless::Read},
     prelude::*,
     render::{
         extract_component::ComponentUniforms,
@@ -14,6 +14,8 @@ use bevy::{
     },
 };
 
+use crate::components::OutlinePostProcessPipelineId;
+
 use super::components;
 use super::resources;
 
@@ -26,21 +28,27 @@ pub struct OutlineRenderNode;
 
 impl ViewNode for OutlineRenderNode {
     type ViewQuery = (
-        &'static ViewTarget,
-        &'static ViewPrepassTextures,
-        &'static components::OutlinePostProcessSettings,
+        Read<ViewTarget>,
+        Read<ViewPrepassTextures>,
+        Read<OutlinePostProcessPipelineId>,
+        Read<components::OutlinePostProcessSettings>,
     );
 
     fn run(
         &self,
         _graph: &mut RenderGraphContext,
         render_context: &mut RenderContext,
-        (view_target, view_prepass_textures, _): QueryItem<Self::ViewQuery>,
+        (
+            view_target,
+            view_prepass_textures,
+            pipeline_id,
+            _,
+        ): QueryItem<Self::ViewQuery>,
         world: &World,
     ) -> Result<(), NodeRunError> {
         let render_pipeline = world.resource::<resources::OutlinePostProcessPipeline>();
         let pipeline_cache = world.resource::<PipelineCache>();
-        let Some(pipeline) = pipeline_cache.get_render_pipeline(render_pipeline.pipeline_id) else {
+        let Some(pipeline) = pipeline_cache.get_render_pipeline(**pipeline_id) else {
             warn!("Failed to get render pipeline from cache, skipping...");
             return Ok(());
         };

src/resources.rs

@@ -1,13 +1,9 @@
 use bevy::{
-    core_pipeline::fullscreen_vertex_shader::fullscreen_shader_vertex_state,
+    core_pipeline::fullscreen_vertex_shader,
     prelude::*,
     render::{
         render_resource::{
-            binding_types::{sampler, texture_2d, uniform_buffer},
-            BindGroupLayout, BindGroupLayoutEntries, CachedRenderPipelineId, ColorTargetState,
-            ColorWrites, FragmentState, MultisampleState, PipelineCache, PrimitiveState,
-            RenderPipelineDescriptor, Sampler, SamplerBindingType, SamplerDescriptor, ShaderStages,
-            TextureFormat, TextureSampleType,
+            binding_types::{sampler, texture_2d, uniform_buffer}, BindGroupLayout, BindGroupLayoutEntries, ColorTargetState, ColorWrites, FragmentState, RenderPipelineDescriptor, Sampler, SamplerBindingType, SamplerDescriptor, ShaderStages, SpecializedRenderPipeline, TextureFormat, TextureSampleType
         },
         renderer::RenderDevice,
     },
@@ -21,7 +17,7 @@ pub struct OutlinePostProcessPipeline {
     pub screen_sampler: Sampler,
     pub normal_sampler: Sampler,
     pub depth_sampler: Sampler,
-    pub pipeline_id: CachedRenderPipelineId,
+    pub shader: Handle<Shader>,
 }
 
 impl FromWorld for OutlinePostProcessPipeline {
@@ -52,36 +48,47 @@ impl FromWorld for OutlinePostProcessPipeline {
             "embedded://bevy_outline_post_process/../assets/shaders/outline_post_process.wgsl",
         );
 
-        let pipeline_id =
-            world
-                .resource_mut::<PipelineCache>()
-                .queue_render_pipeline(RenderPipelineDescriptor {
-                    label: Some("outline_post_process_render_pipeline".into()),
-                    layout: vec![layout.clone()],
-                    push_constant_ranges: vec![],
-                    vertex: fullscreen_shader_vertex_state(),
-                    primitive: PrimitiveState::default(),
-                    depth_stencil: None,
-                    multisample: MultisampleState::default(),
-                    fragment: Some(FragmentState {
-                        shader,
-                        shader_defs: vec![],
-                        entry_point: "fragment".into(),
-                        targets: vec![Some(ColorTargetState {
-                            format: TextureFormat::Rgba8UnormSrgb,
-                            blend: None,
-                            write_mask: ColorWrites::ALL,
-                        })],
-                    }),
-                    zero_initialize_workgroup_memory: false,
-                });
-
         Self {
             layout,
             screen_sampler,
             normal_sampler,
             depth_sampler,
-            pipeline_id,
+            shader,
         }
     }
 }
+
+/// A key that uniquely identifies a built-in postprocessing pipeline.
+#[derive(Clone, Copy, PartialEq, Eq, Hash)]
+pub struct OutlinePostProcessingPipelineKey {
+    /// The format of the source and destination textures.
+    pub texture_format: TextureFormat,
+}
+
+impl SpecializedRenderPipeline for OutlinePostProcessPipeline {
+    type Key = OutlinePostProcessingPipelineKey;
+    
+    fn specialize(&self, key: Self::Key) -> RenderPipelineDescriptor {
+        RenderPipelineDescriptor {
+            label: Some("outline_post_processing".into()),
+            layout: vec![self.layout.clone()],
+            vertex: fullscreen_vertex_shader::fullscreen_shader_vertex_state(),
+            fragment: Some(FragmentState {
+                shader: self.shader.clone(),
+                shader_defs: vec![],
+                entry_point: "fragment".into(),
+                targets: vec![Some(ColorTargetState {
+                    format: key.texture_format,
+                    blend: None,
+                    write_mask: ColorWrites::ALL,
+                })],
+            }),
+            primitive: default(),
+            depth_stencil: None,
+            multisample: default(),
+            push_constant_ranges: vec![],
+            zero_initialize_workgroup_memory: false,
+        }
+    }
+    
+}