Expose Metal MULTI_DRAW_INDIRECT_COUNT via prepass ICBs

Rebuilt on the reworked gfx-rs#9640 prepass architecture:

multi_draw_*_indirect_count (draw, indexed, and mesh-task) executes
through a GPU-generated indirect command buffer driven by an execution
range that a deferred kernel clamps to min(count, max_count), so the
draw count is never read by the CPU. The range clamp and ICB generation
ride the same internal pre-pass command buffer as indirect validation.

Because MULTI_DRAW_INDIRECT_COUNT is advertised per adapter but some
pipelines cannot execute inside an ICB (on current Apple silicon
drivers, any fragment shader that accesses a texture through direct
bindings is rejected — verified empirically on M4; textures bound
through argument buffers are accepted, which matches the constraint
Dawn is migrating to argument buffers to lift), count draws under such
pipelines fall back to a GPU-clamped copy of the argument buffer
consumed by a fixed-length per-draw loop. The count still never
round-trips through the CPU. A new sampled-texture count test covers
the fallback; the existing count readback tests were also verified
against the fallback path directly on M4 hardware.

Also adds wgpu_types::INDIRECT_BUFFER_OFFSET_ALIGNMENT (review asked
for a named alignment rather than a hardcoded 4), validates the count
buffer offset against it, restores the deno chromium-experimental-
multi-draw-indirect surface, and documents the Metal behavior on the
feature flag.

Author: matthargett

CHANGELOG.md

@@ -44,9 +44,14 @@ Bottom level categories:
 
 ### Added/New Features
 
