Support descriptor arrays shorter than binding length

Author: cwfitzgerald

wgpu-core/src/binding_model.rs

@@ -65,8 +65,16 @@ pub enum CreateBindGroupError {
     InvalidTextureView(TextureViewId),
     #[error("sampler {0:?} is invalid")]
     InvalidSampler(SamplerId),
-    #[error("binding count declared with {expected} items, but {actual} items were provided")]
+    #[error(
+        "binding count declared with at most {expected} items, but {actual} items were provided"
+    )]
+    BindingArrayPartialLengthMismatch { actual: usize, expected: usize },
+    #[error(
+        "binding count declared with exactly {expected} items, but {actual} items were provided"
+    )]
     BindingArrayLengthMismatch { actual: usize, expected: usize },
+    #[error("array binding provided zero elements")]
+    BindingArrayZeroLength,
     #[error("bound buffer range {range:?} does not fit in buffer of size {size}")]
     BindingRangeTooLarge {
         buffer: BufferId,

wgpu-core/src/conv.rs

@@ -152,3 +152,12 @@ pub fn check_texture_dimension_size(
 
     Ok(())
 }
+
+pub fn bind_group_layout_flags(features: wgt::Features) -> hal::BindGroupLayoutFlags {
+    let mut flags = hal::BindGroupLayoutFlags::empty();
+    flags.set(
+        hal::BindGroupLayoutFlags::PARTIALLY_BOUND,
+        features.contains(wgt::Features::PARTIALLY_BOUND_BINDING_ARRAY),
+    );
+    flags
+}

wgpu-core/src/device/mod.rs

@@ -19,7 +19,7 @@ use smallvec::SmallVec;
 use thiserror::Error;
 use wgt::{BufferAddress, TextureFormat, TextureViewDimension};
 
-use std::{borrow::Cow, iter, marker::PhantomData, mem, ops::Range, ptr};
+use std::{borrow::Cow, iter, marker::PhantomData, mem, num::NonZeroU32, ops::Range, ptr};
 
 mod life;
 pub mod queue;
@@ -1183,10 +1183,13 @@ impl<A: HalApi> Device<A> {
                 })?;
         }
 
