New Binding Array Limit

tests/tests/binding_array/buffers.rs

@@ -9,7 +9,7 @@ static BINDING_ARRAY_UNIFORM_BUFFERS: GpuTestConfiguration = GpuTestConfiguratio
         TestParameters::default()
             .features(Features::BUFFER_BINDING_ARRAY | Features::UNIFORM_BUFFER_INDEXING)
             .limits(Limits {
-                max_uniform_buffers_per_shader_stage: 16,
+                max_binding_array_elements_per_shader_stage: 16,
                 ..Limits::default()
             })
             // Naga bug on vulkan: https://github.com/gfx-rs/wgpu/issues/6733
@@ -31,7 +31,7 @@ static PARTIAL_BINDING_ARRAY_UNIFORM_BUFFERS: GpuTestConfiguration = GpuTestConf
                     | Features::UNIFORM_BUFFER_INDEXING,
             )
             .limits(Limits {
-                max_uniform_buffers_per_shader_stage: 32,
+                max_binding_array_elements_per_shader_stage: 32,
                 ..Limits::default()
             })
             // Naga bug on vulkan: https://github.com/gfx-rs/wgpu/issues/6733
@@ -53,7 +53,7 @@ static BINDING_ARRAY_STORAGE_BUFFERS: GpuTestConfiguration = GpuTestConfiguratio
                     | Features::SAMPLED_TEXTURE_AND_STORAGE_BUFFER_ARRAY_NON_UNIFORM_INDEXING,
             )
             .limits(Limits {
-                max_storage_buffers_per_shader_stage: 17,
+                max_binding_array_elements_per_shader_stage: 17,
                 ..Limits::default()
             })
             // See https://github.com/gfx-rs/wgpu/issues/6745.
@@ -72,7 +72,7 @@ static PARTIAL_BINDING_ARRAY_STORAGE_BUFFERS: GpuTestConfiguration = GpuTestConf
                     | Features::SAMPLED_TEXTURE_AND_STORAGE_BUFFER_ARRAY_NON_UNIFORM_INDEXING,
             )
             .limits(Limits {
-                max_storage_buffers_per_shader_stage: 33,
+                max_binding_array_elements_per_shader_stage: 33,
                 ..Limits::default()
             })
             // See https://github.com/gfx-rs/wgpu/issues/6745.

tests/tests/binding_array/sampled_textures.rs

@@ -14,7 +14,7 @@ static BINDING_ARRAY_SAMPLED_TEXTURES: GpuTestConfiguration = GpuTestConfigurati
                     | Features::SAMPLED_TEXTURE_AND_STORAGE_BUFFER_ARRAY_NON_UNIFORM_INDEXING,
             )
             .limits(Limits {
-                max_sampled_textures_per_shader_stage: 16,
+                max_binding_array_elements_per_shader_stage: 16,
                 ..Limits::default()
             }),
     )
@@ -30,7 +30,7 @@ static PARTIAL_BINDING_ARRAY_SAMPLED_TEXTURES: GpuTestConfiguration = GpuTestCon
                     | Features::PARTIALLY_BOUND_BINDING_ARRAY,
             )
             .limits(Limits {
-                max_sampled_textures_per_shader_stage: 32,
+                max_binding_array_elements_per_shader_stage: 32,
                 ..Limits::default()
             }),
     )

tests/tests/binding_array/samplers.rs

@@ -12,7 +12,7 @@ static BINDING_ARRAY_SAMPLERS: GpuTestConfiguration = GpuTestConfiguration::new(
                     | Features::SAMPLED_TEXTURE_AND_STORAGE_BUFFER_ARRAY_NON_UNIFORM_INDEXING,
             )
             .limits(Limits {
-                max_samplers_per_shader_stage: 2,
+                max_binding_array_elements_per_shader_stage: 2,
                 ..Limits::default()
             }),
     )
@@ -28,7 +28,7 @@ static PARTIAL_BINDING_ARRAY_SAMPLERS: GpuTestConfiguration = GpuTestConfigurati
                     | Features::PARTIALLY_BOUND_BINDING_ARRAY,
             )
             .limits(Limits {
-                max_samplers_per_shader_stage: 4,
+                max_binding_array_elements_per_shader_stage: 4,
                 ..Limits::default()
             }),
     )

