react-native-webgpu 0.5.11 → 0.5.14

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

@@ -0,0 +1,57 @@
+#pragma once
+
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "webgpu/webgpu_cpp.h"
+
+#include "JSIConverter.h"
+#include "WGPULogger.h"
+
+namespace jsi = facebook::jsi;
+
+namespace rnwgpu {
+
+// Non-standard, Dawn-only. Mirrors wgpu::DawnTogglesDescriptor field-for-field
+// so the mapping to the native chained struct is 1:1. Chained onto the
+// wgpu::DeviceDescriptor in GPUAdapter::requestDevice.
+struct GPUDawnTogglesDescriptor {
+  std::optional<std::vector<std::string>> enabledToggles;  // Iterable<string>
+  std::optional<std::vector<std::string>> disabledToggles; // Iterable<string>
+};
+
+} // namespace rnwgpu
+
+namespace rnwgpu {
+
+template <>
+struct JSIConverter<std::shared_ptr<rnwgpu::GPUDawnTogglesDescriptor>> {
+  static std::shared_ptr<rnwgpu::GPUDawnTogglesDescriptor>
+  fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
+    auto result = std::make_unique<rnwgpu::GPUDawnTogglesDescriptor>();
+    if (!outOfBounds && arg.isObject()) {
+      auto value = arg.getObject(runtime);
+      if (value.hasProperty(runtime, "enabledToggles")) {
+        auto prop = value.getProperty(runtime, "enabledToggles");
+        result->enabledToggles =
+            JSIConverter<std::optional<std::vector<std::string>>>::fromJSI(
+                runtime, prop, false);
+      }
+      if (value.hasProperty(runtime, "disabledToggles")) {
+        auto prop = value.getProperty(runtime, "disabledToggles");
+        result->disabledToggles =
+            JSIConverter<std::optional<std::vector<std::string>>>::fromJSI(
+                runtime, prop, false);
+      }
+    }
+    return result;
+  }
+  static jsi::Value
+  toJSI(jsi::Runtime &runtime,
+        std::shared_ptr<rnwgpu::GPUDawnTogglesDescriptor> arg) {
+    throw std::runtime_error("Invalid GPUDawnTogglesDescriptor::toJSI()");
+  }
+};
+
+} // namespace rnwgpu

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

@@ -8,8 +8,10 @@
 #include "webgpu/webgpu_cpp.h"
 
 #include "JSIConverter.h"
+#include "RnFeatures.h"
 #include "WGPULogger.h"
 
+#include "GPUDawnTogglesDescriptor.h"
 #include "GPUQueueDescriptor.h"
 
 namespace jsi = facebook::jsi;
@@ -24,6 +26,9 @@ struct GPUDeviceDescriptor {
   std::optional<std::shared_ptr<GPUQueueDescriptor>>
       defaultQueue;                 // GPUQueueDescriptor
   std::optional<std::string> label; // string
+  // Non-standard Dawn-only device toggles, chained onto the wgpu::Device
+  // descriptor in GPUAdapter::requestDevice.
+  std::optional<std::shared_ptr<GPUDawnTogglesDescriptor>> dawnToggles;
 };
 
 } // namespace rnwgpu
@@ -43,10 +48,20 @@ template <> struct JSIConverter<std::vector<wgpu::FeatureName>> {
     vector.reserve(length);
     for (size_t i = 0; i < length; ++i) {
       jsi::Value elementValue = array.getValueAtIndex(runtime, i);
-      if (elementValue.isString()) {
-        vector.emplace_back(JSIConverter<wgpu::FeatureName>::fromJSI(
-            runtime, elementValue, outOfBounds));
+      if (!elementValue.isString()) {
+        continue;
       }
+      auto str = elementValue.asString(runtime).utf8(runtime);
+      // Expand react-native-wgpu's umbrella feature into the platform's
+      // backing Dawn features before they reach RequestDevice.
+      if (str == kRnNativeTextureFeature) {
+        for (auto f : rnNativeTextureBackingFeatures()) {
+          vector.emplace_back(f);
+        }
+        continue;
+      }
+      vector.emplace_back(JSIConverter<wgpu::FeatureName>::fromJSI(
+          runtime, elementValue, outOfBounds));
     }
     return vector;
   }
@@ -87,6 +102,12 @@ template <> struct JSIConverter<std::shared_ptr<rnwgpu::GPUDeviceDescriptor>> {
         result->label = JSIConverter<std::optional<std::string>>::fromJSI(
             runtime, prop, false);
       }
+      if (value.hasProperty(runtime, "dawnToggles")) {
+        auto prop = value.getProperty(runtime, "dawnToggles");
+        result->dawnToggles = JSIConverter<
+            std::optional<std::shared_ptr<GPUDawnTogglesDescriptor>>>::fromJSI(
+            runtime, prop, false);
+      }
     }
 
     return result;

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

