[Merged by Bors] - separate tonemapping and upscaling passes

crates/bevy_core_pipeline/Cargo.toml

@@ -23,4 +23,6 @@ bevy_core = { path = "../bevy_core", version = "0.7.0-dev" }
 bevy_ecs = { path = "../bevy_ecs", version = "0.7.0-dev" }
 bevy_render = { path = "../bevy_render", version = "0.7.0-dev" }
 bevy_utils = { path = "../bevy_utils", version = "0.7.0-dev" }
+bevy_reflect = { path = "../bevy_reflect", version = "0.7.0-dev" }
 
+bitflags = "1.2"

crates/bevy_core_pipeline/src/fullscreen_vertex_shader/fullscreen.wgsl

@@ -0,0 +1,16 @@
+#define_import_path bevy_core_pipeline::fullscreen_vertex_shader
+
+struct FullscreenVertexOutput {
+    [[builtin(position)]]
+    position: vec4<f32>;
+    [[location(0)]]
+    uv: vec2<f32>;
+};
+
+[[stage(vertex)]]
+fn fullscreen_vertex_shader([[builtin(vertex_index)]] vertex_index: u32) -> FullscreenVertexOutput {
+    let uv = vec2<f32>(f32(vertex_index >> 1u), f32(vertex_index & 1u)) * 2.0;
+    let clip_position = vec4<f32>(uv * vec2<f32>(2.0, -2.0) + vec2<f32>(-1.0, 1.0), 0.0, 1.0);
+
+    return FullscreenVertexOutput(clip_position, uv);
+}

crates/bevy_core_pipeline/src/fullscreen_vertex_shader/mod.rs

@@ -0,0 +1,26 @@
+use bevy_asset::HandleUntyped;
+use bevy_reflect::TypeUuid;
+use bevy_render::{prelude::Shader, render_resource::VertexState};
+
+pub const FULLSCREEN_SHADER_HANDLE: HandleUntyped =
+    HandleUntyped::weak_from_u64(Shader::TYPE_UUID, 7837534426033940724);
+
+/// uses the [`FULLSCREEN_SHADER_HANDLE`] to output a
+/// ```wgsl
+/// struct FullscreenVertexOutput {
+///     [[builtin(position)]]
+///     position: vec4<f32>;
+///     [[location(0)]]
+///     uv: vec2<f32>;
+/// };
+/// ```
+/// from the vertex shader.
+/// The draw call should render one triangle: `render_pass.draw(0..3, 0..1);`
+pub fn fullscreen_shader_vertex_state() -> VertexState {
+    VertexState {
+        shader: FULLSCREEN_SHADER_HANDLE.typed(),
+        shader_defs: Vec::new(),
+        entry_point: "fullscreen_vertex_shader".into(),
+        buffers: Vec::new(),
+    }
+}

crates/bevy_core_pipeline/src/lib.rs

@@ -1,8 +1,11 @@
 mod clear_pass;
 mod clear_pass_driver;
+pub mod fullscreen_vertex_shader;
 mod main_pass_2d;
 mod main_pass_3d;
 mod main_pass_driver;
+mod tonemapping;
+mod upscaling;
 
 pub mod prelude {
     #[doc(hidden)]
@@ -16,10 +19,12 @@ pub use clear_pass_driver::*;
 pub use main_pass_2d::*;
 pub use main_pass_3d::*;
 pub use main_pass_driver::*;
+pub use upscaling::*;
 
 use std::ops::Range;
 
 use bevy_app::{App, Plugin};
+use bevy_asset::load_internal_asset;
 use bevy_core::FloatOrd;
 use bevy_ecs::prelude::*;
 use bevy_render::{
@@ -36,6 +41,11 @@ use bevy_render::{
     view::{ExtractedView, Msaa, ViewDepthTexture},
     RenderApp, RenderStage, RenderWorld,
 };
+use tonemapping::TonemappingNode;
+use tonemapping::TonemappingPlugin;
+use upscaling::UpscalingNode;
+
+use crate::fullscreen_vertex_shader::FULLSCREEN_SHADER_HANDLE;
 
 /// When used as a resource, sets the color that is used to clear the screen between frames.
 ///
@@ -82,6 +92,8 @@ pub mod draw_2d_graph {
     }
     pub mod node {
         pub const MAIN_PASS: &str = "main_pass";
+        pub const TONEMAPPING: &str = "tonemapping";
+        pub const UPSCALING: &str = "upscaling";
     }
 }
 
@@ -92,6 +104,8 @@ pub mod draw_3d_graph {
     }
     pub mod node {
         pub const MAIN_PASS: &str = "main_pass";
+        pub const TONEMAPPING: &str = "tonemapping";
+        pub const UPSCALING: &str = "upscaling";
     }
 }
 
