Improve dynamic offset binding errors

CHANGELOG.md

@@ -158,6 +158,7 @@ Additionally `Surface::get_default_config` now returns an Option and returns Non
 - Make `RenderPassCompatibilityError` and `CreateShaderModuleError` not so huge. By @jimblandy in (#3226)[https://github.com/gfx-rs/wgpu/pull/3226]
 - Check for invalid bitflag bits in wgpu-core and allow them to be captured/replayed by @nical in (#3229)[https://github.com/gfx-rs/wgpu/pull/3229]
 - Evaluate `gfx_select!`'s `#[cfg]` conditions at the right time. By @jimblandy in [#3253](https://github.com/gfx-rs/wgpu/pull/3253)
+- Improve error messages when binding bind group with dynamic offsets. By @cwfitzgerald in [#3294](https://github.com/gfx-rs/wgpu/pull/3294)
 
 #### WebGPU
 
@@ -193,7 +194,7 @@ Additionally `Surface::get_default_config` now returns an Option and returns Non
 - Use cargo 1.64 workspace inheritance feature. By @jinleili in [#3107](https://github.com/gfx-rs/wgpu/pull/3107)
 - Move `ResourceMetadata` into its own module. By @jimblandy in [#3213](https://github.com/gfx-rs/wgpu/pull/3213)
 - Add WebAssembly testing infrastructure. By @haraldreingruber in [#3238](https://github.com/gfx-rs/wgpu/pull/3238)
-- Error message when you forget to use cargo-nextest. By @cwfitzgerald in [#]()
+- Error message when you forget to use cargo-nextest. By @cwfitzgerald in [#3293](https://github.com/gfx-rs/wgpu/pull/3293)
 
 #### Vulkan
 

wgpu-core/src/binding_model.rs

@@ -683,23 +683,56 @@ pub enum BindingResource<'a> {
 
 #[derive(Clone, Debug, Error)]
 pub enum BindError {
-    #[error("number of dynamic offsets ({actual}) doesn't match the number of dynamic bindings in the bind group layout ({expected})")]
-    MismatchedDynamicOffsetCount { actual: usize, expected: usize },
     #[error(
-        "dynamic binding at index {idx}: offset {offset} does not respect device's requested `{limit_name}` limit {alignment}"
+        "Bind group {group} expects {expected} dynamic offset{s0}. However {actual} dynamic offset{s1} were provided.",
+        s0 = if *.expected >= 2 { "s" } else { "" },
+        s1 = if *.actual >= 2 { "s" } else { "" },
+    )]
+    MismatchedDynamicOffsetCount {
+        group: u8,
+        actual: usize,
+        expected: usize,
+    },
+    #[error(
+        "Dynamic binding index {idx} (targeting bind group {group}, binding {binding}) with value {offset}, does not respect device's requested `{limit_name}` limit: {alignment}"
     )]
     UnalignedDynamicBinding {
         idx: usize,
+        group: u8,
+        binding: u32,
         offset: u32,
         alignment: u32,
         limit_name: &'static str,
     },
-    #[error("dynamic binding at index {idx} with offset {offset} would overrun the buffer (limit: {max})")]
-    DynamicBindingOutOfBounds { idx: usize, offset: u32, max: u64 },
+    #[error(
+        "Dynamic binding offset index {idx} with offset {offset} would overrun the buffer bound to bind group {group} -> binding {binding}. \
+         Buffer size is {buffer_size} bytes, the binding binds bytes {binding_range:?}, meaning the maximum the binding can be offset is {maximum_dynamic_offset} bytes",
+    )]
+    DynamicBindingOutOfBounds {
+        idx: usize,
+        group: u8,
+        binding: u32,
+        offset: u32,
+        buffer_size: wgt::BufferAddress,
+        binding_range: Range<wgt::BufferAddress>,
+        maximum_dynamic_offset: wgt::BufferAddress,
+    },
 }
 
 #[derive(Debug)]
 pub struct BindGroupDynamicBindingData {
+    /// The index of the binding.
+    ///
+    /// Used for more descriptive errors.
+    pub(crate) binding_idx: u32,
+    /// The size of the buffer.
+    ///
+    /// Used for more descriptive errors.
+    pub(crate) buffer_size: wgt::BufferAddress,
+    /// The range that the binding covers.
+    ///
+    /// Used for more descriptive errors.
+    pub(crate) binding_range: Range<wgt::BufferAddress>,
     /// The maximum value the dynamic offset can have before running off the end of the buffer.
     pub(crate) maximum_dynamic_offset: wgt::BufferAddress,
     /// The binding type.
@@ -739,11 +772,13 @@ pub struct BindGroup<A: HalApi> {
 impl<A: HalApi> BindGroup<A> {
     pub(crate) fn validate_dynamic_bindings(
         &self,
+        bind_group_index: u8,
         offsets: &[wgt::DynamicOffset],
         limits: &wgt::Limits,
     ) -> Result<(), BindError> {
         if self.dynamic_binding_info.len() != offsets.len() {
             return Err(BindError::MismatchedDynamicOffsetCount {
+                group: bind_group_index,
                 expected: self.dynamic_binding_info.len(),
                 actual: offsets.len(),
             });
@@ -758,6 +793,8 @@ impl<A: HalApi> BindGroup<A> {
             let (alignment, limit_name) = buffer_binding_type_alignment(limits, info.binding_type);
             if offset as wgt::BufferAddress % alignment as u64 != 0 {
                 return Err(BindError::UnalignedDynamicBinding {
+                    group: bind_group_index,
+                    binding: info.binding_idx,
                     idx,
                     offset,
                     alignment,
@@ -767,9 +804,13 @@ impl<A: HalApi> BindGroup<A> {
 
             if offset as wgt::BufferAddress > info.maximum_dynamic_offset {
                 return Err(BindError::DynamicBindingOutOfBounds {
+                    group: bind_group_index,
+                    binding: info.binding_idx,
                     idx,
                     offset,
-                    max: info.maximum_dynamic_offset,
+                    buffer_size: info.buffer_size,
+                    binding_range: info.binding_range.clone(),
+                    maximum_dynamic_offset: info.maximum_dynamic_offset,
                 });
             }
         }

wgpu-core/src/command/compute.rs

@@ -428,7 +428,7 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
                         .ok_or(ComputePassErrorInner::InvalidBindGroup(bind_group_id))
                         .map_pass_err(scope)?;
                     bind_group
-                        .validate_dynamic_bindings(&temp_offsets, &cmd_buf.limits)
+                        .validate_dynamic_bindings(index, &temp_offsets, &cmd_buf.limits)
                         .map_pass_err(scope)?;
 
                     cmd_buf.buffer_memory_init_actions.extend(

wgpu-core/src/command/render.rs

@@ -1238,7 +1238,7 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
                             .ok_or(RenderCommandError::InvalidBindGroup(bind_group_id))
                             .map_pass_err(scope)?;
                         bind_group
-                            .validate_dynamic_bindings(&temp_offsets, &cmd_buf.limits)
+                            .validate_dynamic_bindings(index, &temp_offsets, &cmd_buf.limits)
                             .map_pass_err(scope)?;
 
                         // merge the resource tracker in

wgpu-core/src/device/mod.rs

@@ -1732,6 +1732,9 @@ impl<A: HalApi> Device<A> {
         // Record binding info for validating dynamic offsets
         if dynamic {
             dynamic_binding_info.push(binding_model::BindGroupDynamicBindingData {
+                binding_idx: binding,
+                buffer_size: buffer.size,
+                binding_range: bb.offset..bind_end,
                 maximum_dynamic_offset: buffer.size - bind_end,
                 binding_type: binding_ty,
             });