tests/tests/binding_array/storage_textures.rs

@@ -17,7 +17,7 @@ static BINDING_ARRAY_STORAGE_TEXTURES: GpuTestConfiguration = GpuTestConfigurati
                     | Features::TEXTURE_ADAPTER_SPECIFIC_FORMAT_FEATURES,
             )
             .limits(Limits {
-                max_storage_textures_per_shader_stage: 17,
+                max_binding_array_elements_per_shader_stage: 17,
                 ..Limits::default()
             })
             .expect_fail(FailureCase::backend(Backends::METAL)),
@@ -36,7 +36,7 @@ static PARTIAL_BINDING_ARRAY_STORAGE_TEXTURES: GpuTestConfiguration = GpuTestCon
                     | Features::TEXTURE_ADAPTER_SPECIFIC_FORMAT_FEATURES,
             )
             .limits(Limits {
-                max_storage_textures_per_shader_stage: 33,
+                max_binding_array_elements_per_shader_stage: 33,
                 ..Limits::default()
             })
             .expect_fail(FailureCase::backend(Backends::METAL)),

tests/tests/binding_array/validation.rs

@@ -12,6 +12,7 @@ static VALIDATION: GpuTestConfiguration = GpuTestConfiguration::new()
             .features(Features::TEXTURE_BINDING_ARRAY)
             .limits(Limits {
                 max_dynamic_storage_buffers_per_pipeline_layout: 1,
+                max_binding_array_elements_per_shader_stage: 4,
                 ..Limits::downlevel_defaults()
             })
             .expect_fail(

wgpu-core/src/binding_model.rs

@@ -229,6 +229,7 @@ pub enum BindingTypeMaxCountErrorKind {
     StorageBuffers,
     StorageTextures,
     UniformBuffers,
+    BindingArrayElements,
 }
 
 impl BindingTypeMaxCountErrorKind {
@@ -249,6 +250,9 @@ impl BindingTypeMaxCountErrorKind {
                 "max_storage_textures_per_shader_stage"
             }
             BindingTypeMaxCountErrorKind::UniformBuffers => "max_uniform_buffers_per_shader_stage",
+            BindingTypeMaxCountErrorKind::BindingArrayElements => {
+                "max_binding_array_elements_per_shader_stage"
+            }
         }
     }
 }
