multi_draw_indirect_counter

docs/backends.rst

@@ -159,21 +159,25 @@ bytes you wish to change.
     :param data_offset: The starting offset in the data at which to begin copying.
 
 
-There are two functions that allow you to perform multiple draw calls at once.
-Both require that you enable the feature "multi-draw-indirect".
+There are four functions that allow you to perform multiple draw calls at once.
+Two take the number of draws to perform as an argument; two have this value in a buffer.
 
 Typically, these calls do not reduce work or increase parallelism on the GPU. Rather
 they reduce driver overhead on the CPU.
 
+The first two require that you enable the feature ``"multi-draw-indirect"``.
+
 .. py:function:: wgpu.backends.wgpu_native.multi_draw_indirect(render_pass_encoder, buffer, *, offset=0, count):
 
      Equivalent to::
         for i in range(count):
             render_pass_encoder.draw_indirect(buffer, offset + i * 16)
 
     :param render_pass_encoder: The current render pass encoder.
-    :param buffer: The indirect buffer containing the arguments.
+    :param buffer: The indirect buffer containing the arguments. Must have length
+                   at least offset + 16 * count.
     :param offset: The byte offset in the indirect buffer containing the first argument.
+                   Must be a multiple of 4.
     :param count: The number of draw operations to perform.
 
 .. py:function:: wgpu.backends.wgpu_native.multi_draw_indexed_indirect(render_pass_encoder, buffer, *, offset=0, count):
@@ -184,10 +188,51 @@ they reduce driver overhead on the CPU.
 
 
     :param render_pass_encoder: The current render pass encoder.
-    :param buffer: The indirect buffer containing the arguments.
+    :param buffer: The indirect buffer containing the arguments. Must have length
+                   at least offset + 20 * count.
     :param offset: The byte offset in the indirect buffer containing the first argument.
+                   Must be a multiple of 4.
     :param count: The number of draw operations to perform.
 
+The second two require that you enable the feature ``"multi-draw-indirect-count"``.
+They are identical to the previous two, except that the ``count`` argument is replaced by
+three arguments. The value at ``count_buffer_offset`` in ``count_buffer`` is treated as
+an unsigned 32-bit integer. The ``count`` is the minimum of this value and ``max_count``.
+
+.. py:function:: wgpu.backends.wgpu_native.multi_draw_indirect_count(render_pass_encoder, buffer, *, offset=0, count_buffer, count_offset=0, max_count):
+
+     Equivalent to::
+        count = min(<u32 at count_buffer_offset in count_buffer>, max_count)
+        for i in range(count):
+            render_pass_encoder.draw_indirect(buffer, offset + i * 16)
+
+    :param render_pass_encoder: The current render pass encoder.
+    :param buffer: The indirect buffer containing the arguments. Must have length
+                   at least offset + 16 * max_count.
+    :param offset: The byte offset in the indirect buffer containing the first argument.
+                   Must be a multiple of 4.
+    :param count_buffer: The indirect buffer containing the count.
+    :param count_buffer_offset: The offset into count_buffer.
+                   Must be a multiple of 4.
+    :param max_count: The maximum number of draw operations to perform.
+
+.. py:function:: wgpu.backends.wgpu_native.multi_draw_indexed_indirect_count(render_pass_encoder, buffer, *, offset=0, count_buffer, count_offset=0, max_count):
+
+     Equivalent to::
+        count = min(<u32 at count_buffer_offset in count_buffer>, max_count)
+        for i in range(count):
+            render_pass_encoder.draw_indexed_indirect(buffer, offset + i * 2-)
+
+    :param render_pass_encoder: The current render pass encoder.
+    :param buffer: The indirect buffer containing the arguments. Must have length
+                   at least offset + 20 * max_count.
+    :param offset: The byte offset in the indirect buffer containing the first argument.
+                   Must be a multiple of 4.
+    :param count_buffer: The indirect buffer containing the count.
+    :param count_buffer_offset: The offset into count_buffer.
+                   Must be a multiple of 4.
+    :param max_count: The maximum number of draw operations to perform.
+
 
 The js_webgpu backend
 ---------------------

tests/test_wgpu_vertex_instance.py

@@ -8,16 +8,18 @@
 from wgpu.backends.wgpu_native.extras import (
     multi_draw_indexed_indirect,
     multi_draw_indirect,
+    multi_draw_indirect_count,
+    multi_draw_indexed_indirect_count,
 )
 