@@ -3,35 +3,34 @@
 #include <memory>
 #include <optional>
 #include <string>
-#include <variant>
 
 #include "webgpu/webgpu_cpp.h"
 
-#include "Convertors.h"
-
 #include "JSIConverter.h"
-#include "WGPULogger.h"
+#include "VideoFrame.h"
 
 namespace jsi = facebook::jsi;
 
 namespace rnwgpu {
 
+// Mirror of GPUExternalTextureDescriptor from the WebGPU spec, but with our
+// VideoFrame as the (only) supported source. We don't expose colorSpace yet;
+// the C++ side picks dst-sRGB and identity gamut, which is the right default
+// for "render this video frame to a regular sRGB framebuffer".
+//
+// `rotation` / `mirrored` are a non-spec extension: camera frames (e.g. from
+// VisionCamera) arrive in the sensor's native orientation, which differs
+// between iOS (CVPixelBuffer) and Android (AHardwareBuffer). Dawn's
+// ExternalTextureDescriptor can bake a rotation + horizontal mirror into the
+// sampling transform, so the shader sees an upright frame without any extra
+// passes. `rotation` is in degrees and must be one of 0 / 90 / 180 / 270.
 struct GPUExternalTextureDescriptor {
-  // std::variant<std::shared_ptr<HTMLVideoElement>,
-  // std::shared_ptr<VideoFrame>>
-  //     source; // | HTMLVideoElement | VideoFrame
-  // std::optional<wgpu::DefinedColorSpace> colorSpace; // PredefinedColorSpace
-  std::optional<std::string> label; // string
+  std::shared_ptr<VideoFrame> source;
+  std::optional<std::string> label;
+  std::optional<double> rotation;
+  std::optional<bool> mirrored;
 };
 
-static bool conv(wgpu::ExternalTextureDescriptor &out,
-                 const std::shared_ptr<GPUExternalTextureDescriptor> &in) {
-  // TODO: implement
-  // return conv(out.source, in->source) && conv(out.colorSpace, in->colorSpace)
-  // &&
-  // return conv(out.label, in->label);
-  return false;
-}
 } // namespace rnwgpu
 
 namespace rnwgpu {
@@ -40,23 +39,15 @@ template <>
 struct JSIConverter<std::shared_ptr<rnwgpu::GPUExternalTextureDescriptor>> {
   static std::shared_ptr<rnwgpu::GPUExternalTextureDescriptor>
   fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
-    auto result = std::make_unique<rnwgpu::GPUExternalTextureDescriptor>();
+    auto result = std::make_shared<rnwgpu::GPUExternalTextureDescriptor>();
     if (!outOfBounds && arg.isObject()) {
       auto value = arg.getObject(runtime);
       if (value.hasProperty(runtime, "source")) {
         auto prop = value.getProperty(runtime, "source");
-        // result->source = JSIConverter<
-        //     std::variant<std::shared_ptr<HTMLVideoElement>,
-        //                  std::shared_ptr<VideoFrame>>>::fromJSI(runtime,
-        //                  prop,
-        //                                                         false);
-      }
-      if (value.hasProperty(runtime, "colorSpace")) {
-        auto prop = value.getProperty(runtime, "colorSpace");
-        if (!prop.isUndefined()) {
-          // result->colorSpace =
-          //     JSIConverter<std::optional<wgpu::definedColorSpace>>::fromJSI(
-          //         runtime, prop, false);
+        if (!prop.isUndefined() && !prop.isNull()) {
+          result->source =
+              JSIConverter<std::shared_ptr<rnwgpu::VideoFrame>>::fromJSI(
+                  runtime, prop, false);
         }
       }
       if (value.hasProperty(runtime, "label")) {
@@ -66,13 +57,24 @@ struct JSIConverter<std::shared_ptr<rnwgpu::GPUExternalTextureDescriptor>> {
               runtime, prop, false);
         }
       }
+      if (value.hasProperty(runtime, "rotation")) {
+        auto prop = value.getProperty(runtime, "rotation");
+        if (prop.isNumber()) {
+          result->rotation = prop.asNumber();
+        }
+      }
+      if (value.hasProperty(runtime, "mirrored")) {
+        auto prop = value.getProperty(runtime, "mirrored");
+        if (prop.isBool()) {
+          result->mirrored = prop.getBool();
+        }
+      }
     }
-
     return result;
   }
   static jsi::Value
-  toJSI(jsi::Runtime &runtime,
-        std::shared_ptr<rnwgpu::GPUExternalTextureDescriptor> arg) {
+  toJSI(jsi::Runtime & /*runtime*/,
+        std::shared_ptr<rnwgpu::GPUExternalTextureDescriptor> /*arg*/) {
     throw std::runtime_error("Invalid GPUExternalTextureDescriptor::toJSI()");
   }
 };

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

@@ -0,0 +1,62 @@
+#pragma once
+
+#include <memory>
+#include <optional>
+#include <string>
+
+#include "webgpu/webgpu_cpp.h"
+
+#include "JSIConverter.h"
+
+namespace jsi = facebook::jsi;
+
+namespace rnwgpu {
+
+// Descriptor for GPUDevice.importSharedTextureMemory.
+//
+// `handle` is the raw native handle as a uintptr_t (passed as BigInt from JS):
+//   - Apple platforms: IOSurfaceRef
+//   - Android: AHardwareBuffer*
+//
+// Lifetime: the caller is responsible for keeping the underlying object alive
+// for as long as this shared memory is in use. The VideoFrame helper handles
+// this automatically when the handle came from PlatformContext.loadVideoFrame.
+struct GPUSharedTextureMemoryDescriptor {
+  void *handle = nullptr;
+  std::optional<std::string> label;
+};
+
+} // namespace rnwgpu
+
+namespace rnwgpu {
+
+template <>
+struct JSIConverter<std::shared_ptr<rnwgpu::GPUSharedTextureMemoryDescriptor>> {
+  static std::shared_ptr<rnwgpu::GPUSharedTextureMemoryDescriptor>
+  fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
+    auto result =
+        std::make_shared<rnwgpu::GPUSharedTextureMemoryDescriptor>();
+    if (!outOfBounds && arg.isObject()) {
+      auto value = arg.getObject(runtime);
+      if (value.hasProperty(runtime, "handle")) {
+        auto prop = value.getProperty(runtime, "handle");
+        result->handle =
+            JSIConverter<void *>::fromJSI(runtime, prop, false);
+      }
+      if (value.hasProperty(runtime, "label")) {
+        auto prop = value.getProperty(runtime, "label");
+        result->label = JSIConverter<std::optional<std::string>>::fromJSI(
+            runtime, prop, false);
+      }
+    }
+    return result;
+  }
+  static jsi::Value
+  toJSI(jsi::Runtime & /*runtime*/,
+        std::shared_ptr<rnwgpu::GPUSharedTextureMemoryDescriptor> /*arg*/) {
+    throw std::runtime_error(
+        "Invalid GPUSharedTextureMemoryDescriptor::toJSI()");
+  }
+};
+
+} // namespace rnwgpu

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

