.

Author: tychedelia

crates/bevy_core_pipeline/src/deferred/copy_lighting_id.rs

@@ -20,7 +20,7 @@ use super::DEFERRED_LIGHTING_PASS_ID_DEPTH_FORMAT;
 use bevy_ecs::query::QueryItem;
 use bevy_render::{
     render_graph::{NodeRunError, RenderGraphContext, ViewNode},
-    renderer::RenderContext,
+    renderer::{CurrentView, RenderContext, RenderContextParam},
 };
 use bevy_utils::default;
 
@@ -190,3 +190,62 @@ fn prepare_deferred_lighting_id_textures(
         }
     }
 }
+
+// =============================================================================
+// Schedule-based system (new approach)
+// =============================================================================
+
+/// Render system that copies the deferred lighting pass ID to a depth texture.
+///
+/// This is the schedule-based replacement for [`CopyDeferredLightingIdNode`].
+pub fn copy_deferred_lighting_id(
+    view: CurrentView,
+    view_query: Query<(
+        &ViewTarget,
+        &ViewPrepassTextures,
+        &DeferredLightingIdDepthTexture,
+    )>,
+    copy_pipeline: Res<CopyDeferredLightingIdPipeline>,
+    pipeline_cache: Res<PipelineCache>,
+    mut ctx: RenderContextParam,
+) {
+    let view_entity = view.entity();
+    let Ok((_view_target, view_prepass_textures, deferred_lighting_id_depth_texture)) =
+        view_query.get(view_entity)
+    else {
+        return;
+    };
+
+    let Some(pipeline) = pipeline_cache.get_render_pipeline(copy_pipeline.pipeline_id) else {
+        return;
+    };
+    let Some(deferred_lighting_pass_id_texture) = &view_prepass_textures.deferred_lighting_pass_id
+    else {
+        return;
+    };
+
+    let bind_group = ctx.render_device().create_bind_group(
+        "copy_deferred_lighting_id_bind_group",
+        &pipeline_cache.get_bind_group_layout(&copy_pipeline.layout),
+        &BindGroupEntries::single(&deferred_lighting_pass_id_texture.texture.default_view),
+    );
+
+    let mut render_pass = ctx.begin_tracked_render_pass(RenderPassDescriptor {
+        label: Some("copy_deferred_lighting_id"),
+        color_attachments: &[],
+        depth_stencil_attachment: Some(RenderPassDepthStencilAttachment {
+            view: &deferred_lighting_id_depth_texture.texture.default_view,
+            depth_ops: Some(Operations {
+                load: LoadOp::Clear(0.0),
+                store: StoreOp::Store,
+            }),
+            stencil_ops: None,
+        }),
+        timestamp_writes: None,
+        occlusion_query_set: None,
+    });
+
+    render_pass.set_render_pipeline(pipeline);
+    render_pass.set_bind_group(0, &bind_group, &[]);
+    render_pass.draw(0..3, 0..1);
+}

crates/bevy_core_pipeline/src/deferred/node.rs

@@ -10,7 +10,7 @@ use bevy_render::{
     render_graph::{NodeRunError, RenderGraphContext},
     render_phase::{TrackedRenderPass, ViewBinnedRenderPhases},
     render_resource::{CommandEncoderDescriptor, RenderPassDescriptor, StoreOp},
-    renderer::RenderContext,
+    renderer::{CurrentView, RenderContext, RenderContextParam},
     view::ViewDepthTexture,
 };
 use tracing::error;
@@ -271,3 +271,249 @@ fn run_deferred_prepass<'w>(
 
     Ok(())
 }