@@ -112,8 +126,17 @@ pub enum CorePipelineRenderSystems {
 
 impl Plugin for CorePipelinePlugin {
     fn build(&self, app: &mut App) {
+        load_internal_asset!(
+            app,
+            FULLSCREEN_SHADER_HANDLE,
+            "fullscreen_vertex_shader/fullscreen.wgsl",
+            Shader::from_wgsl
+        );
+
         app.init_resource::<ClearColor>()
-            .init_resource::<RenderTargetClearColors>();
+            .init_resource::<RenderTargetClearColors>()
+            .add_plugin(TonemappingPlugin)
+            .add_plugin(UpscalingPlugin);
 
         let render_app = match app.get_sub_app_mut(RenderApp) {
             Ok(render_app) => render_app,
@@ -144,10 +167,17 @@ impl Plugin for CorePipelinePlugin {
 
         let clear_pass_node = ClearPassNode::new(&mut render_app.world);
         let pass_node_2d = MainPass2dNode::new(&mut render_app.world);
+        let tonemapping_2d = TonemappingNode::new(&mut render_app.world);
+        let upscaling_2d = UpscalingNode::new(&mut render_app.world);
+
         let pass_node_3d = MainPass3dNode::new(&mut render_app.world);
+        let tonemapping_3d = TonemappingNode::new(&mut render_app.world);
+        let upscaling_3d = UpscalingNode::new(&mut render_app.world);
         let mut graph = render_app.world.resource_mut::<RenderGraph>();
 
         let mut draw_2d_graph = RenderGraph::default();
+        draw_2d_graph.add_node(draw_2d_graph::node::TONEMAPPING, tonemapping_2d);
+        draw_2d_graph.add_node(draw_2d_graph::node::UPSCALING, upscaling_2d);
         draw_2d_graph.add_node(draw_2d_graph::node::MAIN_PASS, pass_node_2d);
         let input_node_id = draw_2d_graph.set_input(vec![SlotInfo::new(
             draw_2d_graph::input::VIEW_ENTITY,
@@ -161,14 +191,65 @@ impl Plugin for CorePipelinePlugin {
                 MainPass2dNode::IN_VIEW,
             )
             .unwrap();
+
+        draw_2d_graph
+            .add_node_edge(
+                draw_2d_graph::node::MAIN_PASS,
+                draw_2d_graph::node::TONEMAPPING,
+            )
+            .unwrap();
+        draw_2d_graph
+            .add_slot_edge(
+                input_node_id,
+                draw_2d_graph::input::VIEW_ENTITY,
+                draw_2d_graph::node::TONEMAPPING,
+                TonemappingNode::IN_VIEW,
+            )
+            .unwrap();
+        draw_2d_graph
+            .add_slot_edge(
+                draw_2d_graph::node::MAIN_PASS,
+                MainPass2dNode::OUT_TEXTURE,
+                draw_2d_graph::node::TONEMAPPING,
+                TonemappingNode::IN_TEXTURE,
+            )
+            .unwrap();
+
+        draw_2d_graph
+            .add_node_edge(
+                draw_2d_graph::node::TONEMAPPING,
+                draw_2d_graph::node::UPSCALING,
+            )
+            .unwrap();
+        draw_2d_graph
+            .add_slot_edge(
+                input_node_id,
+                draw_2d_graph::input::VIEW_ENTITY,
+                draw_2d_graph::node::UPSCALING,
+                UpscalingNode::IN_VIEW,
+            )
+            .unwrap();
+        draw_2d_graph
+            .add_slot_edge(
+                draw_2d_graph::node::TONEMAPPING,
+                TonemappingNode::OUT_TEXTURE,
+                draw_2d_graph::node::UPSCALING,
+                UpscalingNode::IN_TEXTURE,
+            )
+            .unwrap();
+
         graph.add_sub_graph(draw_2d_graph::NAME, draw_2d_graph);
 
         let mut draw_3d_graph = RenderGraph::default();
         draw_3d_graph.add_node(draw_3d_graph::node::MAIN_PASS, pass_node_3d);
+        draw_3d_graph.add_node(draw_3d_graph::node::TONEMAPPING, tonemapping_3d);
+        draw_3d_graph.add_node(draw_3d_graph::node::UPSCALING, upscaling_3d);
+
         let input_node_id = draw_3d_graph.set_input(vec![SlotInfo::new(
             draw_3d_graph::input::VIEW_ENTITY,
             SlotType::Entity,
         )]);
+
         draw_3d_graph
             .add_slot_edge(
                 input_node_id,
@@ -177,6 +258,53 @@ impl Plugin for CorePipelinePlugin {
                 MainPass3dNode::IN_VIEW,
             )
             .unwrap();
+
+        draw_3d_graph
+            .add_node_edge(
+                draw_3d_graph::node::MAIN_PASS,
+                draw_3d_graph::node::TONEMAPPING,
+            )
+            .unwrap();
+        draw_3d_graph
+            .add_slot_edge(
+                input_node_id,
+                draw_3d_graph::input::VIEW_ENTITY,
+                draw_3d_graph::node::TONEMAPPING,
+                TonemappingNode::IN_VIEW,
+            )
+            .unwrap();
+        draw_3d_graph
+            .add_slot_edge(
+                draw_3d_graph::node::MAIN_PASS,
+                MainPass3dNode::OUT_TEXTURE,
+                draw_3d_graph::node::TONEMAPPING,
+                TonemappingNode::IN_TEXTURE,
+            )
+            .unwrap();
+
+        draw_3d_graph
+            .add_node_edge(
+                draw_3d_graph::node::TONEMAPPING,
+                draw_3d_graph::node::UPSCALING,
+            )
+            .unwrap();
+        draw_3d_graph
+            .add_slot_edge(
+                input_node_id,
+                draw_3d_graph::input::VIEW_ENTITY,
+                draw_3d_graph::node::UPSCALING,
+                UpscalingNode::IN_VIEW,
+            )
+            .unwrap();
+        draw_3d_graph
+            .add_slot_edge(
+                draw_3d_graph::node::TONEMAPPING,
+                TonemappingNode::OUT_TEXTURE,
+                draw_3d_graph::node::UPSCALING,
+                UpscalingNode::IN_TEXTURE,
+            )
+            .unwrap();
+
         graph.add_sub_graph(draw_3d_graph::NAME, draw_3d_graph);
 
         let mut clear_graph = RenderGraph::default();

crates/bevy_core_pipeline/src/main_pass_2d.rs

@@ -15,6 +15,7 @@ pub struct MainPass2dNode {
 
 impl MainPass2dNode {
     pub const IN_VIEW: &'static str = "view";
+    pub const OUT_TEXTURE: &'static str = "output";
 
     pub fn new(world: &mut World) -> Self {
         Self {
@@ -28,6 +29,13 @@ impl Node for MainPass2dNode {
         vec![SlotInfo::new(MainPass2dNode::IN_VIEW, SlotType::Entity)]
     }
 
+    fn output(&self) -> Vec<SlotInfo> {
+        vec![SlotInfo::new(
+            MainPass2dNode::OUT_TEXTURE,
+            SlotType::TextureView,
+        )]
+    }
+
     fn update(&mut self, world: &mut World) {
         self.query.update_archetypes(world);
     }
@@ -65,6 +73,14 @@ impl Node for MainPass2dNode {
             let draw_function = draw_functions.get_mut(item.draw_function).unwrap();
             draw_function.draw(world, &mut tracked_pass, view_entity, item);
         }
+
+        graph
+            .set_output(
+                MainPass2dNode::OUT_TEXTURE,
+                target.main_texture.texture().clone(),
+            )
+            .unwrap();
+
         Ok(())
     }
 }

crates/bevy_core_pipeline/src/main_pass_3d.rs

@@ -25,6 +25,7 @@ pub struct MainPass3dNode {
 
 impl MainPass3dNode {
     pub const IN_VIEW: &'static str = "view";
+    pub const OUT_TEXTURE: &'static str = "output";
 
     pub fn new(world: &mut World) -> Self {
         Self {
@@ -38,6 +39,13 @@ impl Node for MainPass3dNode {
         vec![SlotInfo::new(MainPass3dNode::IN_VIEW, SlotType::Entity)]
     }
 
+    fn output(&self) -> Vec<SlotInfo> {
+        vec![SlotInfo::new(
+            MainPass3dNode::OUT_TEXTURE,
+            SlotType::TextureView,
+        )]
+    }
+
     fn update(&mut self, world: &mut World) {
         self.query.update_archetypes(world);
     }
@@ -166,6 +174,13 @@ impl Node for MainPass3dNode {
             }
         }
 
+        graph
+            .set_output(
+                MainPass3dNode::OUT_TEXTURE,
+                target.main_texture.texture().clone(),
+            )
+            .unwrap();
+
         Ok(())
     }
 }