use Metal's Indirect Command Buffers for true GPU-side multi draw indirect

CHANGELOG.md

@@ -136,6 +136,7 @@ By @beholdnec in [#8505](https://github.com/gfx-rs/wgpu/pull/8505).
 
 #### Metal
 
+- Add Metal indirect-command-buffer lowering for fixed-count multi-draw indirect when render state can be safely resumed. By @matthargett in [#9640](https://github.com/gfx-rs/wgpu/pull/9640).
 - Add `metal::Queue::add_wait_event` / `add_signal_event` (with `remove_*` companions) to stage `MTLSharedEvent` waits/signals on the next `Queue::submit`, for GPU-side interop with foreign APIs. Waits run on an internal CB committed before user CBs. By @AdrianEddy in [#9483](https://github.com/gfx-rs/wgpu/pull/9483).
 - Unconditionally enable `Features::CLIP_DISTANCES`. By @ErichDonGubler in [#9270](https://github.com/gfx-rs/wgpu/pull/9270).
 - Added full support for mesh shaders, including in WGSL shaders. By @inner-daemons in [#8739](https://github.com/gfx-rs/wgpu/pull/8739).

Cargo.toml

@@ -230,6 +230,7 @@ objc2-metal = { version = "0.3.2", default-features = false, features = [
     "MTLCommandBuffer",
     "MTLCommandEncoder",
     "MTLCommandQueue",
+    "MTLArgumentEncoder",
     "MTLComputeCommandEncoder",
     "MTLComputePass",
     "MTLComputePipeline",
@@ -238,6 +239,8 @@ objc2-metal = { version = "0.3.2", default-features = false, features = [
     "MTLDevice",
     "MTLDrawable",
     "MTLEvent",
+    "MTLIndirectCommandBuffer",
+    "MTLIndirectCommandEncoder",
     "MTLLibrary",
     "MTLPipeline",
     "MTLPixelFormat",

deno_webgpu/adapter.rs

@@ -93,8 +93,13 @@ 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();
+      exposed_features.set(
+        wgpu_types::Features::MULTI_DRAW_INDIRECT_COUNT,
+        features.contains(wgpu_types::Features::MULTI_DRAW_INDIRECT_COUNT),
+      );
+      GPUSupportedFeatures::new(scope, exposed_features)
     })
   }
 
@@ -475,7 +480,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

@@ -445,6 +445,80 @@ impl GPURenderPassEncoder {
       .err();
     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);
+  }
 }
 
 #[derive(WebIDL)]

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,