@@ -513,6 +513,8 @@ inline void convertJSUnionToEnum(const std::string &inUnion,
     *outEnum = wgpu::FeatureName::SharedTextureMemoryEGLImage;
   } else if (inUnion == "shared-fence-vk-semaphore-opaque-fd") {
     *outEnum = wgpu::FeatureName::SharedFenceVkSemaphoreOpaqueFD;
+  } else if (inUnion == "shared-fence-sync-fd") {
+    *outEnum = wgpu::FeatureName::SharedFenceSyncFD;
   } else if (inUnion == "shared-fence-vk-semaphore-zircon-handle") {
     *outEnum = wgpu::FeatureName::SharedFenceVkSemaphoreZirconHandle;
   } else if (inUnion == "shared-fence-dxgi-shared-handle") {
@@ -525,6 +527,8 @@ inline void convertJSUnionToEnum(const std::string &inUnion,
     *outEnum = wgpu::FeatureName::StaticSamplers;
   } else if (inUnion == "ycbcr-vulkan-samplers") {
     *outEnum = wgpu::FeatureName::YCbCrVulkanSamplers;
+  } else if (inUnion == "opaque-ycbcr-android-for-external-texture") {
+    *outEnum = wgpu::FeatureName::OpaqueYCbCrAndroidForExternalTexture;
   } else if (inUnion == "shader-module-compilation-options") {
     *outEnum = wgpu::FeatureName::ShaderModuleCompilationOptions;
   } else if (inUnion == "dawn-load-resolve-texture") {
@@ -695,6 +699,9 @@ inline void convertEnumToJSUnion(wgpu::FeatureName inEnum,
   case wgpu::FeatureName::SharedFenceVkSemaphoreOpaqueFD:
     *outUnion = "shared-fence-vk-semaphore-opaque-fd";
     break;
+  case wgpu::FeatureName::SharedFenceSyncFD:
+    *outUnion = "shared-fence-sync-fd";
+    break;
   case wgpu::FeatureName::SharedFenceVkSemaphoreZirconHandle:
     *outUnion = "shared-fence-vk-semaphore-zircon-handle";
     break;
@@ -713,6 +720,9 @@ inline void convertEnumToJSUnion(wgpu::FeatureName inEnum,
   case wgpu::FeatureName::YCbCrVulkanSamplers:
     *outUnion = "ycbcr-vulkan-samplers";
     break;
+  case wgpu::FeatureName::OpaqueYCbCrAndroidForExternalTexture:
+    *outUnion = "opaque-ycbcr-android-for-external-texture";
+    break;
   case wgpu::FeatureName::ShaderModuleCompilationOptions:
     *outUnion = "shader-module-compilation-options";
     break;

package/cpp/webgpu/webgpu.h

@@ -150,7 +150,7 @@ typedef struct WGPUTextureViewImpl* WGPUTextureView WGPU_OBJECT_ATTRIBUTE;
 
 // Structure forward declarations
 struct WGPUAdapterPropertiesD3D;
-struct WGPUAdapterPropertiesExplicitComputeSubgroupSizeConfigs;
+struct WGPUAdapterPropertiesDrm;
 struct WGPUAdapterPropertiesVk;
 struct WGPUAdapterPropertiesWGPU;
 struct WGPUBindingResource;
@@ -158,6 +158,7 @@ struct WGPUBlendComponent;
 struct WGPUBufferBindingLayout;
 struct WGPUBufferHostMappedPointer;
 struct WGPUColor;
+struct WGPUColorSpaceDawn;
 struct WGPUColorTargetStateExpandResolveTextureDawn;
 struct WGPUCommandBufferDescriptor;
 struct WGPUCompatibilityModeLimits;
@@ -430,6 +431,40 @@ typedef enum WGPUCallbackMode {
     WGPUCallbackMode_Force32 = 0x7FFFFFFF
 } WGPUCallbackMode WGPU_ENUM_ATTRIBUTE;
 
+typedef enum WGPUColorSpacePrimariesDawn {
+    WGPUColorSpacePrimariesDawn_SRGB = 0x00000001,
+    WGPUColorSpacePrimariesDawn_Rec709 = 0x00000001,
+    WGPUColorSpacePrimariesDawn_Rec601 = 0x00000002,
+    WGPUColorSpacePrimariesDawn_Rec2020 = 0x00000003,
+    WGPUColorSpacePrimariesDawn_DisplayP3 = 0x00000004,
+    WGPUColorSpacePrimariesDawn_Force32 = 0x7FFFFFFF
+} WGPUColorSpacePrimariesDawn WGPU_ENUM_ATTRIBUTE;
+
+typedef enum WGPUColorSpaceTransferDawn {
+    WGPUColorSpaceTransferDawn_Identity = 0x00000001,
+    WGPUColorSpaceTransferDawn_SRGB = 0x00000002,
+    WGPUColorSpaceTransferDawn_DisplayP3 = 0x00000003,
+    WGPUColorSpaceTransferDawn_SMPTE_170M = 0x00000004,
+    WGPUColorSpaceTransferDawn_HLG = 0x00000005,
+    WGPUColorSpaceTransferDawn_PQ = 0x00000006,
+    WGPUColorSpaceTransferDawn_Force32 = 0x7FFFFFFF
+} WGPUColorSpaceTransferDawn WGPU_ENUM_ATTRIBUTE;
+
+typedef enum WGPUColorSpaceYCbCrMatrixDawn {
+    WGPUColorSpaceYCbCrMatrixDawn_Identity = 0x00000001,
+    WGPUColorSpaceYCbCrMatrixDawn_Rec601 = 0x00000002,
+    WGPUColorSpaceYCbCrMatrixDawn_Rec709 = 0x00000003,
+    WGPUColorSpaceYCbCrMatrixDawn_Rec2020 = 0x00000004,
+    WGPUColorSpaceYCbCrMatrixDawn_Force32 = 0x7FFFFFFF
+} WGPUColorSpaceYCbCrMatrixDawn WGPU_ENUM_ATTRIBUTE;
+
+typedef enum WGPUColorSpaceYCbCrRangeDawn {
+    WGPUColorSpaceYCbCrRangeDawn_Identity = 0x00000001,
+    WGPUColorSpaceYCbCrRangeDawn_Narrow = 0x00000002,
+    WGPUColorSpaceYCbCrRangeDawn_Full = 0x00000003,
+    WGPUColorSpaceYCbCrRangeDawn_Force32 = 0x7FFFFFFF
+} WGPUColorSpaceYCbCrRangeDawn WGPU_ENUM_ATTRIBUTE;
+
 typedef enum WGPUCompareFunction {
     WGPUCompareFunction_Undefined = 0x00000000,
     WGPUCompareFunction_Never = 0x00000001,
@@ -612,12 +647,13 @@ typedef enum WGPUFeatureName {
     WGPUFeatureName_SharedBufferMemoryD3D12SharedMemoryFileMappingHandle = 0x00050038,
     WGPUFeatureName_SharedTextureMemoryD3D12Resource = 0x00050039,
     WGPUFeatureName_ChromiumExperimentalSamplingResourceTable = 0x0005003A,
-    WGPUFeatureName_ChromiumExperimentalSubgroupSizeControl = 0x0005003B,
+    WGPUFeatureName_SubgroupSizeControl = 0x0005003B,
     WGPUFeatureName_AtomicVec2uMinMax = 0x0005003C,
     WGPUFeatureName_Unorm16FormatsForExternalTexture = 0x0005003D,
     WGPUFeatureName_OpaqueYCbCrAndroidForExternalTexture = 0x0005003E,
     WGPUFeatureName_Unorm16Filterable = 0x0005003F,
     WGPUFeatureName_RenderPassRenderArea = 0x00050040,
+    WGPUFeatureName_AdapterPropertiesDrm = 0x00050041,
     WGPUFeatureName_Force32 = 0x7FFFFFFF
 } WGPUFeatureName WGPU_ENUM_ATTRIBUTE;
 
@@ -704,6 +740,8 @@ typedef enum WGPUPowerPreference {
 typedef enum WGPUPredefinedColorSpace {
     WGPUPredefinedColorSpace_SRGB = 0x00000001,
     WGPUPredefinedColorSpace_DisplayP3 = 0x00000002,
+    WGPUPredefinedColorSpace_SRGBLinear = 0x00050003,
+    WGPUPredefinedColorSpace_DisplayP3Linear = 0x00050004,
     WGPUPredefinedColorSpace_Force32 = 0x7FFFFFFF
 } WGPUPredefinedColorSpace WGPU_ENUM_ATTRIBUTE;
 
@@ -904,7 +942,7 @@ typedef enum WGPUSType {
     WGPUSType_SharedTextureMemoryD3D12ResourceDescriptor = 0x0005004E,
     WGPUSType_RequestAdapterOptionsAngleVirtualizationGroup = 0x0005004F,
     WGPUSType_PipelineLayoutResourceTable = 0x00050050,
-    WGPUSType_AdapterPropertiesExplicitComputeSubgroupSizeConfigs = 0x00050051,
+    WGPUSType_AdapterPropertiesDrm = 0x00050051,
     WGPUSType_Force32 = 0x7FFFFFFF
 } WGPUSType WGPU_ENUM_ATTRIBUTE;
 
@@ -1165,6 +1203,7 @@ typedef enum WGPUWGSLLanguageFeatureName {
     WGPUWGSLLanguageFeatureName_TextureAndSamplerLet = 0x00000007,
     WGPUWGSLLanguageFeatureName_SubgroupUniformity = 0x00000008,
     WGPUWGSLLanguageFeatureName_TextureFormatsTier1 = 0x00000009,
+    WGPUWGSLLanguageFeatureName_LinearIndexing = 0x0000000A,
     WGPUWGSLLanguageFeatureName_ChromiumTestingUnimplemented = 0x00050000,
     WGPUWGSLLanguageFeatureName_ChromiumTestingUnsafeExperimental = 0x00050001,
     WGPUWGSLLanguageFeatureName_ChromiumTestingExperimental = 0x00050002,
@@ -1176,9 +1215,7 @@ typedef enum WGPUWGSLLanguageFeatureName {
     WGPUWGSLLanguageFeatureName_FragmentDepth = 0x00050008,
     WGPUWGSLLanguageFeatureName_ImmediateAddressSpace = 0x00050009,
     WGPUWGSLLanguageFeatureName_BufferView = 0x0005000B,
-    WGPUWGSLLanguageFeatureName_FilteringParameters = 0x0005000C,
-    WGPUWGSLLanguageFeatureName_SwizzleAssignment = 0x0005000D,
-    WGPUWGSLLanguageFeatureName_LinearIndexing = 0x0005000E,
+    WGPUWGSLLanguageFeatureName_SwizzleAssignment = 0x0005000C,
     WGPUWGSLLanguageFeatureName_Force32 = 0x7FFFFFFF
 } WGPUWGSLLanguageFeatureName WGPU_ENUM_ATTRIBUTE;
 
@@ -1453,21 +1490,27 @@ typedef struct WGPUAdapterPropertiesD3D {
 })
 
 // Can be chained in WGPUAdapterInfo
-typedef struct WGPUAdapterPropertiesExplicitComputeSubgroupSizeConfigs {
+typedef struct WGPUAdapterPropertiesDrm {
     WGPUChainedStruct chain;
-    uint32_t minExplicitComputeSubgroupSize;
-    uint32_t maxExplicitComputeSubgroupSize;
-    uint32_t maxComputeWorkgroupSubgroups;
-} WGPUAdapterPropertiesExplicitComputeSubgroupSizeConfigs WGPU_STRUCTURE_ATTRIBUTE;
-
-#define WGPU_ADAPTER_PROPERTIES_EXPLICIT_COMPUTE_SUBGROUP_SIZE_CONFIGS_INIT _wgpu_MAKE_INIT_STRUCT(WGPUAdapterPropertiesExplicitComputeSubgroupSizeConfigs, { \
+    WGPUBool hasPrimary;
+    WGPUBool hasRender;
+    uint64_t primaryMajor;
+    uint64_t primaryMinor;
+    uint64_t renderMajor;
+    uint64_t renderMinor;
+} WGPUAdapterPropertiesDrm WGPU_STRUCTURE_ATTRIBUTE;
+
+#define WGPU_ADAPTER_PROPERTIES_DRM_INIT _wgpu_MAKE_INIT_STRUCT(WGPUAdapterPropertiesDrm, { \
     /*.chain=*/_wgpu_MAKE_INIT_STRUCT(WGPUChainedStruct, { \
         /*.next=*/NULL _wgpu_COMMA \
-        /*.sType=*/WGPUSType_AdapterPropertiesExplicitComputeSubgroupSizeConfigs _wgpu_COMMA \
+        /*.sType=*/WGPUSType_AdapterPropertiesDrm _wgpu_COMMA \
     }) _wgpu_COMMA \
-    /*.minExplicitComputeSubgroupSize=*/0 _wgpu_COMMA \
-    /*.maxExplicitComputeSubgroupSize=*/0 _wgpu_COMMA \
-    /*.maxComputeWorkgroupSubgroups=*/0 _wgpu_COMMA \
+    /*.hasPrimary=*/WGPU_FALSE _wgpu_COMMA \
+    /*.hasRender=*/WGPU_FALSE _wgpu_COMMA \
+    /*.primaryMajor=*/0 _wgpu_COMMA \
+    /*.primaryMinor=*/0 _wgpu_COMMA \
+    /*.renderMajor=*/0 _wgpu_COMMA \
+    /*.renderMinor=*/0 _wgpu_COMMA \
 })
 
 // Can be chained in WGPUAdapterInfo
@@ -1574,6 +1617,22 @@ typedef struct WGPUColor {
     /*.a=*/0. _wgpu_COMMA \
 })
 
+typedef struct WGPUColorSpaceDawn {
+    WGPUChainedStruct * nextInChain;
+    WGPUColorSpacePrimariesDawn primaries;
+    WGPUColorSpaceTransferDawn transfer;
+    WGPUColorSpaceYCbCrRangeDawn yCbCrRange;
+    WGPUColorSpaceYCbCrMatrixDawn yCbCrMatrix;
+} WGPUColorSpaceDawn WGPU_STRUCTURE_ATTRIBUTE;
+
+#define WGPU_COLOR_SPACE_DAWN_INIT _wgpu_MAKE_INIT_STRUCT(WGPUColorSpaceDawn, { \
+    /*.nextInChain=*/NULL _wgpu_COMMA \
+    /*.primaries=*/_wgpu_ENUM_ZERO_INIT(WGPUColorSpacePrimariesDawn) _wgpu_COMMA \
+    /*.transfer=*/WGPUColorSpaceTransferDawn_Identity _wgpu_COMMA \
+    /*.yCbCrRange=*/WGPUColorSpaceYCbCrRangeDawn_Identity _wgpu_COMMA \
+    /*.yCbCrMatrix=*/WGPUColorSpaceYCbCrMatrixDawn_Identity _wgpu_COMMA \
+})
+
 // Can be chained in WGPUColorTargetState
 typedef struct WGPUColorTargetStateExpandResolveTextureDawn {
     WGPUChainedStruct chain;
@@ -4454,6 +4513,7 @@ typedef void (*WGPUProcResourceTableDestroy)(WGPUResourceTable resourceTable) WG
 typedef uint32_t (*WGPUProcResourceTableGetSize)(WGPUResourceTable resourceTable) WGPU_FUNCTION_ATTRIBUTE;
 typedef uint32_t (*WGPUProcResourceTableInsertBinding)(WGPUResourceTable resourceTable, WGPUBindingResource const * resource) WGPU_FUNCTION_ATTRIBUTE;
 typedef WGPUStatus (*WGPUProcResourceTableRemoveBinding)(WGPUResourceTable resourceTable, uint32_t slot) WGPU_FUNCTION_ATTRIBUTE;
+typedef void (*WGPUProcResourceTableSetLabel)(WGPUResourceTable resourceTable, WGPUStringView label) WGPU_FUNCTION_ATTRIBUTE;
 typedef WGPUStatus (*WGPUProcResourceTableUpdate)(WGPUResourceTable resourceTable, uint32_t slot, WGPUBindingResource const * resource) WGPU_FUNCTION_ATTRIBUTE;
 typedef void (*WGPUProcResourceTableAddRef)(WGPUResourceTable resourceTable) WGPU_FUNCTION_ATTRIBUTE;
 typedef void (*WGPUProcResourceTableRelease)(WGPUResourceTable resourceTable) WGPU_FUNCTION_ATTRIBUTE;
@@ -4810,6 +4870,7 @@ WGPU_EXPORT void wgpuResourceTableDestroy(WGPUResourceTable resourceTable) WGPU_
 WGPU_EXPORT uint32_t wgpuResourceTableGetSize(WGPUResourceTable resourceTable) WGPU_FUNCTION_ATTRIBUTE;
 WGPU_EXPORT uint32_t wgpuResourceTableInsertBinding(WGPUResourceTable resourceTable, WGPUBindingResource const * resource) WGPU_FUNCTION_ATTRIBUTE;
 WGPU_EXPORT WGPUStatus wgpuResourceTableRemoveBinding(WGPUResourceTable resourceTable, uint32_t slot) WGPU_FUNCTION_ATTRIBUTE;
+WGPU_EXPORT void wgpuResourceTableSetLabel(WGPUResourceTable resourceTable, WGPUStringView label) WGPU_FUNCTION_ATTRIBUTE;
 WGPU_EXPORT WGPUStatus wgpuResourceTableUpdate(WGPUResourceTable resourceTable, uint32_t slot, WGPUBindingResource const * resource) WGPU_FUNCTION_ATTRIBUTE;
 WGPU_EXPORT void wgpuResourceTableAddRef(WGPUResourceTable resourceTable) WGPU_FUNCTION_ATTRIBUTE;
 WGPU_EXPORT void wgpuResourceTableRelease(WGPUResourceTable resourceTable) WGPU_FUNCTION_ATTRIBUTE;