-MAX_INFO = 100
+MAX_INFO = 1000
 
 if not can_use_wgpu_lib:
     pytest.skip("Skipping tests that need the wgpu lib", allow_module_level=True)
 
 
 """
-The fundamental informartion about any of the many draw commands is the
+The fundamental information about any of the many draw commands is the
 <vertex_instance, instance_index> pair that is passed to the vertex shader. By using
 point-list topology, each call to the vertex shader turns into a single call to the
 fragment shader, where the pair is recorded.
@@ -68,7 +70,7 @@
 
 class Runner:
     REQUIRED_FEATURES = ["indirect-first-instance"]
-    OPTIONAL_FEATURES = ["multi-draw-indirect"]  # we'll be adding more
+    OPTIONAL_FEATURES = ["multi-draw-indirect", "multi-draw-indirect-count"]
 
     @classmethod
     def is_usable(cls):
@@ -82,6 +84,7 @@ def __init__(self):
             *[x for x in self.OPTIONAL_FEATURES if x in adapter.features],
         ]
         self.device = adapter.request_device(required_features=features)
+
         self.output_texture = self.device.create_texture(
             # Actual size is immaterial.  Could just be 1x1
             size=[128, 128],
@@ -163,11 +166,19 @@ def __init__(self):
         # We're going to want to try calling these draw functions from a buffer, and it
         # would be nice to test that these buffers have an offset
         self.draw_data_buffer = self.device.create_buffer_with_data(
-            data=np.uint32([0, 0, *self.draw_args1, *self.draw_args2]),
+            # The zeros at the beginning are to test "offset".
+            # The zeros at the end are because the _count methods require to buffer to
+            # be at least byte_offset + 16 * max_count bytes long
+            data=np.uint32([0, 0, *self.draw_args1, *self.draw_args2, *([0] * 50)]),
             usage="INDIRECT",
         )
         self.draw_data_buffer_indexed = self.device.create_buffer_with_data(
-            data=np.uint32([0, 0, *self.draw_indexed_args1, *self.draw_indexed_args2]),
+            # The zeros at the beginning are to test "offset".
+            # The zeros at the end are because the _count methods require to buffer to
+            # be at least byte_offset + 20 * max_count bytes long
+            data=np.uint32(
+                [0, 0, *self.draw_indexed_args1, *self.draw_indexed_args2, *([0] * 50)]
+            ),
             usage="INDIRECT",
         )
 
@@ -211,7 +222,8 @@ def run_draw_test(self, draw_function, indexed, *, expected_result=None):
                 expected_result = self.expected_result_draw_indexed
             else:
                 expected_result = self.expected_result_draw
-        assert info_set == expected_result
+        if info_set != expected_result:
+            pytest.fail(f"Expected {sorted(info_set)}\nGot {sorted(expected_result)}")
 
 
 if not Runner.is_usable():
@@ -337,5 +349,44 @@ def draw(encoder):
         )
 
 
+@pytest.mark.parametrize("indexed", [False, True])
+@pytest.mark.parametrize("test_max_count", [False, True])
+def test_multi_draw_indirect_count(runner, test_max_count, indexed):
+    if "multi-draw-indirect-count" not in runner.device.features:
+        pytest.skip("Must have 'multi-draw-indirect-count' to run")
+
+    print(f"{test_max_count=}, {indexed=} \n")
+
+    count_buffer = runner.device.create_buffer_with_data(
+        data=(np.int32([10, 2])), usage="INDIRECT"
+    )
+    if indexed:
+        function = multi_draw_indexed_indirect_count
+        buffer = runner.draw_data_buffer_indexed
+    else:
+        function = multi_draw_indirect_count
+        buffer = runner.draw_data_buffer
+
+    if test_max_count:
+        # We pull a count of 10, but we're limiting it to 2 via max_count
+        count_buffer_offset, max_count = 0, 2
+    else:
+        # We pull a count of 2, and set the max_count to something bigger.  Buffer
+        # is required to be big enough to handle max_count.
+        count_buffer_offset, max_count = 4, 10
+
+    def draw(encoder):
+        function(
+            encoder,
+            buffer,
+            offset=8,
+            count_buffer=count_buffer,
+            count_buffer_offset=count_buffer_offset,
+            max_count=max_count,
+        )
+
+        runner.run_draw_test(draw, indexed)
+
+
 if __name__ == "__main__":
     run_tests(globals())

wgpu/backends/wgpu_native/_api.py

@@ -3031,6 +3031,32 @@ def _multi_draw_indexed_indirect(self, buffer, offset, count):
             self._internal, buffer._internal, int(offset), int(count)
         )
 
+    def _multi_draw_indirect_count(
+        self, buffer, offset, count_buffer, count_buffer_offset, max_count
+    ):
+        # H: void f(WGPURenderPassEncoder encoder, WGPUBuffer buffer, uint64_t offset, WGPUBuffer count_buffer, uint64_t count_buffer_offset, uint32_t max_count)
+        libf.wgpuRenderPassEncoderMultiDrawIndirectCount(
+            self._internal,
+            buffer._internal,
+            int(offset),
+            count_buffer._internal,
+            int(count_buffer_offset),
+            int(max_count),
+        )
+
+    def _multi_draw_indexed_indirect_count(
+        self, buffer, offset, count_buffer, count_buffer_offset, max_count
+    ):
+        # H: void f(WGPURenderPassEncoder encoder, WGPUBuffer buffer, uint64_t offset, WGPUBuffer count_buffer, uint64_t count_buffer_offset, uint32_t max_count)
+        libf.wgpuRenderPassEncoderMultiDrawIndexedIndirectCount(
+            self._internal,
+            buffer._internal,
+            int(offset),
+            count_buffer._internal,
+            int(count_buffer_offset),
+            int(max_count),
+        )
+
 
 class GPURenderBundleEncoder(
     classes.GPURenderBundleEncoder,

wgpu/backends/wgpu_native/extras.py

@@ -66,22 +66,68 @@ def set_push_constants(
 
 def multi_draw_indirect(render_pass_encoder, buffer, *, offset=0, count):
     """
