Use RenderStartup for bevy_pbr for some basic cases. (#19999)

# Objective

- Progress towards #19887.

## Solution

- For cases that don't need to conditionally add systems, we can just
replace FromWorld impls with systems and then add those systems to
`RenderStartup`.

## Testing

- I ran the `lightmaps`, `reflection_probes`, `deferred_rendering`,
`volumetric_fog`, and `wireframe` examples.

Author: andriyDev

crates/bevy_pbr/src/deferred/mod.rs

@@ -7,7 +7,7 @@ use crate::{
 };
 use crate::{DistanceFog, MeshPipelineKey, ViewFogUniformOffset, ViewLightsUniformOffset};
 use bevy_app::prelude::*;
-use bevy_asset::{embedded_asset, load_embedded_asset, Handle};
+use bevy_asset::{embedded_asset, load_embedded_asset, AssetServer, Handle};
 use bevy_core_pipeline::{
     core_3d::graph::{Core3d, Node3d},
     deferred::{
@@ -19,6 +19,7 @@ use bevy_core_pipeline::{
 use bevy_ecs::{prelude::*, query::QueryItem};
 use bevy_image::BevyDefault as _;
 use bevy_light::{EnvironmentMapLight, ShadowFilteringMethod};
+use bevy_render::RenderStartup;
 use bevy_render::{
     extract_component::{
         ComponentUniforms, ExtractComponent, ExtractComponentPlugin, UniformComponentPlugin,
@@ -104,6 +105,7 @@ impl Plugin for DeferredPbrLightingPlugin {
 
         render_app
             .init_resource::<SpecializedRenderPipelines<DeferredLightingLayout>>()
+            .add_systems(RenderStartup, init_deferred_lighting_layout)
             .add_systems(
                 Render,
                 (prepare_deferred_lighting_pipelines.in_set(RenderSystems::Prepare),),
@@ -121,14 +123,6 @@ impl Plugin for DeferredPbrLightingPlugin {
                 ),
             );
     }
-
-    fn finish(&self, app: &mut App) {
-        let Some(render_app) = app.get_sub_app_mut(RenderApp) else {
-            return;
-        };
-
-        render_app.init_resource::<DeferredLightingLayout>();
-    }
 }
 
 #[derive(Default)]
@@ -394,22 +388,27 @@ impl SpecializedRenderPipeline for DeferredLightingLayout {
     }
 }
 
-impl FromWorld for DeferredLightingLayout {
-    fn from_world(world: &mut World) -> Self {
-        let render_device = world.resource::<RenderDevice>();
-        let layout = render_device.create_bind_group_layout(
-            "deferred_lighting_layout",
-            &BindGroupLayoutEntries::single(
-                ShaderStages::VERTEX_FRAGMENT,
-                uniform_buffer::<PbrDeferredLightingDepthId>(false),
-            ),
-        );
-        Self {
-            mesh_pipeline: world.resource::<MeshPipeline>().clone(),
-            bind_group_layout_2: layout,
-            deferred_lighting_shader: load_embedded_asset!(world, "deferred_lighting.wgsl"),
-        }
-    }
+pub fn init_deferred_lighting_layout(
+    mut commands: Commands,
+    render_device: Res<RenderDevice>,
+    mesh_pipeline: Res<MeshPipeline>,
+    asset_server: Res<AssetServer>,
+) {
+    let layout = render_device.create_bind_group_layout(
+        "deferred_lighting_layout",
+        &BindGroupLayoutEntries::single(
+            ShaderStages::VERTEX_FRAGMENT,
+            uniform_buffer::<PbrDeferredLightingDepthId>(false),
+        ),
+    );
+    commands.insert_resource(DeferredLightingLayout {
+        mesh_pipeline: mesh_pipeline.clone(),
+        bind_group_layout_2: layout,
+        deferred_lighting_shader: load_embedded_asset!(
+            asset_server.as_ref(),
+            "deferred_lighting.wgsl"
+        ),
+    });
 }
 
 pub fn insert_deferred_lighting_pass_id_component(

crates/bevy_pbr/src/light_probe/mod.rs

@@ -289,9 +289,7 @@ impl Plugin for LightProbePlugin {
         load_shader_library!(app, "irradiance_volume.wgsl");
 
         app.add_plugins(ExtractInstancesPlugin::<EnvironmentMapIds>::new());
-    }
 
-    fn finish(&self, app: &mut App) {
         let Some(render_app) = app.get_sub_app_mut(RenderApp) else {
             return;
         };

crates/bevy_pbr/src/lightmap/mod.rs

@@ -42,8 +42,7 @@ use bevy_ecs::{
     reflect::ReflectComponent,
     resource::Resource,
     schedule::IntoScheduleConfigs,
-    system::{Query, Res, ResMut},
-    world::{FromWorld, World},
+    system::{Commands, Query, Res, ResMut},
 };
 use bevy_image::Image;
 use bevy_math::{uvec2, vec4, Rect, UVec2};
@@ -57,7 +56,7 @@ use bevy_render::{
     sync_world::MainEntity,
     texture::{FallbackImage, GpuImage},
     view::ViewVisibility,
-    Extract, ExtractSchedule, RenderApp,
+    Extract, ExtractSchedule, RenderApp, RenderStartup,
 };
 use bevy_render::{renderer::RenderDevice, sync_world::MainEntityHashMap};
 use bevy_utils::default;
@@ -186,17 +185,16 @@ pub struct LightmapSlotIndex(pub(crate) NonMaxU16);
 impl Plugin for LightmapPlugin {
     fn build(&self, app: &mut App) {
         load_shader_library!(app, "lightmap.wgsl");
-    }
 
-    fn finish(&self, app: &mut App) {
         let Some(render_app) = app.get_sub_app_mut(RenderApp) else {
             return;
         };
-
-        render_app.init_resource::<RenderLightmaps>().add_systems(
-            ExtractSchedule,
-            extract_lightmaps.after(MeshExtractionSystems),
-        );
+        render_app
+            .add_systems(RenderStartup, init_render_lightmaps)
+            .add_systems(
+                ExtractSchedule,
+                extract_lightmaps.after(MeshExtractionSystems),
+            );
     }
 }
 
@@ -334,21 +332,20 @@ impl Default for Lightmap {
     }
 }
 
-impl FromWorld for RenderLightmaps {
-    fn from_world(world: &mut World) -> Self {
-        let render_device = world.resource::<RenderDevice>();
-        let render_adapter = world.resource::<RenderAdapter>();
-
-        let bindless_supported = binding_arrays_are_usable(render_device, render_adapter);
-
-        RenderLightmaps {
-            render_lightmaps: default(),
-            slabs: vec![],
-            free_slabs: FixedBitSet::new(),
-            pending_lightmaps: default(),
-            bindless_supported,
-        }
-    }
+pub fn init_render_lightmaps(
+    mut commands: Commands,
+    render_device: Res<RenderDevice>,
+    render_adapter: Res<RenderAdapter>,
+) {
+    let bindless_supported = binding_arrays_are_usable(&render_device, &render_adapter);
+
+    commands.insert_resource(RenderLightmaps {
+        render_lightmaps: default(),
+        slabs: vec![],
+        free_slabs: FixedBitSet::new(),
+        pending_lightmaps: default(),
+        bindless_supported,
+    });
 }
 
 impl RenderLightmaps {

crates/bevy_pbr/src/material.rs

@@ -267,6 +267,15 @@ impl Plugin for MaterialsPlugin {
                 .init_resource::<LightKeyCache>()
                 .init_resource::<LightSpecializationTicks>()
                 .init_resource::<SpecializedShadowMaterialPipelineCache>()
+                .init_resource::<DrawFunctions<Shadow>>()
+                .init_resource::<RenderMaterialInstances>()
+                .init_resource::<MaterialBindGroupAllocators>()
+                .add_render_command::<Shadow, DrawPrepass>()
+                .add_render_command::<Transmissive3d, DrawMaterial>()
+                .add_render_command::<Transparent3d, DrawMaterial>()
+                .add_render_command::<Opaque3d, DrawMaterial>()
+                .add_render_command::<AlphaMask3d, DrawMaterial>()
+                .add_systems(RenderStartup, init_material_pipeline)
                 .add_systems(
                     Render,
                     (
@@ -301,21 +310,6 @@ impl Plugin for MaterialsPlugin {
                 );
         }
     }
-
-    fn finish(&self, app: &mut App) {
-        if let Some(render_app) = app.get_sub_app_mut(RenderApp) {
-            render_app
-                .init_resource::<DrawFunctions<Shadow>>()
-                .init_resource::<RenderMaterialInstances>()
-                .init_resource::<MaterialPipeline>()
-                .init_resource::<MaterialBindGroupAllocators>()
-                .add_render_command::<Shadow, DrawPrepass>()
-                .add_render_command::<Transmissive3d, DrawMaterial>()
-                .add_render_command::<Transparent3d, DrawMaterial>()
-                .add_render_command::<Opaque3d, DrawMaterial>()
-                .add_render_command::<AlphaMask3d, DrawMaterial>();
-        }
-    }
 }
 
 /// Adds the necessary ECS resources and render logic to enable rendering entities using the given [`Material`]
@@ -485,12 +479,10 @@ impl SpecializedMeshPipeline for MaterialPipelineSpecializer {
     }
 }
 
-impl FromWorld for MaterialPipeline {
-    fn from_world(world: &mut World) -> Self {
-        MaterialPipeline {
-            mesh_pipeline: world.resource::<MeshPipeline>().clone(),
-        }
-    }
+pub fn init_material_pipeline(mut commands: Commands, mesh_pipeline: Res<MeshPipeline>) {
+    commands.insert_resource(MaterialPipeline {
+        mesh_pipeline: mesh_pipeline.clone(),
+    });
 }
 
 pub type DrawMaterial = (