Add max_binding_array_acceleration_structure_elements_per_shader_stage limit

kvark · jimblandy · commit adc3534f1ccd · 2026-03-11T08:18:38.000-07:00
diff --git a/tests/tests/wgpu-gpu/binding_array/tlas.rs b/tests/tests/wgpu-gpu/binding_array/tlas.rs
@@ -19,13 +19,11 @@ static BINDING_ARRAY_TLAS: GpuTestConfiguration = GpuTestConfiguration::new()
             .features(
                 Features::EXPERIMENTAL_RAY_QUERY | Features::ACCELERATION_STRUCTURE_BINDING_ARRAY,
             )
-            .limits({
-                let mut limits =
-                    Limits::default().using_minimum_supported_acceleration_structure_values();
-                // Keep this small; we only need a couple of array elements.
-                limits.max_binding_array_elements_per_shader_stage = 8;
-                limits.max_acceleration_structures_per_shader_stage = 8;
-                limits
+            .limits(Limits {
+                max_binding_array_elements_per_shader_stage: 8,
+                max_acceleration_structures_per_shader_stage: 8,
+                max_binding_array_acceleration_structure_elements_per_shader_stage: 8,
+                ..Limits::default().using_minimum_supported_acceleration_structure_values()
             })
             // As of writing, Metal's HAL does not implement binding acceleration structures.
             .skip(FailureCase::backend(Backends::METAL)),
@@ -163,9 +161,7 @@ async fn binding_array_tlas(ctx: TestingContext) {
                 transform_buffer_offset: None,
             }]),
         }),
-        std::iter::empty::<&wgpu::Tlas>()
-            .chain(std::iter::once(&tlas_a))
-            .chain(std::iter::once(&tlas_b)),
+        [&tlas_a, &tlas_b],
     );
 
     ctx.queue.submit(Some(encoder.finish()));
diff --git a/wgpu-core/src/binding_model.rs b/wgpu-core/src/binding_model.rs
@@ -327,6 +327,7 @@ pub enum BindingTypeMaxCountErrorKind {
     UniformBuffers,
     BindingArrayElements,
     BindingArraySamplerElements,
+    BindingArrayAccelerationStructureElements,
     AccelerationStructures,
 }
 