+        let bgl_flags = conv::bind_group_layout_flags(self.features);
+
         let mut hal_bindings = entry_map.values().cloned().collect::<Vec<_>>();
         hal_bindings.sort_by_key(|b| b.binding);
         let hal_desc = hal::BindGroupLayoutDescriptor {
             label,
+            flags: bgl_flags,
             entries: &hal_bindings,
         };
         let raw = unsafe {
@@ -1387,7 +1390,7 @@ impl<A: HalApi> Device<A> {
                 .entries
                 .get(&binding)
                 .ok_or(Error::MissingBindingDeclaration(binding))?;
-            let res_index = match entry.resource {
+            let (res_index, count) = match entry.resource {
                 Br::Buffer(ref bb) => {
                     let bb = Self::create_buffer_binding(
                         bb,
@@ -1402,21 +1405,11 @@ impl<A: HalApi> Device<A> {
 
                     let res_index = hal_buffers.len();
                     hal_buffers.push(bb);
-                    res_index
+                    (res_index, 1)
                 }
                 Br::BufferArray(ref bindings_array) => {
-                    if let Some(count) = decl.count {
-                        let count = count.get() as usize;
-                        let num_bindings = bindings_array.len();
-                        if count != num_bindings {
-                            return Err(Error::BindingArrayLengthMismatch {
-                                actual: num_bindings,
-                                expected: count,
-                            });
-                        }
-                    } else {
-                        return Err(Error::SingleBindingExpected);
-                    }
+                    let num_bindings = bindings_array.len();
+                    Self::check_array_binding(self.features, decl.count, num_bindings)?;
 
                     let res_index = hal_buffers.len();
                     for bb in bindings_array.iter() {
@@ -1432,7 +1425,7 @@ impl<A: HalApi> Device<A> {
                         )?;
                         hal_buffers.push(bb);
                     }
-                    res_index
+                    (res_index, num_bindings)
                 }
                 Br::Sampler(id) => {
                     match decl.ty {
@@ -1464,7 +1457,7 @@ impl<A: HalApi> Device<A> {
 
                             let res_index = hal_samplers.len();
                             hal_samplers.push(&sampler.raw);
-                            res_index
+                            (res_index, 1)
                         }
                         _ => {
                             return Err(Error::WrongBindingType {
@@ -1505,21 +1498,11 @@ impl<A: HalApi> Device<A> {
                         view: &view.raw,
                         usage: internal_use,
                     });
-                    res_index
+                    (res_index, 1)
                 }
                 Br::TextureViewArray(ref bindings_array) => {
-                    if let Some(count) = decl.count {
-                        let count = count.get() as usize;
-                        let num_bindings = bindings_array.len();
-                        if count != num_bindings {
-                            return Err(Error::BindingArrayLengthMismatch {
-                                actual: num_bindings,
-                                expected: count,
-                            });
-                        }
-                    } else {
-                        return Err(Error::SingleBindingExpected);
-                    }
+                    let num_bindings = bindings_array.len();
+                    Self::check_array_binding(self.features, decl.count, num_bindings)?;
 
                     let res_index = hal_textures.len();
                     for &id in bindings_array.iter() {
@@ -1551,13 +1534,14 @@ impl<A: HalApi> Device<A> {
                         });
                     }
 
-                    res_index
+                    (res_index, num_bindings)
                 }
             };
 
             hal_entries.push(hal::BindGroupEntry {
                 binding,
                 resource_index: res_index as u32,
+                count: count as u32,
             });
         }
 
@@ -1596,6 +1580,39 @@ impl<A: HalApi> Device<A> {
         })
     }
 
+    fn check_array_binding(
+        features: wgt::Features,
+        count: Option<NonZeroU32>,
+        num_bindings: usize,
+    ) -> Result<(), super::binding_model::CreateBindGroupError> {
+        use super::binding_model::CreateBindGroupError as Error;
+
+        if let Some(count) = count {
+            let count = count.get() as usize;
+            if count < num_bindings {
+                return Err(Error::BindingArrayPartialLengthMismatch {
+                    actual: num_bindings,
+                    expected: count,
+                });
+            }
+            if count != num_bindings
+                && !features.contains(wgt::Features::PARTIALLY_BOUND_BINDING_ARRAY)
+            {
+                return Err(Error::BindingArrayLengthMismatch {
+                    actual: num_bindings,
+                    expected: count,
+                });
+            }
+            if num_bindings == 0 {
+                return Err(Error::BindingArrayZeroLength);
+            }
+        } else {
+            return Err(Error::SingleBindingExpected);
+        };
+
+        Ok(())
+    }
+
     fn texture_use_parameters(
         binding: u32,
         decl: &wgt::BindGroupLayoutEntry,

wgpu-core/src/instance.rs

@@ -334,10 +334,12 @@ impl<A: HalApi> Adapter<A> {
         desc: &DeviceDescriptor,
         trace_path: Option<&std::path::Path>,
     ) -> Result<Device<A>, RequestDeviceError> {
-        let open = unsafe { self.raw.adapter.open(desc.features) }.map_err(|err| match err {
-            hal::DeviceError::Lost => RequestDeviceError::DeviceLost,
-            hal::DeviceError::OutOfMemory => RequestDeviceError::OutOfMemory,
-        })?;
+        let open = unsafe { self.raw.adapter.open(desc.features, &desc.limits) }.map_err(
+            |err| match err {
+                hal::DeviceError::Lost => RequestDeviceError::DeviceLost,
+                hal::DeviceError::OutOfMemory => RequestDeviceError::OutOfMemory,
+            },
+        )?;
 
         self.create_device_from_hal(self_id, open, desc, trace_path)
     }

wgpu-hal/examples/halmark/main.rs

@@ -102,8 +102,11 @@ impl<A: hal::Api> Example<A> {
             );
             (exposed.adapter, exposed.capabilities)
         };
-        let hal::OpenDevice { device, mut queue } =
-            unsafe { adapter.open(wgt::Features::empty()).unwrap() };
+        let hal::OpenDevice { device, mut queue } = unsafe {
+            adapter
+                .open(wgt::Features::empty(), &wgt::Limits::default())
+                .unwrap()
+        };
 
         let window_size: (u32, u32) = window.inner_size().into();
         let surface_config = hal::SurfaceConfiguration {
@@ -146,6 +149,7 @@ impl<A: hal::Api> Example<A> {
 
         let global_bgl_desc = hal::BindGroupLayoutDescriptor {
             label: None,
+            flags: hal::BindGroupLayoutFlags::empty(),
             entries: &[
                 wgt::BindGroupLayoutEntry {
                     binding: 0,
@@ -183,6 +187,8 @@ impl<A: hal::Api> Example<A> {
             unsafe { device.create_bind_group_layout(&global_bgl_desc).unwrap() };
 
         let local_bgl_desc = hal::BindGroupLayoutDescriptor {
+            label: None,
+            flags: hal::BindGroupLayoutFlags::empty(),
             entries: &[wgt::BindGroupLayoutEntry {
                 binding: 0,
                 visibility: wgt::ShaderStages::VERTEX,
@@ -193,7 +199,6 @@ impl<A: hal::Api> Example<A> {
                 },
                 count: None,
             }],
-            label: None,
         };
         let local_group_layout =
             unsafe { device.create_bind_group_layout(&local_bgl_desc).unwrap() };
@@ -417,14 +422,17 @@ impl<A: hal::Api> Example<A> {
                     hal::BindGroupEntry {
                         binding: 0,
                         resource_index: 0,
+                        count: 1,
                     },
                     hal::BindGroupEntry {
                         binding: 1,
                         resource_index: 0,
+                        count: 1,
                     },
                     hal::BindGroupEntry {
                         binding: 2,
                         resource_index: 0,
+                        count: 1,
                     },
                 ],
             };
@@ -446,6 +454,7 @@ impl<A: hal::Api> Example<A> {
                 entries: &[hal::BindGroupEntry {
                     binding: 0,
                     resource_index: 0,
+                    count: 1,
                 }],
             };
             unsafe { device.create_bind_group(&local_group_desc).unwrap() }

wgpu-hal/src/dx12/adapter.rs

@@ -262,6 +262,7 @@ impl crate::Adapter<super::Api> for super::Adapter {
     unsafe fn open(
         &self,
         features: wgt::Features,
+        _limits: &wgt::Limits,
     ) -> Result<crate::OpenDevice<super::Api>, crate::DeviceError> {
         let queue = self
             .device

wgpu-hal/src/empty.rs

@@ -74,7 +74,11 @@ impl crate::Surface<Api> for Context {
 }
 
 impl crate::Adapter<Api> for Context {
-    unsafe fn open(&self, features: wgt::Features) -> DeviceResult<crate::OpenDevice<Api>> {
+    unsafe fn open(
+        &self,
+        features: wgt::Features,
+        _limits: &wgt::Limits,
+    ) -> DeviceResult<crate::OpenDevice<Api>> {
         Err(crate::DeviceError::Lost)
     }
     unsafe fn texture_format_capabilities(

wgpu-hal/src/gles/adapter.rs

@@ -419,6 +419,7 @@ impl crate::Adapter<super::Api> for super::Adapter {
     unsafe fn open(
         &self,
         features: wgt::Features,
+        _limits: &wgt::Limits,
     ) -> Result<crate::OpenDevice<super::Api>, crate::DeviceError> {
         let gl = &self.shared.context.lock();
         gl.pixel_store_i32(glow::UNPACK_ALIGNMENT, 1);

wgpu-hal/src/lib.rs

@@ -188,7 +188,11 @@ pub trait Surface<A: Api>: Send + Sync {
 }
 
 pub trait Adapter<A: Api>: Send + Sync {
-    unsafe fn open(&self, features: wgt::Features) -> Result<OpenDevice<A>, DeviceError>;
+    unsafe fn open(
+        &self,
+        features: wgt::Features,
+        limits: &wgt::Limits,
+    ) -> Result<OpenDevice<A>, DeviceError>;
 
     /// Return the set of supported capabilities for a texture format.
     unsafe fn texture_format_capabilities(
@@ -524,6 +528,14 @@ bitflags!(
     }
 );
 
+bitflags!(
+    /// Pipeline layout creation flags.
+    pub struct BindGroupLayoutFlags: u32 {
+        /// Allows for bind group binding arrays to be shorter than the array in the BGL.
+        const PARTIALLY_BOUND = 1 << 0;
+    }
+);
+
 bitflags!(
     /// Texture format capability flags.
     pub struct TextureFormatCapabilities: u32 {
@@ -798,6 +810,7 @@ pub struct SamplerDescriptor<'a> {
 #[derive(Clone, Debug)]
 pub struct BindGroupLayoutDescriptor<'a> {
     pub label: Label<'a>,
+    pub flags: BindGroupLayoutFlags,
     pub entries: &'a [wgt::BindGroupLayoutEntry],
 }
 
@@ -847,6 +860,7 @@ impl<A: Api> Clone for TextureBinding<'_, A> {
 pub struct BindGroupEntry {
     pub binding: u32,
     pub resource_index: u32,
+    pub count: u32,
 }
 
 /// BindGroup descriptor.

wgpu-hal/src/metal/adapter.rs

@@ -19,6 +19,7 @@ impl crate::Adapter<super::Api> for super::Adapter {
     unsafe fn open(
         &self,
         features: wgt::Features,
+        _limits: &wgt::Limits,
     ) -> Result<crate::OpenDevice<super::Api>, crate::DeviceError> {
         let queue = self
             .shared