multi_draw_indirect_counter

.github/workflows/ci.yml

@@ -176,7 +176,7 @@ jobs:
             pyversion: '3.13'
           - name: Test Linux pypy3
             os: ubuntu-latest
-            pyversion: 'pypy3.9'
+            pyversion: 'pypy3.10'
     steps:
     - uses: actions/checkout@v4
     - name: Set up Python ${{ matrix.pyversion }}

.github/workflows/screenshots.yml

@@ -19,8 +19,6 @@ jobs:
         python-version: '3.12'
     - name: Install llvmpipe and lavapipe for offscreen canvas
       run: |
-        sudo apt-get update -y -qq
-        sudo add-apt-repository ppa:oibaf/graphics-drivers -y
         sudo apt-get update -y -qq
         sudo apt install -y libegl1-mesa-dev libgl1-mesa-dri libxcb-xfixes0-dev mesa-vulkan-drivers
     - name: Install dev dependencies

.readthedocs.yaml

@@ -6,7 +6,7 @@ version: 2
 build:
   os: ubuntu-22.04
   tools:
-    python: "3.11"
+    python: "3.12"
 # If we ever want to run wgpu stuff in the doc build
 #  apt_packages:
 #    - libegl1-mesa-dev

CHANGELOG.md

@@ -17,6 +17,57 @@ Possible sections in each release:
 * Security: in case of vulnerabilities.
 
 
+### [v0.21.0] - 17-03-2025
+
+This releases updates to using wgpu-native v24.0.0.2, and updates the API to the latest WebGPU spec (IDL).
+
+Added:
+
+* New `canvas_context.get_configuration()` method.
+* New `device.adapter_info` property.
+* New `usage` arg for `texture.create_view()`.
+* New `feaure_level` arg for `request_adapter()`. More a diagnostic tool, not for most end-users.
+
+
+### [v0.20.1] - 14-03-2025
+
+Other:
+* Add release notes.
+
+
+### [v0.20.0] - 14-03-2025
+
+Added:
+
+* Add Imgui based Stats component by @panxinmiao in https://github.com/pygfx/wgpu-py/pull/670 and https://github.com/pygfx/wgpu-py/pull/674
+* Can pass constants to compute helper by @kushalkolar in https://github.com/pygfx/wgpu-py/pull/676
+* Add simple matmul example by @kushalkolar in https://github.com/pygfx/wgpu-py/pull/677
+
+Fixed:
+
+* Fix imgui scroll event by @panxinmiao in https://github.com/pygfx/wgpu-py/pull/678
+
+Changed:
+
+* Improve error handling by @almarklein in https://github.com/pygfx/wgpu-py/pull/667
+* Bring sleep back to WgpuAwaitable. Slowly back off on the amount of time sleeping. by @fyellin in https://github.com/pygfx/wgpu-py/pull/655
+* Improve performance for 'bitmap' render method by @almarklein in https://github.com/pygfx/wgpu-py/pull/680
+
+Other:
+
+* Stop setting AA_EnableHighDpiScaling since Qt Says it is not needed by @hmaarrfk in https://github.com/pygfx/wgpu-py/pull/657
+* Remove unneeded pytest-anyio package by @hmaarrfk in https://github.com/pygfx/wgpu-py/pull/658
+* Actually run the tests instead of fully skipping them by @hmaarrfk in https://github.com/pygfx/wgpu-py/pull/659
+* Improve state of the art for screenshot testing by @hmaarrfk in https://github.com/pygfx/wgpu-py/pull/555
+* Use default lavapipe for screenshot by @Vipitis in https://github.com/pygfx/wgpu-py/pull/660
+* Fix one typo in _helpers.py by @hmaarrfk in https://github.com/pygfx/wgpu-py/pull/661
+* Fix typo in README.md by @patrini32 in https://github.com/pygfx/wgpu-py/pull/662
+* Improve docs regarding drives on Linux by @almarklein in https://github.com/pygfx/wgpu-py/pull/668
+* Add patches for conda compatibility by @hmaarrfk in https://github.com/pygfx/wgpu-py/pull/666
+* Allow disabling downloading lib when creating wheel by @almarklein in https://github.com/pygfx/wgpu-py/pull/669
+* examples/imgui_cmap_picker.py - update for imgui bundle 1.6.2 by @pthom in https://github.com/pygfx/wgpu-py/pull/671
+
+
 ### [v0.19.3] - 10-12-2024
 
 Fixed:

