Make render phases render world resources instead of components.

crates/bevy_core_pipeline/src/core_2d/main_pass_2d_node.rs

@@ -4,7 +4,7 @@ use bevy_render::{
     camera::ExtractedCamera,
     diagnostic::RecordDiagnostics,
     render_graph::{Node, NodeRunError, RenderGraphContext},
-    render_phase::SortedRenderPhase,
+    render_phase::ViewSortedRenderPhases,
     render_resource::RenderPassDescriptor,
     renderer::RenderContext,
     view::{ExtractedView, ViewTarget},
@@ -13,14 +13,7 @@ use bevy_render::{
 use bevy_utils::tracing::info_span;
 
 pub struct MainPass2dNode {
-    query: QueryState<
-        (
-            &'static ExtractedCamera,
-            &'static SortedRenderPhase<Transparent2d>,
-            &'static ViewTarget,
-        ),
-        With<ExtractedView>,
-    >,
+    query: QueryState<(&'static ExtractedCamera, &'static ViewTarget), With<ExtractedView>>,
 }
 
 impl FromWorld for MainPass2dNode {
@@ -43,12 +36,21 @@ impl Node for MainPass2dNode {
         world: &World,
     ) -> Result<(), NodeRunError> {
         let view_entity = graph.view_entity();
-        let Ok((camera, transparent_phase, target)) = self.query.get_manual(world, view_entity)
-        else {
+        let Ok((camera, target)) = self.query.get_manual(world, view_entity) else {
             // no target
             return Ok(());
         };
 
+        let Some(transparent_phases) =
+            world.get_resource::<ViewSortedRenderPhases<Transparent2d>>()
+        else {
+            return Ok(());
+        };
+
+        let Some(transparent_phase) = transparent_phases.get(&view_entity) else {
+            return Ok(());
+        };
+
         {
             #[cfg(feature = "trace")]
             let _main_pass_2d = info_span!("main_pass_2d").entered();

crates/bevy_core_pipeline/src/core_2d/mod.rs

@@ -38,7 +38,7 @@ use bevy_render::{
     render_graph::{EmptyNode, RenderGraphApp, ViewNodeRunner},
     render_phase::{
         sort_phase_system, CachedRenderPipelinePhaseItem, DrawFunctionId, DrawFunctions, PhaseItem,
-        PhaseItemExtraIndex, SortedPhaseItem, SortedRenderPhase,
+        PhaseItemExtraIndex, SortedPhaseItem, ViewSortedRenderPhases,
     },
     render_resource::CachedRenderPipelineId,
     Extract, ExtractSchedule, Render, RenderApp, RenderSet,
@@ -60,6 +60,7 @@ impl Plugin for Core2dPlugin {
         };
         render_app
             .init_resource::<DrawFunctions<Transparent2d>>()
+            .init_resource::<ViewSortedRenderPhases<Transparent2d>>()
             .add_systems(ExtractSchedule, extract_core_2d_camera_phases)
             .add_systems(
                 Render,
@@ -149,13 +150,15 @@ impl CachedRenderPipelinePhaseItem for Transparent2d {
 
 pub fn extract_core_2d_camera_phases(
     mut commands: Commands,
+    mut transparent_2d_phases: ResMut<ViewSortedRenderPhases<Transparent2d>>,
     cameras_2d: Extract<Query<(Entity, &Camera), With<Camera2d>>>,
 ) {
     for (entity, camera) in &cameras_2d {
-        if camera.is_active {
-            commands
-                .get_or_spawn(entity)
-                .insert(SortedRenderPhase::<Transparent2d>::default());
+        if !camera.is_active {
+            continue;
         }
+
+        commands.get_or_spawn(entity);
+        transparent_2d_phases.insert_or_clear(entity);
     }
 }

crates/bevy_core_pipeline/src/core_3d/main_opaque_pass_3d_node.rs

@@ -2,12 +2,12 @@ use crate::{
     core_3d::Opaque3d,
     skybox::{SkyboxBindGroup, SkyboxPipelineId},
 };
-use bevy_ecs::{prelude::World, query::QueryItem};
+use bevy_ecs::{entity::Entity, prelude::World, query::QueryItem};
 use bevy_render::{
     camera::ExtractedCamera,
     diagnostic::RecordDiagnostics,
     render_graph::{NodeRunError, RenderGraphContext, ViewNode},
-    render_phase::{BinnedRenderPhase, TrackedRenderPass},
+    render_phase::{TrackedRenderPass, ViewBinnedRenderPhases},
     render_resource::{CommandEncoderDescriptor, PipelineCache, RenderPassDescriptor, StoreOp},
     renderer::RenderContext,
     view::{ViewDepthTexture, ViewTarget, ViewUniformOffset},
@@ -24,9 +24,8 @@ use super::AlphaMask3d;
 pub struct MainOpaquePass3dNode;
 impl ViewNode for MainOpaquePass3dNode {
     type ViewQuery = (
+        Entity,
         &'static ExtractedCamera,
-        &'static BinnedRenderPhase<Opaque3d>,
-        &'static BinnedRenderPhase<AlphaMask3d>,
         &'static ViewTarget,
         &'static ViewDepthTexture,
         Option<&'static SkyboxPipelineId>,
@@ -39,9 +38,8 @@ impl ViewNode for MainOpaquePass3dNode {
         graph: &mut RenderGraphContext,
         render_context: &mut RenderContext<'w>,
         (
+            view,
             camera,
-            opaque_phase,
-            alpha_mask_phase,
             target,
             depth,
             skybox_pipeline,
@@ -50,6 +48,19 @@ impl ViewNode for MainOpaquePass3dNode {
         ): QueryItem<'w, Self::ViewQuery>,
         world: &'w World,
     ) -> Result<(), NodeRunError> {
+        let (Some(opaque_phases), Some(alpha_mask_phases)) = (
+            world.get_resource::<ViewBinnedRenderPhases<Opaque3d>>(),
+            world.get_resource::<ViewBinnedRenderPhases<AlphaMask3d>>(),
+        ) else {
+            return Ok(());
+        };
+
+        let (Some(opaque_phase), Some(alpha_mask_phase)) =
+            (opaque_phases.get(&view), alpha_mask_phases.get(&view))
+        else {
+            return Ok(());
+        };
+
         let diagnostics = render_context.diagnostic_recorder();
 
         let color_attachments = [Some(target.get_color_attachment())];

crates/bevy_core_pipeline/src/core_3d/main_transmissive_pass_3d_node.rs

@@ -4,7 +4,7 @@ use bevy_ecs::{prelude::*, query::QueryItem};
 use bevy_render::{
     camera::ExtractedCamera,
     render_graph::{NodeRunError, RenderGraphContext, ViewNode},
-    render_phase::SortedRenderPhase,
+    render_phase::ViewSortedRenderPhases,
     render_resource::{Extent3d, RenderPassDescriptor, StoreOp},
     renderer::RenderContext,
     view::{ViewDepthTexture, ViewTarget},
@@ -22,7 +22,6 @@ impl ViewNode for MainTransmissivePass3dNode {
     type ViewQuery = (
         &'static ExtractedCamera,
         &'static Camera3d,
-        &'static SortedRenderPhase<Transmissive3d>,
         &'static ViewTarget,
         Option<&'static ViewTransmissionTexture>,
         &'static ViewDepthTexture,
@@ -32,13 +31,21 @@ impl ViewNode for MainTransmissivePass3dNode {
         &self,
         graph: &mut RenderGraphContext,
         render_context: &mut RenderContext,
-        (camera, camera_3d, transmissive_phase, target, transmission, depth): QueryItem<
-            Self::ViewQuery,
-        >,
+        (camera, camera_3d, target, transmission, depth): QueryItem<Self::ViewQuery>,
         world: &World,
     ) -> Result<(), NodeRunError> {
         let view_entity = graph.view_entity();
 
+        let Some(transmissive_phases) =
+            world.get_resource::<ViewSortedRenderPhases<Transmissive3d>>()
+        else {
+            return Ok(());
+        };
+
+        let Some(transmissive_phase) = transmissive_phases.get(&view_entity) else {
+            return Ok(());
+        };
+
         let physical_target_size = camera.physical_target_size.unwrap();
 
         let render_pass_descriptor = RenderPassDescriptor {

crates/bevy_core_pipeline/src/core_3d/main_transparent_pass_3d_node.rs

@@ -4,7 +4,7 @@ use bevy_render::{
     camera::ExtractedCamera,
     diagnostic::RecordDiagnostics,
     render_graph::{NodeRunError, RenderGraphContext, ViewNode},
-    render_phase::SortedRenderPhase,
+    render_phase::ViewSortedRenderPhases,
     render_resource::{RenderPassDescriptor, StoreOp},
     renderer::RenderContext,
     view::{ViewDepthTexture, ViewTarget},
@@ -20,19 +20,28 @@ pub struct MainTransparentPass3dNode;
 impl ViewNode for MainTransparentPass3dNode {
     type ViewQuery = (
         &'static ExtractedCamera,
-        &'static SortedRenderPhase<Transparent3d>,
         &'static ViewTarget,
         &'static ViewDepthTexture,
     );
     fn run(
         &self,
         graph: &mut RenderGraphContext,
         render_context: &mut RenderContext,
-        (camera, transparent_phase, target, depth): QueryItem<Self::ViewQuery>,
+        (camera, target, depth): QueryItem<Self::ViewQuery>,
         world: &World,
     ) -> Result<(), NodeRunError> {
         let view_entity = graph.view_entity();
 
+        let Some(transparent_phases) =
+            world.get_resource::<ViewSortedRenderPhases<Transparent3d>>()
+        else {
+            return Ok(());
+        };
+
+        let Some(transparent_phase) = transparent_phases.get(&view_entity) else {
+            return Ok(());
+        };
+
         if !transparent_phase.items.is_empty() {
             // Run the transparent pass, sorted back-to-front
             // NOTE: Scoped to drop the mutable borrow of render_context