Refactor shared specialize params into a SystemParam

crates/bevy_pbr/src/material.rs

@@ -35,7 +35,7 @@ use bevy_render::erased_render_asset::{
     ErasedRenderAsset, ErasedRenderAssetPlugin, ErasedRenderAssets, PrepareAssetError,
 };
 use bevy_render::mesh::mark_3d_meshes_as_changed_if_their_assets_changed;
-use bevy_render::render_asset::{prepare_assets, RenderAssets};
+use bevy_render::render_asset::prepare_assets;
 use bevy_render::renderer::RenderQueue;
 use bevy_render::RenderStartup;
 use bevy_render::{
@@ -885,9 +885,8 @@ pub fn check_entities_needing_specialization<M>(
 }
 
 pub fn specialize_material_meshes(
-    render_meshes: Res<RenderAssets<RenderMesh>>,
+    params: SpecializeMeshParams<EntitySpecializationTicks, RenderMeshInstances>,
     render_materials: Res<ErasedRenderAssets<PreparedMaterial>>,
-    render_mesh_instances: Res<RenderMeshInstances>,
     render_material_instances: Res<RenderMaterialInstances>,
     render_lightmaps: Res<RenderLightmaps>,
     render_visibility_ranges: Res<RenderVisibilityRanges>,
@@ -904,13 +903,10 @@ pub fn specialize_material_meshes(
     ),
     views: Query<(&ExtractedView, &RenderVisibleEntities)>,
     view_key_cache: Res<ViewKeyCache>,
-    entity_specialization_ticks: Res<EntitySpecializationTicks>,
     view_specialization_ticks: Res<ViewSpecializationTicks>,
     mut specialized_material_pipeline_cache: ResMut<SpecializedMaterialPipelineCache>,
     mut pipelines: ResMut<SpecializedMeshPipelines<MaterialPipelineSpecializer>>,
     pipeline: Res<MaterialPipeline>,
-    pipeline_cache: Res<PipelineCache>,
-    ticks: SystemChangeTick,
 ) {
     // Record the retained IDs of all shadow views so that we can expire old
     // pipeline IDs.
@@ -943,22 +939,27 @@ pub fn specialize_material_meshes(
             else {
                 continue;
             };
-            let Some(mesh_instance) = render_mesh_instances.render_mesh_queue_data(*visible_entity)
+            let Some(mesh_instance) = params
+                .render_mesh_instances
+                .render_mesh_queue_data(*visible_entity)
             else {
                 continue;
             };
-            let entity_tick = entity_specialization_ticks.get(visible_entity).unwrap();
+            let entity_tick = params
+                .entity_specialization_ticks
+                .get(visible_entity)
+                .unwrap();
             let last_specialized_tick = view_specialized_material_pipeline_cache
                 .get(visible_entity)
                 .map(|(tick, _)| *tick);
             let needs_specialization = last_specialized_tick.is_none_or(|tick| {
-                view_tick.is_newer_than(tick, ticks.this_run())
-                    || entity_tick.is_newer_than(tick, ticks.this_run())
+                view_tick.is_newer_than(tick, params.ticks.this_run())
+                    || entity_tick.is_newer_than(tick, params.ticks.this_run())
             });
             if !needs_specialization {
                 continue;
             }
-            let Some(mesh) = render_meshes.get(mesh_instance.mesh_asset_id) else {
+            let Some(mesh) = params.render_meshes.get(mesh_instance.mesh_asset_id) else {
                 continue;
             };
             let Some(material) = render_materials.get(material_instance.asset_id) else {
@@ -1012,7 +1013,7 @@ pub fn specialize_material_meshes(
                 properties: material.properties.clone(),
             };
             let pipeline_id = pipelines.specialize(
-                &pipeline_cache,
+                &params.pipeline_cache,
                 &material_pipeline_specializer,
                 erased_key,
                 &mesh.layout,
@@ -1026,7 +1027,7 @@ pub fn specialize_material_meshes(
             };
 
             view_specialized_material_pipeline_cache
-                .insert(*visible_entity, (ticks.this_run(), pipeline_id));
+                .insert(*visible_entity, (params.ticks.this_run(), pipeline_id));
         }
     }
 

crates/bevy_pbr/src/prepass/mod.rs

@@ -40,7 +40,6 @@ use bevy_math::{Affine3A, Vec4};
 use bevy_render::{
     globals::{GlobalsBuffer, GlobalsUniform},
     prelude::{Camera, Mesh},
-    render_asset::RenderAssets,
     render_phase::*,
     render_resource::*,
     renderer::{RenderDevice, RenderQueue},
@@ -821,9 +820,8 @@ pub fn check_prepass_views_need_specialization(
 }
 
 pub fn specialize_prepass_material_meshes(
-    render_meshes: Res<RenderAssets<RenderMesh>>,
+    params: SpecializeMeshParams<EntitySpecializationTicks, RenderMeshInstances>,
     render_materials: Res<ErasedRenderAssets<PreparedMaterial>>,
-    render_mesh_instances: Res<RenderMeshInstances>,
     render_material_instances: Res<RenderMaterialInstances>,
     render_lightmaps: Res<RenderLightmaps>,
     render_visibility_ranges: Res<RenderVisibilityRanges>,
@@ -848,20 +846,14 @@ pub fn specialize_prepass_material_meshes(
     ),
     (
         mut specialized_material_pipeline_cache,
-        ticks,
         prepass_pipeline,
         mut pipelines,
-        pipeline_cache,
         view_specialization_ticks,
-        entity_specialization_ticks,
     ): (
         ResMut<SpecializedPrepassMaterialPipelineCache>,
-        SystemChangeTick,
         Res<PrepassPipeline>,
         ResMut<SpecializedMeshPipelines<PrepassPipelineSpecializer>>,
-        Res<PipelineCache>,
         Res<ViewPrepassSpecializationTicks>,
-        Res<EntitySpecializationTicks>,
     ),
 ) {
     for (extracted_view, visible_entities, msaa, motion_vector_prepass, deferred_prepass) in &views
@@ -890,17 +882,22 @@ pub fn specialize_prepass_material_meshes(
             else {
                 continue;
             };
-            let Some(mesh_instance) = render_mesh_instances.render_mesh_queue_data(*visible_entity)
+            let Some(mesh_instance) = params
+                .render_mesh_instances
+                .render_mesh_queue_data(*visible_entity)
             else {
                 continue;
             };
-            let entity_tick = entity_specialization_ticks.get(visible_entity).unwrap();
+            let entity_tick = params
+                .entity_specialization_ticks
+                .get(visible_entity)
+                .unwrap();
             let last_specialized_tick = view_specialized_material_pipeline_cache
                 .get(visible_entity)
                 .map(|(tick, _)| *tick);
             let needs_specialization = last_specialized_tick.is_none_or(|tick| {
-                view_tick.is_newer_than(tick, ticks.this_run())
-                    || entity_tick.is_newer_than(tick, ticks.this_run())
+                view_tick.is_newer_than(tick, params.ticks.this_run())
+                    || entity_tick.is_newer_than(tick, params.ticks.this_run())
             });
             if !needs_specialization {
                 continue;
@@ -913,7 +910,7 @@ pub fn specialize_prepass_material_meshes(
                 view_specialized_material_pipeline_cache.remove(visible_entity);
                 continue;
             }
-            let Some(mesh) = render_meshes.get(mesh_instance.mesh_asset_id) else {
+            let Some(mesh) = params.render_meshes.get(mesh_instance.mesh_asset_id) else {
                 continue;
             };
 
@@ -997,7 +994,7 @@ pub fn specialize_prepass_material_meshes(
                 properties: material.properties.clone(),
             };
             let pipeline_id = pipelines.specialize(
-                &pipeline_cache,
+                &params.pipeline_cache,
                 &prepass_pipeline_specializer,
                 erased_key,
                 &mesh.layout,
@@ -1011,7 +1008,7 @@ pub fn specialize_prepass_material_meshes(
             };
 
             view_specialized_material_pipeline_cache
-                .insert(*visible_entity, (ticks.this_run(), pipeline_id));
+                .insert(*visible_entity, (params.ticks.this_run(), pipeline_id));
         }
     }
 }

crates/bevy_pbr/src/render/light.rs

@@ -34,9 +34,7 @@ use bevy_render::{
 };
 use bevy_render::{
     diagnostic::RecordDiagnostics,
-    mesh::RenderMesh,
     primitives::{CascadesFrusta, CubemapFrusta, Frustum, HalfSpace},
-    render_asset::RenderAssets,
     render_graph::{Node, NodeRunError, RenderGraphContext},
     render_phase::*,
     render_resource::*,
@@ -1678,16 +1676,14 @@ pub fn check_views_lights_need_specialization(
 }
 
 pub fn specialize_shadows(
+    params: SpecializeMeshParams<EntitySpecializationTicks, RenderMeshInstances>,
     prepass_pipeline: Res<PrepassPipeline>,
-    (render_meshes, render_mesh_instances, render_materials, render_material_instances): (
-        Res<RenderAssets<RenderMesh>>,
-        Res<RenderMeshInstances>,
+    (render_materials, render_material_instances): (
         Res<ErasedRenderAssets<PreparedMaterial>>,
         Res<RenderMaterialInstances>,
     ),
     shadow_render_phases: Res<ViewBinnedRenderPhases<Shadow>>,
     mut pipelines: ResMut<SpecializedMeshPipelines<PrepassPipelineSpecializer>>,
-    pipeline_cache: Res<PipelineCache>,
     render_lightmaps: Res<RenderLightmaps>,
     view_lights: Query<(Entity, &ViewLightEntities), With<ExtractedView>>,
     view_light_entities: Query<(&LightEntity, &ExtractedView)>,
@@ -1700,8 +1696,6 @@ pub fn specialize_shadows(
     light_key_cache: Res<LightKeyCache>,
     mut specialized_material_pipeline_cache: ResMut<SpecializedShadowMaterialPipelineCache>,
     light_specialization_ticks: Res<LightSpecializationTicks>,
-    entity_specialization_ticks: Res<EntitySpecializationTicks>,
-    ticks: SystemChangeTick,
 ) {
     // Record the retained IDs of all shadow views so that we can expire old
     // pipeline IDs.
@@ -1766,18 +1760,22 @@ pub fn specialize_shadows(
                     continue;
                 };
 
-                let Some(mesh_instance) =
-                    render_mesh_instances.render_mesh_queue_data(visible_entity)
+                let Some(mesh_instance) = params
+                    .render_mesh_instances
+                    .render_mesh_queue_data(visible_entity)
                 else {
                     continue;
                 };
-                let entity_tick = entity_specialization_ticks.get(&visible_entity).unwrap();
+                let entity_tick = params
+                    .entity_specialization_ticks
+                    .get(&visible_entity)
+                    .unwrap();
                 let last_specialized_tick = view_specialized_material_pipeline_cache
                     .get(&visible_entity)
                     .map(|(tick, _)| *tick);
                 let needs_specialization = last_specialized_tick.is_none_or(|tick| {
-                    view_tick.is_newer_than(tick, ticks.this_run())
-                        || entity_tick.is_newer_than(tick, ticks.this_run())
+                    view_tick.is_newer_than(tick, params.ticks.this_run())
+                        || entity_tick.is_newer_than(tick, params.ticks.this_run())
                 });
                 if !needs_specialization {
                     continue;
@@ -1795,7 +1793,7 @@ pub fn specialize_shadows(
                 {
                     continue;
                 }
-                let Some(mesh) = render_meshes.get(mesh_instance.mesh_asset_id) else {
+                let Some(mesh) = params.render_meshes.get(mesh_instance.mesh_asset_id) else {
                     continue;
                 };
 
@@ -1832,7 +1830,7 @@ pub fn specialize_shadows(
                     properties: material.properties.clone(),
                 };
                 let pipeline_id = pipelines.specialize(
-                    &pipeline_cache,
+                    &params.pipeline_cache,
                     &material_pipeline_specializer,
                     erased_key,
                     &mesh.layout,
@@ -1846,7 +1844,7 @@ pub fn specialize_shadows(
                 };
 
                 view_specialized_material_pipeline_cache
-                    .insert(visible_entity, (ticks.this_run(), pipeline_id));
+                    .insert(visible_entity, (params.ticks.this_run(), pipeline_id));
             }
         }
     }

crates/bevy_pbr/src/wireframe.rs

@@ -732,20 +732,16 @@ pub fn check_wireframe_entities_needing_specialization(
 }
 
 pub fn specialize_wireframes(
-    render_meshes: Res<RenderAssets<RenderMesh>>,
-    render_mesh_instances: Res<RenderMeshInstances>,
+    params: SpecializeMeshParams<WireframeEntitySpecializationTicks, RenderMeshInstances>,
     render_wireframe_instances: Res<RenderWireframeInstances>,
     render_visibility_ranges: Res<RenderVisibilityRanges>,
     wireframe_phases: Res<ViewBinnedRenderPhases<Wireframe3d>>,
     views: Query<(&ExtractedView, &RenderVisibleEntities)>,
     view_key_cache: Res<ViewKeyCache>,
-    entity_specialization_ticks: Res<WireframeEntitySpecializationTicks>,
     view_specialization_ticks: Res<ViewSpecializationTicks>,
     mut specialized_material_pipeline_cache: ResMut<SpecializedWireframePipelineCache>,
     mut pipelines: ResMut<SpecializedMeshPipelines<Wireframe3dPipeline>>,
     pipeline: Res<Wireframe3dPipeline>,
-    pipeline_cache: Res<PipelineCache>,
-    ticks: SystemChangeTick,
 ) {
     // Record the retained IDs of all views so that we can expire old
     // pipeline IDs.
@@ -773,22 +769,27 @@ pub fn specialize_wireframes(
             if !render_wireframe_instances.contains_key(visible_entity) {
                 continue;
             };
-            let Some(mesh_instance) = render_mesh_instances.render_mesh_queue_data(*visible_entity)
+            let Some(mesh_instance) = params
+                .render_mesh_instances
+                .render_mesh_queue_data(*visible_entity)
             else {
                 continue;
             };
-            let entity_tick = entity_specialization_ticks.get(visible_entity).unwrap();
+            let entity_tick = params
+                .entity_specialization_ticks
+                .get(visible_entity)
+                .unwrap();
             let last_specialized_tick = view_specialized_material_pipeline_cache
                 .get(visible_entity)
                 .map(|(tick, _)| *tick);
             let needs_specialization = last_specialized_tick.is_none_or(|tick| {
-                view_tick.is_newer_than(tick, ticks.this_run())
-                    || entity_tick.is_newer_than(tick, ticks.this_run())
+                view_tick.is_newer_than(tick, params.ticks.this_run())
+                    || entity_tick.is_newer_than(tick, params.ticks.this_run())
             });
             if !needs_specialization {
                 continue;
             }
-            let Some(mesh) = render_meshes.get(mesh_instance.mesh_asset_id) else {
+            let Some(mesh) = params.render_meshes.get(mesh_instance.mesh_asset_id) else {
                 continue;
             };
 
@@ -816,7 +817,7 @@ pub fn specialize_wireframes(
             }
 
             let pipeline_id =
-                pipelines.specialize(&pipeline_cache, &pipeline, mesh_key, &mesh.layout);
+                pipelines.specialize(&params.pipeline_cache, &pipeline, mesh_key, &mesh.layout);
             let pipeline_id = match pipeline_id {
                 Ok(id) => id,
                 Err(err) => {
@@ -826,7 +827,7 @@ pub fn specialize_wireframes(
             };
 
             view_specialized_material_pipeline_cache
-                .insert(*visible_entity, (ticks.this_run(), pipeline_id));
+                .insert(*visible_entity, (params.ticks.this_run(), pipeline_id));
         }
     }
 

crates/bevy_render/src/render_resource/pipeline_cache.rs

@@ -1,5 +1,7 @@
 use crate::WgpuWrapper;
 use crate::{
+    mesh::RenderMesh,
+    render_asset::RenderAssets,
     render_resource::*,
     renderer::{RenderAdapter, RenderDevice},
     Extract,
@@ -9,7 +11,7 @@ use bevy_asset::{AssetEvent, AssetId, Assets, Handle};
 use bevy_ecs::{
     event::EventReader,
     resource::Resource,
-    system::{Res, ResMut},
+    system::{Res, ResMut, SystemChangeTick, SystemParam},
 };
 use bevy_platform::collections::{HashMap, HashSet};
 use bevy_tasks::Task;
@@ -751,6 +753,20 @@ impl PipelineCache {
     }
 }
 
+/// Parameters shared between mesh specialization systems.
+#[derive(SystemParam)]
+pub struct SpecializeMeshParams<
+    'w,
+    EntitySpecializationTicks: Resource,
+    RenderMeshInstances: Resource,
+> {
+    pub pipeline_cache: Res<'w, PipelineCache>,
+    pub entity_specialization_ticks: Res<'w, EntitySpecializationTicks>,
+    pub render_mesh_instances: Res<'w, RenderMeshInstances>,
+    pub render_meshes: Res<'w, RenderAssets<RenderMesh>>,
+    pub ticks: SystemChangeTick,
+}
+
 fn pipeline_error_context(cached_pipeline: &CachedPipeline) -> String {
     fn format(
         shader: &Handle<Shader>,