README.md

@@ -178,3 +178,28 @@ differences.
 
 If you want to update the reference screenshot for a given example, you can grab
 those from the build artifacts as well and commit them to your branch.
+
+### Testing Locally
+
+Testing locally is possible, however pixel perfect results will differ from
+those on the CIs due to discrepencies in hardware, and driver (we use llvmpipe)
+versions.
+
+On linux, it is possible to force the usage of LLVMPIPE in the test suite
+and compare the generated results of screenshots. Beware, the results on your machine
+may differ to those on the CI. We always include the CI screenshots in the test suite
+to improve the repeatability of the tests.
+
+If you have access to a linux machine with llvmpipe installed, you may run the
+example pixel comparison testing by setting the WGPUPY_WGPU_ADAPTER_NAME
+environment variable appropriately. For example
+
+
+```
+WGPUPY_WGPU_ADAPTER_NAME=llvmpipe pytest -v examples/
+```
+
+The `WGPUPY_WGPU_ADAPTER_NAME` variable is modeled after the
+https://github.com/gfx-rs/wgpu?tab=readme-ov-file#environment-variables
+and should only be used for testing the wgpu-py library itself.
+It is not part of the supported wgpu-py interface.

codegen/apipatcher.py

@@ -644,7 +644,12 @@ def apply(self, code):
                         method_structs.update(self._get_sub_structs(idl, structname))
                 all_structs.update(method_structs)
                 # Collect structs being checked
-                checked = structure_checks[classname, methodname]
+                try:
+                    checked = structure_checks[classname, methodname]
+                except KeyError:
+                    print(
+                        f"Could not validate check_struct for {classname}.{methodname}; need another codegen run."
+                    )
 
                 # Test that a matching check is done
                 unchecked = method_structs.difference(checked)

codegen/files.py

@@ -12,7 +12,13 @@ def read_file(*fname):
     """Read a file from disk using the relative filename. Line endings are normalized."""
     filename = os.path.join(lib_dir, *fname)
     with open(filename, "rb") as f:
-        return f.read().decode().replace("\r\n", "\n").replace("\r", "\n")
+        return (
+            f.read()
+            .decode()
+            .replace("\r\n", "\n")
+            .replace("\r", "\n")
+            .replace("\\\n", "")  # Macros escaping a newline
+        )
 
 
 class FileCache:

codegen/hparser.py

@@ -95,14 +95,15 @@ def _parse_from_h(self):
             assert name1.startswith("WGPU")
             name = name1[4:]
             self.enums[name] = enum = {}
-            for f in code[i2 + 1 : i3].strip().strip(";").split(","):
-                f = remove_c_comments(f).strip()
+            code_block = code[i2 + 1 : i3].strip().strip(";")
+            block = remove_c_comments(code_block).strip()
+            for f in block.split(","):
                 if not f:
-                    continue  # happens when last item has a comma
+                    continue  # no item after last comma
                 key, _, val = f.partition("=")
                 # Handle key
                 key = key.strip()
-                assert key.startswith("WGPU") and "_" in key
+                assert key.startswith("WGPU") and "_" in key, f"key={key}"
                 key = key.split("_", 1)[1]
                 # Turn value into an int
                 val = val.strip()
@@ -120,18 +121,38 @@ def _parse_from_h(self):
                 else:
                     enum[key] = int(val)
 
-        # Turn some enums into flags
         for line in code.splitlines():
+            # collect flags
+            # schme: typedef WGPUFlags WGPUFlagName;
             if line.startswith("typedef WGPUFlags "):
                 parts = line.strip().strip(";").split()
                 assert len(parts) == 3
                 name = parts[-1]
