Use RenderDevice for wgpu::Limits in SpecializedMaterial(2d)

Author: superdump

crates/bevy_pbr/src/lib.rs

@@ -37,11 +37,11 @@ use bevy_asset::{load_internal_asset, Assets, Handle, HandleUntyped};
 use bevy_ecs::prelude::*;
 use bevy_reflect::TypeUuid;
 use bevy_render::{
-    options::WgpuOptions,
     prelude::Color,
     render_graph::RenderGraph,
     render_phase::{sort_phase_system, AddRenderCommand, DrawFunctions},
     render_resource::{Shader, SpecializedPipelines},
+    renderer::RenderDevice,
     view::VisibilitySystems,
     RenderApp, RenderStage,
 };
@@ -140,9 +140,9 @@ impl Plugin for PbrPlugin {
         // stage?
         let use_storage_buffers = app
             .world
-            .get_resource::<WgpuOptions>()
+            .get_resource::<RenderDevice>()
             .unwrap()
-            .limits
+            .limits()
             .max_storage_buffers_per_shader_stage
             >= 3;
 

crates/bevy_pbr/src/material.rs

@@ -16,7 +16,6 @@ use bevy_ecs::{
 };
 use bevy_render::{
     mesh::Mesh,
-    options::WgpuOptions,
     render_asset::{RenderAsset, RenderAssetPlugin, RenderAssets},
     render_component::ExtractComponentPlugin,
     render_phase::{
@@ -80,7 +79,7 @@ impl<M: Material> SpecializedMaterial for M {
 
     #[inline]
     fn key(
-        _wgpu_options: &WgpuOptions,
+        _render_device: &RenderDevice,
         _material: &<Self as RenderAsset>::PreparedAsset,
     ) -> Self::Key {
     }
@@ -133,7 +132,7 @@ pub trait SpecializedMaterial: Asset + RenderAsset {
     /// passed in to the [`SpecializedMaterial::specialize`] function when compiling the [`RenderPipeline`](bevy_render::render_resource::RenderPipeline)
     /// for a given entity's material.
     fn key(
-        wgpu_options: &WgpuOptions,
+        render_device: &RenderDevice,
         material: &<Self as RenderAsset>::PreparedAsset,
     ) -> Self::Key;
 
@@ -279,13 +278,13 @@ impl<M: SpecializedMaterial, const I: usize> EntityRenderCommand for SetMaterial
 
 #[allow(clippy::too_many_arguments)]
 pub fn queue_material_meshes<M: SpecializedMaterial>(
-    wgpu_options: Res<WgpuOptions>,
     opaque_draw_functions: Res<DrawFunctions<Opaque3d>>,
     alpha_mask_draw_functions: Res<DrawFunctions<AlphaMask3d>>,
     transparent_draw_functions: Res<DrawFunctions<Transparent3d>>,
     material_pipeline: Res<MaterialPipeline<M>>,
     mut pipelines: ResMut<SpecializedPipelines<MaterialPipeline<M>>>,
     mut pipeline_cache: ResMut<RenderPipelineCache>,
+    render_device: Res<RenderDevice>,
     msaa: Res<Msaa>,
     render_meshes: Res<RenderAssets<Mesh>>,
     render_materials: Res<RenderAssets<M>>,
@@ -298,7 +297,7 @@ pub fn queue_material_meshes<M: SpecializedMaterial>(
         &mut RenderPhase<Transparent3d>,
     )>,
 ) {
-    let wgpu_options = wgpu_options.into_inner();
+    let render_device = render_device.into_inner();
     for (view, visible_entities, mut opaque_phase, mut alpha_mask_phase, mut transparent_phase) in
         views.iter_mut()
     {
@@ -337,7 +336,7 @@ pub fn queue_material_meshes<M: SpecializedMaterial>(
                         mesh_key |= MeshPipelineKey::TRANSPARENT_MAIN_PASS;
                     }
 
-                    let specialized_key = M::key(wgpu_options, material);
+                    let specialized_key = M::key(render_device, material);
                     let pipeline_id = pipelines.specialize(
                         &mut pipeline_cache,
                         &material_pipeline,

crates/bevy_pbr/src/pbr_material.rs

@@ -5,7 +5,6 @@ use bevy_math::Vec4;
 use bevy_reflect::TypeUuid;
 use bevy_render::{
     color::Color,
-    options::WgpuOptions,
     prelude::Shader,
     render_asset::{PrepareAssetError, RenderAsset, RenderAssets},
     render_resource::{
@@ -335,12 +334,12 @@ impl SpecializedMaterial for StandardMaterial {
     type Key = StandardMaterialKey;
 
     fn key(
-        wgpu_options: &WgpuOptions,
+        render_device: &RenderDevice,
         render_asset: &<Self as RenderAsset>::PreparedAsset,
     ) -> Self::Key {
         StandardMaterialKey {
             normal_map: render_asset.has_normal_map,
-            storage_buffers: wgpu_options.limits.max_storage_buffers_per_shader_stage >= 3,
+            storage_buffers: render_device.limits().max_storage_buffers_per_shader_stage >= 3,
         }
     }
 

crates/bevy_pbr/src/render/light.rs

@@ -1210,7 +1210,6 @@ impl ViewClusterBindings {
 
 pub fn prepare_clusters(
     mut commands: Commands,
-    wgpu_options: Res<WgpuOptions>,
     render_device: Res<RenderDevice>,
     render_queue: Res<RenderQueue>,
     global_light_meta: Res<GlobalLightMeta>,
@@ -1223,7 +1222,7 @@ pub fn prepare_clusters(
         With<RenderPhase<Transparent3d>>,
     >,
 ) {
-    let use_storage_buffers = wgpu_options.limits.max_storage_buffers_per_shader_stage >= 3;
+    let use_storage_buffers = render_device.limits().max_storage_buffers_per_shader_stage >= 3;
     for (entity, cluster_config, extracted_clusters) in views.iter() {
         let mut view_clusters_bindings = ViewClusterBindings::new(use_storage_buffers);
         view_clusters_bindings.reserve_and_clear();

crates/bevy_pbr/src/render/mesh.rs

@@ -12,7 +12,6 @@ use bevy_math::{Mat4, Size};
 use bevy_reflect::TypeUuid;
 use bevy_render::{
     mesh::{GpuBufferInfo, Mesh},
-    options::WgpuOptions,
     render_asset::RenderAssets,
     render_component::{ComponentUniforms, DynamicUniformIndex, UniformComponentPlugin},
     render_phase::{EntityRenderCommand, RenderCommandResult, TrackedRenderPass},
@@ -168,9 +167,9 @@ impl FromWorld for MeshPipeline {
     fn from_world(world: &mut World) -> Self {
         let render_device = world.get_resource::<RenderDevice>().unwrap();
         let (cluster_buffer_binding_type, cluster_min_binding_size) = if world
-            .get_resource::<WgpuOptions>()
+            .get_resource::<RenderDevice>()
             .unwrap()
-            .limits
+            .limits()
             .max_storage_buffers_per_shader_stage
             >= 3
         {

crates/bevy_sprite/src/mesh2d/material.rs

@@ -75,7 +75,11 @@ impl<M: Material2d> SpecializedMaterial2d for M {
     type Key = ();
 
     #[inline]
-    fn key(_material: &<Self as RenderAsset>::PreparedAsset) -> Self::Key {}
+    fn key(
+        _render_device: &RenderDevice,
+        _material: &<Self as RenderAsset>::PreparedAsset,
+    ) -> Self::Key {
+    }
 
     #[inline]
     fn specialize(_key: Self::Key, _descriptor: &mut RenderPipelineDescriptor) {}
@@ -119,7 +123,10 @@ pub trait SpecializedMaterial2d: Asset + RenderAsset {
     /// Extract the [`SpecializedMaterial2d::Key`] for the "prepared" version of this material. This key will be
     /// passed in to the [`SpecializedMaterial2d::specialize`] function when compiling the [`RenderPipeline`](bevy_render::render_resource::RenderPipeline)
     /// for a given entity's material.
-    fn key(material: &<Self as RenderAsset>::PreparedAsset) -> Self::Key;
+    fn key(
+        render_device: &RenderDevice,
+        material: &<Self as RenderAsset>::PreparedAsset,
+    ) -> Self::Key;
 
     /// Specializes the given `descriptor` according to the given `key`.
     fn specialize(key: Self::Key, descriptor: &mut RenderPipelineDescriptor);
@@ -261,6 +268,7 @@ pub fn queue_material2d_meshes<M: SpecializedMaterial2d>(
     material2d_pipeline: Res<Material2dPipeline<M>>,
     mut pipelines: ResMut<SpecializedPipelines<Material2dPipeline<M>>>,
     mut pipeline_cache: ResMut<RenderPipelineCache>,
+    render_device: Res<RenderDevice>,
     msaa: Res<Msaa>,
     render_meshes: Res<RenderAssets<Mesh>>,
     render_materials: Res<RenderAssets<M>>,
@@ -270,6 +278,7 @@ pub fn queue_material2d_meshes<M: SpecializedMaterial2d>(
     if material2d_meshes.is_empty() {
         return;
     }
+    let render_device = render_device.into_inner();
     for (visible_entities, mut transparent_phase) in views.iter_mut() {
         let draw_transparent_pbr = transparent_draw_functions
             .read()
@@ -292,7 +301,7 @@ pub fn queue_material2d_meshes<M: SpecializedMaterial2d>(
                             Mesh2dPipelineKey::from_primitive_topology(mesh.primitive_topology);
                     }
 
-                    let specialized_key = M::key(material2d);
+                    let specialized_key = M::key(render_device, material2d);
                     let pipeline_id = pipelines.specialize(
                         &mut pipeline_cache,
                         &material2d_pipeline,

examples/shader/shader_material_glsl.rs

@@ -93,7 +93,7 @@ impl RenderAsset for CustomMaterial {
 impl SpecializedMaterial for CustomMaterial {
     type Key = ();
 
-    fn key(_: &<CustomMaterial as RenderAsset>::PreparedAsset) -> Self::Key {}
+    fn key(_: &RenderDevice, _: &<CustomMaterial as RenderAsset>::PreparedAsset) -> Self::Key {}
 
     fn specialize(_: Self::Key, descriptor: &mut RenderPipelineDescriptor) {
         descriptor.vertex.entry_point = "main".into();