Deferred Renderer

Cargo.toml

@@ -591,6 +591,16 @@ description = "Illustrates bloom configuration using HDR and emissive materials"
 category = "3D Rendering"
 wasm = true
 
+[[example]]
+name = "deferred_rendering"
+path = "examples/3d/deferred_rendering.rs"
+
+[package.metadata.example.deferred_rendering]
+name = "Deferred Rendering"
+description = "Renders meshes with both forward and deferred pipelines"
+category = "3D Rendering"
+wasm = true
+
 [[example]]
 name = "load_gltf"
 path = "examples/3d/load_gltf.rs"

assets/shaders/array_texture.wgsl

@@ -1,6 +1,6 @@
 #import bevy_pbr::mesh_vertex_output    MeshVertexOutput
 #import bevy_pbr::mesh_view_bindings    view
-#import bevy_pbr::pbr_types             STANDARD_MATERIAL_FLAGS_DOUBLE_SIDED_BIT
+#import bevy_pbr::pbr_types             STANDARD_MATERIAL_FLAGS_DOUBLE_SIDED_BIT, PbrInput, pbr_input_new
 #import bevy_core_pipeline::tonemapping tone_mapping
 #import bevy_pbr::pbr_functions as fns
 
@@ -18,7 +18,7 @@ fn fragment(
 
     // Prepare a 'processed' StandardMaterial by sampling all textures to resolve
     // the material members
-    var pbr_input: fns::PbrInput = fns::pbr_input_new();
+    var pbr_input: PbrInput = pbr_input_new();
 
     pbr_input.material.base_color = textureSample(my_array_texture, my_array_texture_sampler, mesh.uv, layer);
 #ifdef VERTEX_COLORS

crates/bevy_core_pipeline/src/core_3d/main_opaque_pass_3d_node.rs

@@ -1,7 +1,7 @@
 use crate::{
     clear_color::{ClearColor, ClearColorConfig},
     core_3d::{Camera3d, Opaque3d},
-    prepass::{DepthPrepass, MotionVectorPrepass, NormalPrepass},
+    prepass::{DeferredPrepass, DepthPrepass, MotionVectorPrepass, NormalPrepass},
     skybox::{SkyboxBindGroup, SkyboxPipelineId},
 };
 use bevy_ecs::{prelude::*, query::QueryItem};
@@ -34,6 +34,7 @@ impl ViewNode for MainOpaquePass3dNode {
         Option<&'static DepthPrepass>,
         Option<&'static NormalPrepass>,
         Option<&'static MotionVectorPrepass>,
+        Option<&'static DeferredPrepass>,
         Option<&'static SkyboxPipelineId>,
         Option<&'static SkyboxBindGroup>,
         &'static ViewUniformOffset,
@@ -53,12 +54,24 @@ impl ViewNode for MainOpaquePass3dNode {
             depth_prepass,
             normal_prepass,
             motion_vector_prepass,
+            deferred_prepass,
             skybox_pipeline,
             skybox_bind_group,
             view_uniform_offset,
         ): QueryItem<Self::ViewQuery>,
         world: &World,
     ) -> Result<(), NodeRunError> {
+        let load = if deferred_prepass.is_none() {
+            match camera_3d.clear_color {
+                ClearColorConfig::Default => LoadOp::Clear(world.resource::<ClearColor>().0.into()),
+                ClearColorConfig::Custom(color) => LoadOp::Clear(color.into()),
+                ClearColorConfig::None => LoadOp::Load,
+            }
+        } else {
+            // If the deferred pass has run, don't clear again in this pass.
+            LoadOp::Load
+        };
+
         // Run the opaque pass, sorted front-to-back
         // NOTE: Scoped to drop the mutable borrow of render_context
         #[cfg(feature = "trace")]
@@ -69,23 +82,17 @@ impl ViewNode for MainOpaquePass3dNode {
             label: Some("main_opaque_pass_3d"),
             // NOTE: The opaque pass loads the color
             // buffer as well as writing to it.
-            color_attachments: &[Some(target.get_color_attachment(Operations {
-                load: match camera_3d.clear_color {
-                    ClearColorConfig::Default => {
-                        LoadOp::Clear(world.resource::<ClearColor>().0.into())
-                    }
-                    ClearColorConfig::Custom(color) => LoadOp::Clear(color.into()),
-                    ClearColorConfig::None => LoadOp::Load,
-                },
-                store: true,
-            }))],
+            color_attachments: &[Some(
+                target.get_color_attachment(Operations { load, store: true }),
+            )],
             depth_stencil_attachment: Some(RenderPassDepthStencilAttachment {
                 view: &depth.view,
                 // NOTE: The opaque main pass loads the depth buffer and possibly overwrites it
                 depth_ops: Some(Operations {
                     load: if depth_prepass.is_some()
                         || normal_prepass.is_some()
                         || motion_vector_prepass.is_some()
+                        || deferred_prepass.is_some()
                     {
                         // if any prepass runs, it will generate a depth buffer so we should use it,
                         // even if only the normal_prepass is used.

crates/bevy_core_pipeline/src/core_3d/mod.rs

@@ -10,6 +10,7 @@ pub mod graph {
     pub mod node {
         pub const MSAA_WRITEBACK: &str = "msaa_writeback";
         pub const PREPASS: &str = "prepass";
+        pub const DEFERRED: &str = "deferred";
         pub const START_MAIN_PASS: &str = "start_main_pass";
         pub const MAIN_OPAQUE_PASS: &str = "main_opaque_pass";
         pub const MAIN_TRANSPARENT_PASS: &str = "main_transparent_pass";
@@ -24,17 +25,27 @@ pub mod graph {
 }
 pub const CORE_3D: &str = graph::NAME;
 
+#[derive(Resource, ExtractResource, Clone)]
+pub struct Core3DDepthFormat(pub TextureFormat);
+
+impl Default for Core3DDepthFormat {
+    fn default() -> Self {
+        Core3DDepthFormat(TextureFormat::Depth32Float)
+    }
+}
+
 use std::cmp::Reverse;
 
 pub use camera_3d::*;
 pub use main_opaque_pass_3d_node::*;
 pub use main_transparent_pass_3d_node::*;
 
-use bevy_app::{App, Plugin};
+use bevy_app::{App, Plugin, PostUpdate};
 use bevy_ecs::prelude::*;
 use bevy_render::{
     camera::{Camera, ExtractedCamera},
     extract_component::ExtractComponentPlugin,
+    extract_resource::{ExtractResource, ExtractResourcePlugin},
     prelude::Msaa,
     render_graph::{EmptyNode, RenderGraphApp, ViewNodeRunner},
     render_phase::{
@@ -46,16 +57,20 @@ use bevy_render::{
         TextureUsages,
     },
     renderer::RenderDevice,
+    settings::WgpuFeatures,
     texture::TextureCache,
     view::ViewDepthTexture,
     Extract, ExtractSchedule, Render, RenderApp, RenderSet,
 };
-use bevy_utils::{FloatOrd, HashMap};
+use bevy_utils::{tracing::warn, FloatOrd, HashMap};
 
 use crate::{
+    deferred::{
+        node::DeferredNode, AlphaMask3dDeferred, Opaque3dDeferred, DEFERRED_PREPASS_FORMAT,
+    },
     prepass::{
-        node::PrepassNode, AlphaMask3dPrepass, DepthPrepass, MotionVectorPrepass, NormalPrepass,
-        Opaque3dPrepass, ViewPrepassTextures, DEPTH_PREPASS_FORMAT, MOTION_VECTOR_PREPASS_FORMAT,
+        node::PrepassNode, AlphaMask3dPrepass, DeferredPrepass, DepthPrepass, MotionVectorPrepass,
+        NormalPrepass, Opaque3dPrepass, ViewPrepassTextures, MOTION_VECTOR_PREPASS_FORMAT,
         NORMAL_PREPASS_FORMAT,
     },
     skybox::SkyboxPlugin,
@@ -67,9 +82,15 @@ pub struct Core3dPlugin;
 
 impl Plugin for Core3dPlugin {
     fn build(&self, app: &mut App) {
-        app.register_type::<Camera3d>()
+        app.init_resource::<Core3DDepthFormat>()
+            .register_type::<Camera3d>()
             .register_type::<Camera3dDepthLoadOp>()
-            .add_plugins((SkyboxPlugin, ExtractComponentPlugin::<Camera3d>::default()));
+            .add_plugins((
+                SkyboxPlugin,
+                ExtractComponentPlugin::<Camera3d>::default(),
+                ExtractResourcePlugin::<Core3DDepthFormat>::default(),
+            ))
+            .add_systems(PostUpdate, (check_msaa, check_depth_format));
 
         let render_app = match app.get_sub_app_mut(RenderApp) {
             Ok(render_app) => render_app,
@@ -82,6 +103,8 @@ impl Plugin for Core3dPlugin {
             .init_resource::<DrawFunctions<Transparent3d>>()
             .init_resource::<DrawFunctions<Opaque3dPrepass>>()
             .init_resource::<DrawFunctions<AlphaMask3dPrepass>>()
+            .init_resource::<DrawFunctions<Opaque3dDeferred>>()
+            .init_resource::<DrawFunctions<AlphaMask3dDeferred>>()
             .add_systems(ExtractSchedule, extract_core_3d_camera_phases)
             .add_systems(ExtractSchedule, extract_camera_prepass_phase)
             .add_systems(
@@ -98,13 +121,16 @@ impl Plugin for Core3dPlugin {
                     sort_phase_system::<Transparent3d>.in_set(RenderSet::PhaseSort),
                     sort_phase_system::<Opaque3dPrepass>.in_set(RenderSet::PhaseSort),
                     sort_phase_system::<AlphaMask3dPrepass>.in_set(RenderSet::PhaseSort),
+                    sort_phase_system::<Opaque3dDeferred>.in_set(RenderSet::PhaseSort),
+                    sort_phase_system::<AlphaMask3dDeferred>.in_set(RenderSet::PhaseSort),
                 ),
             );
 
         use graph::node::*;
         render_app
             .add_render_sub_graph(CORE_3D)
             .add_render_graph_node::<ViewNodeRunner<PrepassNode>>(CORE_3D, PREPASS)
+            .add_render_graph_node::<ViewNodeRunner<DeferredNode>>(CORE_3D, DEFERRED)
             .add_render_graph_node::<EmptyNode>(CORE_3D, START_MAIN_PASS)
             .add_render_graph_node::<ViewNodeRunner<MainOpaquePass3dNode>>(
                 CORE_3D,
@@ -122,6 +148,7 @@ impl Plugin for Core3dPlugin {
                 CORE_3D,
                 &[
                     PREPASS,
+                    DEFERRED,
                     START_MAIN_PASS,
                     MAIN_OPAQUE_PASS,
                     MAIN_TRANSPARENT_PASS,
@@ -297,12 +324,14 @@ pub fn extract_camera_prepass_phase(
                 Option<&DepthPrepass>,
                 Option<&NormalPrepass>,
                 Option<&MotionVectorPrepass>,
+                Option<&DeferredPrepass>,
             ),
             With<Camera3d>,
         >,
     >,
 ) {
-    for (entity, camera, depth_prepass, normal_prepass, motion_vector_prepass) in cameras_3d.iter()
+    for (entity, camera, depth_prepass, normal_prepass, motion_vector_prepass, deferred_prepass) in
+        cameras_3d.iter()
     {
         if camera.is_active {
             let mut entity = commands.get_or_spawn(entity);
@@ -317,6 +346,13 @@ pub fn extract_camera_prepass_phase(
                 ));
             }
 
+            if deferred_prepass.is_some() {
+                entity.insert((
+                    RenderPhase::<Opaque3dDeferred>::default(),
+                    RenderPhase::<AlphaMask3dDeferred>::default(),
+                ));
+            }
+
             if depth_prepass.is_some() {
                 entity.insert(DepthPrepass);
             }
@@ -326,12 +362,16 @@ pub fn extract_camera_prepass_phase(
             if motion_vector_prepass.is_some() {
                 entity.insert(MotionVectorPrepass);
             }
+            if deferred_prepass.is_some() {
+                entity.insert(DeferredPrepass);
+            }
         }
     }
 }
 
 pub fn prepare_core_3d_depth_textures(
     mut commands: Commands,
+    depth_format: Res<Core3DDepthFormat>,
     mut texture_cache: ResMut<TextureCache>,
     msaa: Res<Msaa>,
     render_device: Res<RenderDevice>,
@@ -374,7 +414,7 @@ pub fn prepare_core_3d_depth_textures(
                     sample_count: msaa.samples(),
                     dimension: TextureDimension::D2,
                     // PERF: vulkan docs recommend using 24 bit depth for better performance
-                    format: TextureFormat::Depth32Float,
+                    format: depth_format.0,
                     usage,
                     view_formats: &[],
                 };
@@ -390,9 +430,53 @@ pub fn prepare_core_3d_depth_textures(
     }
 }
 
+// Disable msaa and warn if using deferred rendering
+pub fn check_msaa(
+    mut msaa: ResMut<Msaa>,
+    views_3d: Query<Entity, (With<Camera>, With<DeferredPrepass>)>,
+) {
+    if !views_3d.is_empty() {
+        match *msaa {
+            Msaa::Off => (),
+            _ => {
+                warn!("MSAA is incompatible with deferred rendering and has been disabled.");
+                *msaa = Msaa::Off;
+            }
+        };
+    }
+}
+
+// Automatically selects a supported depth stencil format if required.
+pub fn check_depth_format(
+    render_device: Option<Res<RenderDevice>>,
+    mut depth_format: ResMut<Core3DDepthFormat>,
+    views_3d: Query<Entity, (With<Camera>, With<DeferredPrepass>)>,
+) {
+    if let Some(render_device) = render_device {
+        if !views_3d.is_empty() {
+            match depth_format.0 {
+                TextureFormat::Depth24PlusStencil8 | TextureFormat::Depth32FloatStencil8 => (),
+                _ => {
+                    let prev_depth_format = depth_format.0;
+                    if render_device
+                        .features()
+                        .contains(WgpuFeatures::DEPTH32FLOAT_STENCIL8)
+                    {
+                        depth_format.0 = TextureFormat::Depth32FloatStencil8;
+                    } else {
+                        depth_format.0 = TextureFormat::Depth24PlusStencil8;
+                    }
+                    warn!("Deferred rendering requires a depth stencil format. Changing depth format from {:?} to {:?}.", prev_depth_format, depth_format.0);
+                }
+            }
+        }
+    }
+}
+
 // Prepares the textures used by the prepass
 pub fn prepare_prepass_textures(
     mut commands: Commands,
+    depth_format: Res<Core3DDepthFormat>,
     mut texture_cache: ResMut<TextureCache>,
     msaa: Res<Msaa>,
     render_device: Res<RenderDevice>,
@@ -403,6 +487,7 @@ pub fn prepare_prepass_textures(
             Option<&DepthPrepass>,
             Option<&NormalPrepass>,
             Option<&MotionVectorPrepass>,
+            Option<&DeferredPrepass>,
         ),
         (
             With<RenderPhase<Opaque3dPrepass>>,
@@ -412,8 +497,11 @@ pub fn prepare_prepass_textures(
 ) {
     let mut depth_textures = HashMap::default();
     let mut normal_textures = HashMap::default();
+    let mut deferred_textures = HashMap::default();
     let mut motion_vectors_textures = HashMap::default();
-    for (entity, camera, depth_prepass, normal_prepass, motion_vector_prepass) in &views_3d {
+    for (entity, camera, depth_prepass, normal_prepass, motion_vector_prepass, deferred_prepass) in
+        &views_3d
+    {
         let Some(physical_target_size) = camera.physical_target_size else {
             continue;
         };
@@ -434,7 +522,7 @@ pub fn prepare_prepass_textures(
                         mip_level_count: 1,
                         sample_count: msaa.samples(),
                         dimension: TextureDimension::D2,
-                        format: DEPTH_PREPASS_FORMAT,
+                        format: depth_format.0,
                         usage: TextureUsages::COPY_DST
                             | TextureUsages::RENDER_ATTACHMENT
                             | TextureUsages::TEXTURE_BINDING,
@@ -489,10 +577,33 @@ pub fn prepare_prepass_textures(
                 .clone()
         });
 
+        let cached_deferred_texture = deferred_prepass.is_some().then(|| {
+            deferred_textures
+                .entry(camera.target.clone())
+                .or_insert_with(|| {
+                    texture_cache.get(
+                        &render_device,
+                        TextureDescriptor {
+                            label: Some("prepass_deferred_texture"),
+                            size,
+                            mip_level_count: 1,
+                            sample_count: 1,
+                            dimension: TextureDimension::D2,
+                            format: DEFERRED_PREPASS_FORMAT,
+                            usage: TextureUsages::RENDER_ATTACHMENT
+                                | TextureUsages::TEXTURE_BINDING,
+                            view_formats: &[],
+                        },
+                    )
+                })
+                .clone()
+        });
+
         commands.entity(entity).insert(ViewPrepassTextures {
             depth: cached_depth_texture,
             normal: cached_normals_texture,
             motion_vectors: cached_motion_vectors_texture,
+            deferred: cached_deferred_texture,
             size,
         });
     }