react-native-wgpu 0.1.22 → 0.2.0

package/cpp/rnwgpu/api/GPUCompilationInfo.h

@@ -22,9 +22,6 @@ struct GPUCompilationMessage {
   uint64_t linePos;
   uint64_t offset;
   uint64_t length;
-  uint64_t utf16LinePos;
-  uint64_t utf16Offset;
-  uint64_t utf16Length;
 };
 
 class GPUCompilationInfo : public m::HybridObject {
@@ -75,12 +72,6 @@ template <> struct JSIConverter<std::vector<rnwgpu::GPUCompilationMessage>> {
                              static_cast<double>(message.offset));
       messageObj.setProperty(runtime, "length",
                              static_cast<double>(message.length));
-      messageObj.setProperty(runtime, "utf16LinePos",
-                             static_cast<double>(message.utf16LinePos));
-      messageObj.setProperty(runtime, "utf16Offset",
-                             static_cast<double>(message.utf16Offset));
-      messageObj.setProperty(runtime, "utf16Length",
-                             static_cast<double>(message.utf16Length));
       result.setValueAtIndex(runtime, i, messageObj);
     }
     return result;

package/cpp/rnwgpu/api/GPUDevice.cpp

@@ -22,7 +22,7 @@ GPUDevice::createBuffer(std::shared_ptr<GPUBufferDescriptor> descriptor) {
 }
 
 std::shared_ptr<GPUSupportedLimits> GPUDevice::getLimits() {
-  wgpu::SupportedLimits limits{};
+  wgpu::Limits limits{};
   if (!_instance.GetLimits(&limits)) {
     throw std::runtime_error("failed to get device limits");
   }
@@ -301,9 +301,8 @@ GPUDevice::popErrorScope() {
             break;
           }
           case wgpu::ErrorType::Unknown:
-          case wgpu::ErrorType::DeviceLost:
-            result = std::make_shared<GPUError>(wgpu::ErrorType::DeviceLost,
-                                                message);
+            result =
+                std::make_shared<GPUError>(wgpu::ErrorType::Unknown, message);
             break;
           default:
             throw std::runtime_error(
@@ -321,13 +320,11 @@ GPUDevice::popErrorScope() {
 }
 
 std::unordered_set<std::string> GPUDevice::getFeatures() {
-  size_t count = _instance.EnumerateFeatures(nullptr);
-  std::vector<wgpu::FeatureName> features(count);
-  if (count > 0) {
-    _instance.EnumerateFeatures(features.data());
-  }
+  wgpu::SupportedFeatures supportedFeatures;
+  _instance.GetFeatures(&supportedFeatures);
   std::unordered_set<std::string> result;
-  for (auto feature : features) {
+  for (size_t i = 0; i < supportedFeatures.featureCount; ++i) {
+    auto feature = supportedFeatures.features[i];
     std::string name;
     convertEnumToJSUnion(feature, &name);
     result.insert(name);

package/cpp/rnwgpu/api/GPUFeatures.h

@@ -47,9 +47,6 @@ static void convertEnumToJSUnion(wgpu::FeatureName inEnum,
   case wgpu::FeatureName::Subgroups:
     *outUnion = "subgroups";
     break;
-  case wgpu::FeatureName::SubgroupsF16:
-    *outUnion = "subgroups-f16";
-    break;
   case wgpu::FeatureName::DawnInternalUsages:
     *outUnion = "dawn-internal-usages";
     break;
@@ -65,9 +62,6 @@ static void convertEnumToJSUnion(wgpu::FeatureName inEnum,
   case wgpu::FeatureName::ImplicitDeviceSynchronization:
     *outUnion = "implicit-device-synchronization";
     break;
-    //  case wgpu::FeatureName::SurfaceCapabilities:
-    //    *outUnion = "surface-capabilities";
-    //    break;
   case wgpu::FeatureName::TransientAttachments:
     *outUnion = "transient-attachments";
     break;
@@ -83,11 +77,8 @@ static void convertEnumToJSUnion(wgpu::FeatureName inEnum,
   case wgpu::FeatureName::ANGLETextureSharing:
     *outUnion = "angle-texture-sharing";
     break;
-  case wgpu::FeatureName::ChromiumExperimentalSubgroups:
-    *outUnion = "chromium-experimental-subgroups";
-    break;
-  case wgpu::FeatureName::ChromiumExperimentalSubgroupUniformControlFlow:
-    *outUnion = "chromium-experimental-subgroup-uniform-control-flow";
+  case wgpu::FeatureName::ChromiumExperimentalSubgroupMatrix:
+    *outUnion = "chromium-experimental-subgroups-matrix";
     break;
   case wgpu::FeatureName::PixelLocalStorageCoherent:
     *outUnion = "pixel-local-storage-coherent";
@@ -134,10 +125,10 @@ static void convertEnumToJSUnion(wgpu::FeatureName inEnum,
   case wgpu::FeatureName::R8UnormStorage:
     *outUnion = "r8unorm-storage";
     break;
-  case wgpu::FeatureName::FormatCapabilities:
+  case wgpu::FeatureName::DawnFormatCapabilities:
     *outUnion = "format-capabilities";
     break;
-  case wgpu::FeatureName::DrmFormatCapabilities:
+  case wgpu::FeatureName::DawnDrmFormatCapabilities:
     *outUnion = "drm-format-capabilities";
     break;
   case wgpu::FeatureName::Norm16TextureFormats:
@@ -185,7 +176,7 @@ static void convertEnumToJSUnion(wgpu::FeatureName inEnum,
   case wgpu::FeatureName::SharedFenceVkSemaphoreOpaqueFD:
     *outUnion = "shared-fence-vk-semaphore-opaque-fd";
     break;
-  case wgpu::FeatureName::SharedFenceVkSemaphoreSyncFD:
+  case wgpu::FeatureName::SharedFenceSyncFD:
     *outUnion = "shared-fence-vk-semaphore-sync-fd";
     break;
   case wgpu::FeatureName::SharedFenceVkSemaphoreZirconHandle:

package/cpp/rnwgpu/api/GPUQueue.cpp

@@ -87,8 +87,8 @@ void GPUQueue::copyExternalImageToTexture(
     std::shared_ptr<GPUImageCopyExternalImage> source,
     std::shared_ptr<GPUImageCopyTextureTagged> destination,
     std::shared_ptr<GPUExtent3D> size) {
-  wgpu::ImageCopyTexture dst{};
-  wgpu::TextureDataLayout layout{};
+  wgpu::TexelCopyTextureInfo dst{};
+  wgpu::TexelCopyBufferLayout layout{};
   wgpu::Extent3D sz{};
   Convertor conv;
   uint32_t bytesPerPixel =
@@ -137,8 +137,8 @@ void GPUQueue::writeTexture(std::shared_ptr<GPUImageCopyTexture> destination,
                             std::shared_ptr<ArrayBuffer> data,
                             std::shared_ptr<GPUImageDataLayout> dataLayout,
                             std::shared_ptr<GPUExtent3D> size) {
-  wgpu::ImageCopyTexture dst{};
-  wgpu::TextureDataLayout layout{};
+  wgpu::TexelCopyTextureInfo dst{};
+  wgpu::TexelCopyBufferLayout layout{};
   wgpu::Extent3D sz{};
   Convertor conv;
   if (!conv(dst, destination) ||   //

package/cpp/rnwgpu/api/GPUShaderModule.cpp

@@ -25,9 +25,6 @@ GPUShaderModule::getCompilationInfo() {
               message.linePos = wgpuMessage.linePos;
               message.offset = wgpuMessage.offset;
               message.length = wgpuMessage.length;
-              message.utf16LinePos = wgpuMessage.utf16LinePos;
-              message.utf16Offset = wgpuMessage.utf16Offset;
-              message.utf16Length = wgpuMessage.utf16Length;
               result->_messages.push_back(std::move(message));
             }
           }

package/cpp/rnwgpu/api/GPUSupportedLimits.cpp

@@ -3,131 +3,127 @@
 namespace rnwgpu {
 
 double GPUSupportedLimits::getMaxTextureDimension1D() {
-  return _instance.limits.maxTextureDimension1D;
+  return _instance.maxTextureDimension1D;
 }
 
 double GPUSupportedLimits::getMaxTextureDimension2D() {
-  return _instance.limits.maxTextureDimension2D;
+  return _instance.maxTextureDimension2D;
 }
 
 double GPUSupportedLimits::getMaxTextureDimension3D() {
-  return _instance.limits.maxTextureDimension3D;
+  return _instance.maxTextureDimension3D;
 }
 
 double GPUSupportedLimits::getMaxTextureArrayLayers() {
-  return _instance.limits.maxTextureArrayLayers;
+  return _instance.maxTextureArrayLayers;
 }
 
 double GPUSupportedLimits::getMaxBindGroups() {
-  return _instance.limits.maxBindGroups;
+  return _instance.maxBindGroups;
 }
 
 double GPUSupportedLimits::getMaxBindGroupsPlusVertexBuffers() {
-  return _instance.limits.maxBindGroupsPlusVertexBuffers;
+  return _instance.maxBindGroupsPlusVertexBuffers;
 }
 
 double GPUSupportedLimits::getMaxBindingsPerBindGroup() {
-  return _instance.limits.maxBindingsPerBindGroup;
+  return _instance.maxBindingsPerBindGroup;
 }
 
 double GPUSupportedLimits::getMaxDynamicUniformBuffersPerPipelineLayout() {
-  return _instance.limits.maxDynamicUniformBuffersPerPipelineLayout;
+  return _instance.maxDynamicUniformBuffersPerPipelineLayout;
 }
 
 double GPUSupportedLimits::getMaxDynamicStorageBuffersPerPipelineLayout() {
-  return _instance.limits.maxDynamicStorageBuffersPerPipelineLayout;
+  return _instance.maxDynamicStorageBuffersPerPipelineLayout;
 }
 
 double GPUSupportedLimits::getMaxSampledTexturesPerShaderStage() {
-  return _instance.limits.maxSampledTexturesPerShaderStage;
+  return _instance.maxSampledTexturesPerShaderStage;
 }
 
 double GPUSupportedLimits::getMaxSamplersPerShaderStage() {
-  return _instance.limits.maxSamplersPerShaderStage;
+  return _instance.maxSamplersPerShaderStage;
 }
 
 double GPUSupportedLimits::getMaxStorageBuffersPerShaderStage() {
-  return _instance.limits.maxStorageBuffersPerShaderStage;
+  return _instance.maxStorageBuffersPerShaderStage;
 }
 
 double GPUSupportedLimits::getMaxStorageTexturesPerShaderStage() {
-  return _instance.limits.maxStorageTexturesPerShaderStage;
+  return _instance.maxStorageTexturesPerShaderStage;
 }
 
 double GPUSupportedLimits::getMaxUniformBuffersPerShaderStage() {
-  return _instance.limits.maxUniformBuffersPerShaderStage;
+  return _instance.maxUniformBuffersPerShaderStage;
 }
 
 double GPUSupportedLimits::getMaxUniformBufferBindingSize() {
-  return _instance.limits.maxUniformBufferBindingSize;
+  return _instance.maxUniformBufferBindingSize;
 }
 
 double GPUSupportedLimits::getMaxStorageBufferBindingSize() {
-  return _instance.limits.maxStorageBufferBindingSize;
+  return _instance.maxStorageBufferBindingSize;
 }
 
 double GPUSupportedLimits::getMinUniformBufferOffsetAlignment() {
-  return _instance.limits.minUniformBufferOffsetAlignment;
+  return _instance.minUniformBufferOffsetAlignment;
 }
 
 double GPUSupportedLimits::getMinStorageBufferOffsetAlignment() {
-  return _instance.limits.minStorageBufferOffsetAlignment;
+  return _instance.minStorageBufferOffsetAlignment;
 }
 
 double GPUSupportedLimits::getMaxVertexBuffers() {
-  return _instance.limits.maxVertexBuffers;
+  return _instance.maxVertexBuffers;
 }
 
 double GPUSupportedLimits::getMaxBufferSize() {
-  return _instance.limits.maxBufferSize;
+  return _instance.maxBufferSize;
 }
 
 double GPUSupportedLimits::getMaxVertexAttributes() {
-  return _instance.limits.maxVertexAttributes;
+  return _instance.maxVertexAttributes;
 }
 
 double GPUSupportedLimits::getMaxVertexBufferArrayStride() {
-  return _instance.limits.maxVertexBufferArrayStride;
-}
-
-double GPUSupportedLimits::getMaxInterStageShaderComponents() {
-  return _instance.limits.maxInterStageShaderComponents;
+  return _instance.maxVertexBufferArrayStride;
 }
 
 double GPUSupportedLimits::getMaxInterStageShaderVariables() {
-  return _instance.limits.maxInterStageShaderVariables;
+  return _instance.maxInterStageShaderVariables;
 }
 
 double GPUSupportedLimits::getMaxColorAttachments() {
-  return _instance.limits.maxColorAttachments;
+  return _instance.maxColorAttachments;
 }
 
 double GPUSupportedLimits::getMaxColorAttachmentBytesPerSample() {
-  return _instance.limits.maxColorAttachmentBytesPerSample;
+  return _instance.maxColorAttachmentBytesPerSample;
 }
 
 double GPUSupportedLimits::getMaxComputeWorkgroupStorageSize() {
-  return _instance.limits.maxComputeWorkgroupStorageSize;
+  return _instance.maxComputeWorkgroupStorageSize;
 }
 
 double GPUSupportedLimits::getMaxComputeInvocationsPerWorkgroup() {
-  return _instance.limits.maxComputeInvocationsPerWorkgroup;
+  return _instance.maxComputeInvocationsPerWorkgroup;
 }
 
 double GPUSupportedLimits::getMaxComputeWorkgroupSizeX() {
-  return _instance.limits.maxComputeWorkgroupSizeX;
+  return _instance.maxComputeWorkgroupSizeX;
 }
 
 double GPUSupportedLimits::getMaxComputeWorkgroupSizeY() {
-  return _instance.limits.maxComputeWorkgroupSizeY;
+  return _instance.maxComputeWorkgroupSizeY;
 }
 
 double GPUSupportedLimits::getMaxComputeWorkgroupSizeZ() {
-  return _instance.limits.maxComputeWorkgroupSizeZ;
+  return _instance.maxComputeWorkgroupSizeZ;
 }
 
 double GPUSupportedLimits::getMaxComputeWorkgroupsPerDimension() {
-  return _instance.limits.maxComputeWorkgroupsPerDimension;
+  return _instance.maxComputeWorkgroupsPerDimension;
 }
 
 } // namespace rnwgpu

package/cpp/rnwgpu/api/GPUSupportedLimits.h

@@ -16,7 +16,7 @@ namespace m = margelo;
 
 class GPUSupportedLimits : public m::HybridObject {
 public:
-  explicit GPUSupportedLimits(wgpu::SupportedLimits instance)
+  explicit GPUSupportedLimits(wgpu::Limits instance)
       : HybridObject("GPUSupportedLimits"), _instance(instance) {}
 
 public:
@@ -44,7 +44,6 @@ public:
   double getMaxBufferSize();
   double getMaxVertexAttributes();
   double getMaxVertexBufferArrayStride();
-  double getMaxInterStageShaderComponents();
   double getMaxInterStageShaderVariables();
   double getMaxColorAttachments();
   double getMaxColorAttachmentBytesPerSample();
@@ -117,9 +116,6 @@ public:
     registerHybridGetter("maxVertexBufferArrayStride",
                          &GPUSupportedLimits::getMaxVertexBufferArrayStride,
                          this);
-    registerHybridGetter("maxInterStageShaderComponents",
-                         &GPUSupportedLimits::getMaxInterStageShaderComponents,
-                         this);
     registerHybridGetter("maxInterStageShaderVariables",
                          &GPUSupportedLimits::getMaxInterStageShaderVariables,
                          this);
@@ -148,10 +144,10 @@ public:
         &GPUSupportedLimits::getMaxComputeWorkgroupsPerDimension, this);
   }
 
-  inline const wgpu::SupportedLimits get() { return _instance; }
+  inline const wgpu::Limits get() { return _instance; }
 
 private:
-  wgpu::SupportedLimits _instance;
+  wgpu::Limits _instance;
 };
 
 } // namespace rnwgpu

package/cpp/rnwgpu/api/descriptors/Unions.h

@@ -432,10 +432,110 @@ static void convertJSUnionToEnum(const std::string &inUnion,
     *outEnum = wgpu::FeatureName::BGRA8UnormStorage;
   } else if (inUnion == "float32-filterable") {
     *outEnum = wgpu::FeatureName::Float32Filterable;
-  } else if (inUnion == "clip-distances") {
-    *outEnum = wgpu::FeatureName::ClipDistances;
+  } else if (inUnion == "subgroups") {
+    *outEnum = wgpu::FeatureName::Subgroups;
+  } else if (inUnion == "dawn-internal-usages") {
+    *outEnum = wgpu::FeatureName::DawnInternalUsages;
+  } else if (inUnion == "dawn-multi-planar-formats") {
+    *outEnum = wgpu::FeatureName::DawnMultiPlanarFormats;
+  } else if (inUnion == "dawn-native") {
+    *outEnum = wgpu::FeatureName::DawnNative;
+  } else if (inUnion == "chromium-experimental-timestamp-query-inside-passes") {
+    *outEnum = wgpu::FeatureName::ChromiumExperimentalTimestampQueryInsidePasses;
+  } else if (inUnion == "implicit-device-synchronization") {
+    *outEnum = wgpu::FeatureName::ImplicitDeviceSynchronization;
+  } else if (inUnion == "transient-attachments") {
+    *outEnum = wgpu::FeatureName::TransientAttachments;
+  } else if (inUnion == "msaa-render-to-single-sampled") {
+    *outEnum = wgpu::FeatureName::MSAARenderToSingleSampled;
   } else if (inUnion == "dual-source-blending") {
     *outEnum = wgpu::FeatureName::DualSourceBlending;
+  } else if (inUnion == "d3d11-multithread-protected") {
+    *outEnum = wgpu::FeatureName::D3D11MultithreadProtected;
+  } else if (inUnion == "angle-texture-sharing") {
+    *outEnum = wgpu::FeatureName::ANGLETextureSharing;
+  } else if (inUnion == "chromium-experimental-subgroups-matrix") {
+    *outEnum = wgpu::FeatureName::ChromiumExperimentalSubgroupMatrix;
+  } else if (inUnion == "pixel-local-storage-coherent") {
+    *outEnum = wgpu::FeatureName::PixelLocalStorageCoherent;
+  } else if (inUnion == "pixel-local-storage-non-coherent") {
+    *outEnum = wgpu::FeatureName::PixelLocalStorageNonCoherent;
+  } else if (inUnion == "unorm16-texture-formats") {
+    *outEnum = wgpu::FeatureName::Unorm16TextureFormats;
+  } else if (inUnion == "snorm16-texture-formats") {
+    *outEnum = wgpu::FeatureName::Snorm16TextureFormats;
+  } else if (inUnion == "multi-planar-format-extended-usages") {
+    *outEnum = wgpu::FeatureName::MultiPlanarFormatExtendedUsages;
+  } else if (inUnion == "multi-planar-format-p010") {
+    *outEnum = wgpu::FeatureName::MultiPlanarFormatP010;
+  } else if (inUnion == "host-mapped-pointer") {
+    *outEnum = wgpu::FeatureName::HostMappedPointer;
+  } else if (inUnion == "multi-planar-render-targets") {
+    *outEnum = wgpu::FeatureName::MultiPlanarRenderTargets;
+  } else if (inUnion == "multi-planar-format-nv12a") {
+    *outEnum = wgpu::FeatureName::MultiPlanarFormatNv12a;
+  } else if (inUnion == "framebuffer-fetch") {
+    *outEnum = wgpu::FeatureName::FramebufferFetch;
+  } else if (inUnion == "buffer-map-extended-usages") {
+    *outEnum = wgpu::FeatureName::BufferMapExtendedUsages;
+  } else if (inUnion == "adapter-properties-memory-heaps") {
+    *outEnum = wgpu::FeatureName::AdapterPropertiesMemoryHeaps;
+  } else if (inUnion == "adapter-properties-d3d") {
+    *outEnum = wgpu::FeatureName::AdapterPropertiesD3D;
+  } else if (inUnion == "adapter-properties-vk") {
+    *outEnum = wgpu::FeatureName::AdapterPropertiesVk;
+  } else if (inUnion == "r8unorm-storage") {
+    *outEnum = wgpu::FeatureName::R8UnormStorage;
+  } else if (inUnion == "dawn-format-capabilities") {
+    *outEnum = wgpu::FeatureName::DawnFormatCapabilities;
+  } else if (inUnion == "norm16-texture-formats") {
+    *outEnum = wgpu::FeatureName::Norm16TextureFormats;
+  } else if (inUnion == "multi-planar-format-nv16") {
+    *outEnum = wgpu::FeatureName::MultiPlanarFormatNv16;
+  } else if (inUnion == "multi-planar-format-nv24") {
+    *outEnum = wgpu::FeatureName::MultiPlanarFormatNv24;
+  } else if (inUnion == "multi-planar-format-p210") {
+    *outEnum = wgpu::FeatureName::MultiPlanarFormatP210;
+  } else if (inUnion == "multi-planar-format-p410") {
+    *outEnum = wgpu::FeatureName::MultiPlanarFormatP410;
+  } else if (inUnion == "shared-texture-memory-vk-dedicated-allocation") {
+    *outEnum = wgpu::FeatureName::SharedTextureMemoryVkDedicatedAllocation;
+  } else if (inUnion == "shared-texture-memory-ahardware-buffer") {
+    *outEnum = wgpu::FeatureName::SharedTextureMemoryAHardwareBuffer;
+  } else if (inUnion == "shared-texture-memory-dma-buf") {
+    *outEnum = wgpu::FeatureName::SharedTextureMemoryDmaBuf;
+  } else if (inUnion == "shared-texture-memory-opaque-fd") {
+    *outEnum = wgpu::FeatureName::SharedTextureMemoryOpaqueFD;
+  } else if (inUnion == "shared-texture-memory-zircon-handle") {
+    *outEnum = wgpu::FeatureName::SharedTextureMemoryZirconHandle;
+  } else if (inUnion == "shared-texture-memory-dxgi-shared-handle") {
+    *outEnum = wgpu::FeatureName::SharedTextureMemoryDXGISharedHandle;
+  } else if (inUnion == "shared-texture-memory-d3d11-texture2d") {
+    *outEnum = wgpu::FeatureName::SharedTextureMemoryD3D11Texture2D;
+  } else if (inUnion == "shared-texture-memory-iosurface") {
+    *outEnum = wgpu::FeatureName::SharedTextureMemoryIOSurface;
+  } else if (inUnion == "shared-texture-memory-egl-image") {
+    *outEnum = wgpu::FeatureName::SharedTextureMemoryEGLImage;
+  } else if (inUnion == "shared-fence-vk-semaphore-opaque-fd") {
+    *outEnum = wgpu::FeatureName::SharedFenceVkSemaphoreOpaqueFD;
+  } else if (inUnion == "shared-fence-vk-semaphore-zircon-handle") {
+    *outEnum = wgpu::FeatureName::SharedFenceVkSemaphoreZirconHandle;
+  } else if (inUnion == "shared-fence-dxgi-shared-handle") {
+    *outEnum = wgpu::FeatureName::SharedFenceDXGISharedHandle;
+  } else if (inUnion == "shared-fence-mtl-shared-event") {
+    *outEnum = wgpu::FeatureName::SharedFenceMTLSharedEvent;
+  } else if (inUnion == "shared-buffer-memory-d3d12-resource") {
+    *outEnum = wgpu::FeatureName::SharedBufferMemoryD3D12Resource;
+  } else if (inUnion == "static-samplers") {
+    *outEnum = wgpu::FeatureName::StaticSamplers;
+  } else if (inUnion == "ycbcr-vulkan-samplers") {
+    *outEnum = wgpu::FeatureName::YCbCrVulkanSamplers;
+  } else if (inUnion == "shader-module-compilation-options") {
+    *outEnum = wgpu::FeatureName::ShaderModuleCompilationOptions;
+  } else if (inUnion == "dawn-load-resolve-texture") {
+    *outEnum = wgpu::FeatureName::DawnLoadResolveTexture;
+  } else if (inUnion == "clip-distances") {
+    *outEnum = wgpu::FeatureName::ClipDistances;
   } else {
     throw invalidUnion(inUnion);
   }
@@ -477,12 +577,165 @@ static void convertEnumToJSUnion(wgpu::FeatureName inEnum,
   case wgpu::FeatureName::Float32Filterable:
     *outUnion = "float32-filterable";
     break;
-  case wgpu::FeatureName::ClipDistances:
-    *outUnion = "clip-distances";
+  case wgpu::FeatureName::Subgroups:
+    *outUnion = "subgroups";
+    break;
+  case wgpu::FeatureName::DawnInternalUsages:
+    *outUnion = "dawn-internal-usages";
+    break;
+  case wgpu::FeatureName::DawnMultiPlanarFormats:
+    *outUnion = "dawn-multi-planar-formats";
+    break;
+  case wgpu::FeatureName::DawnNative:
+    *outUnion = "dawn-native";
+    break;
+  case wgpu::FeatureName::ChromiumExperimentalTimestampQueryInsidePasses:
+    *outUnion = "chromium-experimental-timestamp-query-inside-passes";
+    break;
+  case wgpu::FeatureName::ImplicitDeviceSynchronization:
+    *outUnion = "implicit-device-synchronization";
+    break;
+    //  case wgpu::FeatureName::SurfaceCapabilities:
+    //    *outUnion = "surface-capabilities";
+    //    break;
+  case wgpu::FeatureName::TransientAttachments:
+    *outUnion = "transient-attachments";
+    break;
+  case wgpu::FeatureName::MSAARenderToSingleSampled:
+    *outUnion = "msaa-render-to-single-sampled";
     break;
   case wgpu::FeatureName::DualSourceBlending:
     *outUnion = "dual-source-blending";
     break;
+  case wgpu::FeatureName::D3D11MultithreadProtected:
+    *outUnion = "d3d11-multithread-protected";
+    break;
+  case wgpu::FeatureName::ANGLETextureSharing:
+    *outUnion = "angle-texture-sharing";
+    break;
+    case wgpu::FeatureName::ChromiumExperimentalSubgroupMatrix:
+    *outUnion = "chromium-experimental-subgroups-matrix";
+    break;
+  case wgpu::FeatureName::PixelLocalStorageCoherent:
+    *outUnion = "pixel-local-storage-coherent";
+    break;
+  case wgpu::FeatureName::PixelLocalStorageNonCoherent:
+    *outUnion = "pixel-local-storage-non-coherent";
+    break;
+  case wgpu::FeatureName::Unorm16TextureFormats:
+    *outUnion = "unorm16-texture-formats";
+    break;
+  case wgpu::FeatureName::Snorm16TextureFormats:
+    *outUnion = "snorm16-texture-formats";
+    break;
+  case wgpu::FeatureName::MultiPlanarFormatExtendedUsages:
+    *outUnion = "multi-planar-format-extended-usages";
+    break;
+  case wgpu::FeatureName::MultiPlanarFormatP010:
+    *outUnion = "multi-planar-format-p010";
+    break;
+  case wgpu::FeatureName::HostMappedPointer:
+    *outUnion = "host-mapped-pointer";
+    break;
+  case wgpu::FeatureName::MultiPlanarRenderTargets:
+    *outUnion = "multi-planar-render-targets";
+    break;
+  case wgpu::FeatureName::MultiPlanarFormatNv12a:
+    *outUnion = "multi-planar-format-nv12a";
+    break;
+  case wgpu::FeatureName::FramebufferFetch:
+    *outUnion = "framebuffer-fetch";
+    break;
+  case wgpu::FeatureName::BufferMapExtendedUsages:
+    *outUnion = "buffer-map-extended-usages";
+    break;
+  case wgpu::FeatureName::AdapterPropertiesMemoryHeaps:
+    *outUnion = "adapter-properties-memory-heaps";
+    break;
+  case wgpu::FeatureName::AdapterPropertiesD3D:
+    *outUnion = "adapter-properties-d3d";
+    break;
+  case wgpu::FeatureName::AdapterPropertiesVk:
+    *outUnion = "adapter-properties-vk";
+    break;
+  case wgpu::FeatureName::R8UnormStorage:
+    *outUnion = "r8unorm-storage";
+    break;
+  case wgpu::FeatureName::DawnFormatCapabilities:
+    *outUnion = "dawn-format-capabilities";
+    break;
+  case wgpu::FeatureName::Norm16TextureFormats:
+    *outUnion = "norm16-texture-formats";
+    break;
+  case wgpu::FeatureName::MultiPlanarFormatNv16:
+    *outUnion = "multi-planar-format-nv16";
+    break;
+  case wgpu::FeatureName::MultiPlanarFormatNv24:
+    *outUnion = "multi-planar-format-nv24";
+    break;
+  case wgpu::FeatureName::MultiPlanarFormatP210:
+    *outUnion = "multi-planar-format-p210";
+    break;
+  case wgpu::FeatureName::MultiPlanarFormatP410:
+    *outUnion = "multi-planar-format-p410";
+    break;
+  case wgpu::FeatureName::SharedTextureMemoryVkDedicatedAllocation:
+    *outUnion = "shared-texture-memory-vk-dedicated-allocation";
+    break;
+  case wgpu::FeatureName::SharedTextureMemoryAHardwareBuffer:
+    *outUnion = "shared-texture-memory-ahardware-buffer";
+    break;
+  case wgpu::FeatureName::SharedTextureMemoryDmaBuf:
+    *outUnion = "shared-texture-memory-dma-buf";
+    break;
+  case wgpu::FeatureName::SharedTextureMemoryOpaqueFD:
+    *outUnion = "shared-texture-memory-opaque-fd";
+    break;
+  case wgpu::FeatureName::SharedTextureMemoryZirconHandle:
+    *outUnion = "shared-texture-memory-zircon-handle";
+    break;
+  case wgpu::FeatureName::SharedTextureMemoryDXGISharedHandle:
+    *outUnion = "shared-texture-memory-dxgi-shared-handle";
+    break;
+  case wgpu::FeatureName::SharedTextureMemoryD3D11Texture2D:
+    *outUnion = "shared-texture-memory-d3d11-texture2d";
+    break;
+  case wgpu::FeatureName::SharedTextureMemoryIOSurface:
+    *outUnion = "shared-texture-memory-iosurface";
+    break;
+  case wgpu::FeatureName::SharedTextureMemoryEGLImage:
+    *outUnion = "shared-texture-memory-egl-image";
+    break;
+  case wgpu::FeatureName::SharedFenceVkSemaphoreOpaqueFD:
+    *outUnion = "shared-fence-vk-semaphore-opaque-fd";
+    break;
+  case wgpu::FeatureName::SharedFenceVkSemaphoreZirconHandle:
+    *outUnion = "shared-fence-vk-semaphore-zircon-handle";
+    break;
+  case wgpu::FeatureName::SharedFenceDXGISharedHandle:
+    *outUnion = "shared-fence-dxgi-shared-handle";
+    break;
+  case wgpu::FeatureName::SharedFenceMTLSharedEvent:
+    *outUnion = "shared-fence-mtl-shared-event";
+    break;
+  case wgpu::FeatureName::SharedBufferMemoryD3D12Resource:
+    *outUnion = "shared-buffer-memory-d3d12-resource";
+    break;
+  case wgpu::FeatureName::StaticSamplers:
+    *outUnion = "static-samplers";
+    break;
+  case wgpu::FeatureName::YCbCrVulkanSamplers:
+    *outUnion = "ycbcr-vulkan-samplers";
+    break;
+  case wgpu::FeatureName::ShaderModuleCompilationOptions:
+    *outUnion = "shader-module-compilation-options";
+    break;
+  case wgpu::FeatureName::DawnLoadResolveTexture:
+    *outUnion = "dawn-load-resolve-texture";
+    break;
+  case wgpu::FeatureName::ClipDistances:
+    *outUnion = "clip-distances";
+    break;
   default:
     throw invalidEnum(inEnum);
   }