prepare bevy_light for split (#19965)

# Objective

- prepare bevy_light for split

## Solution

- extract cascade module (this is not strictly necessary for bevy_light)
- clean up imports to be less globby and tangled
- move light specific stuff into light modules
- move light system and type init from pbr into new LightPlugin

## Testing

- 3d_scene, lighting

NOTE TO REVIEWERS: it may help to review commits independently.

Author: atlv24

crates/bevy_pbr/src/lib.rs

@@ -122,6 +122,7 @@ pub mod graph {
     }
 }
 
+pub use crate::cascade::{CascadeShadowConfig, CascadeShadowConfigBuilder, Cascades};
 use crate::{deferred::DeferredPbrLightingPlugin, graph::NodePbr};
 use bevy_app::prelude::*;
 use bevy_asset::{AssetApp, AssetPath, Assets, Handle};
@@ -130,19 +131,16 @@ use bevy_ecs::prelude::*;
 use bevy_image::Image;
 use bevy_render::{
     alpha::AlphaMode,
-    camera::{sort_cameras, CameraUpdateSystems, Projection},
+    camera::{sort_cameras, Projection},
     extract_component::ExtractComponentPlugin,
     extract_resource::ExtractResourcePlugin,
     load_shader_library,
     render_graph::RenderGraph,
     render_resource::ShaderRef,
     sync_component::SyncComponentPlugin,
-    view::VisibilitySystems,
     ExtractSchedule, Render, RenderApp, RenderDebugFlags, RenderSystems,
 };
 
