Update to wgpu-native 0.8.0.2 (#167)

almarklein · web-flow · commit 6ff9fd98cb91 · 2021-06-04T22:42:48.000+02:00
* update to latest wgpu-native

* make codegen make some extra mappings for rs

* fix API deviation

* re-codegen, force vulkan, request more-texture-features, obtain adapter properties

* add notes on some restrictions
diff --git a/codegen/rspatcher.py b/codegen/rspatcher.py
@@ -109,6 +109,28 @@ def write_mappings():
         pylines.append(f'    "{key}": {cstructfield2enum[key]!r},')
     pylines.append("}\n")
 
+    # Write a few native-only mappings: key => int
+    pylines.append("enum_str2int = {")
+    for name in ["BackendType"]:
+        pylines.append(f'    "{name}":' + " {")
+        for key, val in hp.enums[name].items():
+            if key == "Force32":
+                continue
+            pylines.append(f'        "{key}": {val},')
+        pylines.append("    }")
+    pylines.append("}")
+
+    # Write a few native-only mappings: int => key
+    pylines.append("enum_int2str = {")
+    for name in ["BackendType", "AdapterType"]:
+        pylines.append(f'    "{name}":' + " {")
+        for key, val in hp.enums[name].items():
+            if key == "Force32":
+                continue
+            pylines.append(f'        {val}: "{key}",')
+        pylines.append("    },")
+    pylines.append("}")
+
     # Wrap up
     code = blacken("\n".join(pylines))  # just in case; code is already black
     with open(os.path.join(lib_dir, "backends", "rs_mappings.py"), "wb") as f:
diff --git a/tests/test_rs_render_tex.py b/tests/test_rs_render_tex.py
@@ -492,9 +492,11 @@ def render_textured_square(fragment_shader, texture_format, texture_size, textur
     # Determine sampler type.
     # Note that integer texture types cannot even use a sampler.
     sampler_type = wgpu.SamplerBindingType.filtering
-    if "32float" in texture_format:
-        sampler_type = wgpu.SamplerBindingType.non_filtering
-        texture_sample_type = wgpu.TextureSampleType.unfilterable_float
+    # On Vanilla wgpu, float32 textures cannot use a filtering
+    # (interpolating) texture, but we request a feature so that we can.
+    # if "32float" in texture_format:
+    #     sampler_type = wgpu.SamplerBindingType.non_filtering
+    #     texture_sample_type = wgpu.TextureSampleType.unfilterable_float
 
     # Bindings and layout
     bindings = [
diff --git a/wgpu/backends/rs.py b/wgpu/backends/rs.py
@@ -41,7 +41,7 @@
 from .._coreutils import ApiDiff
 
 from .rs_ffi import ffi, lib, check_expected_version
-from .rs_mappings import cstructfield2enum, enummap
+from .rs_mappings import cstructfield2enum, enummap, enum_str2int, enum_int2str
 from .rs_helpers import (
     get_surface_id_from_canvas,
     get_memoryview_from_address,
@@ -53,8 +53,8 @@
 apidiff = ApiDiff()
 
 # The wgpu-native version that we target/expect
-__version__ = "0.8.0.1"
-__commit_sha__ = "691468c9817b51a81530fb277a9b30fcc4a71ea7"
+__version__ = "0.8.0.2"
+__commit_sha__ = "66a4139579f2499a67b7ade1a6c3bcb414046c64"
 version_info = tuple(map(int, __version__.split(".")))
 check_expected_version(version_info)  # produces a warning on mismatch
 
@@ -212,12 +212,27 @@ def request_adapter(self, *, canvas, power_preference=None):
         else:
             surface_id = get_surface_id_from_canvas(canvas)
 
+        # Force Vulkan on Windows, to avoid DX12 which seems to ignore
+        # the NVidia control panel settings. I guess Vulkan is more
+        # mature than Metal too, so let's just force that for now.
+        # See https://github.com/gfx-rs/wgpu/issues/1416
+        # force_backend = lib.WGPUBackendType_Vulkan
+        force_backend = enum_str2int["BackendType"]["Vulkan"]
+
+        # H: chain: WGPUChainedStruct, backend: WGPUBackendType
+        extras = new_struct_p(
+            "WGPUAdapterExtras *",
+            backend=force_backend,
+            # not used: chain
+        )
+        extras.chain.sType = lib.WGPUSType_AdapterExtras
+
         # Convert the descriptor
         # H: nextInChain: WGPUChainedStruct *, compatibleSurface: WGPUSurface
         struct = new_struct_p(
             "WGPURequestAdapterOptions *",
             compatibleSurface=surface_id,
-            # not used: nextInChain
+            nextInChain=ffi.cast("WGPUChainedStruct * ", extras),
         )
 
         # Do the API call and get the adapter id
@@ -251,16 +266,19 @@ def callback(received, userdata):
             # not used: backendType
         )
 
-        # todo: This function exists in the headerfile but not in the lib (yet)
         # H: void f(WGPUAdapter adapter, WGPUAdapterProperties * properties)
-        # lib.wgpuAdapterGetProperties(adapter_id, c_properties)
+        lib.wgpuAdapterGetProperties(adapter_id, c_properties)
         properties = {
             "name": "",
             "vendorID": c_properties.vendorID,
             "deviceID": c_properties.deviceID,
             "driverDescription": "",
-            "adapterType": c_properties.adapterType,
-            "backendType": c_properties.backendType,
+            "adapterType": enum_int2str["AdapterType"].get(
+                c_properties.adapterType, "unknown"
+            ),
+            "backendType": enum_int2str["BackendType"].get(
+                c_properties.backendType, "unknown"
+            ),
         }
         if c_properties.name:
             properties["name"] = ffi.string(c_properties.name).decode(errors="ignore")
@@ -335,13 +353,26 @@ def _request_device(self, label, features, limits, trace_path):
         limits2 = base.DEFAULT_ADAPTER_LIMITS.copy()
         limits2.update(limits or {})
 
-        # H: chain: WGPUChainedStruct, maxBindGroups: int, label: char*, tracePath: char*
+        # Vanilla WGPU does not support interpolating samplers for float32 textures,
+        # which is sad for scientific data in particular. We can enable it
+        # (on the hardware were wgpu-py likely runs) using the feature:
+        # WGPUNativeFeature_TEXTURE_ADAPTER_SPECIFIC_FORMAT_FEATURES
+
+        # H: chain: WGPUChainedStruct, maxTextureDimension1D: int, maxTextureDimension2D: int, maxTextureDimension3D: int, maxTextureArrayLayers: int, maxBindGroups: int, maxDynamicStorageBuffersPerPipelineLayout: int, maxStorageBuffersPerShaderStage: int, maxStorageBufferBindingSize: int, nativeFeatures: WGPUNativeFeature, label: char*, tracePath: char*
         extras = new_struct_p(
             "WGPUDeviceExtras *",
             label=to_c_label(label),
             maxBindGroups=limits2["max_bind_groups"],
+            maxStorageBuffersPerShaderStage=6,
             tracePath=c_trace_path,
+            nativeFeatures=lib.WGPUNativeFeature_TEXTURE_ADAPTER_SPECIFIC_FORMAT_FEATURES,
             # not used: chain
+            # not used: maxTextureDimension1D
+            # not used: maxTextureDimension2D
+            # not used: maxTextureDimension3D
+            # not used: maxTextureArrayLayers
+            # not used: maxDynamicStorageBuffersPerPipelineLayout
+            # not used: maxStorageBufferBindingSize
         )
         extras.chain.sType = lib.WGPUSType_DeviceExtras
 
@@ -917,34 +948,37 @@ def create_render_pipeline(
         if fragment is not None:
             c_color_targets_list = []
             for target in fragment["targets"]:
-                alpha_blend = _tuple_from_tuple_or_dict(
-                    target["blend"]["alpha"],
-                    ("src_factor", "dst_factor", "operation"),
-                )
-                # H: srcFactor: WGPUBlendFactor, dstFactor: WGPUBlendFactor, operation: WGPUBlendOperation
-                c_alpha_blend = new_struct(
-                    "WGPUBlendComponent",
-                    srcFactor=alpha_blend[0],
-                    dstFactor=alpha_blend[1],
-                    operation=alpha_blend[2],
-                )
-                color_blend = _tuple_from_tuple_or_dict(
-                    target["blend"]["color"],
-                    ("src_factor", "dst_factor", "operation"),
-                )
-                # H: srcFactor: WGPUBlendFactor, dstFactor: WGPUBlendFactor, operation: WGPUBlendOperation
-                c_color_blend = new_struct(
-                    "WGPUBlendComponent",
-                    srcFactor=color_blend[0],
-                    dstFactor=color_blend[1],
-                    operation=color_blend[2],
-                )
-                # H: color: WGPUBlendComponent, alpha: WGPUBlendComponent
-                c_blend = new_struct_p(
-                    "WGPUBlendState *",
-                    color=c_color_blend,
-                    alpha=c_alpha_blend,
-                )
+                if not target.get("blend", None):
+                    c_blend = ffi.NULL
+                else:
+                    alpha_blend = _tuple_from_tuple_or_dict(
+                        target["blend"]["alpha"],
+                        ("src_factor", "dst_factor", "operation"),
+                    )
+                    # H: srcFactor: WGPUBlendFactor, dstFactor: WGPUBlendFactor, operation: WGPUBlendOperation
+                    c_alpha_blend = new_struct(
+                        "WGPUBlendComponent",
+                        srcFactor=alpha_blend[0],
+                        dstFactor=alpha_blend[1],
+                        operation=alpha_blend[2],
+                    )
+                    color_blend = _tuple_from_tuple_or_dict(
+                        target["blend"]["color"],
+                        ("src_factor", "dst_factor", "operation"),
+                    )
+                    # H: srcFactor: WGPUBlendFactor, dstFactor: WGPUBlendFactor, operation: WGPUBlendOperation
+                    c_color_blend = new_struct(
+                        "WGPUBlendComponent",
+                        srcFactor=color_blend[0],
+                        dstFactor=color_blend[1],
+                        operation=color_blend[2],
+                    )
+                    # H: color: WGPUBlendComponent, alpha: WGPUBlendComponent
+                    c_blend = new_struct_p(
+                        "WGPUBlendState *",
+                        color=c_color_blend,
+                        alpha=c_alpha_blend,
+                    )
                 # H: nextInChain: WGPUChainedStruct *, format: WGPUTextureFormat, blend: WGPUBlendState *, writeMask: WGPUColorWriteMaskFlags/int
                 c_color_state = new_struct(
                     "WGPUColorTargetState",
diff --git a/wgpu/backends/rs_mappings.py b/wgpu/backends/rs_mappings.py
@@ -227,3 +227,32 @@
     "VertexAttribute.format": "VertexFormat",
     "VertexBufferLayout.stepMode": "InputStepMode",
 }
+
+enum_str2int = {
+    "BackendType": {
+        "Null": 0,
+        "D3D11": 1,
+        "D3D12": 2,
+        "Metal": 3,
+        "Vulkan": 4,
+        "OpenGL": 5,
+        "OpenGLES": 6,
+    }
+}
+enum_int2str = {
+    "BackendType": {
+        0: "Null",
+        1: "D3D11",
+        2: "D3D12",
+        3: "Metal",
+        4: "Vulkan",
+        5: "OpenGL",
+        6: "OpenGLES",
+    },
+    "AdapterType": {
+        0: "DiscreteGPU",
+        1: "IntegratedGPU",
+        2: "CPU",
+        3: "Unknown",
+    },
+}
diff --git a/wgpu/base.py b/wgpu/base.py
@@ -661,13 +661,13 @@ def create_render_pipeline(
                 "format": wgpu.TextureFormat.depth24plus_stencil8,
                 "depth_write_enabled": False,  # optional
                 "depth_compare": wgpu.CompareFunction.always,  # optional
-                "front": {  # optional
+                "stencil_front": {  # optional
                     "compare": wgpu.CompareFunction.equal,
                     "fail_op": wgpu.StencilOperation.keep,
                     "depth_fail_op": wgpu.StencilOperation.keep,
                     "pass_op": wgpu.StencilOperation.keep,
                 },
-                "back": {  # optional
+                "stencil_back": {  # optional
                     "compare": wgpu.CompareFunction.equal,
                     "fail_op": wgpu.StencilOperation.keep,
                     "depth_fail_op": wgpu.StencilOperation.keep,
@@ -690,7 +690,8 @@ def create_render_pipeline(
                 "alpha_to_coverage_enabled": False  # optional
             }
 
-        Example fragment (FragmentState) dict:
+        Example fragment (FragmentState) dict. The `blend` parameter can be None
+        to disable blending (not all texture formats support blending).
 
         .. code-block:: py
 
diff --git a/wgpu/resources/codegen_report.md b/wgpu/resources/codegen_report.md
@@ -3,7 +3,7 @@
 * The webgpu.idl defines 34 classes with 82 functions
 * The webgpu.idl defines 5 flags, 31 enums, 52 structs
 * The wgpu.h defines 106 functions
-* The wgpu.h defines 5 flags, 36 enums, 58 structs
+* The wgpu.h defines 5 flags, 37 enums, 59 structs
 ## Updating API
 * Wrote 5 flags to flags.py
 * Wrote 31 enums to enums.py
@@ -41,4 +41,4 @@
 * Wrote 169 enum mappings and 45 struct-field mappings to rs_mappings.py
 * Validated 65 C function calls
 * Not using 46 C functions
-* Validated 65 C structs
+* Validated 66 C structs
diff --git a/wgpu/resources/wgpu.h b/wgpu/resources/wgpu.h
@@ -1,21 +1,18 @@
 #ifndef WGPU_H_
 #define WGPU_H_
 
-#include "webgpu-headers/webgpu.h"
+#include "webgpu.h"
 
 typedef enum WGPUNativeSType {
     // Start at 6 to prevent collisions with webgpu STypes
     WGPUSType_DeviceExtras = 0x60000001,
+    WGPUSType_AdapterExtras = 0x60000002,
     WGPUNativeSType_Force32 = 0x7FFFFFFF
 } WGPUNativeSType;
 
-
-typedef struct WGPUDeviceExtras {
-    WGPUChainedStruct chain;
-    uint32_t maxBindGroups;
-    const char* label;
-    const char* tracePath;
-} WGPUDeviceExtras;
+typedef enum WGPUNativeFeature {
+    WGPUNativeFeature_TEXTURE_ADAPTER_SPECIFIC_FORMAT_FEATURES = 0x10000000
+} WGPUNativeFeature;
 
 typedef enum WGPULogLevel {
     WGPULogLevel_Off = 0x00000000,
@@ -27,6 +24,30 @@ typedef enum WGPULogLevel {
     WGPULogLevel_Force32 = 0x7FFFFFFF
 } WGPULogLevel;
 
+typedef struct WGPUAdapterExtras {
+    WGPUChainedStruct chain;
+    WGPUBackendType backend;
+} WGPUAdapterExtras;
+
+typedef struct WGPUDeviceExtras {
+    WGPUChainedStruct chain;
+    uint32_t maxTextureDimension1D;
+    uint32_t maxTextureDimension2D;
+    uint32_t maxTextureDimension3D;
+    uint32_t maxTextureArrayLayers;
+    uint32_t maxBindGroups;
+    uint32_t maxDynamicStorageBuffersPerPipelineLayout;
+    uint32_t maxStorageBuffersPerShaderStage;
+    uint32_t maxStorageBufferBindingSize;
+
+    WGPUNativeFeature nativeFeatures;
+
+    const char* label;
+    const char* tracePath;
+} WGPUDeviceExtras;
+
+
+
 typedef void (*WGPULogCallback)(WGPULogLevel level, const char *msg);
 
 void wgpuDevicePoll(WGPUDevice device, bool force_wait);
@@ -39,4 +60,4 @@ uint32_t wgpuGetVersion(void);
 
 void wgpuRenderPassEncoderSetPushConstants(WGPURenderPassEncoder encoder, WGPUShaderStage stages, uint32_t offset, uint32_t sizeBytes, void* const data);
 
-#endif 
+#endif
