Key render phases off the main world view entity, not the render world view entity.

crates/bevy_core_pipeline/src/core_2d/main_opaque_pass_2d_node.rs

@@ -7,7 +7,7 @@ use bevy_render::{
     render_phase::{TrackedRenderPass, ViewBinnedRenderPhases},
     render_resource::{CommandEncoderDescriptor, RenderPassDescriptor, StoreOp},
     renderer::RenderContext,
-    view::{ViewDepthTexture, ViewTarget},
+    view::{ExtractedView, ViewDepthTexture, ViewTarget},
 };
 use tracing::error;
 #[cfg(feature = "trace")]
@@ -22,6 +22,7 @@ pub struct MainOpaquePass2dNode;
 impl ViewNode for MainOpaquePass2dNode {
     type ViewQuery = (
         &'static ExtractedCamera,
+        &'static ExtractedView,
         &'static ViewTarget,
         &'static ViewDepthTexture,
     );
@@ -30,7 +31,7 @@ impl ViewNode for MainOpaquePass2dNode {
         &self,
         graph: &mut RenderGraphContext,
         render_context: &mut RenderContext<'w>,
-        (camera, target, depth): QueryItem<'w, Self::ViewQuery>,
+        (camera, view, target, depth): QueryItem<'w, Self::ViewQuery>,
         world: &'w World,
     ) -> Result<(), NodeRunError> {
         let (Some(opaque_phases), Some(alpha_mask_phases)) = (
@@ -47,8 +48,8 @@ impl ViewNode for MainOpaquePass2dNode {
 
         let view_entity = graph.view_entity();
         let (Some(opaque_phase), Some(alpha_mask_phase)) = (
-            opaque_phases.get(&view_entity),
-            alpha_mask_phases.get(&view_entity),
+            opaque_phases.get(&view.retained_view_entity),
+            alpha_mask_phases.get(&view.retained_view_entity),
         ) else {
             return Ok(());
         };

crates/bevy_core_pipeline/src/core_2d/main_transparent_pass_2d_node.rs

@@ -7,7 +7,7 @@ use bevy_render::{
     render_phase::ViewSortedRenderPhases,
     render_resource::{RenderPassDescriptor, StoreOp},
     renderer::RenderContext,
-    view::{ViewDepthTexture, ViewTarget},
+    view::{ExtractedView, ViewDepthTexture, ViewTarget},
 };
 use tracing::error;
 #[cfg(feature = "trace")]
@@ -19,6 +19,7 @@ pub struct MainTransparentPass2dNode {}
 impl ViewNode for MainTransparentPass2dNode {
     type ViewQuery = (
         &'static ExtractedCamera,
+        &'static ExtractedView,
         &'static ViewTarget,
         &'static ViewDepthTexture,
     );
@@ -27,7 +28,7 @@ impl ViewNode for MainTransparentPass2dNode {
         &self,
         graph: &mut RenderGraphContext,
         render_context: &mut RenderContext<'w>,
-        (camera, target, depth): bevy_ecs::query::QueryItem<'w, Self::ViewQuery>,
+        (camera, view, target, depth): bevy_ecs::query::QueryItem<'w, Self::ViewQuery>,
         world: &'w World,
     ) -> Result<(), NodeRunError> {
         let Some(transparent_phases) =
@@ -37,7 +38,7 @@ impl ViewNode for MainTransparentPass2dNode {
         };
 
         let view_entity = graph.view_entity();
-        let Some(transparent_phase) = transparent_phases.get(&view_entity) else {
+        let Some(transparent_phase) = transparent_phases.get(&view.retained_view_entity) else {
             return Ok(());
         };
 

crates/bevy_core_pipeline/src/core_2d/mod.rs

@@ -33,15 +33,18 @@ pub mod graph {
 use core::ops::Range;
 
 use bevy_asset::UntypedAssetId;
-use bevy_render::batching::gpu_preprocessing::GpuPreprocessingMode;
-use bevy_utils::HashMap;
+use bevy_render::{
+    batching::gpu_preprocessing::GpuPreprocessingMode,
+    view::{ExtractedView, RetainedViewEntity},
+};
+use bevy_utils::{HashMap, HashSet};
 pub use camera_2d::*;
 pub use main_opaque_pass_2d_node::*;
 pub use main_transparent_pass_2d_node::*;
 
 use crate::{tonemapping::TonemappingNode, upscaling::UpscalingNode};
 use bevy_app::{App, Plugin};
-use bevy_ecs::{entity::EntityHashSet, prelude::*};
+use bevy_ecs::prelude::*;
 use bevy_math::FloatOrd;
 use bevy_render::{
     camera::{Camera, ExtractedCamera},
@@ -57,7 +60,7 @@ use bevy_render::{
         TextureFormat, TextureUsages,
     },
     renderer::RenderDevice,
-    sync_world::{MainEntity, RenderEntity},
+    sync_world::MainEntity,
     texture::TextureCache,
     view::{Msaa, ViewDepthTexture},
     Extract, ExtractSchedule, Render, RenderApp, RenderSet,
@@ -397,20 +400,24 @@ pub fn extract_core_2d_camera_phases(
     mut transparent_2d_phases: ResMut<ViewSortedRenderPhases<Transparent2d>>,
     mut opaque_2d_phases: ResMut<ViewBinnedRenderPhases<Opaque2d>>,
     mut alpha_mask_2d_phases: ResMut<ViewBinnedRenderPhases<AlphaMask2d>>,
-    cameras_2d: Extract<Query<(RenderEntity, &Camera), With<Camera2d>>>,
-    mut live_entities: Local<EntityHashSet>,
+    cameras_2d: Extract<Query<(Entity, &Camera), With<Camera2d>>>,
+    mut live_entities: Local<HashSet<RetainedViewEntity>>,
 ) {
     live_entities.clear();
 
-    for (entity, camera) in &cameras_2d {
+    for (main_entity, camera) in &cameras_2d {
         if !camera.is_active {
             continue;
         }
-        transparent_2d_phases.insert_or_clear(entity);
-        opaque_2d_phases.insert_or_clear(entity, GpuPreprocessingMode::None);
-        alpha_mask_2d_phases.insert_or_clear(entity, GpuPreprocessingMode::None);
 
-        live_entities.insert(entity);
+        // This is the main 2D camera, so we use the first subview index (0).
+        let retained_view_entity = RetainedViewEntity::new(main_entity.into(), 0);
+
+        transparent_2d_phases.insert_or_clear(retained_view_entity);
+        opaque_2d_phases.insert_or_clear(retained_view_entity, GpuPreprocessingMode::None);
+        alpha_mask_2d_phases.insert_or_clear(retained_view_entity, GpuPreprocessingMode::None);
+
+        live_entities.insert(retained_view_entity);
     }
 
     // Clear out all dead views.
@@ -425,11 +432,13 @@ pub fn prepare_core_2d_depth_textures(
     render_device: Res<RenderDevice>,
     transparent_2d_phases: Res<ViewSortedRenderPhases<Transparent2d>>,
     opaque_2d_phases: Res<ViewBinnedRenderPhases<Opaque2d>>,
-    views_2d: Query<(Entity, &ExtractedCamera, &Msaa), (With<Camera2d>,)>,
+    views_2d: Query<(Entity, &ExtractedCamera, &ExtractedView, &Msaa), (With<Camera2d>,)>,
 ) {
     let mut textures = <HashMap<_, _>>::default();
-    for (view, camera, msaa) in &views_2d {
-        if !opaque_2d_phases.contains_key(&view) || !transparent_2d_phases.contains_key(&view) {
+    for (view, camera, extracted_view, msaa) in &views_2d {
+        if !opaque_2d_phases.contains_key(&extracted_view.retained_view_entity)
+            || !transparent_2d_phases.contains_key(&extracted_view.retained_view_entity)
+        {
             continue;
         };
 

crates/bevy_core_pipeline/src/core_3d/main_opaque_pass_3d_node.rs

@@ -2,15 +2,15 @@ use crate::{
     core_3d::Opaque3d,
     skybox::{SkyboxBindGroup, SkyboxPipelineId},
 };
-use bevy_ecs::{entity::Entity, prelude::World, query::QueryItem};
+use bevy_ecs::{prelude::World, query::QueryItem};
 use bevy_render::{
     camera::ExtractedCamera,
     diagnostic::RecordDiagnostics,
     render_graph::{NodeRunError, RenderGraphContext, ViewNode},
     render_phase::{TrackedRenderPass, ViewBinnedRenderPhases},
     render_resource::{CommandEncoderDescriptor, PipelineCache, RenderPassDescriptor, StoreOp},
     renderer::RenderContext,
-    view::{ViewDepthTexture, ViewTarget, ViewUniformOffset},
+    view::{ExtractedView, ViewDepthTexture, ViewTarget, ViewUniformOffset},
 };
 use tracing::error;
 #[cfg(feature = "trace")]
@@ -24,8 +24,8 @@ use super::AlphaMask3d;
 pub struct MainOpaquePass3dNode;
 impl ViewNode for MainOpaquePass3dNode {
     type ViewQuery = (
-        Entity,
         &'static ExtractedCamera,
+        &'static ExtractedView,
         &'static ViewTarget,
         &'static ViewDepthTexture,
         Option<&'static SkyboxPipelineId>,
@@ -38,8 +38,8 @@ impl ViewNode for MainOpaquePass3dNode {
         graph: &mut RenderGraphContext,
         render_context: &mut RenderContext<'w>,
         (
-            view,
             camera,
+            extracted_view,
             target,
             depth,
             skybox_pipeline,
@@ -55,9 +55,10 @@ impl ViewNode for MainOpaquePass3dNode {
             return Ok(());
         };
 
-        let (Some(opaque_phase), Some(alpha_mask_phase)) =
-            (opaque_phases.get(&view), alpha_mask_phases.get(&view))
-        else {
+        let (Some(opaque_phase), Some(alpha_mask_phase)) = (
+            opaque_phases.get(&extracted_view.retained_view_entity),
+            alpha_mask_phases.get(&extracted_view.retained_view_entity),
+        ) else {
             return Ok(());
         };
 

crates/bevy_core_pipeline/src/core_3d/main_transmissive_pass_3d_node.rs

@@ -7,7 +7,7 @@ use bevy_render::{
     render_phase::ViewSortedRenderPhases,
     render_resource::{Extent3d, RenderPassDescriptor, StoreOp},
     renderer::RenderContext,
-    view::{ViewDepthTexture, ViewTarget},
+    view::{ExtractedView, ViewDepthTexture, ViewTarget},
 };
 use core::ops::Range;
 use tracing::error;
@@ -22,6 +22,7 @@ pub struct MainTransmissivePass3dNode;
 impl ViewNode for MainTransmissivePass3dNode {
     type ViewQuery = (
         &'static ExtractedCamera,
+        &'static ExtractedView,
         &'static Camera3d,
         &'static ViewTarget,
         Option<&'static ViewTransmissionTexture>,
@@ -32,7 +33,7 @@ impl ViewNode for MainTransmissivePass3dNode {
         &self,
         graph: &mut RenderGraphContext,
         render_context: &mut RenderContext,
-        (camera, camera_3d, target, transmission, depth): QueryItem<Self::ViewQuery>,
+        (camera, view, camera_3d, target, transmission, depth): QueryItem<Self::ViewQuery>,
         world: &World,
     ) -> Result<(), NodeRunError> {
         let view_entity = graph.view_entity();
@@ -43,7 +44,7 @@ impl ViewNode for MainTransmissivePass3dNode {
             return Ok(());
         };
 
-        let Some(transmissive_phase) = transmissive_phases.get(&view_entity) else {
+        let Some(transmissive_phase) = transmissive_phases.get(&view.retained_view_entity) else {
             return Ok(());
         };
 

crates/bevy_core_pipeline/src/core_3d/main_transparent_pass_3d_node.rs

@@ -7,7 +7,7 @@ use bevy_render::{
     render_phase::ViewSortedRenderPhases,
     render_resource::{RenderPassDescriptor, StoreOp},
     renderer::RenderContext,
-    view::{ViewDepthTexture, ViewTarget},
+    view::{ExtractedView, ViewDepthTexture, ViewTarget},
 };
 use tracing::error;
 #[cfg(feature = "trace")]
@@ -21,14 +21,15 @@ pub struct MainTransparentPass3dNode;
 impl ViewNode for MainTransparentPass3dNode {
     type ViewQuery = (
         &'static ExtractedCamera,
+        &'static ExtractedView,
         &'static ViewTarget,
         &'static ViewDepthTexture,
     );
     fn run(
         &self,
         graph: &mut RenderGraphContext,
         render_context: &mut RenderContext,
-        (camera, target, depth): QueryItem<Self::ViewQuery>,
+        (camera, view, target, depth): QueryItem<Self::ViewQuery>,
         world: &World,
     ) -> Result<(), NodeRunError> {
         let view_entity = graph.view_entity();
@@ -39,7 +40,7 @@ impl ViewNode for MainTransparentPass3dNode {
             return Ok(());
         };
 
-        let Some(transparent_phase) = transparent_phases.get(&view_entity) else {
+        let Some(transparent_phase) = transparent_phases.get(&view.retained_view_entity) else {
             return Ok(());
         };