WIP post_processing plugin copy

Author: IceSentry

Cargo.toml

@@ -3828,6 +3828,19 @@ name = "fallback_image"
 path = "examples/shader/fallback_image.rs"
 doc-scrape-examples = true
 
+[package.metadata.example.fallback_image]
+hidden = true
+
+[[example]]
+name = "fullscreen_material"
+path = "examples/shader/fullscreen_material.rs"
+doc-scrape-examples = true
+
+[package.metadata.example.fullscreen_material]
+name = "Fullscreen Material"
+description = "Demonstrates how to write a fullscreen material"
+category = "3D Rendering"
+
 [[example]]
 name = "reflection_probes"
 path = "examples/3d/reflection_probes.rs"
@@ -3839,9 +3852,6 @@ description = "Demonstrates reflection probes"
 category = "3D Rendering"
 wasm = false
 
-[package.metadata.example.fallback_image]
-hidden = true
-
 [package.metadata.example.window_resizing]
 name = "Window Resizing"
 description = "Demonstrates resizing and responding to resizing a window"

assets/shaders/my_post_processing.wgsl

@@ -0,0 +1,48 @@
+// This shader computes the chromatic aberration effect
+
+// Since post processing is a fullscreen effect, we use the fullscreen vertex shader provided by bevy.
+// This will import a vertex shader that renders a single fullscreen triangle.
+//
+// A fullscreen triangle is a single triangle that covers the entire screen.
+// The box in the top left in that diagram is the screen. The 4 x are the corner of the screen
+//
+// Y axis
+//  1 |  x-----x......
+//  0 |  |  s  |  . ´
+// -1 |  x_____x´
+// -2 |  :  .´
+// -3 |  :´
+//    +---------------  X axis
+//      -1  0  1  2  3
+//
+// As you can see, the triangle ends up bigger than the screen.
+//
+// You don't need to worry about this too much since bevy will compute the correct UVs for you.
+#import bevy_core_pipeline::fullscreen_vertex_shader::FullscreenVertexOutput
+
+@group(0) @binding(0) var screen_texture: texture_2d<f32>;
+@group(0) @binding(1) var texture_sampler: sampler;
+struct PostProcessSettings {
+    intensity: f32,
+#ifdef SIXTEEN_BYTE_ALIGNMENT
+    // WebGL2 structs must be 16 byte aligned.
+    _webgl2_padding: vec3<f32>
+#endif
+}
+@group(0) @binding(2) var<uniform> settings: PostProcessSettings;
+
+@fragment
+fn fragment(in: FullscreenVertexOutput) -> @location(0) vec4<f32> {
+    // Chromatic aberration strength
+    let offset_strength = settings.intensity;
+
+    // Sample each color channel with an arbitrary shift
+    return vec4<f32>(
+        textureSample(screen_texture, texture_sampler, in.uv + vec2<f32>(offset_strength, -offset_strength)).r,
+        textureSample(screen_texture, texture_sampler, in.uv + vec2<f32>(-offset_strength, 0.0)).g,
+        textureSample(screen_texture, texture_sampler, in.uv + vec2<f32>(0.0, offset_strength)).b,
+        1.0
+    );
+}
+
+

examples/shader/custom_post_processing.rs

@@ -30,6 +30,7 @@ use bevy::{
         RenderApp, RenderStartup,
     },
 };
+use plugin::{FullscreenMaterial, FullscreenMaterialPlugin};
 
 /// This example uses a shader source file from the assets subdirectory
 const SHADER_ASSET_PATH: &str = "shaders/post_processing.wgsl";
@@ -312,6 +313,7 @@ fn setup(
             intensity: 0.02,
             ..default()
         },
+        MyPostProcessing { data: 1.0 },
     ));
 
     // cube
@@ -355,3 +357,146 @@ fn update_settings(mut settings: Query<&mut PostProcessSettings>, time: Res<Time
         setting.intensity = intensity;
     }
 }