@@ -354,6 +355,9 @@ impl BindingTypeMaxCountErrorKind {
             BindingTypeMaxCountErrorKind::BindingArraySamplerElements => {
                 "max_binding_array_sampler_elements_per_shader_stage"
             }
+            BindingTypeMaxCountErrorKind::BindingArrayAccelerationStructureElements => {
+                "max_binding_array_acceleration_structure_elements_per_shader_stage"
+            }
             BindingTypeMaxCountErrorKind::AccelerationStructures => {
                 "max_acceleration_structures_per_shader_stage"
             }
@@ -433,6 +437,7 @@ pub(crate) struct BindingTypeMaxCountValidator {
     acceleration_structures: PerStageBindingTypeCounter,
     binding_array_elements: PerStageBindingTypeCounter,
     binding_array_sampler_elements: PerStageBindingTypeCounter,
+    binding_array_acceleration_structure_elements: PerStageBindingTypeCounter,
     has_bindless_array: bool,
 }
 
@@ -444,9 +449,16 @@ impl BindingTypeMaxCountValidator {
             self.binding_array_elements.add(binding.visibility, count);
             self.has_bindless_array = true;
 
-            if let wgt::BindingType::Sampler(_) = binding.ty {
-                self.binding_array_sampler_elements
-                    .add(binding.visibility, count);
+            match binding.ty {
+                wgt::BindingType::Sampler(_) => {
+                    self.binding_array_sampler_elements
+                        .add(binding.visibility, count);
+                }
+                wgt::BindingType::AccelerationStructure { .. } => {
+                    self.binding_array_acceleration_structure_elements
+                        .add(binding.visibility, count);
+                }
+                _ => {}
             }
         } else {
             match binding.ty {
@@ -513,6 +525,8 @@ impl BindingTypeMaxCountValidator {
             .merge(&other.binding_array_elements);
         self.binding_array_sampler_elements
             .merge(&other.binding_array_sampler_elements);
+        self.binding_array_acceleration_structure_elements
+            .merge(&other.binding_array_acceleration_structure_elements);
     }
 
     pub(crate) fn validate(&self, limits: &wgt::Limits) -> Result<(), BindingTypeMaxCountError> {
@@ -560,6 +574,11 @@ impl BindingTypeMaxCountValidator {
             limits.max_binding_array_sampler_elements_per_shader_stage,
             BindingTypeMaxCountErrorKind::BindingArraySamplerElements,
         )?;
+        self.binding_array_acceleration_structure_elements
+            .validate(
+                limits.max_binding_array_acceleration_structure_elements_per_shader_stage,
+                BindingTypeMaxCountErrorKind::BindingArrayAccelerationStructureElements,
+            )?;
         self.acceleration_structures.validate(
             limits.max_acceleration_structures_per_shader_stage,
             BindingTypeMaxCountErrorKind::AccelerationStructures,
diff --git a/wgpu-hal/src/dx12/adapter.rs b/wgpu-hal/src/dx12/adapter.rs
@@ -925,7 +925,12 @@ impl super::Adapter {
                     } else {
                         0
                     },
-
+                    max_binding_array_acceleration_structure_elements_per_shader_stage:
+                        if supports_ray_tracing {
+                            max_srv_count / 2
+                        } else {
+                            0
+                        },
                     max_multiview_view_count,
                 }),
                 alignments: crate::Alignments {
diff --git a/wgpu-hal/src/gles/adapter.rs b/wgpu-hal/src/gles/adapter.rs
@@ -715,6 +715,7 @@ impl super::Adapter {
             max_uniform_buffers_per_shader_stage,
             max_binding_array_elements_per_shader_stage: 0,
             max_binding_array_sampler_elements_per_shader_stage: 0,
+            max_binding_array_acceleration_structure_elements_per_shader_stage: 0,
             max_uniform_buffer_binding_size: unsafe {
                 gl.get_parameter_i32(glow::MAX_UNIFORM_BLOCK_SIZE)
             } as u64,
diff --git a/wgpu-hal/src/metal/adapter.rs b/wgpu-hal/src/metal/adapter.rs
@@ -1178,6 +1178,7 @@ impl super::PrivateCapabilities {
             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_binding_array_acceleration_structure_elements_per_shader_stage: 0,
             // Note: any adjustment here will not be reflected in the stored `PrivateCapabilities`.
             max_uniform_buffer_binding_size: self.max_buffer_size.min(!0u32 as u64),
             max_storage_buffer_binding_size: self.max_buffer_size.min(!0u32 as u64)
diff --git a/wgpu-hal/src/noop/mod.rs b/wgpu-hal/src/noop/mod.rs
@@ -179,6 +179,7 @@ pub const CAPABILITIES: crate::Capabilities = {
             max_uniform_buffers_per_shader_stage: ALLOC_MAX_U32,
             max_binding_array_elements_per_shader_stage: ALLOC_MAX_U32,
             max_binding_array_sampler_elements_per_shader_stage: ALLOC_MAX_U32,
+            max_binding_array_acceleration_structure_elements_per_shader_stage: ALLOC_MAX_U32,
             max_uniform_buffer_binding_size: ALLOC_MAX_U64,
             max_storage_buffer_binding_size: ALLOC_MAX_U64,
             max_vertex_buffers: ALLOC_MAX_U32,
diff --git a/wgpu-hal/src/vulkan/adapter.rs b/wgpu-hal/src/vulkan/adapter.rs
@@ -1478,6 +1478,14 @@ impl PhysicalDeviceProperties {
             max_uniform_buffers_per_shader_stage: limits.max_per_stage_descriptor_uniform_buffers,
             max_binding_array_elements_per_shader_stage: max_binding_array_elements,
             max_binding_array_sampler_elements_per_shader_stage: max_sampler_binding_array_elements,
+            max_binding_array_acceleration_structure_elements_per_shader_stage: if self
+                .descriptor_indexing
+                .is_some()
+            {
+                max_acceleration_structures_per_shader_stage
+            } else {
+                0
+            },
             max_uniform_buffer_binding_size: limits
                 .max_uniform_buffer_range
                 .min(crate::auxil::MAX_I32_BINDING_SIZE)
diff --git a/wgpu-info/src/human.rs b/wgpu-info/src/human.rs
@@ -158,6 +158,7 @@ fn print_adapter(output: &mut impl io::Write, report: &AdapterReport, idx: usize
         max_uniform_buffers_per_shader_stage,
         max_binding_array_elements_per_shader_stage,
         max_binding_array_sampler_elements_per_shader_stage,
+        max_binding_array_acceleration_structure_elements_per_shader_stage,
         max_uniform_buffer_binding_size,
         max_storage_buffer_binding_size,
         max_vertex_buffers,
@@ -212,6 +213,7 @@ fn print_adapter(output: &mut impl io::Write, report: &AdapterReport, idx: usize
     writeln!(output, "\t\t               Max Uniform Buffers Per Shader Stage: {max_uniform_buffers_per_shader_stage}")?;
     writeln!(output, "\t\t        Max Binding Array Elements Per Shader Stage: {max_binding_array_elements_per_shader_stage}")?;
     writeln!(output, "\t\tMax Binding Array Sampler Elements Per Shader Stage: {max_binding_array_sampler_elements_per_shader_stage}")?;
+    writeln!(output, "\t\t   Max Binding Array AS Elements Per Shader Stage: {max_binding_array_acceleration_structure_elements_per_shader_stage}")?;
     writeln!(output, "\t\t                    Max Uniform Buffer Binding Size: {max_uniform_buffer_binding_size}")?;
     writeln!(output, "\t\t                    Max Storage Buffer Binding Size: {max_storage_buffer_binding_size}")?;
     writeln!(output, "\t\t                                    Max Buffer Size: {max_buffer_size}")?;
diff --git a/wgpu-types/src/limits.rs b/wgpu-types/src/limits.rs
@@ -38,6 +38,10 @@ macro_rules! with_limits {
         $macro_name!(max_storage_textures_per_shader_stage, Ordering::Less);
         $macro_name!(max_uniform_buffers_per_shader_stage, Ordering::Less);
         $macro_name!(max_binding_array_elements_per_shader_stage, Ordering::Less);
+        $macro_name!(
+            max_binding_array_acceleration_structure_elements_per_shader_stage,
+            Ordering::Less
+        );
         $macro_name!(max_uniform_buffer_binding_size, Ordering::Less);
         $macro_name!(max_storage_buffer_binding_size, Ordering::Less);
         $macro_name!(max_vertex_buffers, Ordering::Less);
@@ -155,6 +159,10 @@ pub struct Limits {
     ///
     /// This "defaults" to 0. However if binding arrays are supported, all devices can support 500,000. Higher is "better".
     pub max_binding_array_elements_per_shader_stage: u32,
+    /// Amount of individual acceleration structures within binding arrays that can be accessed in a single shader stage.
+    ///
+    /// This "defaults" to 0. Higher is "better".
+    pub max_binding_array_acceleration_structure_elements_per_shader_stage: u32,
     /// Amount of individual samplers within binding arrays that can be accessed in a single shader stage.
     ///
     /// This "defaults" to 0. However if binding arrays are supported, all devices can support 1,000. Higher is "better".
@@ -318,6 +326,7 @@ impl Limits {
     ///     max_storage_textures_per_shader_stage: 4,
     ///     max_uniform_buffers_per_shader_stage: 12,
     ///     max_binding_array_elements_per_shader_stage: 0,
+    ///     max_binding_array_acceleration_structure_elements_per_shader_stage: 0,
     ///     max_binding_array_sampler_elements_per_shader_stage: 0,
     ///     max_uniform_buffer_binding_size: 64 << 10, // (64 KiB)
     ///     max_storage_buffer_binding_size: 128 << 20, // (128 MiB)
@@ -376,6 +385,7 @@ impl Limits {
             max_storage_textures_per_shader_stage: 4,
             max_uniform_buffers_per_shader_stage: 12,
             max_binding_array_elements_per_shader_stage: 0,
+            max_binding_array_acceleration_structure_elements_per_shader_stage: 0,
             max_binding_array_sampler_elements_per_shader_stage: 0,
             max_uniform_buffer_binding_size: 64 << 10, // (64 KiB)
             max_storage_buffer_binding_size: 128 << 20, // (128 MiB)
@@ -438,6 +448,7 @@ impl Limits {
     ///     max_storage_textures_per_shader_stage: 4,
     ///     max_uniform_buffers_per_shader_stage: 12,
     ///     max_binding_array_elements_per_shader_stage: 0,
+    ///     max_binding_array_acceleration_structure_elements_per_shader_stage: 0,
     ///     max_binding_array_sampler_elements_per_shader_stage: 0,
     ///     max_uniform_buffer_binding_size: 16 << 10, // * (16 KiB)
     ///     max_storage_buffer_binding_size: 128 << 20, // (128 MiB)
@@ -516,6 +527,7 @@ impl Limits {
     ///     max_storage_textures_per_shader_stage: 0, // +
     ///     max_uniform_buffers_per_shader_stage: 11, // +
     ///     max_binding_array_elements_per_shader_stage: 0,
+    ///     max_binding_array_acceleration_structure_elements_per_shader_stage: 0,
     ///     max_binding_array_sampler_elements_per_shader_stage: 0,
     ///     max_uniform_buffer_binding_size: 16 << 10, // * (16 KiB)
     ///     max_storage_buffer_binding_size: 0, // * +
diff --git a/wgpu/src/backend/webgpu.rs b/wgpu/src/backend/webgpu.rs
@@ -804,6 +804,7 @@ fn map_wgt_limits(limits: webgpu_sys::GpuSupportedLimits) -> wgt::Limits {
         max_uniform_buffers_per_shader_stage: limits.max_uniform_buffers_per_shader_stage(),
         max_binding_array_elements_per_shader_stage: 0,
         max_binding_array_sampler_elements_per_shader_stage: 0,
+        max_binding_array_acceleration_structure_elements_per_shader_stage: 0,
         max_uniform_buffer_binding_size: limits.max_uniform_buffer_binding_size() as u64,
         max_storage_buffer_binding_size: limits.max_storage_buffer_binding_size() as u64,
         max_vertex_buffers: limits.max_vertex_buffers(),
diff --git a/wgpu/src/backend/wgpu_core.rs b/wgpu/src/backend/wgpu_core.rs
@@ -1193,15 +1193,17 @@ impl dispatch::DeviceInterface for CoreDevice {
         }
         let mut remaining_arrayed_buffer_bindings = &arrayed_buffer_bindings[..];
 
-        // Gather all the TLAS IDs used by TLAS arrays first (same pattern as other arrayed resources).
-        //
-        // Note: there isn't currently a dedicated feature flag for TLAS binding arrays at the wgpu API
-        // layer; validation happens in wgpu-core against `BindGroupLayoutEntry::count`.
         let mut arrayed_acceleration_structures = Vec::new();
-        for entry in desc.entries.iter() {
-            if let BindingResource::AccelerationStructureArray(array) = entry.resource {
-                arrayed_acceleration_structures
-                    .extend(array.iter().map(|tlas| tlas.inner.as_core().id));
+        if self
+            .features
+            .contains(Features::ACCELERATION_STRUCTURE_BINDING_ARRAY)
+        {
+            // Gather all the TLAS IDs used by TLAS arrays first (same pattern as other arrayed resources).
+            for entry in desc.entries.iter() {
+                if let BindingResource::AccelerationStructureArray(array) = entry.resource {
+                    arrayed_acceleration_structures
+                        .extend(array.iter().map(|tlas| tlas.inner.as_core().id));
+                }
             }
         }
         let mut remaining_arrayed_acceleration_structures = &arrayed_acceleration_structures[..];
