Implement wgpuAdapterGetLimits, add test that limit requests are applied

src/library_webgpu.js

@@ -2604,6 +2604,7 @@ var LibraryWebGPU = {
         setLimitU32IfDefined("maxInterStageShaderComponents", {{{ C_STRUCTS.WGPULimits.maxInterStageShaderComponents }}});
         setLimitU32IfDefined("maxInterStageShaderVariables", {{{ C_STRUCTS.WGPULimits.maxInterStageShaderVariables }}});
         setLimitU32IfDefined("maxColorAttachments", {{{ C_STRUCTS.WGPULimits.maxColorAttachments }}});
+        setLimitU32IfDefined("maxColorAttachmentBytesPerSample", {{{ C_STRUCTS.WGPULimits.maxColorAttachmentBytesPerSample }}});
         setLimitU32IfDefined("maxComputeWorkgroupStorageSize", {{{ C_STRUCTS.WGPULimits.maxComputeWorkgroupStorageSize }}});
         setLimitU32IfDefined("maxComputeInvocationsPerWorkgroup", {{{ C_STRUCTS.WGPULimits.maxComputeInvocationsPerWorkgroup }}});
         setLimitU32IfDefined("maxComputeWorkgroupSizeX", {{{ C_STRUCTS.WGPULimits.maxComputeWorkgroupSizeX }}});

test/test_browser.py

@@ -4524,6 +4524,10 @@ def test_webgl_simple_extensions(self, simple_enable_extensions, webgl_version):
   def test_webgpu_basic_rendering(self, args):
     self.btest_exit('webgpu_basic_rendering.cpp', args=['-sUSE_WEBGPU'] + args)
 
+  @requires_graphics_hardware
+  def test_webgpu_required_limits(self):
+    self.btest_exit('webgpu_required_limits.cpp', args=['-sUSE_WEBGPU', '-sASYNCIFY'])
+
   # TODO(#19645): Extend this test to proxied WebGPU when it's re-enabled.
   @requires_graphics_hardware
   def test_webgpu_basic_rendering_pthreads(self):

test/webgpu_required_limits.cpp

@@ -0,0 +1,92 @@
+#include <cassert>
+#include <emscripten.h>
+#include <iostream>
+#include <webgpu/webgpu.h>
+
+int adapter_limit_maxColorAttachmentBytesPerSample = -1;
+
+EM_ASYNC_JS(int, get_limit, (), {
+  if (!navigator.gpu) {
+    throw Error("WebGPU not supported.");
+  }
+
+  const adapter = await navigator.gpu.requestAdapter();
+  if (!adapter) {
+    throw Error("Couldn't request WebGPU adapter.");
+  }
+
+  console.log("adapter limits", adapter.limits);
+
+  return adapter.limits.maxColorAttachmentBytesPerSample;
+});
+
+void on_device_request_ended(WGPURequestDeviceStatus status,
+                             WGPUDevice device,
+                             char const* message,
+                             void* userdata) {
+  assert(status == WGPURequestDeviceStatus::WGPURequestDeviceStatus_Success);
+
+  WGPUSupportedLimits device_supported_limits{};
+  wgpuDeviceGetLimits(device, &device_supported_limits);
+
+  std::cout << "required maxColorAttachmentBytesPerSample="
+            << adapter_limit_maxColorAttachmentBytesPerSample << std::endl;
+  std::cout << "supported maxColorAttachmentBytesPerSample="
+            << device_supported_limits.limits.maxColorAttachmentBytesPerSample
+            << std::endl;
+
+  // device supported limit MUST be equal or larger than what was requested,
+  // otherwise device acquisition should have failed
+  assert(device_supported_limits.limits.maxColorAttachmentBytesPerSample >=
+         adapter_limit_maxColorAttachmentBytesPerSample);
+}
+
+void on_adapter_request_ended(WGPURequestAdapterStatus status,
+                              WGPUAdapter adapter,
+                              char const* message,
+                              void* userdata) {
+  assert(status == WGPURequestAdapterStatus::WGPURequestAdapterStatus_Success);
+
+  // retrieving limits supported by adapter - currently unsupported!
+  // WGPUSupportedLimits adapter_supported_limits {};
+  // wgpuAdapterGetLimits(adapter, &adapter_supported_limits);
+  // adapter_limit_maxColorAttachmentBytesPerSample =
+  // adapter_supported_limits.limits.maxColorAttachmentBytesPerSample;
+
+  // use js callout instead
+  adapter_limit_maxColorAttachmentBytesPerSample = get_limit();
+  std::cout << "adapter supports maxColorAttachmentBytesPerSample="
+            << adapter_limit_maxColorAttachmentBytesPerSample << std::endl;
+
+  // if max supported limit is the default, we cant check if requesting more works
+  if (adapter_limit_maxColorAttachmentBytesPerSample == 32) {
+    exit(0);
+  }
+
+  WGPURequiredLimits device_required_limits{};
+  device_required_limits.limits.minStorageBufferOffsetAlignment =
+    256; // irrelevant but needs to be set
+  device_required_limits.limits.minUniformBufferOffsetAlignment =
+    256; // irrelevant but needs to be set
+
+  // requesting adapter supported limit
+  device_required_limits.limits.maxColorAttachmentBytesPerSample =
+    adapter_limit_maxColorAttachmentBytesPerSample;
+
+  WGPUDeviceDescriptor device_desc{};
+  device_desc.requiredFeatureCount = 0;
+  device_desc.requiredLimits = &device_required_limits;
+
+  wgpuAdapterRequestDevice(
+    adapter, &device_desc, on_device_request_ended, nullptr);
+}
+
+int main() {
+  const WGPUInstance instance = wgpuCreateInstance(nullptr);
+
+  WGPURequestAdapterOptions adapter_options{};
+  wgpuInstanceRequestAdapter(
+    instance, &adapter_options, on_adapter_request_ended, nullptr);
+
+  return 0;
+}