-    This is equvalent to
+    This is equivalent to
     for i in range(count):
         render_pass_encoder.draw(buffer, offset + i * 16)
 
-    You must enable the featue "multi-draw-indirect" to use this function.
+    You must enable the feature "multi-draw-indirect" to use this function.
     """
     render_pass_encoder._multi_draw_indirect(buffer, offset, count)
 
 
 def multi_draw_indexed_indirect(render_pass_encoder, buffer, *, offset=0, count):
     """
-    This is equvalent to
+    This is equivalent to
 
     for i in range(count):
         render_pass_encoder.draw_indexed(buffer, offset + i * 20)
 
-    You must enable the featue "multi-draw-indirect" to use this function.
+    You must enable the feature "multi-draw-indirect" to use this function.
     """
     render_pass_encoder._multi_draw_indexed_indirect(buffer, offset, count)
+
+
+def multi_draw_indirect_count(
+    render_pass_encoder,
+    buffer,
+    *,
+    offset=0,
+    count_buffer,
+    count_buffer_offset=0,
+    max_count,
+):
+    """
+    This is equivalent to:
+
+    count = min(<u32 at offset count_buffer_offset of count_buffer>, max_count)
+    for i in range(count):
+        render_pass_encoder.draw(buffer, offset + i * 16)
+
+    You must enable the feature "multi-draw-indirect-count" to use this function.
+    """
+    render_pass_encoder._multi_draw_indirect_count(
+        buffer, offset, count_buffer, count_buffer_offset, max_count
+    )
+
+
+def multi_draw_indexed_indirect_count(
+    render_pass_encoder,
+    buffer,
+    *,
+    offset=0,
+    count_buffer,
+    count_buffer_offset=0,
+    max_count,
+):
+    """
+    This is equivalent to:
+
+    count = min(<u32 at offset count_buffer_offset of count_buffer>, max_count)
+    for i in range(count):
+        render_pass_encoder.draw_indexed(buffer, offset + i * 20)
+
+    You must enable the feature "multi-draw-indirect-count" to use this function.
+    """
+    render_pass_encoder._multi_draw_indexed_indirect_count(
+        buffer, offset, count_buffer, count_buffer_offset, max_count
+    )

wgpu/resources/codegen_report.md

@@ -20,7 +20,7 @@
 * Diffs for GPUQueue: add read_buffer, add read_texture, hide copy_external_image_to_texture
 * Validated 37 classes, 112 methods, 45 properties
 ### Patching API for backends/wgpu_native/_api.py
-* Validated 37 classes, 100 methods, 0 properties
+* Validated 37 classes, 102 methods, 0 properties
 ## Validating backends/wgpu_native/_api.py
 * Enum field FeatureName.texture-compression-bc-sliced-3d missing in wgpu.h
 * Enum field FeatureName.clip-distances missing in wgpu.h
@@ -35,6 +35,6 @@
 * Enum CanvasAlphaMode missing in wgpu.h
 * Enum CanvasToneMappingMode missing in wgpu.h
 * Wrote 236 enum mappings and 47 struct-field mappings to wgpu_native/_mappings.py
-* Validated 133 C function calls
-* Not using 70 C functions
+* Validated 135 C function calls
+* Not using 68 C functions
 * Validated 81 C structs