Add wgpuInstanceHasWGSLLanguageFeature (#21055)

* Add wgpuInstanceHasWGSLLanguageFeature

* Check wgslLanguageFeatures exists

Author: beaufortfrancois

src/library_sigs.js

@@ -1642,6 +1642,7 @@ sigs = {
   wgpuDeviceSetUncapturedErrorCallback__sig: 'vppp',
   wgpuGetProcAddress__sig: 'ppp',
   wgpuInstanceCreateSurface__sig: 'ppp',
+  wgpuInstanceHasWGSLLanguageFeature__sig: 'ipi',
   wgpuInstanceProcessEvents__sig: 'vp',
   wgpuInstanceReference__sig: 'vp',
   wgpuInstanceRelease__sig: 'vp',

src/library_webgpu.js

@@ -350,6 +350,13 @@ var LibraryWebGPU = {
     },
 
     // This section is auto-generated. See system/include/webgpu/README.md for details.
+    WGSLFeatureName: [
+      undefined,
+      'readonly_and_readwrite_storage_textures',
+      'packed_4x8_integer_dot_product',
+      'unrestricted_pointer_parameters',
+      'pointer_composite_access',
+    ],
     AddressMode: [
       'repeat',
       'mirror-repeat',
@@ -2400,6 +2407,13 @@ var LibraryWebGPU = {
     return WebGPU.mgrSurface.create(context);
   },
 
+  wgpuInstanceHasWGSLLanguageFeature: (instance, featureEnumValue) => {
+    if (!('wgslLanguageFeatures' in navigator["gpu"])) {
+      return false;
+    }
+    return navigator["gpu"]["wgslLanguageFeatures"].has(WebGPU.WGSLFeatureName[featureEnumValue]);
+  },
+
   wgpuInstanceProcessEvents: (instance) => {
     // TODO: This could probably be emulated with ASYNCIFY.
 #if ASSERTIONS

system/include/webgpu/README.md

@@ -41,5 +41,6 @@ test/runner browser.test_webgpu_basic_rendering --browser="google-chrome-unstabl
 Alternatively you can test your emscripten updates by building the source file, and then serve (e.g. use node http-server) and view in browser to make sure things work fine.
 
 ```
+emcc --clear-cache
 emcc test/webgpu_basic_rendering.cpp -sUSE_WEBGPU -o path/to/index.html
 ```

system/include/webgpu/webgpu.h

@@ -169,6 +169,15 @@ struct WGPUVertexState;
 struct WGPUFragmentState;
 struct WGPURenderPipelineDescriptor;
 
+typedef enum WGPUWGSLFeatureName {
+    WGPUWGSLFeatureName_Undefined = 0x00000000,
+    WGPUWGSLFeatureName_ReadonlyAndReadwriteStorageTextures = 0x00000001,
+    WGPUWGSLFeatureName_Packed4x8IntegerDotProduct = 0x00000002,
+    WGPUWGSLFeatureName_UnrestrictedPointerParameters = 0x00000003,
+    WGPUWGSLFeatureName_PointerCompositeAccess = 0x00000004,
+    WGPUWGSLFeatureName_Force32 = 0x7FFFFFFF
+} WGPUWGSLFeatureName WGPU_ENUM_ATTRIBUTE;
+
 typedef enum WGPUAdapterType {
     WGPUAdapterType_DiscreteGPU = 0x00000000,
     WGPUAdapterType_IntegratedGPU = 0x00000001,
@@ -1345,6 +1354,7 @@ typedef void (*WGPUProcDeviceRelease)(WGPUDevice device) WGPU_FUNCTION_ATTRIBUTE
 
 // Procs of Instance
 typedef WGPUSurface (*WGPUProcInstanceCreateSurface)(WGPUInstance instance, WGPUSurfaceDescriptor const * descriptor) WGPU_FUNCTION_ATTRIBUTE;
+typedef bool (*WGPUProcInstanceHasWGSLLanguageFeature)(WGPUInstance instance, WGPUWGSLFeatureName feature) WGPU_FUNCTION_ATTRIBUTE;
 typedef void (*WGPUProcInstanceProcessEvents)(WGPUInstance instance) WGPU_FUNCTION_ATTRIBUTE;
 typedef void (*WGPUProcInstanceRequestAdapter)(WGPUInstance instance, WGPU_NULLABLE WGPURequestAdapterOptions const * options, WGPURequestAdapterCallback callback, void * userdata) WGPU_FUNCTION_ATTRIBUTE;
 typedef void (*WGPUProcInstanceReference)(WGPUInstance instance) WGPU_FUNCTION_ATTRIBUTE;
@@ -1579,6 +1589,7 @@ WGPU_EXPORT void wgpuDeviceRelease(WGPUDevice device) WGPU_FUNCTION_ATTRIBUTE;
 
 // Methods of Instance
 WGPU_EXPORT WGPUSurface wgpuInstanceCreateSurface(WGPUInstance instance, WGPUSurfaceDescriptor const * descriptor) WGPU_FUNCTION_ATTRIBUTE;
+WGPU_EXPORT bool wgpuInstanceHasWGSLLanguageFeature(WGPUInstance instance, WGPUWGSLFeatureName feature) WGPU_FUNCTION_ATTRIBUTE;
 WGPU_EXPORT void wgpuInstanceProcessEvents(WGPUInstance instance) WGPU_FUNCTION_ATTRIBUTE;
 WGPU_EXPORT void wgpuInstanceRequestAdapter(WGPUInstance instance, WGPU_NULLABLE WGPURequestAdapterOptions const * options, WGPURequestAdapterCallback callback, void * userdata) WGPU_FUNCTION_ATTRIBUTE;
 WGPU_EXPORT void wgpuInstanceReference(WGPUInstance instance) WGPU_FUNCTION_ATTRIBUTE;

system/include/webgpu/webgpu_cpp.h

@@ -144,6 +144,14 @@ namespace wgpu {
     static constexpr size_t kWholeMapSize = WGPU_WHOLE_MAP_SIZE;
     static constexpr uint64_t kWholeSize = WGPU_WHOLE_SIZE;
 
+    enum class WGSLFeatureName : uint32_t {
+        Undefined = 0x00000000,
+        ReadonlyAndReadwriteStorageTextures = 0x00000001,
+        Packed4x8IntegerDotProduct = 0x00000002,
+        UnrestrictedPointerParameters = 0x00000003,
+        PointerCompositeAccess = 0x00000004,
+    };
+
     enum class AdapterType : uint32_t {
         DiscreteGPU = 0x00000000,
         IntegratedGPU = 0x00000001,
@@ -984,6 +992,7 @@ namespace wgpu {
         using ObjectBase::operator=;
 
         Surface CreateSurface(SurfaceDescriptor const * descriptor) const;
+        bool HasWGSLLanguageFeature(WGSLFeatureName feature) const;
         void ProcessEvents() const;
         void RequestAdapter(RequestAdapterOptions const * options, RequestAdapterCallback callback, void * userdata) const;
 

system/lib/webgpu/webgpu_cpp.cpp

@@ -7,6 +7,17 @@
 
 namespace wgpu {
 
+    // WGSLFeatureName
+
+    static_assert(sizeof(WGSLFeatureName) == sizeof(WGPUWGSLFeatureName), "sizeof mismatch for WGSLFeatureName");
+    static_assert(alignof(WGSLFeatureName) == alignof(WGPUWGSLFeatureName), "alignof mismatch for WGSLFeatureName");
+
+    static_assert(static_cast<uint32_t>(WGSLFeatureName::Undefined) == WGPUWGSLFeatureName_Undefined, "value mismatch for WGSLFeatureName::Undefined");
+    static_assert(static_cast<uint32_t>(WGSLFeatureName::ReadonlyAndReadwriteStorageTextures) == WGPUWGSLFeatureName_ReadonlyAndReadwriteStorageTextures, "value mismatch for WGSLFeatureName::ReadonlyAndReadwriteStorageTextures");
+    static_assert(static_cast<uint32_t>(WGSLFeatureName::Packed4x8IntegerDotProduct) == WGPUWGSLFeatureName_Packed4x8IntegerDotProduct, "value mismatch for WGSLFeatureName::Packed4x8IntegerDotProduct");
+    static_assert(static_cast<uint32_t>(WGSLFeatureName::UnrestrictedPointerParameters) == WGPUWGSLFeatureName_UnrestrictedPointerParameters, "value mismatch for WGSLFeatureName::UnrestrictedPointerParameters");
+    static_assert(static_cast<uint32_t>(WGSLFeatureName::PointerCompositeAccess) == WGPUWGSLFeatureName_PointerCompositeAccess, "value mismatch for WGSLFeatureName::PointerCompositeAccess");
+
     // AdapterType
 
     static_assert(sizeof(AdapterType) == sizeof(WGPUAdapterType), "sizeof mismatch for AdapterType");
@@ -2024,6 +2035,10 @@ namespace wgpu {
         auto result = wgpuInstanceCreateSurface(Get(), reinterpret_cast<WGPUSurfaceDescriptor const * >(descriptor));
         return Surface::Acquire(result);
     }
+    bool Instance::HasWGSLLanguageFeature(WGSLFeatureName feature) const {
+        auto result = wgpuInstanceHasWGSLLanguageFeature(Get(), static_cast<WGPUWGSLFeatureName>(feature));
+        return result;
+    }
     void Instance::ProcessEvents() const {
         wgpuInstanceProcessEvents(Get());
     }