bevy_pbr: Add SupportedBindingTypes that can be constructed from RenderDevice::limits()

superdump · superdump · commit 132f203ca2a7 · 2022-03-24T20:06:54.000+01:00
diff --git a/crates/bevy_pbr/src/lib.rs b/crates/bevy_pbr/src/lib.rs
@@ -40,7 +40,7 @@ use bevy_render::{
     prelude::Color,
     render_graph::RenderGraph,
     render_phase::{sort_phase_system, AddRenderCommand, DrawFunctions},
-    render_resource::{Shader, SpecializedMeshPipelines},
+    render_resource::{Shader, SpecializedMeshPipelines, SupportedBindingTypes},
     renderer::RenderDevice,
     view::VisibilitySystems,
     RenderApp, RenderStage,
@@ -127,14 +127,10 @@ impl Plugin for PbrPlugin {
                 },
             );
 
-        // NOTE: 3 storage buffer bindings are needed for clustered-forward rendering so check
-        // that at least that many are supported
-        let use_storage_buffers = app
-            .world
-            .resource::<RenderDevice>()
-            .limits()
-            .max_storage_buffers_per_shader_stage
-            >= 3;
+        let supported_binding_types = SupportedBindingTypes::from_device(
+            app.world.resource::<RenderDevice>(),
+            CLUSTERED_FORWARD_STORAGE_BUFFER_COUNT,
+        );
 
         let render_app = match app.get_sub_app_mut(RenderApp) {
             Ok(render_app) => render_app,
@@ -174,7 +170,7 @@ impl Plugin for PbrPlugin {
             .init_resource::<ShadowPipeline>()
             .init_resource::<DrawFunctions<Shadow>>()
             .init_resource::<LightMeta>()
-            .insert_resource(GlobalLightMeta::new(use_storage_buffers))
+            .insert_resource(GlobalLightMeta::new(supported_binding_types))
             .init_resource::<SpecializedMeshPipelines<ShadowPipeline>>();
 
         let shadow_pass_node = ShadowPassNode::new(&mut render_app.world);
diff --git a/crates/bevy_pbr/src/light.rs b/crates/bevy_pbr/src/light.rs
@@ -9,6 +9,7 @@ use bevy_render::{
     color::Color,
     prelude::Image,
     primitives::{Aabb, CubemapFrusta, Frustum, Sphere},
+    render_resource::SupportedBindingTypes,
     renderer::RenderDevice,
     view::{ComputedVisibility, RenderLayers, Visibility, VisibleEntities},
 };
@@ -18,7 +19,7 @@ use bevy_window::Windows;
 
 use crate::{
     calculate_cluster_factors, CubeMapFace, CubemapVisibleEntities, ViewClusterBindings,
-    CUBE_MAP_FACES, MAX_POINT_LIGHTS, POINT_LIGHT_NEAR_Z,
+    CLUSTERED_FORWARD_STORAGE_BUFFER_COUNT, CUBE_MAP_FACES, MAX_POINT_LIGHTS, POINT_LIGHT_NEAR_Z,
 };
 
 /// A light that emits light in all directions from a central point.
@@ -729,10 +730,12 @@ pub(crate) fn assign_lights_to_clusters(
             ),
     );
 
-    // NOTE: Clustered-forward rendering requires 3 buffer bindings so only use storage buffers
-    // if at least 3 are supported
-    let use_storage_buffers = render_device.limits().max_storage_buffers_per_shader_stage >= 3;
-    if !use_storage_buffers && lights.len() > MAX_POINT_LIGHTS {
+    let supports_storage_buffers = SupportedBindingTypes::from_device(
+        render_device.into_inner(),
+        CLUSTERED_FORWARD_STORAGE_BUFFER_COUNT,
+    )
+    .contains(SupportedBindingTypes::STORAGE);
+    if lights.len() > MAX_POINT_LIGHTS && !supports_storage_buffers {
         lights.sort_by(|light_1, light_2| {
             point_light_order(
                 (&light_1.entity, &light_1.shadows_enabled),
diff --git a/crates/bevy_pbr/src/pbr_material.rs b/crates/bevy_pbr/src/pbr_material.rs
@@ -1,4 +1,7 @@
-use crate::{AlphaMode, MaterialPipeline, SpecializedMaterial, PBR_SHADER_HANDLE};
+use crate::{
+    AlphaMode, MaterialPipeline, SpecializedMaterial, CLUSTERED_FORWARD_STORAGE_BUFFER_COUNT,
+    PBR_SHADER_HANDLE,
+};
 use bevy_asset::{AssetServer, Handle};
 use bevy_ecs::system::{lifetimeless::SRes, SystemParamItem};
 use bevy_math::Vec4;
@@ -370,9 +373,11 @@ impl SpecializedMaterial for StandardMaterial {
         StandardMaterialKey {
             normal_map: render_asset.has_normal_map,
             cull_mode: render_asset.cull_mode,
-            // NOTE: Clustered-forward rendering requires 3 storage buffer bindings so check that
-            // at least that many are supported.
-            use_storage_buffers: render_device.limits().max_storage_buffers_per_shader_stage >= 3,
+            use_storage_buffers: SupportedBindingTypes::from_device(
+                render_device,
+                CLUSTERED_FORWARD_STORAGE_BUFFER_COUNT,
+            )
+            .contains(SupportedBindingTypes::STORAGE),
         }
     }
 
diff --git a/crates/bevy_pbr/src/render/light.rs b/crates/bevy_pbr/src/render/light.rs
@@ -102,8 +102,8 @@ pub enum GpuPointLights {
 }
 
 impl GpuPointLights {
-    fn new(use_storage_buffers: bool) -> Self {
-        if use_storage_buffers {
+    fn new(supported_binding_types: SupportedBindingTypes) -> Self {
+        if supported_binding_types.contains(SupportedBindingTypes::STORAGE) {
             Self::storage()
         } else {
             Self::uniform()
@@ -595,15 +595,19 @@ pub struct ViewLightsUniformOffset {
     pub offset: u32,
 }
 
+// NOTE: Clustered-forward rendering requires 3 storage buffer bindings so check that
+// at least that many are supported using this constant and SupportedBindingType::from_device()
+pub const CLUSTERED_FORWARD_STORAGE_BUFFER_COUNT: u32 = 3;
+
 pub struct GlobalLightMeta {
     pub gpu_point_lights: GpuPointLights,
     pub entity_to_index: HashMap<Entity, usize>,
 }
 
 impl GlobalLightMeta {
-    pub fn new(use_storage_buffers: bool) -> Self {
+    pub fn new(supported_binding_types: SupportedBindingTypes) -> Self {
         Self {
-            gpu_point_lights: GpuPointLights::new(use_storage_buffers),
+            gpu_point_lights: GpuPointLights::new(supported_binding_types),
             entity_to_index: HashMap::default(),
         }
     }
@@ -1018,8 +1022,8 @@ enum ViewClusterBuffers {
 }
 
 impl ViewClusterBuffers {
-    fn new(use_storage_buffers: bool) -> Self {
-        if use_storage_buffers {
+    fn new(supported_binding_types: SupportedBindingTypes) -> Self {
+        if supported_binding_types.contains(SupportedBindingTypes::STORAGE) {
             Self::storage()
         } else {
             Self::uniform()
@@ -1053,11 +1057,11 @@ impl ViewClusterBindings {
     const MAX_UNIFORM_ITEMS: usize = Self::MAX_OFFSETS / 4;
     pub const MAX_INDICES: usize = 16384;
 
-    pub fn new(use_storage_buffers: bool) -> Self {
+    pub fn new(supported_binding_types: SupportedBindingTypes) -> Self {
         Self {
             n_indices: 0,
             n_offsets: 0,
-            buffers: ViewClusterBuffers::new(use_storage_buffers),
+            buffers: ViewClusterBuffers::new(supported_binding_types),
         }
     }
 
@@ -1199,9 +1203,12 @@ pub fn prepare_clusters(
         With<RenderPhase<Transparent3d>>,
     >,
 ) {
-    let use_storage_buffers = render_device.limits().max_storage_buffers_per_shader_stage >= 3;
+    let render_device = render_device.into_inner();
+    let supported_binding_types =
+        SupportedBindingTypes::from_device(render_device, CLUSTERED_FORWARD_STORAGE_BUFFER_COUNT);
+    let supports_storage_buffers = supported_binding_types.contains(SupportedBindingTypes::STORAGE);
     for (entity, cluster_config, extracted_clusters) in views.iter() {
-        let mut view_clusters_bindings = ViewClusterBindings::new(use_storage_buffers);
+        let mut view_clusters_bindings = ViewClusterBindings::new(supported_binding_types);
         view_clusters_bindings.reserve_and_clear();
 
         let mut indices_full = false;
@@ -1219,9 +1226,9 @@ pub fn prepare_clusters(
                         for entity in cluster_lights.iter() {
                             if let Some(light_index) = global_light_meta.entity_to_index.get(entity)
                             {
-                                if !use_storage_buffers
-                                    && view_clusters_bindings.n_indices()
-                                        >= ViewClusterBindings::MAX_INDICES
+                                if view_clusters_bindings.n_indices()
+                                    >= ViewClusterBindings::MAX_INDICES
+                                    && !supports_storage_buffers
                                 {
                                     warn!("Cluster light index lists is full! The PointLights in the view are affecting too many clusters.");
                                     indices_full = true;
@@ -1237,7 +1244,7 @@ pub fn prepare_clusters(
             }
         }
 
-        view_clusters_bindings.write_buffers(&render_device, &render_queue);
+        view_clusters_bindings.write_buffers(render_device, &render_queue);
 
         commands.get_or_spawn(entity).insert(view_clusters_bindings);
     }
diff --git a/crates/bevy_pbr/src/render/mesh.rs b/crates/bevy_pbr/src/render/mesh.rs
@@ -1,6 +1,7 @@
 use crate::{
     GlobalLightMeta, GpuLights, LightMeta, NotShadowCaster, NotShadowReceiver, ShadowPipeline,
     ViewClusterBindings, ViewLightsUniformOffset, ViewShadowBindings,
+    CLUSTERED_FORWARD_STORAGE_BUFFER_COUNT,
 };
 use bevy_app::Plugin;
 use bevy_asset::{load_internal_asset, Handle, HandleUntyped};
@@ -167,7 +168,12 @@ impl FromWorld for MeshPipeline {
     fn from_world(world: &mut World) -> Self {
         let render_device = world.resource::<RenderDevice>();
         let (cluster_buffer_binding_type, cluster_min_binding_size) =
-            if render_device.limits().max_storage_buffers_per_shader_stage >= 3 {
+            if SupportedBindingTypes::from_device(
+                render_device,
+                CLUSTERED_FORWARD_STORAGE_BUFFER_COUNT,
+            )
+            .contains(SupportedBindingTypes::STORAGE)
+            {
                 (BufferBindingType::Storage { read_only: true }, None)
             } else {
                 (BufferBindingType::Uniform, BufferSize::new(16384))
diff --git a/crates/bevy_render/src/render_resource/storage_buffer.rs b/crates/bevy_render/src/render_resource/storage_buffer.rs
@@ -8,6 +8,31 @@ use crate::renderer::{RenderDevice, RenderQueue};
 
 use super::Buffer;
 
+bitflags::bitflags! {
+    #[repr(transparent)]
+    pub struct SupportedBindingTypes: u32 {
+        const UNIFORM         = (1 << 0);
+        const STORAGE         = (1 << 1);
+        const NONE            = 0;
+        const UNINITIALIZED   = 0xFFFF;
+    }
+}
+
+impl SupportedBindingTypes {
+    pub fn from_device(
+        render_device: &RenderDevice,
+        required_binding_count_per_stage: u32,
+    ) -> SupportedBindingTypes {
+        let mut supported_binding_types = SupportedBindingTypes::UNIFORM;
+        if render_device.limits().max_storage_buffers_per_shader_stage
+            >= required_binding_count_per_stage
+        {
+            supported_binding_types |= SupportedBindingTypes::STORAGE;
+        }
+        supported_binding_types
+    }
+}
+
 /// A helper for a storage buffer binding with a body, or a variable-sized array, or both.
 pub struct StorageBuffer<T: AsStd430, U: AsStd430 = ()> {
     body: U,
