update to wgpu-native 24.0.0.2

codegen/files.py

@@ -12,7 +12,7 @@ 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", "")
 
 
 class FileCache:

codegen/hparser.py

@@ -95,14 +95,16 @@ 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()
+            # print(f"Found enum {name}")
+            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  # happens when last item has a 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 +122,30 @@ def _parse_from_h(self):
                 else:
                     enum[key] = int(val)
 
-        # Turn some enums into flags
+        # collect flags
+        # schme: typedef WGPUFlags WGPUFlagName;
         for line in code.splitlines():
             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)
+                self.flags[name] = self.enums.pop[name] if name in self.enums else {}
+
+        #fill flags
+        # schema: static const WGPUFlagName WGPUFlagName_Value = 0x0000000000000001;
+        for line in code.splitlines():
+            if line.startswith("static const"):
+                line = remove_c_comments(line).strip()
+                flag_name = line.removeprefix("static const").lstrip().split()[0]
+                assert flag_name in self.flags
+                flag_value, _, val = line.removeprefix(f"static const {flag_name}").strip().rstrip(";").partition("=")
+                assert flag_value.startswith("WGPU")
+                # taken from above, maybe refactor to a helper function (parse_value_as_int)
+                val = self._parse_val_to_int(val)
+                self.flags[flag_name][flag_value.strip()] = val
+
 
         # Collect structs. This is relatively easy, since we only need the C code.
         # But we don't deal with union structs.
@@ -229,3 +243,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)

wgpu/backends/wgpu_native/__init__.py

@@ -11,8 +11,8 @@
 
 
 # The wgpu-native version that we target/expect
-__version__ = "22.1.0.5"
-__commit_sha__ = "fad19f5990d8eb9a6e942eb957344957193fe66d"
+__version__ = "24.0.0.1"
+__commit_sha__ = "f29ebee88362934f8f9fab530f3ccb7fde2d49a9"
 version_info = tuple(map(int, __version__.split(".")))
 _check_expected_version(version_info)  # produces a warning on mismatch