centralise the shaderdefs that should always be defined

Author: mockersf

crates/bevy_internal/Cargo.toml

@@ -55,7 +55,7 @@ x11 = ["bevy_winit/x11"]
 subpixel_glyph_atlas = ["bevy_text/subpixel_glyph_atlas"]
 
 # Optimise for WebGL2
-webgl = ["bevy_core_pipeline/webgl", "bevy_pbr/webgl", "bevy_render/webgl", "bevy_sprite/webgl"]
+webgl = ["bevy_core_pipeline/webgl", "bevy_pbr/webgl", "bevy_render/webgl"]
 
 # enable systems that allow for automated testing on CI
 bevy_ci_testing = ["bevy_app/bevy_ci_testing", "bevy_render/ci_limits"]

crates/bevy_pbr/src/render/light.rs

@@ -212,7 +212,6 @@ pub struct ShadowPipeline {
     pub skinned_mesh_layout: BindGroupLayout,
     pub point_light_sampler: Sampler,
     pub directional_light_sampler: Sampler,
-    pub clustered_forward_buffer_binding_type: BufferBindingType,
 }
 
 // TODO: this pattern for initializing the shaders / pipeline isn't ideal. this should be handled by the asset system
@@ -221,9 +220,6 @@ impl FromWorld for ShadowPipeline {
         let world = world.cell();
         let render_device = world.resource::<RenderDevice>();
 
-        let clustered_forward_buffer_binding_type = render_device
-            .get_supported_read_only_binding_type(CLUSTERED_FORWARD_STORAGE_BUFFER_COUNT);
-
         let view_layout = render_device.create_bind_group_layout(&BindGroupLayoutDescriptor {
             entries: &[
                 // View
@@ -268,7 +264,6 @@ impl FromWorld for ShadowPipeline {
                 compare: Some(CompareFunction::GreaterEqual),
                 ..Default::default()
             }),
-            clustered_forward_buffer_binding_type,
         }
     }
 }
@@ -330,13 +325,6 @@ impl SpecializedMeshPipeline for ShadowPipeline {
             bind_group_layout.push(self.mesh_layout.clone());
         }
 