-                if name.endswith("Flags"):
-                    assert name.startswith("WGPU")
-                    name1 = name[4:-1]  # xxFlags -> xxFlag
-                    name2 = name[4:-5]  # xxFlags -> xx
-                    name = name1 if name1 in self.enums else name2
-                self.flags[name] = self.enums.pop(name)
+                assert name.startswith("WGPU")
+                name = name[4:]
+                assert not name.endswith("Flags"), "XxxxFlags should not longer exist"
+                assert name not in self.enums, "flags used to look like enums"
+                self.flags[name] = {}
+
+            # fill flags
+            # schema: static const WGPUFlagName WGPUFlagName_Value = 0x0000000000000001;
+            if line.startswith("static const"):
+                line = remove_c_comments(line).strip()
+                flag_name = line.removeprefix("static const").lstrip().split()[0]
+                flag_key, _, val = (
+                    line.removeprefix(f"static const {flag_name}")
+                    .strip()
+                    .rstrip(";")
+                    .partition("=")
+                )
+                # Check / normalize flag_name
+                assert flag_name.startswith("WGPU")
+                flag_name = flag_name[4:]
+                assert flag_name in self.flags
+                # Check / normalize flag_key
+                assert flag_key.startswith(f"WGPU{flag_name}_")
+                flag_key = flag_key.partition("_")[2].strip()
+                self.flags[flag_name][flag_key] = self._parse_val_to_int(val)
 
         # Collect structs. This is relatively easy, since we only need the C code.
         # But we don't deal with union structs.
@@ -229,3 +250,22 @@ def _parse_from_cffi(self):
                     while alt_name != ffi.getctype(alt_name):
                         alt_name = ffi.getctype(alt_name)
                         self.structs[alt_name] = self.structs[name]
+
+    def _parse_val_to_int(self, val):
+        """
+        little helper to parse complex values for enums.
+        """
+        val = val.strip(" ()")
+        if "|" in val:
+            # recursively handle the "OR" values?
+            res_val = 0
+            for sub_val in val.split("|"):
+                res_val |= self._parse_val_to_int(sub_val)
+            return res_val
+        if val.startswith("0x"):
+            return int(val, 16)
+        elif "<<" in val:
+            val1, _, val2 = val.partition("<<")
+            return int(val1) << int(val2)
+        else:
+            return int(val)

codegen/idlparser.py

@@ -217,6 +217,7 @@ def resolve_type(self, typename):
             "AllowSharedBufferSource": "memoryview",
             "GPUPipelineConstantValue": "float",
             "GPUExternalTexture": "object",
+            "undefined": "None",
         }
         name = pythonmap.get(name, name)
 

codegen/tests/test_codegen_rspatcher.py

@@ -37,7 +37,7 @@ def test_patch_structs():
     """
     code2 = patch_wgpu_native_backend(dedent(code1))
     assert all(line[4:] in code2 for line in code1 if line.strip())
-    assert "usage: WGPUBufferUsageFlags/int" in code2
+    assert "usage: WGPUBufferUsage/int" in code2
     assert "size: int" in code2
     assert "# FIXME:" not in code2
     assert code2 == patch_wgpu_native_backend(code2)  # Don't stack comments
@@ -53,7 +53,7 @@ def test_patch_structs():
     """
     code2 = patch_wgpu_native_backend(dedent(code1))
     assert all(line[4:] in code2 for line in code1 if line.strip())
-    assert "usage: WGPUBufferUsageFlags/int" in code2
+    assert "usage: WGPUBufferUsage/int" in code2
     assert "size: int" in code2
     assert "# FIXME:" not in code2
 
@@ -72,15 +72,15 @@ def test_patch_structs():
     # Missing values
     code1 = 'struct = new_struct_p("WGPUBufferDescriptor *",label=c_label,size=size,)'
     code2 = patch_wgpu_native_backend(dedent(code1))
-    assert "usage: WGPUBufferUsageFlags/int" in code2
+    assert "usage: WGPUBufferUsage/int" in code2
     assert "# FIXME:" not in code2
     assert "usage" in code2  # comment added
     assert code2 == patch_wgpu_native_backend(code2)  # Don't stack comments
 
     # Too many values
     code1 = 'struct = new_struct_p("WGPUBufferDescriptor *",label=c_label,foo=size,)'
     code2 = patch_wgpu_native_backend(dedent(code1))
-    assert "usage: WGPUBufferUsageFlags/int" in code2
+    assert "usage: WGPUBufferUsage/int" in code2
     assert "# FIXME: unknown" in code2
     assert code2 == patch_wgpu_native_backend(code2)  # Don't stack comments
 