+
+mod plugin {
+    use std::marker::PhantomData;
+
+    use bevy::{core_pipeline::FullscreenShader, prelude::*, shader::ShaderRef};
+    use bevy_render::{
+        extract_component::{
+            DynamicUniformIndex, ExtractComponent, ExtractComponentPlugin, UniformComponentPlugin,
+        },
+        render_graph::ViewNode,
+        render_resource::{
+            binding_types::{sampler, texture_2d, uniform_buffer},
+            encase::internal::WriteInto,
+            AsBindGroup, BindGroupLayout, BindGroupLayoutEntries, CachedRenderPipelineId,
+            ColorTargetState, ColorWrites, FragmentState, PipelineCache, RenderPipelineDescriptor,
+            Sampler, SamplerBindingType, SamplerDescriptor, ShaderStages, ShaderType,
+            TextureFormat, TextureSampleType,
+        },
+        renderer::RenderDevice,
+        view::ViewTarget,
+        RenderApp, RenderStartup,
+    };
+
+    use crate::PostProcessSettings;
+
+    #[derive(Default)]
+    pub struct FullscreenMaterialPlugin<T: FullscreenMaterial> {
+        _marker: PhantomData<T>,
+    }
+    impl<T: FullscreenMaterial> Plugin for FullscreenMaterialPlugin<T> {
+        fn build(&self, app: &mut App) {
+            app.add_plugins((
+                ExtractComponentPlugin::<T>::default(),
+                UniformComponentPlugin::<T>::default(),
+            ));
+
+            // We need to get the render app from the main app
+            let Some(render_app) = app.get_sub_app_mut(RenderApp) else {
+                return;
+            };
+            render_app.add_systems(RenderStartup, init_pipeline::<T>);
+        }
+    }
+
+    pub trait FullscreenMaterial:
+        Component + ExtractComponent + AsBindGroup + Clone + Copy + ShaderType + WriteInto
+    {
+        fn fragment_shader() -> ShaderRef;
+    }
+    #[derive(Resource)]
+    struct FullscreenMaterialPipeline {
+        layout: BindGroupLayout,
+        sampler: Sampler,
+        pipeline_id: CachedRenderPipelineId,
+    }
+    fn init_pipeline<T: FullscreenMaterial>(
+        mut commands: Commands,
+        render_device: Res<RenderDevice>,
+        asset_server: Res<AssetServer>,
+        fullscreen_shader: Res<FullscreenShader>,
+        pipeline_cache: Res<PipelineCache>,
+    ) {
+        // We need to define the bind group layout used for our pipeline
+        let layout = render_device.create_bind_group_layout(
+            "post_process_bind_group_layout",
+            &BindGroupLayoutEntries::sequential(
+                // The layout entries will only be visible in the fragment stage
+                ShaderStages::FRAGMENT,
+                (
+                    // The screen texture
+                    texture_2d(TextureSampleType::Float { filterable: true }),
+                    // The sampler that will be used to sample the screen texture
+                    sampler(SamplerBindingType::Filtering),
+                    // The settings uniform that will control the effect
+                    uniform_buffer::<T>(true),
+                ),
+            ),
+        );
+        // We can create the sampler here since it won't change at runtime and doesn't depend on the view
+        let sampler = render_device.create_sampler(&SamplerDescriptor::default());
+        let mayber_shader = match T::fragment_shader() {
+            ShaderRef::Default => {
+                unimplemented!("No default fallback for FullscreenMaterial shader")
+            }
+            ShaderRef::Handle(handle) => handle,
+            ShaderRef::Path(path) => asset_server.load(path),
+        };
+        // This will setup a fullscreen triangle for the vertex state.
+        let vertex_state = fullscreen_shader.to_vertex_state();
+        let pipeline_id = pipeline_cache
+            // This will add the pipeline to the cache and queue its creation
+            .queue_render_pipeline(RenderPipelineDescriptor {
+                label: Some("post_process_pipeline".into()),
+                layout: vec![layout.clone()],
+                vertex: vertex_state,
+                fragment: Some(FragmentState {
+                    shader,
+                    // Make sure this matches the entry point of your shader.
+                    // It can be anything as long as it matches here and in the shader.
+                    targets: vec![Some(ColorTargetState {
+                        format: TextureFormat::bevy_default(),
+                        blend: None,
+                        write_mask: ColorWrites::ALL,
+                    })],
+                    ..default()
+                }),
+                ..default()
+            });
+        commands.insert_resource(FullscreenMaterialPipeline {
+            layout,
+            sampler,
+            pipeline_id,
+        });
+    }
+    struct FullscreenMaterialNode<T: FullscreenMaterial> {
+        _marker: PhantomData<T>,
+    }
+
+    impl<T: FullscreenMaterial> ViewNode for FullscreenMaterialNode<T> {
+        // The node needs a query to gather data from the ECS in order to do its rendering,
+        // but it's not a normal system so we need to define it manually.
+        //
+        // This query will only run on the view entity
+        type ViewQuery = (
+            &'static ViewTarget,
+            // This makes sure the node only runs on cameras with the PostProcessSettings component
+            &'static T,
+            // As there could be multiple post processing components sent to the GPU (one per camera),
+            // we need to get the index of the one that is associated with the current view.
+            &'static DynamicUniformIndex<T>,
+        );
+
+        fn run<'w>(
+            &self,
+            graph: &mut bevy_render::render_graph::RenderGraphContext,
+            render_context: &mut bevy_render::renderer::RenderContext<'w>,
+            view_query: bevy_ecs::query::QueryItem<'w, '_, Self::ViewQuery>,
+            world: &'w World,
+        ) -> std::result::Result<(), bevy_render::render_graph::NodeRunError> {
+            todo!()
+        }
+    }
+}