-use bevy_transform::TransformSystems;
-
 use std::path::PathBuf;
 
 fn shader_ref(path: PathBuf) -> ShaderRef {
@@ -205,22 +203,8 @@ impl Plugin for PbrPlugin {
         load_shader_library!(app, "meshlet/dummy_visibility_buffer_resolve.wgsl");
 
         app.register_asset_reflect::<StandardMaterial>()
-            .register_type::<AmbientLight>()
-            .register_type::<CascadeShadowConfig>()
-            .register_type::<Cascades>()
             .register_type::<ClusterConfig>()
-            .register_type::<DirectionalLight>()
-            .register_type::<DirectionalLightShadowMap>()
-            .register_type::<NotShadowCaster>()
-            .register_type::<NotShadowReceiver>()
-            .register_type::<PointLight>()
-            .register_type::<PointLightShadowMap>()
-            .register_type::<SpotLight>()
-            .register_type::<ShadowFilteringMethod>()
-            .init_resource::<AmbientLight>()
             .init_resource::<GlobalVisibleClusterableObjects>()
-            .init_resource::<DirectionalLightShadowMap>()
-            .init_resource::<PointLightShadowMap>()
             .register_type::<DefaultOpaqueRendererMethod>()
             .init_resource::<DefaultOpaqueRendererMethod>()
             .add_plugins((
@@ -243,7 +227,7 @@ impl Plugin for PbrPlugin {
                 ExtractComponentPlugin::<ShadowFilteringMethod>::default(),
                 LightmapPlugin,
                 LightProbePlugin,
-                PbrProjectionPlugin,
+                LightPlugin,
                 GpuMeshPreprocessPlugin {
                     use_gpu_instance_buffer_builder: self.use_gpu_instance_buffer_builder,
                 },
@@ -266,64 +250,6 @@ impl Plugin for PbrPlugin {
                     SimulationLightSystems::AssignLightsToClusters,
                 )
                     .chain(),
-            )
-            .configure_sets(
-                PostUpdate,
-                SimulationLightSystems::UpdateDirectionalLightCascades
-                    .ambiguous_with(SimulationLightSystems::UpdateDirectionalLightCascades),
-            )
-            .configure_sets(
-                PostUpdate,
-                SimulationLightSystems::CheckLightVisibility
-                    .ambiguous_with(SimulationLightSystems::CheckLightVisibility),
-            )
-            .add_systems(
-                PostUpdate,
-                (
-                    add_clusters
-                        .in_set(SimulationLightSystems::AddClusters)
-                        .after(CameraUpdateSystems),
-                    assign_objects_to_clusters
-                        .in_set(SimulationLightSystems::AssignLightsToClusters)
-                        .after(TransformSystems::Propagate)
-                        .after(VisibilitySystems::CheckVisibility)
-                        .after(CameraUpdateSystems),
-                    clear_directional_light_cascades
-                        .in_set(SimulationLightSystems::UpdateDirectionalLightCascades)
-                        .after(TransformSystems::Propagate)
-                        .after(CameraUpdateSystems),
-                    update_directional_light_frusta
-                        .in_set(SimulationLightSystems::UpdateLightFrusta)
-                        // This must run after CheckVisibility because it relies on `ViewVisibility`
-                        .after(VisibilitySystems::CheckVisibility)
-                        .after(TransformSystems::Propagate)
-                        .after(SimulationLightSystems::UpdateDirectionalLightCascades)
-                        // We assume that no entity will be both a directional light and a spot light,
-                        // so these systems will run independently of one another.
-                        // FIXME: Add an archetype invariant for this https://github.com/bevyengine/bevy/issues/1481.
-                        .ambiguous_with(update_spot_light_frusta),
-                    update_point_light_frusta
-                        .in_set(SimulationLightSystems::UpdateLightFrusta)
-                        .after(TransformSystems::Propagate)
-                        .after(SimulationLightSystems::AssignLightsToClusters),
-                    update_spot_light_frusta
-                        .in_set(SimulationLightSystems::UpdateLightFrusta)
-                        .after(TransformSystems::Propagate)
-                        .after(SimulationLightSystems::AssignLightsToClusters),
-                    (
-                        check_dir_light_mesh_visibility,
-                        check_point_light_mesh_visibility,
-                    )
-                        .in_set(SimulationLightSystems::CheckLightVisibility)
-                        .after(VisibilitySystems::CalculateBounds)
-                        .after(TransformSystems::Propagate)
-                        .after(SimulationLightSystems::UpdateLightFrusta)
-                        // NOTE: This MUST be scheduled AFTER the core renderer visibility check
-                        // because that resets entity `ViewVisibility` for the first view
-                        // which would override any results from this otherwise
-                        .after(VisibilitySystems::CheckVisibility)
-                        .before(VisibilitySystems::MarkNewlyHiddenEntitiesInvisible),
-                ),
             );
 
         if self.add_default_deferred_lighting_plugin {
@@ -401,17 +327,3 @@ impl Plugin for PbrPlugin {
         app.insert_resource(global_cluster_settings);
     }
 }
-
-/// Camera projection PBR functionality.
-#[derive(Default)]
-pub struct PbrProjectionPlugin;
-impl Plugin for PbrProjectionPlugin {
-    fn build(&self, app: &mut App) {
-        app.add_systems(
-            PostUpdate,
-            build_directional_light_cascades
-                .in_set(SimulationLightSystems::UpdateDirectionalLightCascades)
-                .after(clear_directional_light_cascades),
-        );
-    }
-}

crates/bevy_pbr/src/light/ambient_light.rs

@@ -1,8 +1,12 @@
-use super::*;
+use bevy_camera::Camera;
+use bevy_color::Color;
+use bevy_ecs::prelude::*;
+use bevy_reflect::prelude::*;
+use bevy_render::{extract_component::ExtractComponent, extract_resource::ExtractResource};
 
 /// An ambient light, which lights the entire scene equally.
 ///
-/// This resource is inserted by the [`PbrPlugin`] and by default it is set to a low ambient light.
+/// This resource is inserted by the [`LightPlugin`] and by default it is set to a low ambient light.
 ///
 /// It can also be added to a camera to override the resource (or default) ambient for that camera only.
 ///
@@ -17,6 +21,8 @@ use super::*;
 ///    ambient_light.brightness = 100.0;
 /// }
 /// ```
+///
+/// [`LightPlugin`]: crate::LightPlugin
 #[derive(Resource, Component, Clone, Debug, ExtractResource, ExtractComponent, Reflect)]
 #[reflect(Resource, Component, Debug, Default, Clone)]
 #[require(Camera)]