codegen/wgpu_native_patcher.py

@@ -15,6 +15,7 @@
 
 import re
 from collections import defaultdict
+from itertools import chain
 
 from codegen.utils import print, format_code, Patcher, to_snake_case
 from codegen.hparser import get_h_parser
@@ -290,42 +291,47 @@ def apply(self, code):
 class StructPatcher(Patcher):
     def apply(self, code):
         self._init(code)
-        hp = get_h_parser()
-
         count = 0
-        line_index = -1
-        brace_depth = 0
 
         for line, i in self.iter_lines():
+            # detect struct definition start (only when not already inside a struct)
             if "new_struct_p(" in line or "new_struct(" in line:
                 if line.lstrip().startswith("def "):
                     continue  # Implementation
                 if "_new_struct" in line:
                     continue  # Implementation
                 if "new_struct_p()" in line or "new_struct()" in line:
                     continue  # Comments or docs
-                line_index = i
                 j = line.index("new_struct")
                 line = line[j:]  # start brace searching from right pos
-                brace_depth = 0
-
-            if line_index >= 0:
-                for c in line:
-                    if c == "#":
-                        break
-                    elif c == "(":
-                        brace_depth += 1
-                    elif c == ")":
-                        brace_depth -= 1
-                        assert brace_depth >= 0
-                        if brace_depth == 0:
-                            self._validate_struct(hp, line_index, i)
-                            count += 1
-                            line_index = -1
-                            break
+                # call a function to find the end and validate so we don't skip over nested structure in this loop
+                self._find_struct_end(line, i)
+                count += 1
 
         print(f"Validated {count} C structs")
 
+    def _find_struct_end(self, first_line, start_line_index):
+        """
+        If a struct start is found, this function will find the end of the struct and then validate it
+        """
+        brace_depth = 0
+        hp = get_h_parser()
+        for line, i in chain(
+            [(first_line, 0)], self.iter_lines(start_line=start_line_index + 1)
+        ):
+            for c in line:
+                if c == "#":
+                    break
+                elif c == "(":
+                    brace_depth += 1
+                elif c == ")":
+                    brace_depth -= 1
+                    assert brace_depth >= 0
+                    if brace_depth == 0:
+                        # here we have found the end of this struct so now we can validate it.
+                        self._validate_struct(hp, start_line_index, i)
+                        return  # we assume it always works?
+
     def _validate_struct(self, hp, i1, i2):
         """Validate a specific struct usage."""
 
@@ -381,19 +387,32 @@ def _validate_struct(self, hp, i1, i2):
             self.insert_line(i1, indent + "# H: " + fields)
 
         # Check keys
+        brace_count = 0
         keys_found = []
         for j in range(2, len(lines) - 1):
             line = lines[j]
-            key = line.split("=")[0].strip()
-            if key.startswith("# not used:"):
-                key = key.split(":")[1].split("=")[0].strip()
-            elif key.startswith("#"):
-                continue
-            keys_found.append(key)
-            if key not in struct:
-                msg = f"unknown C struct field {struct_name}.{key}"
-                self.insert_line(i1 + j, f"{indent}# FIXME: {msg}")
-                print(f"ERROR: {msg}")
+            if brace_count <= 0:
+                # ready to find a new key candidate
+                key = line.split("=")[0].strip()
+                if key.startswith("# not used:"):
+                    key = key.split(":")[1].split("=")[0].strip()
+                elif key.startswith("#"):
+                    continue
+            # (still) inside a multi-line structure
+            for c in line.strip():
+                if c == "#":
+                    break  # we can ignore this line past the comment in terms of nested structures
+                elif c == "(":
+                    brace_count += 1
+                elif c == ")":
+                    brace_count -= 1
+            if brace_count == 0:
+                # here we finished through the multi line structure
+                keys_found.append(key)
+                if key not in struct:
+                    msg = f"unknown C struct field {struct_name}.{key}"
+                    self.insert_line(i1 + j, f"{indent}# FIXME: {msg}")
+                    print(f"ERROR: {msg}")
 
         # Insert comments for unused keys
         more_lines = []