+
+// =============================================================================
+// Schedule-based systems (new approach)
+// =============================================================================
+
+/// Type alias for the deferred prepass view query.
+type DeferredPrepassViewQuery = (
+    &'static ExtractedCamera,
+    &'static ExtractedView,
+    &'static ViewDepthTexture,
+    &'static ViewPrepassTextures,
+    Option<&'static MainPassResolutionOverride>,
+    Has<OcclusionCulling>,
+    Has<NoIndirectDrawing>,
+);
+
+/// Render system for the early deferred G-buffer prepass.
+///
+/// This is the schedule-based replacement for [`EarlyDeferredGBufferPrepassNode`].
+/// It draws meshes that were visible last frame to the G-buffer.
+/// If occlusion culling isn't in use, this simply draws all meshes.
+pub fn early_deferred_prepass(
+    world: &World,
+    view: CurrentView,
+    view_query: Query<DeferredPrepassViewQuery>,
+    opaque_deferred_phases: Res<ViewBinnedRenderPhases<Opaque3dDeferred>>,
+    alpha_mask_deferred_phases: Res<ViewBinnedRenderPhases<AlphaMask3dDeferred>>,
+    mut ctx: RenderContextParam,
+) {
+    let view_entity = view.entity();
+    let Ok((camera, extracted_view, view_depth_texture, view_prepass_textures, resolution_override, _, _)) =
+        view_query.get(view_entity)
+    else {
+        return;
+    };
+
+    run_deferred_prepass_system(
+        world,
+        view_entity,
+        camera,
+        extracted_view,
+        view_depth_texture,
+        view_prepass_textures,
+        resolution_override,
+        false,
+        &opaque_deferred_phases,
+        &alpha_mask_deferred_phases,
+        &mut ctx,
+        "early deferred prepass",
+    );
+}
+
+/// Render system for the late deferred G-buffer prepass.
+///
+/// This is the schedule-based replacement for [`LateDeferredGBufferPrepassNode`].
+/// It runs after occlusion culling against meshes that were visible last frame.
+/// If occlusion culling isn't in use, this is a no-op.
+pub fn late_deferred_prepass(
+    world: &World,
+    view: CurrentView,
+    view_query: Query<DeferredPrepassViewQuery>,
+    opaque_deferred_phases: Res<ViewBinnedRenderPhases<Opaque3dDeferred>>,
+    alpha_mask_deferred_phases: Res<ViewBinnedRenderPhases<AlphaMask3dDeferred>>,
+    mut ctx: RenderContextParam,
+) {
+    let view_entity = view.entity();
+    let Ok((
+        camera,
+        extracted_view,
+        view_depth_texture,
+        view_prepass_textures,
+        resolution_override,
+        occlusion_culling,
+        no_indirect_drawing,
+    )) = view_query.get(view_entity)
+    else {
+        return;
+    };
+
+    // We only need a late prepass if we have occlusion culling and indirect drawing
+    if !occlusion_culling || no_indirect_drawing {
+        return;
+    }
+
+    run_deferred_prepass_system(
+        world,
+        view_entity,
+        camera,
+        extracted_view,
+        view_depth_texture,
+        view_prepass_textures,
+        resolution_override,
+        true,
+        &opaque_deferred_phases,
+        &alpha_mask_deferred_phases,
+        &mut ctx,
+        "late deferred prepass",
+    );
+}
+
+/// Shared implementation for deferred prepass systems.
+#[allow(clippy::too_many_arguments)]
+fn run_deferred_prepass_system(
+    world: &World,
+    view_entity: Entity,
+    camera: &ExtractedCamera,
+    extracted_view: &ExtractedView,
+    view_depth_texture: &ViewDepthTexture,
+    view_prepass_textures: &ViewPrepassTextures,
+    resolution_override: Option<&MainPassResolutionOverride>,
+    is_late: bool,
+    opaque_deferred_phases: &ViewBinnedRenderPhases<Opaque3dDeferred>,
+    alpha_mask_deferred_phases: &ViewBinnedRenderPhases<AlphaMask3dDeferred>,
+    ctx: &mut RenderContextParam,
+    label: &'static str,
+) {
+    let (Some(opaque_deferred_phase), Some(alpha_mask_deferred_phase)) = (
+        opaque_deferred_phases.get(&extracted_view.retained_view_entity),
+        alpha_mask_deferred_phases.get(&extracted_view.retained_view_entity),
+    ) else {
+        return;
+    };
+
+    #[cfg(feature = "trace")]
+    let _deferred_span = info_span!("deferred_prepass").entered();
+
+    let mut color_attachments = vec![];
+    color_attachments.push(
+        view_prepass_textures
+            .normal
+            .as_ref()
+            .map(|normals_texture| normals_texture.get_attachment()),
+    );
+    color_attachments.push(
+        view_prepass_textures
+            .motion_vectors
+            .as_ref()
+            .map(|motion_vectors_texture| motion_vectors_texture.get_attachment()),
+    );
+
+    // If we clear the deferred texture with LoadOp::Clear(Default::default()) we get these errors:
+    // Chrome: GL_INVALID_OPERATION: No defined conversion between clear value and attachment format.
+    // Firefox: WebGL warning: clearBufferu?[fi]v: This attachment is of type FLOAT, but this function is of type UINT.
+    // Appears to be unsupported: https://registry.khronos.org/webgl/specs/latest/2.0/#3.7.9
+    // For webgl2 we fallback to manually clearing
+    #[cfg(all(feature = "webgl", target_arch = "wasm32", not(feature = "webgpu")))]
+    if !is_late {
+        if let Some(deferred_texture) = &view_prepass_textures.deferred {
+            ctx.command_encoder().clear_texture(
+                &deferred_texture.texture.texture,
+                &bevy_render::render_resource::ImageSubresourceRange::default(),
+            );
+        }
+    }
+
+    color_attachments.push(
+        view_prepass_textures
+            .deferred
+            .as_ref()
+            .map(|deferred_texture| {
+                if is_late {
+                    deferred_texture.get_attachment()
+                } else {
+                    #[cfg(all(feature = "webgl", target_arch = "wasm32", not(feature = "webgpu")))]
+                    {
+                        bevy_render::render_resource::RenderPassColorAttachment {
+                            view: &deferred_texture.texture.default_view,
+                            resolve_target: None,
+                            ops: bevy_render::render_resource::Operations {
+                                load: bevy_render::render_resource::LoadOp::Load,
+                                store: StoreOp::Store,
+                            },
+                            depth_slice: None,
+                        }
+                    }
+                    #[cfg(any(
+                        not(feature = "webgl"),
+                        not(target_arch = "wasm32"),
+                        feature = "webgpu"
+                    ))]
+                    deferred_texture.get_attachment()
+                }
+            }),
+    );
+
+    color_attachments.push(
+        view_prepass_textures
+            .deferred_lighting_pass_id
+            .as_ref()
+            .map(|deferred_lighting_pass_id| deferred_lighting_pass_id.get_attachment()),
+    );
+
+    // If all color attachments are none: clear the color attachment list so that no fragment shader is required
+    if color_attachments.iter().all(Option::is_none) {
+        color_attachments.clear();
+    }
+
+    let depth_stencil_attachment = Some(view_depth_texture.get_attachment(StoreOp::Store));
+
+    let mut render_pass = ctx.begin_tracked_render_pass(RenderPassDescriptor {
+        label: Some(label),
+        color_attachments: &color_attachments,
+        depth_stencil_attachment,
+        timestamp_writes: None,
+        occlusion_query_set: None,
+    });
+
+    if let Some(viewport) =
+        Viewport::from_viewport_and_override(camera.viewport.as_ref(), resolution_override)
+    {
+        render_pass.set_camera_viewport(&viewport);
+    }
+
+    // Opaque draws
+    if !opaque_deferred_phase.multidrawable_meshes.is_empty()
+        || !opaque_deferred_phase.batchable_meshes.is_empty()
+        || !opaque_deferred_phase.unbatchable_meshes.is_empty()
+    {
+        #[cfg(feature = "trace")]
+        let _opaque_prepass_span = info_span!("opaque_deferred_prepass").entered();
+        if let Err(err) = opaque_deferred_phase.render(&mut render_pass, world, view_entity) {
+            error!("Error encountered while rendering the opaque deferred phase {err:?}");
+        }
+    }
+
+    // Alpha masked draws
+    if !alpha_mask_deferred_phase.is_empty() {
+        #[cfg(feature = "trace")]
+        let _alpha_mask_deferred_span = info_span!("alpha_mask_deferred_prepass").entered();
+        if let Err(err) = alpha_mask_deferred_phase.render(&mut render_pass, world, view_entity) {
+            error!("Error encountered while rendering the alpha mask deferred phase {err:?}");
+        }
+    }
+
+    // Drop the render pass before the texture copy
+    drop(render_pass);
+
+    // After rendering to the view depth texture, copy it to the prepass depth texture
+    if let Some(prepass_depth_texture) = &view_prepass_textures.depth {
+        ctx.command_encoder().copy_texture_to_texture(
+            view_depth_texture.texture.as_image_copy(),
+            prepass_depth_texture.texture.texture.as_image_copy(),
+            view_prepass_textures.size,
+        );
+    }
+}