Use RenderStartup for meshlets. (#20210)

# Objective

- Progress towards #19887.

## Solution

- Convert FromWorld impls to systems in `RenderStartup`.
- Use a closure system for initializing `ResourceManager` to capture the
`cluster_buffer_slots`.

## Testing

- Ran the `meshlet` example and it behaves the same as main.

Author: andriyDev

crates/bevy_pbr/src/meshlet/meshlet_mesh_manager.rs

@@ -5,8 +5,7 @@ use alloc::sync::Arc;
 use bevy_asset::{AssetId, Assets};
 use bevy_ecs::{
     resource::Resource,
-    system::{Res, ResMut},
-    world::{FromWorld, World},
+    system::{Commands, Res, ResMut},
 };
 use bevy_math::Vec2;
 use bevy_platform::collections::HashMap;
@@ -30,20 +29,17 @@ pub struct MeshletMeshManager {
         HashMap<AssetId<MeshletMesh>, ([Range<BufferAddress>; 7], MeshletAabb, u32)>,
 }
 
-impl FromWorld for MeshletMeshManager {
-    fn from_world(world: &mut World) -> Self {
-        let render_device = world.resource::<RenderDevice>();
-        Self {
-            vertex_positions: PersistentGpuBuffer::new("meshlet_vertex_positions", render_device),
-            vertex_normals: PersistentGpuBuffer::new("meshlet_vertex_normals", render_device),
-            vertex_uvs: PersistentGpuBuffer::new("meshlet_vertex_uvs", render_device),
-            indices: PersistentGpuBuffer::new("meshlet_indices", render_device),
-            bvh_nodes: PersistentGpuBuffer::new("meshlet_bvh_nodes", render_device),
-            meshlets: PersistentGpuBuffer::new("meshlets", render_device),
-            meshlet_cull_data: PersistentGpuBuffer::new("meshlet_cull_data", render_device),
-            meshlet_mesh_slices: HashMap::default(),
-        }
-    }
+pub fn init_meshlet_mesh_manager(mut commands: Commands, render_device: Res<RenderDevice>) {
+    commands.insert_resource(MeshletMeshManager {
+        vertex_positions: PersistentGpuBuffer::new("meshlet_vertex_positions", &render_device),
+        vertex_normals: PersistentGpuBuffer::new("meshlet_vertex_normals", &render_device),
+        vertex_uvs: PersistentGpuBuffer::new("meshlet_vertex_uvs", &render_device),
+        indices: PersistentGpuBuffer::new("meshlet_indices", &render_device),
+        bvh_nodes: PersistentGpuBuffer::new("meshlet_bvh_nodes", &render_device),
+        meshlets: PersistentGpuBuffer::new("meshlets", &render_device),
+        meshlet_cull_data: PersistentGpuBuffer::new("meshlet_cull_data", &render_device),
+        meshlet_mesh_slices: HashMap::default(),
+    });
 }
 
 impl MeshletMeshManager {

crates/bevy_pbr/src/meshlet/mod.rs

@@ -49,14 +49,17 @@ use self::{
     material_shade_nodes::{
         MeshletDeferredGBufferPrepassNode, MeshletMainOpaquePass3dNode, MeshletPrepassNode,
     },
-    meshlet_mesh_manager::{perform_pending_meshlet_mesh_writes, MeshletMeshManager},
+    meshlet_mesh_manager::perform_pending_meshlet_mesh_writes,
     pipelines::*,
     resource_manager::{
         prepare_meshlet_per_frame_resources, prepare_meshlet_view_bind_groups, ResourceManager,
     },
     visibility_buffer_raster_node::MeshletVisibilityBufferRasterPassNode,
 };
-use crate::{graph::NodePbr, PreviousGlobalTransform};
+use crate::{
+    graph::NodePbr, meshlet::meshlet_mesh_manager::init_meshlet_mesh_manager,
+    PreviousGlobalTransform,
+};
 use bevy_app::{App, Plugin};
 use bevy_asset::{embedded_asset, AssetApp, AssetId, Handle};
 use bevy_core_pipeline::{
@@ -70,7 +73,7 @@ use bevy_ecs::{
     query::Has,
     reflect::ReflectComponent,
     schedule::IntoScheduleConfigs,
-    system::{Commands, Query},
+    system::{Commands, Query, Res},
 };
 use bevy_reflect::{std_traits::ReflectDefault, Reflect};
 use bevy_render::{
@@ -79,7 +82,7 @@ use bevy_render::{
     renderer::RenderDevice,
     settings::WgpuFeatures,
     view::{self, prepare_view_targets, Msaa, Visibility, VisibilityClass},
-    ExtractSchedule, Render, RenderApp, RenderSystems,
+    ExtractSchedule, Render, RenderApp, RenderStartup, RenderSystems,
 };
 use bevy_transform::components::Transform;
 use derive_more::From;
@@ -163,22 +166,18 @@ impl Plugin for MeshletPlugin {
 
         app.init_asset::<MeshletMesh>()
             .register_asset_loader(MeshletMeshLoader);
-    }
 
-    fn finish(&self, app: &mut App) {
         let Some(render_app) = app.get_sub_app_mut(RenderApp) else {
             return;
         };
 
-        let render_device = render_app.world().resource::<RenderDevice>().clone();
-        let features = render_device.features();
-        if !features.contains(Self::required_wgpu_features()) {
-            error!(
-                "MeshletPlugin can't be used. GPU lacks support for required features: {:?}.",
-                Self::required_wgpu_features().difference(features)
-            );
-            std::process::exit(1);
-        }
+        // Create a variable here so we can move-capture it.
+        let cluster_buffer_slots = self.cluster_buffer_slots;
+        let init_resource_manager_system =
+            move |mut commands: Commands, render_device: Res<RenderDevice>| {
+                commands
+                    .insert_resource(ResourceManager::new(cluster_buffer_slots, &render_device));
+            };
 
         render_app
             .add_render_graph_node::<MeshletVisibilityBufferRasterPassNode>(
@@ -214,13 +213,18 @@ impl Plugin for MeshletPlugin {
                     Node3d::EndMainPass,
                 ),
             )
-            .init_resource::<MeshletMeshManager>()
             .insert_resource(InstanceManager::new())
-            .insert_resource(ResourceManager::new(
-                self.cluster_buffer_slots,
-                &render_device,
-            ))
-            .init_resource::<MeshletPipelines>()
+            .add_systems(
+                RenderStartup,
+                (
+                    check_meshlet_features,
+                    (
+                        (init_resource_manager_system, init_meshlet_pipelines).chain(),
+                        init_meshlet_mesh_manager,
+                    ),
+                )
+                    .chain(),
+            )
             .add_systems(ExtractSchedule, extract_meshlet_mesh_entities)
             .add_systems(
                 Render,
@@ -240,6 +244,17 @@ impl Plugin for MeshletPlugin {
     }
 }
 
+fn check_meshlet_features(render_device: Res<RenderDevice>) {
+    let features = render_device.features();
+    if !features.contains(MeshletPlugin::required_wgpu_features()) {
+        error!(
+            "MeshletPlugin can't be used. GPU lacks support for required features: {:?}.",
+            MeshletPlugin::required_wgpu_features().difference(features)
+        );
+        std::process::exit(1);
+    }
+}
+
 /// The meshlet mesh equivalent of [`bevy_render::mesh::Mesh3d`].
 #[derive(Component, Clone, Debug, Default, Deref, DerefMut, Reflect, PartialEq, Eq, From)]
 #[reflect(Component, Default, Clone, PartialEq)]