@@ -323,49 +327,53 @@ pub(crate) struct BindingTypeMaxCountValidator {
     storage_textures: PerStageBindingTypeCounter,
     uniform_buffers: PerStageBindingTypeCounter,
     acceleration_structures: PerStageBindingTypeCounter,
+    binding_array_elements: PerStageBindingTypeCounter,
     has_bindless_array: bool,
 }
 
 impl BindingTypeMaxCountValidator {
     pub(crate) fn add_binding(&mut self, binding: &wgt::BindGroupLayoutEntry) {
         let count = binding.count.map_or(1, |count| count.get());
-        match binding.ty {
-            wgt::BindingType::Buffer {
-                ty: wgt::BufferBindingType::Uniform,
-                has_dynamic_offset,
-                ..
-            } => {
-                self.uniform_buffers.add(binding.visibility, count);
-                if has_dynamic_offset {
-                    self.dynamic_uniform_buffers += count;
+
+        if binding.count.is_some() {
+            self.binding_array_elements.add(binding.visibility, count);
+            self.has_bindless_array = true;
+        } else {
+            match binding.ty {
+                wgt::BindingType::Buffer {
+                    ty: wgt::BufferBindingType::Uniform,
+                    has_dynamic_offset,
+                    ..
+                } => {
+                    self.uniform_buffers.add(binding.visibility, count);
+                    if has_dynamic_offset {
+                        self.dynamic_uniform_buffers += count;
+                    }
                 }
-            }
-            wgt::BindingType::Buffer {
-                ty: wgt::BufferBindingType::Storage { .. },
-                has_dynamic_offset,
-                ..
-            } => {
-                self.storage_buffers.add(binding.visibility, count);
-                if has_dynamic_offset {
-                    self.dynamic_storage_buffers += count;
+                wgt::BindingType::Buffer {
+                    ty: wgt::BufferBindingType::Storage { .. },
+                    has_dynamic_offset,
+                    ..
+                } => {
+                    self.storage_buffers.add(binding.visibility, count);
+                    if has_dynamic_offset {
+                        self.dynamic_storage_buffers += count;
+                    }
+                }
+                wgt::BindingType::Sampler { .. } => {
+                    self.samplers.add(binding.visibility, count);
+                }
+                wgt::BindingType::Texture { .. } => {
+                    self.sampled_textures.add(binding.visibility, count);
+                }
+                wgt::BindingType::StorageTexture { .. } => {
+                    self.storage_textures.add(binding.visibility, count);
+                }
+                wgt::BindingType::AccelerationStructure => {
+                    self.acceleration_structures.add(binding.visibility, count);
                 }
-            }
-            wgt::BindingType::Sampler { .. } => {
-                self.samplers.add(binding.visibility, count);
-            }
-            wgt::BindingType::Texture { .. } => {
-                self.sampled_textures.add(binding.visibility, count);
-            }
-            wgt::BindingType::StorageTexture { .. } => {
-                self.storage_textures.add(binding.visibility, count);
-            }
-            wgt::BindingType::AccelerationStructure => {
-                self.acceleration_structures.add(binding.visibility, count);
             }
         }
-        if binding.count.is_some() {
-            self.has_bindless_array = true;
-        }
     }
 
     pub(crate) fn merge(&mut self, other: &Self) {
@@ -376,6 +384,10 @@ impl BindingTypeMaxCountValidator {
         self.storage_buffers.merge(&other.storage_buffers);
         self.storage_textures.merge(&other.storage_textures);
         self.uniform_buffers.merge(&other.uniform_buffers);
+        self.acceleration_structures
+            .merge(&other.acceleration_structures);
+        self.binding_array_elements
+            .merge(&other.binding_array_elements);
     }
 
     pub(crate) fn validate(&self, limits: &wgt::Limits) -> Result<(), BindingTypeMaxCountError> {
@@ -415,6 +427,10 @@ impl BindingTypeMaxCountValidator {
             limits.max_uniform_buffers_per_shader_stage,
             BindingTypeMaxCountErrorKind::UniformBuffers,
         )?;
+        self.binding_array_elements.validate(
+            limits.max_binding_array_elements_per_shader_stage,
+            BindingTypeMaxCountErrorKind::BindingArrayElements,
+        )?;
         Ok(())
     }
 

wgpu-hal/src/dx12/adapter.rs

@@ -341,14 +341,11 @@ impl super::Adapter {
             wgt::Features::TEXTURE_BINDING_ARRAY
                 | wgt::Features::STORAGE_TEXTURE_ARRAY_NON_UNIFORM_INDEXING
                 | wgt::Features::UNIFORM_BUFFER_INDEXING
-                | wgt::Features::SAMPLED_TEXTURE_AND_STORAGE_BUFFER_ARRAY_NON_UNIFORM_INDEXING,
-            shader_model >= naga::back::hlsl::ShaderModel::V5_1,
-        );
-
-        // See note below the table https://learn.microsoft.com/en-us/windows/win32/direct3d12/hardware-support
-        features.set(
-            wgt::Features::PARTIALLY_BOUND_BINDING_ARRAY,
-            options.ResourceBindingTier.0 >= Direct3D12::D3D12_RESOURCE_BINDING_TIER_3.0,
+                | wgt::Features::SAMPLED_TEXTURE_AND_STORAGE_BUFFER_ARRAY_NON_UNIFORM_INDEXING
+                // See note below the table https://learn.microsoft.com/en-us/windows/win32/direct3d12/hardware-support
+                | wgt::Features::PARTIALLY_BOUND_BINDING_ARRAY,
+            shader_model >= naga::back::hlsl::ShaderModel::V5_1
+                && options.ResourceBindingTier.0 >= Direct3D12::D3D12_RESOURCE_BINDING_TIER_3.0,
         );
 
         let bgra8unorm_storage_supported = {
@@ -497,6 +494,8 @@ impl super::Adapter {
                     max_storage_buffers_per_shader_stage: uav_count / 4,
                     max_storage_textures_per_shader_stage: uav_count / 4,
                     max_uniform_buffers_per_shader_stage: full_heap_count,
+                    max_binding_array_elements_per_shader_stage: full_heap_count,
+                    max_binding_array_sampler_elements_per_shader_stage: full_heap_count,
                     max_uniform_buffer_binding_size:
                         Direct3D12::D3D12_REQ_CONSTANT_BUFFER_ELEMENT_COUNT * 16,
                     max_storage_buffer_binding_size: auxil::MAX_I32_BINDING_SIZE,

wgpu-hal/src/gles/adapter.rs

@@ -684,6 +684,8 @@ impl super::Adapter {
             max_storage_buffers_per_shader_stage,
             max_storage_textures_per_shader_stage,
             max_uniform_buffers_per_shader_stage,
+            max_binding_array_elements_per_shader_stage: 0,
+            max_binding_array_sampler_elements_per_shader_stage: 0,
             max_uniform_buffer_binding_size: unsafe {
                 gl.get_parameter_i32(glow::MAX_UNIFORM_BLOCK_SIZE)
             } as u32,

wgpu-hal/src/metal/adapter.rs

@@ -592,6 +592,8 @@ impl super::PrivateCapabilities {
             // `TimestampQuerySupport::INSIDE_WGPU_PASSES` emerges from the other flags.
         }
 
+        let argument_buffers = device.argument_buffers_support();
+
         Self {
             family_check,
             msl_version: if os_is_xr || version.at_least((14, 0), (17, 0), os_is_mac) {
@@ -626,7 +628,7 @@ impl super::PrivateCapabilities {
             },
             msaa_apple7: family_check && device.supports_family(MTLGPUFamily::Apple7),
             resource_heaps: Self::supports_any(device, RESOURCE_HEAP_SUPPORT),
-            argument_buffers: device.argument_buffers_support(),
+            argument_buffers,
             shared_textures: !os_is_mac,
             mutable_comparison_samplers: Self::supports_any(
                 device,
@@ -725,6 +727,28 @@ impl super::PrivateCapabilities {
                 31
             },
             max_samplers_per_stage: 16,
+            max_binding_array_elements: if argument_buffers == metal::MTLArgumentBuffersTier::Tier2
+            {
+                1_000_000
+            } else if family_check && device.supports_family(MTLGPUFamily::Apple4) {
+                96
+            } else {
+                31
+            },
+            max_sampler_binding_array_elements: if family_check
+                && device.supports_family(MTLGPUFamily::Apple9)
+            {
+                500_000
+            } else if family_check
+                && (device.supports_family(MTLGPUFamily::Apple7)
+                    || device.supports_family(MTLGPUFamily::Mac2))
+            {
+                1000
+            } else if family_check && device.supports_family(MTLGPUFamily::Apple6) {
+                128
+            } else {
+                16
+            },
             buffer_alignment: if os_is_mac || os_is_xr { 256 } else { 64 },
             max_buffer_size: if version.at_least((10, 14), (12, 0), os_is_mac) {
                 // maxBufferLength available on macOS 10.14+ and iOS 12.0+
@@ -1013,6 +1037,9 @@ impl super::PrivateCapabilities {
                 max_storage_buffers_per_shader_stage: self.max_buffers_per_stage,
                 max_storage_textures_per_shader_stage: self.max_textures_per_stage,
                 max_uniform_buffers_per_shader_stage: self.max_buffers_per_stage,
+                max_binding_array_elements_per_shader_stage: self.max_binding_array_elements,
+                max_binding_array_sampler_elements_per_shader_stage: self
+                    .max_sampler_binding_array_elements,
                 max_uniform_buffer_binding_size: self.max_buffer_size.min(!0u32 as u64) as u32,
                 max_storage_buffer_binding_size: self.max_buffer_size.min(!0u32 as u64) as u32,
                 max_vertex_buffers: self.max_vertex_buffers,

wgpu-hal/src/metal/mod.rs

@@ -261,6 +261,8 @@ struct PrivateCapabilities {
     max_vertex_buffers: ResourceIndex,
     max_textures_per_stage: ResourceIndex,
     max_samplers_per_stage: ResourceIndex,
+    max_binding_array_elements: ResourceIndex,
+    max_sampler_binding_array_elements: ResourceIndex,
     buffer_alignment: u64,
     max_buffer_size: u64,
     max_texture_size: u64,