Render point and spot light shadow maps only once, regardless of the number of cameras. (#23713)

The intention has long been to render shadow maps for point and spot
lights only once, regardless of the number of views. This is reflected
in the fact that `RetainedViewEntity::auxiliary_entity` is
`Entity::PLACEHOLDER` for them. Unfortunately, this is currently
inconsistently implemented, and a separate `ExtractedView` is presently
spawned and rendered to for every point and spot light shadow map. The
behavior of these views is inconsistent because they violate the
invariant that there must only be one render-world view per
`RetainedViewEntity`.

This patch changes Bevy's behavior to spawn only one `ExtractedView` for
point and spot lights. This required some significant rearchitecting of
the render schedule because the render schedule is currently driven off
cameras. Driving the rendering off cameras is incorrect for point and
spot light shadow maps, which aren't associated with any camera.

This PR fixes the regression on the `render_layers` test in `testbed_3d`
in PR #23481, in that it renders the way it rendered before that PR.
Note, however, that the rendering isn't what may have been intended: the
shadows don't match the visible objects. That's because the shadows come
from point lights, which aren't associated with cameras, and therefore
shadows are rendered using the default set of `RenderLayers`. A future
patch may want to add flags to cameras that specify that they should
have their own point light and spot light shadow maps that inherit the
render layer (and HLOD) behavior of their associated cameras. As this
patch is fairly large, though, and because my immediate goal is to fix
the regression in #23481, I think those flags are best implemented in a
follow-up.

<img width="2564" height="1500" alt="Screenshot 2026-04-07 215221"
src="https://github.com/user-attachments/assets/2b37f35c-84e7-4473-9962-968a8cbd7619"
/>

Author: pcwalton

crates/bevy_core_pipeline/src/schedule.rs

@@ -9,13 +9,16 @@
 //! The [`camera_driver`] system is responsible for iterating over all cameras in the world
 //! and executing their associated schedules. In this way, the schedule for each camera is a
 //! sub-schedule or sub-graph of the root render graph schedule.
+use core::fmt::{self, Display, Formatter};
+
 use bevy_camera::{ClearColor, NormalizedRenderTarget};
 use bevy_ecs::{
     entity::EntityHashSet,
     prelude::*,
-    schedule::{IntoScheduleConfigs, Schedule, ScheduleLabel, SystemSet},
+    schedule::{InternedScheduleLabel, IntoScheduleConfigs, Schedule, ScheduleLabel, SystemSet},
 };
 use bevy_log::info_span;
+use bevy_reflect::Reflect;
 use bevy_render::{
     camera::{ExtractedCamera, SortedCameras},
     render_resource::{
@@ -108,6 +111,16 @@ impl Core2d {
 #[derive(Resource)]
 struct CameraWindows(EntityHashSet);
 
+/// A render-world marker component for a view that corresponds to neither a
+/// camera nor a camera-associated shadow map.
+///
+/// This is used for point light and spot light shadow maps, since these aren't
+/// associated with views.
+#[derive(Clone, Copy, Component, Debug, Reflect)]
+#[reflect(Clone, Component)]
+#[reflect(from_reflect = false)]
+pub struct RootNonCameraView(#[reflect(ignore)] pub InternedScheduleLabel);
+
 /// The default entry point for camera driven rendering added to the root [`bevy_render::renderer::RenderGraph`]
 /// schedule. This system iterates over all cameras in the world, executing their associated
 /// rendering schedules defined by the [`bevy_render::camera::CameraRenderGraph`] component.
@@ -117,49 +130,71 @@ struct CameraWindows(EntityHashSet);
 /// operations (e.g. one-off compute passes) before or after this system in the root render
 /// graph schedule.
 pub fn camera_driver(world: &mut World) {
-    let sorted_cameras: Vec<_> = {
+    // Gather up all cameras and auxiliary views not associated with a camera.
+    let root_views: Vec<_> = {
+        let mut auxiliary_views = world.query_filtered::<Entity, With<RootNonCameraView>>();
         let sorted = world.resource::<SortedCameras>();
-        sorted.0.iter().map(|c| (c.entity, c.order)).collect()
+        auxiliary_views
+            .iter(world)
+            .map(RootView::Auxiliary)
+            .chain(sorted.0.iter().map(|c| RootView::Camera {
+                entity: c.entity,
+                order: c.order,
+            }))
+            .collect()
     };
 
     let mut camera_windows = EntityHashSet::default();
 
-    for camera in sorted_cameras {
-        #[cfg(feature = "trace")]
-        let (camera_entity, order) = camera;
-        #[cfg(not(feature = "trace"))]
-        let (camera_entity, _) = camera;
-        let Some(camera) = world.get::<ExtractedCamera>(camera_entity) else {
-            continue;
-        };
+    for root_view in root_views {
+        let mut run_schedule = true;
+        let (schedule, view_entity);
+
+        match root_view {
+            RootView::Camera {
+                entity: camera_entity,
+                ..
+            } => {
+                let Some(camera) = world.get::<ExtractedCamera>(camera_entity) else {
+                    continue;
+                };
+
+                schedule = camera.schedule;
+                let target = camera.target.clone();
+
+                if let Some(NormalizedRenderTarget::Window(window_ref)) = &target {
+                    let window_entity = window_ref.entity();
+                    let windows = world.resource::<ExtractedWindows>();
+                    if windows
+                        .windows
+                        .get(&window_entity)
+                        .is_some_and(|w| w.physical_width > 0 && w.physical_height > 0)
+                    {
+                        camera_windows.insert(window_entity);
+                    } else {
+                        run_schedule = false;
+                    }
+                }
+
+                view_entity = camera_entity;
+            }
 
-        let schedule = camera.schedule;
-        let target = camera.target.clone();
+            RootView::Auxiliary(auxiliary_view_entity) => {
+                let Some(root_view) = world.get::<RootNonCameraView>(auxiliary_view_entity) else {
+                    continue;
+                };
 
-        let mut run_schedule = true;
-        if let Some(NormalizedRenderTarget::Window(window_ref)) = &target {
-            let window_entity = window_ref.entity();
-            let windows = world.resource::<ExtractedWindows>();
-            if windows
-                .windows
-                .get(&window_entity)
-                .is_some_and(|w| w.physical_width > 0 && w.physical_height > 0)
-            {
-                camera_windows.insert(window_entity);
-            } else {
-                run_schedule = false;
+                view_entity = auxiliary_view_entity;
+                schedule = root_view.0;
             }
         }
 
         if run_schedule {
-            world.insert_resource(CurrentView(camera_entity));
+            world.insert_resource(CurrentView(view_entity));
 
             #[cfg(feature = "trace")]
-            let _span = bevy_log::info_span!(
-                "camera_schedule",
-                camera = format!("Camera {} ({:?})", order, camera_entity)
-            )
-            .entered();
+            let _span =
+                bevy_log::info_span!("camera_schedule", camera = root_view.to_string()).entered();
 
             world.run_schedule(schedule);
         }
@@ -169,6 +204,26 @@ pub fn camera_driver(world: &mut World) {
     world.insert_resource(CameraWindows(camera_windows));
 }
 
+/// A view not associated with any other camera.
+enum RootView {
+    /// A camera.
+    Camera { entity: Entity, order: isize },
+
+    /// An auxiliary view not associated with a camera.
+    ///
+    /// This is currently used for point and spot light shadow maps.
+    Auxiliary(Entity),
+}
+
+impl Display for RootView {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        match *self {
+            RootView::Camera { entity, order } => write!(f, "Camera {} ({:?})", order, entity),
+            RootView::Auxiliary(entity) => write!(f, "Auxiliary View {:?}", entity),
+        }
+    }
+}
+
 pub(crate) fn submit_pending_command_buffers(world: &mut World) {
     let mut pending = world.resource_mut::<PendingCommandBuffers>();
     let buffer_count = pending.len();

crates/bevy_pbr/src/lib.rs

@@ -423,11 +423,19 @@ impl Plugin for PbrPlugin {
         render_app.add_systems(
             Core3d,
             (
-                shadow_pass::<EARLY_SHADOW_PASS>
+                per_view_shadow_pass::<EARLY_SHADOW_PASS>
                     .after(early_prepass_build_indirect_parameters)
                     .before(early_downsample_depth)
-                    .before(shadow_pass::<LATE_SHADOW_PASS>),
-                shadow_pass::<LATE_SHADOW_PASS>
+                    .before(per_view_shadow_pass::<LATE_SHADOW_PASS>),
+                per_view_shadow_pass::<LATE_SHADOW_PASS>
+                    .after(late_prepass_build_indirect_parameters)
+                    .before(main_build_indirect_parameters)
+                    .before(Core3dSystems::MainPass),
+                shared_shadow_pass::<EARLY_SHADOW_PASS>
+                    .after(early_prepass_build_indirect_parameters)
+                    .before(early_downsample_depth)
+                    .before(per_view_shadow_pass::<LATE_SHADOW_PASS>),
+                shared_shadow_pass::<LATE_SHADOW_PASS>
                     .after(late_prepass_build_indirect_parameters)
                     .before(main_build_indirect_parameters)
                     .before(Core3dSystems::MainPass),

crates/bevy_pbr/src/material.rs

@@ -995,12 +995,13 @@ pub(crate) fn specialize_material_meshes(
                     continue;
                 }
 
+                // Check for material instance, mesh, and material. If any of
+                // these fail, it's probably because the relevant asset hasn't
+                // loaded yet. In that case, add the entity to the list of
+                // pending mesh materials and bail.
                 let Some(material_instance) =
                     render_material_instances.instances.get(visible_entity)
                 else {
-                    // We couldn't fetch the material instance, probably because
-                    // the material hasn't been loaded yet. Add the entity to
-                    // the list of pending mesh materials and bail.
                     view_pending_mesh_material_queues
                         .current_frame
                         .insert((*render_entity, *visible_entity));
@@ -1009,9 +1010,6 @@ pub(crate) fn specialize_material_meshes(
                 let Some(mesh_instance) =
                     render_mesh_instances.render_mesh_queue_data(*visible_entity)
                 else {
-                    // We couldn't fetch the mesh, probably because it hasn't
-                    // been loaded yet. Add the entity to the list of pending
-                    // mesh materials and bail.
                     view_pending_mesh_material_queues
                         .current_frame
                         .insert((*render_entity, *visible_entity));
@@ -1021,9 +1019,6 @@ pub(crate) fn specialize_material_meshes(
                     continue;
                 };
                 let Some(material) = render_materials.get(material_instance.asset_id) else {
-                    // We couldn't fetch the material, probably because the
-                    // material hasn't been loaded yet. Add the entity to the
-                    // list of pending mesh materials and bail.
                     view_pending_mesh_material_queues
                         .current_frame
                         .insert((*render_entity, *visible_entity));
@@ -1188,30 +1183,25 @@ pub fn queue_material_meshes(
                 continue;
             };
 
+            // Check for material instance, mesh, and material. If any of these
+            // fail, it's probably because the relevant asset hasn't loaded yet.
+            // In that case, add the entity to the list of pending mesh
+            // materials and bail.
             let Some(material_instance) = render_material_instances.instances.get(visible_entity)
             else {
-                // We couldn't fetch the material, probably because the material
-                // hasn't been loaded yet. Add the entity to the list of pending
-                // mesh materials and bail.
                 view_pending_mesh_material_queues
                     .current_frame
                     .insert((*render_entity, *visible_entity));
                 continue;
             };
             let Some(mesh_instance) = render_mesh_instances.render_mesh_queue_data(*visible_entity)
             else {
-                // We couldn't fetch the mesh, probably because it hasn't been
-                // loaded yet. Add the entity to the list of pending mesh
-                // materials and bail.
                 view_pending_mesh_material_queues
                     .current_frame
                     .insert((*render_entity, *visible_entity));
                 continue;
             };
             let Some(material) = render_materials.get(material_instance.asset_id) else {
-                // We couldn't fetch the material, probably because the material
-                // hasn't been loaded yet. Add the entity to the list of pending
-                // mesh materials and bail.
                 view_pending_mesh_material_queues
                     .current_frame
                     .insert((*render_entity, *visible_entity));

crates/bevy_pbr/src/meshlet/mod.rs

@@ -43,7 +43,7 @@ use self::{
     },
     visibility_buffer_raster_node::meshlet_visibility_buffer_raster,
 };
-use crate::render::{shadow_pass, EARLY_SHADOW_PASS};
+use crate::render::{per_view_shadow_pass, EARLY_SHADOW_PASS};
 use crate::{meshlet::meshlet_mesh_manager::init_meshlet_mesh_manager, PreviousGlobalTransform};
 use bevy_app::{App, Plugin};
 use bevy_asset::{embedded_asset, AssetApp, AssetId, Handle};
@@ -198,9 +198,10 @@ impl Plugin for MeshletPlugin {
             .add_systems(
                 Core3d,
                 (
-                    meshlet_visibility_buffer_raster.before(shadow_pass::<EARLY_SHADOW_PASS>),
+                    meshlet_visibility_buffer_raster
+                        .before(per_view_shadow_pass::<EARLY_SHADOW_PASS>),
                     meshlet_prepass
-                        .after(shadow_pass::<EARLY_SHADOW_PASS>)
+                        .after(per_view_shadow_pass::<EARLY_SHADOW_PASS>)
                         .in_set(Core3dSystems::Prepass),
                     meshlet_deferred_gbuffer_prepass
                         .after(meshlet_prepass)

crates/bevy_pbr/src/meshlet/visibility_buffer_raster_node.rs

@@ -2,7 +2,7 @@ use super::{
     pipelines::MeshletPipelines,
     resource_manager::{MeshletViewBindGroups, MeshletViewResources, ResourceManager},
 };
-use crate::{LightEntity, ShadowView, ViewLightEntities};
+use crate::{LightEntity, ShadowView};
 use bevy_color::LinearRgba;
 use bevy_core_pipeline::prepass::PreviousViewUniformOffset;
 use bevy_ecs::prelude::*;
@@ -27,7 +27,6 @@ pub fn meshlet_visibility_buffer_raster(
         &PreviousViewUniformOffset,
         &MeshletViewBindGroups,
         &MeshletViewResources,
-        &ViewLightEntities,
     )>,
     view_light_query: Query<(
         &ShadowView,
@@ -47,7 +46,6 @@ pub fn meshlet_visibility_buffer_raster(
         previous_view_offset,
         meshlet_view_bind_groups,
         meshlet_view_resources,
-        lights,
     ) = view.into_inner();
 
     let Some((
@@ -194,19 +192,15 @@ pub fn meshlet_visibility_buffer_raster(
     ctx.command_encoder().pop_debug_group();
     time_span.end(ctx.command_encoder());
 
-    for light_entity in &lights.lights {
-        let Ok((
-            shadow_view,
-            light_type,
-            view_offset,
-            previous_view_offset,
-            meshlet_view_bind_groups,
-            meshlet_view_resources,
-        )) = view_light_query.get(*light_entity)
-        else {
-            continue;
-        };
-
+    for (
+        shadow_view,
+        light_type,
+        view_offset,
+        previous_view_offset,
+        meshlet_view_bind_groups,
+        meshlet_view_resources,
+    ) in view_light_query.iter()
+    {
         let shadow_visibility_buffer_hardware_raster_pipeline =
             if let LightEntity::Directional { .. } = light_type {
                 visibility_buffer_hardware_raster_shadow_view_unclipped_pipeline