+#### General
+
+- Added `wgpu_types::INDIRECT_BUFFER_OFFSET_ALIGNMENT` naming the required 4-byte alignment of indirect-argument buffer offsets, and validate that the count-buffer offset in `multi_draw_*_indirect_count` honors it. By @matthargett in [#9679](https://github.com/gfx-rs/wgpu/pull/9679).
+
 #### Metal
 
 - Metal now lowers fixed-count `multi_draw_indirect` / `multi_draw_indexed_indirect` (and their mesh-task counterpart) with 8 or more draws to GPU-generated indirect command buffers. The generation compute runs in the internal pre-pass command buffer that already carries indirect-draw validation, so the render pass is never interrupted. By @matthargett in [#9640](https://github.com/gfx-rs/wgpu/pull/9640).
+- Expose `MULTI_DRAW_INDIRECT_COUNT` on Metal when indirect command buffers are supported. `multi_draw_*_indirect_count` executes through a GPU-generated indirect command buffer with a GPU-clamped execution range; draws recorded with a pipeline that can't execute inside an ICB fall back to a series of indirect draws over GPU-clamped arguments. The draw count is never read by the CPU. By @matthargett in [#9679](https://github.com/gfx-rs/wgpu/pull/9679).
 
 #### Hal
 

deno_webgpu/adapter.rs

@@ -93,8 +93,17 @@ impl GPUAdapter {
     self.features.get(scope, |scope| {
       let features = self.instance.adapter_features(self.id);
       // Only expose WebGPU features, not wgpu native-only features
-      let features = features & wgpu_types::Features::all_webgpu_mask();
-      GPUSupportedFeatures::new(scope, features)
+      let mut exposed_features =
+        features & wgpu_types::Features::all_webgpu_mask();
+      // Exception: `MULTI_DRAW_INDIRECT_COUNT` is native-only in wgpu, but
+      // Chromium exposes the same capability to WebGPU as the experimental
+      // feature "chromium-experimental-multi-draw-indirect", so we surface it
+      // under that name (see `GPUSupportedFeatures` and `webidl.rs`).
+      exposed_features.set(
+        wgpu_types::Features::MULTI_DRAW_INDIRECT_COUNT,
+        features.contains(wgpu_types::Features::MULTI_DRAW_INDIRECT_COUNT),
+      );
+      GPUSupportedFeatures::new(scope, exposed_features)
     })
   }
 
@@ -480,7 +489,13 @@ impl GPUSupportedFeatures {
     let set = v8::Set::new(scope);
 
     for feature in features.iter() {
-      let key = v8::String::new(scope, feature.as_str().unwrap()).unwrap();
+      let name = match feature {
+        wgpu_types::Features::MULTI_DRAW_INDIRECT_COUNT => {
+          "chromium-experimental-multi-draw-indirect"
+        }
+        _ => feature.as_str().unwrap(),
+      };
+      let key = v8::String::new(scope, name).unwrap();
       set.add(scope, key.into());
     }
 

deno_webgpu/render_pass.rs

@@ -448,6 +448,80 @@ impl GPURenderPassEncoder {
     self.error_handler.push_error(err);
   }
 
+  #[required(3)]
+  #[undefined]
+  fn multi_draw_indirect(
+    &self,
+    #[webidl] indirect_buffer: Ptr<GPUBuffer>,
+    #[webidl(options(enforce_range = true))] indirect_offset: u64,
+    #[webidl(options(enforce_range = true))] max_draw_count: u32,
+    #[webidl] draw_count_buffer: Option<Ptr<GPUBuffer>>,
+    #[webidl(default = 0, options(enforce_range = true))]
+    draw_count_buffer_offset: u64,
+  ) {
+    let err = if let Some(draw_count_buffer) = draw_count_buffer {
+      self
+        .instance
+        .render_pass_multi_draw_indirect_count(
+          &mut self.render_pass.borrow_mut(),
+          indirect_buffer.id,
+          indirect_offset,
+          draw_count_buffer.id,
+          draw_count_buffer_offset,
+          max_draw_count,
+        )
+        .err()
+    } else {
+      self
+        .instance
+        .render_pass_multi_draw_indirect(
+          &mut self.render_pass.borrow_mut(),
+          indirect_buffer.id,
+          indirect_offset,
+          max_draw_count,
+        )
+        .err()
+    };
+    self.error_handler.push_error(err);
+  }
+
+  #[required(3)]
+  #[undefined]
+  fn multi_draw_indexed_indirect(
+    &self,
+    #[webidl] indirect_buffer: Ptr<GPUBuffer>,
+    #[webidl(options(enforce_range = true))] indirect_offset: u64,
+    #[webidl(options(enforce_range = true))] max_draw_count: u32,
+    #[webidl] draw_count_buffer: Option<Ptr<GPUBuffer>>,
+    #[webidl(default = 0, options(enforce_range = true))]
+    draw_count_buffer_offset: u64,
+  ) {
+    let err = if let Some(draw_count_buffer) = draw_count_buffer {
+      self
+        .instance
+        .render_pass_multi_draw_indexed_indirect_count(
+          &mut self.render_pass.borrow_mut(),
+          indirect_buffer.id,
+          indirect_offset,
+          draw_count_buffer.id,
+          draw_count_buffer_offset,
+          max_draw_count,
+        )
+        .err()
+    } else {
+      self
+        .instance
+        .render_pass_multi_draw_indexed_indirect(
+          &mut self.render_pass.borrow_mut(),
+          indirect_buffer.id,
+          indirect_offset,
+          max_draw_count,
+        )
+        .err()
+    };
+    self.error_handler.push_error(err);
+  }
+
   #[required(2)]
   #[undefined]
   fn set_immediates<'a>(

deno_webgpu/webidl.rs

@@ -374,7 +374,13 @@ impl<'a> WebIdlConverter<'a> for GPUFeatureName {
     _options: &Self::Options,
   ) -> Result<Self, WebIdlError> {
     let s = value.to_rust_string_lossy(scope);
-    s.parse().map(Self).map_err(|()| {
+    let feature = match s.as_str() {
+      "chromium-experimental-multi-draw-indirect" => {
+        Ok(wgpu_types::Features::MULTI_DRAW_INDIRECT_COUNT)
+      }
+      _ => s.parse(),
+    };
+    feature.map(Self).map_err(|()| {
       WebIdlError::new(
         prefix,
         context,

tests/tests/wgpu-gpu/draw_indirect.rs

@@ -35,6 +35,7 @@ pub fn all_tests(vec: &mut Vec<GpuTestInitializer>) {
         MULTI_DRAW_INDEXED_INDIRECT_GPU_GENERATED_ARGS,
         MULTI_DRAW_INDIRECT_COUNT_READBACK,
         MULTI_DRAW_INDEXED_INDIRECT_COUNT_READBACK,
+        MULTI_DRAW_INDIRECT_COUNT_SAMPLED_TEXTURE,
         MULTI_DRAW_INDIRECT_OVER_ICB_WORKGROUP,
         MULTI_DRAW_INDIRECT_FIRST_VERTEX_AND_INSTANCE,
         MULTI_DRAW_INDIRECT_MIXED_SEQUENCE,
@@ -1350,6 +1351,171 @@ static MULTI_DRAW_INDEXED_INDIRECT_COUNT_READBACK: GpuTestConfiguration =
         )
         .run_async(|ctx| run_multi_draw_indirect_count_readback(ctx, true));
 
+/// Like `run_multi_draw_indirect_count_readback`, but the fragment shader
+/// samples a texture. On Metal GPUs where sampled textures exclude a pipeline
+/// from indirect-command-buffer execution, this exercises the GPU-clamped
+/// per-draw fallback instead of the ICB path.
+async fn run_multi_draw_indirect_count_sampled_texture(ctx: TestingContext) {
+    let shader = ctx
+        .device
+        .create_shader_module(wgpu::ShaderModuleDescriptor {
+            label: Some("count sampled texture"),
+            source: wgpu::ShaderSource::Wgsl(
+                "
+                @group(0) @binding(0) var color_texture: texture_2d<f32>;
+                @group(0) @binding(1) var color_sampler: sampler;
+
+                @vertex
+                fn vs_main(@builtin(vertex_index) vertex_index: u32) -> @builtin(position) vec4<f32> {
+                    // One triangle covering the whole viewport; only
+                    // `first_vertex == 0` draws are issued, since
+                    // `vertex_index`'s interaction with `first_vertex` differs
+                    // per backend on the (unvalidated) count path and isn't
+                    // what this test targets.
+                    var positions = array<vec2<f32>, 3>(
+                        vec2<f32>(-1.0, -3.0),
+                        vec2<f32>(3.0, 1.0),
+                        vec2<f32>(-1.0, 1.0),
+                    );
+                    return vec4<f32>(positions[vertex_index], 0.0, 1.0);
+                }
+
+                @fragment
+                fn fs_main() -> @location(0) vec4<f32> {
+                    return textureSample(color_texture, color_sampler, vec2<f32>(0.5, 0.5));
+                }
+                "
+                .into(),
+            ),
+        });
+
+    let white_texture = ctx.device.create_texture_with_data(
+        &ctx.queue,
+        &wgpu::TextureDescriptor {
+            label: Some("white 1x1"),
+            size: wgpu::Extent3d {
+                width: 1,
+                height: 1,
+                depth_or_array_layers: 1,
+            },
+            mip_level_count: 1,
+            sample_count: 1,
+            dimension: wgpu::TextureDimension::D2,
+            format: wgpu::TextureFormat::Rgba8Unorm,
+            usage: wgpu::TextureUsages::TEXTURE_BINDING | wgpu::TextureUsages::COPY_DST,
+            view_formats: &[],
+        },
+        wgpu::util::TextureDataOrder::LayerMajor,
+        &[u8::MAX; 4],
+    );
+    let sampler = ctx
+        .device
+        .create_sampler(&wgpu::SamplerDescriptor::default());
+
+    let pipeline = ctx
+        .device
+        .create_render_pipeline(&wgpu::RenderPipelineDescriptor {
+            label: Some("count sampled texture"),
+            layout: None,
+            vertex: wgpu::VertexState {
+                module: &shader,
+                entry_point: Some("vs_main"),
+                compilation_options: Default::default(),
+                buffers: &[],
+            },
+            fragment: Some(wgpu::FragmentState {
+                module: &shader,
+                entry_point: Some("fs_main"),
+                compilation_options: Default::default(),
+                targets: &[Some(wgpu::TextureFormat::Rgba8Unorm.into())],
+            }),
+            primitive: wgpu::PrimitiveState::default(),
+            depth_stencil: None,
+            multisample: wgpu::MultisampleState::default(),
+            multiview_mask: None,
+            cache: None,
+        });
+    let bind_group = ctx.device.create_bind_group(&wgpu::BindGroupDescriptor {
+        label: None,
+        layout: &pipeline.get_bind_group_layout(0),
+        entries: &[
+            wgpu::BindGroupEntry {
+                binding: 0,
+                resource: wgpu::BindingResource::TextureView(
+                    &white_texture.create_view(&wgpu::TextureViewDescriptor::default()),
+                ),
+            },
+            wgpu::BindGroupEntry {
+                binding: 1,
+                resource: wgpu::BindingResource::Sampler(&sampler),
+            },
+        ],
+    });
+
+    let max_draw_count = ICB_MULTI_DRAW_TEST_COUNT as u32;
+    let mut args = vec![
+        wgpu::util::DrawIndirectArgs {
+            vertex_count: 0,
+            instance_count: 1,
+            first_vertex: 0,
+            first_instance: 0,
+        };
+        ICB_MULTI_DRAW_TEST_COUNT
+    ];
+    args[0] = wgpu::util::DrawIndirectArgs {
+        vertex_count: 3,
+        instance_count: 1,
+        first_vertex: 0,
+        first_instance: 0,
+    };
+    let indirect_buffer = create_draw_indirect_buffer(&ctx, &args);
+    let count_buffer = ctx.device.create_buffer_init(&BufferInitDescriptor {
+        label: None,
+        contents: bytemuck::cast_slice(&[1u32]),
+        usage: wgpu::BufferUsages::INDIRECT,
+    });
+
+    let (out_texture, out_texture_view) = create_rgba8_render_target(&ctx, 256, 256);
+    let mut encoder = ctx
+        .device
+        .create_command_encoder(&wgpu::CommandEncoderDescriptor::default());
+    {
+        let mut rpass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
+            label: None,
+            color_attachments: &[Some(wgpu::RenderPassColorAttachment {
+                ops: wgpu::Operations {
+                    load: wgpu::LoadOp::Clear(wgpu::Color::BLACK),
+                    store: wgpu::StoreOp::Store,
+                },
+                resolve_target: None,
+                view: &out_texture_view,
+                depth_slice: None,
+            })],
+            depth_stencil_attachment: None,
+            timestamp_writes: None,
+            occlusion_query_set: None,
+            multiview_mask: None,
+        });
+        rpass.set_pipeline(&pipeline);
+        rpass.set_bind_group(0, &bind_group, &[]);
+        rpass.multi_draw_indirect_count(&indirect_buffer, 0, &count_buffer, 0, max_draw_count);
+    }
+
+    let data = submit_and_read_rgba8_texture(&ctx, encoder, &out_texture, 256, 256).await;
+    assert_all_pixels_rgba8(&data, [u8::MAX; 4]);
+}
+
+#[gpu_test]
+static MULTI_DRAW_INDIRECT_COUNT_SAMPLED_TEXTURE: GpuTestConfiguration =
+    GpuTestConfiguration::new()
+        .parameters(
+            TestParameters::default()
+                .downlevel_flags(wgpu::DownlevelFlags::INDIRECT_EXECUTION)
+                .features(wgpu::Features::MULTI_DRAW_INDIRECT_COUNT)
+                .limits(wgpu::Limits::downlevel_defaults()),
+        )
+        .run_async(run_multi_draw_indirect_count_sampled_texture);
+
 async fn run_gpu_generated_multi_draw_test(ctx: TestingContext, indexed: bool) {
     let draw_count = ICB_MULTI_DRAW_TEST_COUNT as u32;
     let indirect_stride = if indexed {

wgpu-core/src/command/render.rs

@@ -967,8 +967,18 @@ pub enum RenderPassErrorInner {
     MissingFeatures(#[from] MissingFeatures),
     #[error(transparent)]
     MissingDownlevelFlags(#[from] MissingDownlevelFlags),
-    #[error("Indirect buffer offset {0:?} is not a multiple of 4")]
+    #[error(
+        "Indirect buffer offset {offset:?} is not a multiple of {alignment}",
+        offset = .0,
+        alignment = wgt::INDIRECT_BUFFER_OFFSET_ALIGNMENT
+    )]
     UnalignedIndirectBufferOffset(BufferAddress),
+    #[error(
+        "Indirect draw count buffer offset {offset:?} is not a multiple of {alignment}",
+        offset = .0,
+        alignment = wgt::INDIRECT_BUFFER_OFFSET_ALIGNMENT
+    )]
+    UnalignedIndirectCountBufferOffset(BufferAddress),
     #[error("Indirect draw arguments of {args_size} bytes (count = {count}) starting at {offset} would overrun buffer size of {buffer_size}")]
     IndirectBufferOverrun {
         count: u32,
@@ -1115,6 +1125,7 @@ impl WebGpuError for RenderPassError {
             | RenderPassErrorInner::InvalidDepthOps
             | RenderPassErrorInner::InvalidStencilOps
             | RenderPassErrorInner::UnalignedIndirectBufferOffset(..)
+            | RenderPassErrorInner::UnalignedIndirectCountBufferOffset(..)
             | RenderPassErrorInner::IndirectBufferOverrun { .. }
             | RenderPassErrorInner::IndirectCountBufferOverrun { .. }
             | RenderPassErrorInner::ResourceUsageCompatibility(..)
@@ -3314,7 +3325,7 @@ fn multi_draw_indirect(
     indirect_buffer.check_usage(BufferUsages::INDIRECT)?;
     indirect_buffer.check_destroyed(state.pass.base.snatch_guard)?;
 
-    if !offset.is_multiple_of(4) {
+    if !offset.is_multiple_of(wgt::INDIRECT_BUFFER_OFFSET_ALIGNMENT) {
         return Err(RenderPassErrorInner::UnalignedIndirectBufferOffset(offset));
     }
 
@@ -3533,9 +3544,14 @@ fn multi_draw_indirect_count(
     count_buffer.check_usage(BufferUsages::INDIRECT)?;
     let count_raw = count_buffer.try_raw(state.pass.base.snatch_guard)?;
 
-    if !offset.is_multiple_of(4) {
+    if !offset.is_multiple_of(wgt::INDIRECT_BUFFER_OFFSET_ALIGNMENT) {
         return Err(RenderPassErrorInner::UnalignedIndirectBufferOffset(offset));
     }
+    if !count_buffer_offset.is_multiple_of(wgt::INDIRECT_BUFFER_OFFSET_ALIGNMENT) {
+        return Err(RenderPassErrorInner::UnalignedIndirectCountBufferOffset(
+            count_buffer_offset,
+        ));
+    }
 
     let args_size = match stride.checked_mul(u64::from(max_count)) {
         Some(sz) if sz <= indirect_buffer.size && indirect_buffer.size - sz >= offset => sz,

wgpu-hal/src/metal/adapter.rs

@@ -1364,6 +1364,10 @@ impl super::CapabilitiesQuery {
             F::EXPERIMENTAL_MESH_SHADER_MULTIVIEW,
             self.supported_vertex_amplification_factor > 1 && self.mesh_shaders,
         );
+        features.set(
+            F::MULTI_DRAW_INDIRECT_COUNT,
+            self.indirect_command_buffers_rendering && self.indirect_command_buffers_compute,
+        );
 
         // Cooperative matrix (simdgroup matrix) requires MSL 2.3+
         features.set(