-        if !matches!(
-            self.clustered_forward_buffer_binding_type,
-            BufferBindingType::Storage { .. }
-        ) {
-            shader_defs.push(String::from("NO_STORAGE_BUFFERS_SUPPORT"));
-        }
-
         let vertex_buffer_layout = layout.get_layout(&vertex_attributes)?;
 
         Ok(RenderPipelineDescriptor {

crates/bevy_pbr/src/render/mesh.rs

@@ -573,18 +573,6 @@ impl SpecializedMeshPipeline for MeshPipeline {
             vertex_attributes.push(Mesh::ATTRIBUTE_COLOR.at_shader_location(4));
         }
 
-        // TODO: consider exposing this in shaders in a more generally useful way, such as:
-        // # if AVAILABLE_STORAGE_BUFFER_BINDINGS == 3
-        // /* use storage buffers here */
-        // # elif
-        // /* use uniforms here */
-        if !matches!(
-            self.clustered_forward_buffer_binding_type,
-            BufferBindingType::Storage { .. }
-        ) {
-            shader_defs.push(String::from("NO_STORAGE_BUFFERS_SUPPORT"));
-        }
-
         let mut bind_group_layout = vec![self.view_layout.clone()];
         if layout.contains(Mesh::ATTRIBUTE_JOINT_INDEX)
             && layout.contains(Mesh::ATTRIBUTE_JOINT_WEIGHT)
@@ -615,9 +603,6 @@ impl SpecializedMeshPipeline for MeshPipeline {
             depth_write_enabled = true;
         }
 
-        #[cfg(feature = "webgl")]
-        shader_defs.push(String::from("NO_ARRAY_TEXTURES_SUPPORT"));
-
         Ok(RenderPipelineDescriptor {
             vertex: VertexState {
                 shader: MESH_SHADER_HANDLE.typed::<Shader>(),

crates/bevy_render/src/render_resource/pipeline_cache.rs

@@ -15,7 +15,10 @@ use bevy_ecs::system::{Res, ResMut};
 use bevy_utils::{default, tracing::error, Entry, HashMap, HashSet};
 use std::{hash::Hash, mem, ops::Deref, sync::Arc};
 use thiserror::Error;
-use wgpu::{PipelineLayoutDescriptor, ShaderModule, VertexBufferLayout as RawVertexBufferLayout};
+use wgpu::{
+    BufferBindingType, PipelineLayoutDescriptor, ShaderModule,
+    VertexBufferLayout as RawVertexBufferLayout,
+};
 
 enum PipelineDescriptor {
     RenderPipelineDescriptor(Box<RenderPipelineDescriptor>),
@@ -117,9 +120,26 @@ impl ShaderCache {
         let module = match data.processed_shaders.entry(shader_defs.to_vec()) {
             Entry::Occupied(entry) => entry.into_mut(),
             Entry::Vacant(entry) => {
+                let mut shader_defs = shader_defs.to_vec();
+                #[cfg(feature = "webgl")]
+                shader_defs.push(String::from("NO_ARRAY_TEXTURES_SUPPORT"));
+
+                // TODO: 3 is the value from CLUSTERED_FORWARD_STORAGE_BUFFER_COUNT declared in bevy_pbr
+                // consider exposing this in shaders in a more generally useful way, such as:
+                // # if AVAILABLE_STORAGE_BUFFER_BINDINGS == 3
+                // /* use storage buffers here */
+                // # elif
+                // /* use uniforms here */
+                if !matches!(
+                    render_device.get_supported_read_only_binding_type(3),
+                    BufferBindingType::Storage { .. }
+                ) {
+                    shader_defs.push(String::from("NO_STORAGE_BUFFERS_SUPPORT"));
+                }
+
                 let processed = self.processor.process(
                     shader,
-                    shader_defs,
+                    &shader_defs,
                     &self.shaders,
                     &self.import_path_shaders,
                 )?;

crates/bevy_sprite/Cargo.toml

@@ -8,9 +8,6 @@ repository = "https://github.com/bevyengine/bevy"
 license = "MIT OR Apache-2.0"
 keywords = ["bevy"]
 
-[features]
-webgl = []
-
 [dependencies]
 # bevy
 bevy_app = { path = "../bevy_app", version = "0.8.0-dev" }

crates/bevy_sprite/src/mesh2d/mesh.rs

@@ -136,7 +136,6 @@ pub struct Mesh2dPipeline {
     pub mesh_layout: BindGroupLayout,
     // This dummy white texture is to be used in place of optional textures
     pub dummy_white_gpu_image: GpuImage,
-    pub clustered_forward_buffer_binding_type: BufferBindingType,
 }
 
 impl FromWorld for Mesh2dPipeline {
@@ -159,10 +158,6 @@ impl FromWorld for Mesh2dPipeline {
             label: Some("mesh2d_view_layout"),
         });
 
-        // 3 is the value from CLUSTERED_FORWARD_STORAGE_BUFFER_COUNT that is declared in bevy_pbr
-        let clustered_forward_buffer_binding_type =
-            render_device.get_supported_read_only_binding_type(3);
-
         let mesh_layout = render_device.create_bind_group_layout(&BindGroupLayoutDescriptor {
             entries: &[BindGroupLayoutEntry {
                 binding: 0,
@@ -226,7 +221,6 @@ impl FromWorld for Mesh2dPipeline {
             view_layout,
             mesh_layout,
             dummy_white_gpu_image,
-            clustered_forward_buffer_binding_type,
         }
     }
 }
@@ -322,16 +316,6 @@ impl SpecializedMeshPipeline for Mesh2dPipeline {
             vertex_attributes.push(Mesh::ATTRIBUTE_COLOR.at_shader_location(4));
         }
 
-        #[cfg(feature = "webgl")]
-        shader_defs.push(String::from("NO_ARRAY_TEXTURES_SUPPORT"));
-
-        if !matches!(
-            self.clustered_forward_buffer_binding_type,
-            BufferBindingType::Storage { .. }
-        ) {
-            shader_defs.push(String::from("NO_STORAGE_BUFFERS_SUPPORT"));
-        }
-
         let vertex_buffer_layout = layout.get_layout(&vertex_attributes)?;
 
         Ok(RenderPipelineDescriptor {