react-native-wgpu 0.1.0 → 0.1.3

package/android/src/main/java/com/webgpu/WebGPUView.java

@@ -1,24 +1,79 @@
 package com.webgpu;
 
-import androidx.annotation.Nullable;
+import androidx.annotation.NonNull;
 
 import android.content.Context;
-import android.util.AttributeSet;
+import android.view.Surface;
+import android.view.SurfaceHolder;
+import android.view.SurfaceView;
 
-import android.view.View;
+import com.facebook.proguard.annotations.DoNotStrip;
+import com.facebook.react.uimanager.ThemedReactContext;
 
-public class WebGPUView extends View {
+public class WebGPUView extends SurfaceView implements SurfaceHolder.Callback {
+
+  private Integer mContextId;
+  private WebGPUModule mModule;
 
   public WebGPUView(Context context) {
     super(context);
+    getHolder().addCallback(this);
+  }
+
+  public void setContextId(Integer contextId) {
+    if (mModule == null) {
+      Context context = getContext();
+      if (context instanceof ThemedReactContext) {
+        mModule = ((ThemedReactContext) context).getReactApplicationContext().getNativeModule(WebGPUModule.class);
+      }
+    }
+    mContextId = contextId;
+  }
+
+  @Override
+  protected void onLayout(boolean changed, int left, int top, int right, int bottom) {
+    super.onLayout(changed, left, top, right, bottom);
   }
 
-  public WebGPUView(Context context, @Nullable AttributeSet attrs) {
-    super(context, attrs);
+  @Override
+  public void surfaceCreated(@NonNull SurfaceHolder holder) {
+    float density = getResources().getDisplayMetrics().density;
+    float width = getWidth() / density;
+    float height = getHeight() / density;
+    onSurfaceCreate(holder.getSurface(), mContextId, width, height);
+    mModule.onSurfaceCreated(mContextId);
   }
 
-  public WebGPUView(Context context, @Nullable AttributeSet attrs, int defStyleAttr) {
-    super(context, attrs, defStyleAttr);
+  @Override
+  public void surfaceChanged(@NonNull SurfaceHolder holder, int format, int width, int height) {
+    float density = getResources().getDisplayMetrics().density;
+    float scaledWidth = width / density;
+    float scaledHeight = height / density;
+    onSurfaceChanged(holder.getSurface(), mContextId, scaledWidth, scaledHeight);
   }
 
+  @Override
+  public void surfaceDestroyed(@NonNull SurfaceHolder holder) {
+    onSurfaceDestroy(mContextId);
+  }
+
+  @DoNotStrip
+  private native void onSurfaceCreate(
+    Surface surface,
+    int contextId,
+    float width,
+    float height
+  );
+
+  @DoNotStrip
+  private native void onSurfaceChanged(
+    Surface surface,
+    int contextId,
+    float width,
+    float height
+  );
+
+
+  @DoNotStrip
+  private native void onSurfaceDestroy(int contextId);
 }

package/android/src/main/java/com/webgpu/WebGPUViewManager.java

@@ -1,8 +1,6 @@
 package com.webgpu;
 
-import android.graphics.Color;
-
-import androidx.annotation.Nullable;
+import androidx.annotation.NonNull;
 
 import com.facebook.react.module.annotations.ReactModule;
 import com.facebook.react.uimanager.ThemedReactContext;
@@ -13,6 +11,7 @@ public class WebGPUViewManager extends WebGPUViewManagerSpec<WebGPUView> {
 
   public static final String NAME = "WebGPUView";
 
+  @NonNull
   @Override
   public String getName() {
     return NAME;
@@ -24,8 +23,8 @@ public class WebGPUViewManager extends WebGPUViewManagerSpec<WebGPUView> {
   }
 
   @Override
-  @ReactProp(name = "color")
-  public void setColor(WebGPUView view, @Nullable String color) {
-    view.setBackgroundColor(Color.parseColor(color));
+  @ReactProp(name = "contextId")
+  public void setContextId(WebGPUView view, int value) {
+    view.setContextId(value);
   }
 }

package/android/src/newarch/{WgpuViewManagerSpec.java → com/webgpu/WebGPUViewManagerSpec.java}

@@ -6,14 +6,14 @@ import androidx.annotation.Nullable;
 
 import com.facebook.react.uimanager.SimpleViewManager;
 import com.facebook.react.uimanager.ViewManagerDelegate;
-import com.facebook.react.viewmanagers.WgpuViewManagerDelegate;
-import com.facebook.react.viewmanagers.WgpuViewManagerInterface;
+import com.facebook.react.viewmanagers.WebGPUViewManagerDelegate;
+import com.facebook.react.viewmanagers.WebGPUViewManagerInterface;
 
-public abstract class WgpuViewManagerSpec<T extends View> extends SimpleViewManager<T> implements WgpuViewManagerInterface<T> {
+public abstract class WebGPUViewManagerSpec<T extends View> extends SimpleViewManager<T> implements WebGPUViewManagerInterface<T> {
   private final ViewManagerDelegate<T> mDelegate;
 
-  public WgpuViewManagerSpec() {
-    mDelegate = new WgpuViewManagerDelegate(this);
+  public WebGPUViewManagerSpec() {
+    mDelegate = new WebGPUViewManagerDelegate(this);
   }
 
   @Nullable

package/android/src/oldarch/com/webgpu/NativeWebGPUModuleSpec.java

@@ -0,0 +1,23 @@
+package com.webgpu;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactContextBaseJavaModule;
+
+class NativeWebGPUModuleSpec extends ReactContextBaseJavaModule {
+
+  public static final String NAME = "WebGPUModule";
+
+  public NativeWebGPUModuleSpec(@Nullable ReactApplicationContext reactContext) {
+    super(reactContext);
+  }
+
+  @NonNull
+  @Override
+  public String getName() {
+    return NAME;
+  }
+
+}

package/android/src/oldarch/{WebGPUViewManagerSpec.java → com/webgpu/WebGPUViewManagerSpec.java}

@@ -7,5 +7,5 @@ import androidx.annotation.Nullable;
 import com.facebook.react.uimanager.SimpleViewManager;
 
 public abstract class WebGPUViewManagerSpec<T extends View> extends SimpleViewManager<T> {
-  public abstract void setColor(T view, @Nullable String value);
+  public abstract void setContextId(T view, int contextId);
 }

package/cpp/{Logger.h → WGPULogger.h}

@@ -11,7 +11,7 @@
 #include <android/log.h>
 #endif
 
-#ifdef TARGET_OS_IPHONE
+#ifdef __APPLE__
 #include <syslog.h>
 #endif
 
@@ -27,10 +27,10 @@ public:
    */
   static void logToConsole(std::string message) {
 #if defined(ANDROID) || defined(__ANDROID__)
-    __android_log_write(ANDROID_LOG_INFO, "RNSkia", message.c_str());
+    __android_log_write(ANDROID_LOG_INFO, "WebGPU", message.c_str());
 #endif
 
-#ifdef TARGET_OS_IPHONE
+#ifdef __APPLE__
     syslog(LOG_ERR, "%s\n", message.c_str());
 #endif
   }
@@ -47,10 +47,10 @@ public:
     static char buffer[512];
     vsnprintf(buffer, sizeof(buffer), fmt, args);
 #if defined(ANDROID) || defined(__ANDROID__)
-    __android_log_write(ANDROID_LOG_INFO, "RNSkia", buffer);
+    __android_log_write(ANDROID_LOG_INFO, "WebGPU", buffer);
 #endif
-#ifdef TARGET_OS_IPHONE
-    syslog(LOG_ERR, "RNSKIA: %s\n", buffer);
+#ifdef __APPLE__
+    syslog(LOG_ERR, "WebGPU: %s\n", buffer);
 #endif
     va_end(args);
   }
@@ -69,6 +69,13 @@ public:
     warn.call(runtime, jsi::String::createFromUtf8(runtime, message));
   }
 
+  static void errorToJavascriptConsole(jsi::Runtime &runtime,
+                                      const std::string &message) {
+    auto console = Logger::getJavascriptConsole(runtime).asObject(runtime);
+    auto warn = console.getPropertyAsFunction(runtime, "error");
+    warn.call(runtime, jsi::String::createFromUtf8(runtime, message));
+  }
+
 private:
   static jsi::Value getJavascriptConsole(jsi::Runtime &runtime) {
     auto console = runtime.global().getProperty(runtime, "console");

package/cpp/dawn/webgpu.h

@@ -124,6 +124,7 @@ typedef struct WGPUTextureImpl* WGPUTexture WGPU_OBJECT_ATTRIBUTE;
 typedef struct WGPUTextureViewImpl* WGPUTextureView WGPU_OBJECT_ATTRIBUTE;
 
 // Structure forward declarations
+struct WGPUINTERNAL__HAVE_EMDAWNWEBGPU_HEADER;
 struct WGPUAdapterInfo;
 struct WGPUAdapterProperties;
 struct WGPUAdapterPropertiesD3D;
@@ -482,6 +483,8 @@ typedef enum WGPUFeatureName {
     WGPUFeatureName_RG11B10UfloatRenderable = 0x00000009,
     WGPUFeatureName_BGRA8UnormStorage = 0x0000000A,
     WGPUFeatureName_Float32Filterable = 0x0000000B,
+    WGPUFeatureName_Subgroups = 0x0000000C,
+    WGPUFeatureName_SubgroupsF16 = 0x0000000D,
     WGPUFeatureName_DawnInternalUsages = 0x00050000,
     WGPUFeatureName_DawnMultiPlanarFormats = 0x00050001,
     WGPUFeatureName_DawnNative = 0x00050002,
@@ -1223,6 +1226,12 @@ typedef struct WGPUUncapturedErrorCallbackInfo2 {
     /*.userdata2=*/nullptr WGPU_COMMA \
 })
 
+typedef struct WGPUINTERNAL__HAVE_EMDAWNWEBGPU_HEADER {
+} WGPUINTERNAL__HAVE_EMDAWNWEBGPU_HEADER WGPU_STRUCTURE_ATTRIBUTE;
+
+#define WGPU_INTERNAL__HAVE_EMDAWNWEBGPU_HEADER_INIT WGPU_MAKE_INIT_STRUCT(WGPUINTERNAL__HAVE_EMDAWNWEBGPU_HEADER, { \
+})
+
 typedef struct WGPUAdapterInfo {
     WGPUChainedStructOut * nextInChain;
     char const * vendor;

package/cpp/dawn/webgpu_cpp.h

@@ -25,7 +25,7 @@
 // OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifdef __EMSCRIPTEN__
-#error "Do not include this header. Emscripten already provides headers needed for WebGPU."
+#error "This header is for native Dawn. Use Dawn's or Emscripten's Emscripten bindings instead."
 #endif
 #ifndef WEBGPU_CPP_H_
 #define WEBGPU_CPP_H_
@@ -303,6 +303,8 @@ enum class FeatureName : uint32_t {
     RG11B10UfloatRenderable = WGPUFeatureName_RG11B10UfloatRenderable,
     BGRA8UnormStorage = WGPUFeatureName_BGRA8UnormStorage,
     Float32Filterable = WGPUFeatureName_Float32Filterable,
+    Subgroups = WGPUFeatureName_Subgroups,
+    SubgroupsF16 = WGPUFeatureName_SubgroupsF16,
     DawnInternalUsages = WGPUFeatureName_DawnInternalUsages,
     DawnMultiPlanarFormats = WGPUFeatureName_DawnMultiPlanarFormats,
     DawnNative = WGPUFeatureName_DawnNative,
@@ -1080,6 +1082,7 @@ class SwapChain;
 class Texture;
 class TextureView;
 
+struct INTERNAL__HAVE_EMDAWNWEBGPU_HEADER;
 struct AdapterInfo;
 struct AdapterProperties;
 struct AdapterPropertiesD3D;
@@ -1867,6 +1870,11 @@ static_assert(offsetof(ChainedStruct, sType) == offsetof(WGPUChainedStruct, sTyp
     "offsetof mismatch for ChainedStruct::sType");
 
 
+struct INTERNAL__HAVE_EMDAWNWEBGPU_HEADER {
+    inline operator const WGPUINTERNAL__HAVE_EMDAWNWEBGPU_HEADER&() const noexcept;
+
+};
+
 struct AdapterInfo {
     inline AdapterInfo();
     inline ~AdapterInfo();
@@ -1888,6 +1896,7 @@ struct AdapterInfo {
     Bool const compatibilityMode = false;
 
   private:
+    inline void FreeMembers();
     static inline void Reset(AdapterInfo& value);
 };
 
@@ -1912,6 +1921,7 @@ struct AdapterProperties {
     Bool const compatibilityMode = false;
 
   private:
+    inline void FreeMembers();
     static inline void Reset(AdapterProperties& value);
 };
 
@@ -2678,6 +2688,7 @@ struct SharedBufferMemoryEndAccessState {
     uint64_t const * const signaledValues = {};
 
   private:
+    inline void FreeMembers();
     static inline void Reset(SharedBufferMemoryEndAccessState& value);
 };
 
@@ -2927,6 +2938,7 @@ struct SharedTextureMemoryEndAccessState {
     uint64_t const * const signaledValues = {};
 
   private:
+    inline void FreeMembers();
     static inline void Reset(SharedTextureMemoryEndAccessState& value);
 };
 
@@ -3046,6 +3058,7 @@ struct SurfaceCapabilities {
     CompositeAlphaMode const * const alphaModes = {};
 
   private:
+    inline void FreeMembers();
     static inline void Reset(SurfaceCapabilities& value);
 };
 
@@ -3312,6 +3325,7 @@ struct AdapterPropertiesMemoryHeaps : ChainedStructOut {
     MemoryHeapInfo const * const heapInfo = {};
 
   private:
+    inline void FreeMembers();
     static inline void Reset(AdapterPropertiesMemoryHeaps& value);
 };
 
@@ -3394,6 +3408,7 @@ struct DrmFormatCapabilities : ChainedStructOut {
     DrmFormatProperties const * const properties = {};
 
   private:
+    inline void FreeMembers();
     static inline void Reset(DrmFormatCapabilities& value);
 };
 
@@ -3726,13 +3741,19 @@ struct DeviceDescriptor : protected detail::DeviceDescriptor {
 #pragma GCC diagnostic ignored "-Winvalid-offsetof"
 #endif
 
+// INTERNAL__HAVE_EMDAWNWEBGPU_HEADER implementation
+
+INTERNAL__HAVE_EMDAWNWEBGPU_HEADER::operator const WGPUINTERNAL__HAVE_EMDAWNWEBGPU_HEADER&() const noexcept {
+    return *reinterpret_cast<const WGPUINTERNAL__HAVE_EMDAWNWEBGPU_HEADER*>(this);
+}
+
+static_assert(sizeof(INTERNAL__HAVE_EMDAWNWEBGPU_HEADER) == sizeof(WGPUINTERNAL__HAVE_EMDAWNWEBGPU_HEADER), "sizeof mismatch for INTERNAL__HAVE_EMDAWNWEBGPU_HEADER");
+static_assert(alignof(INTERNAL__HAVE_EMDAWNWEBGPU_HEADER) == alignof(WGPUINTERNAL__HAVE_EMDAWNWEBGPU_HEADER), "alignof mismatch for INTERNAL__HAVE_EMDAWNWEBGPU_HEADER");
+
 // AdapterInfo implementation
 AdapterInfo::AdapterInfo() = default;
 AdapterInfo::~AdapterInfo() {
-    if (this->vendor != nullptr || this->architecture != nullptr || this->device != nullptr || this->description != nullptr) {
-        wgpuAdapterInfoFreeMembers(
-            *reinterpret_cast<WGPUAdapterInfo*>(this));
-    }
+    FreeMembers();
 }
 
 AdapterInfo::AdapterInfo(AdapterInfo&& rhs)
@@ -3752,7 +3773,7 @@ AdapterInfo& AdapterInfo::operator=(AdapterInfo&& rhs) {
     if (&rhs == this) {
         return *this;
     }
-    this->~AdapterInfo();
+    FreeMembers();
     ::wgpu::detail::AsNonConstReference(this->vendor) = std::move(rhs.vendor);
     ::wgpu::detail::AsNonConstReference(this->architecture) = std::move(rhs.architecture);
     ::wgpu::detail::AsNonConstReference(this->device) = std::move(rhs.device);
@@ -3766,7 +3787,14 @@ AdapterInfo& AdapterInfo::operator=(AdapterInfo&& rhs) {
     return *this;
 }
 
-    // static
+void AdapterInfo::FreeMembers() {
+    if (this->vendor != nullptr || this->architecture != nullptr || this->device != nullptr || this->description != nullptr) {
+        wgpuAdapterInfoFreeMembers(
+            *reinterpret_cast<WGPUAdapterInfo*>(this));
+    }
+}
+
+// static
 void AdapterInfo::Reset(AdapterInfo& value) {
     AdapterInfo defaultValue{};
     ::wgpu::detail::AsNonConstReference(value.vendor) = defaultValue.vendor;
@@ -3810,10 +3838,7 @@ static_assert(offsetof(AdapterInfo, compatibilityMode) == offsetof(WGPUAdapterIn
 // AdapterProperties implementation
 AdapterProperties::AdapterProperties() = default;
 AdapterProperties::~AdapterProperties() {
-    if (this->vendorName != nullptr || this->architecture != nullptr || this->name != nullptr || this->driverDescription != nullptr) {
-        wgpuAdapterPropertiesFreeMembers(
-            *reinterpret_cast<WGPUAdapterProperties*>(this));
-    }
+    FreeMembers();
 }
 
 AdapterProperties::AdapterProperties(AdapterProperties&& rhs)
@@ -3833,7 +3858,7 @@ AdapterProperties& AdapterProperties::operator=(AdapterProperties&& rhs) {
     if (&rhs == this) {
         return *this;
     }
-    this->~AdapterProperties();
+    FreeMembers();
     ::wgpu::detail::AsNonConstReference(this->vendorID) = std::move(rhs.vendorID);
     ::wgpu::detail::AsNonConstReference(this->vendorName) = std::move(rhs.vendorName);
     ::wgpu::detail::AsNonConstReference(this->architecture) = std::move(rhs.architecture);
@@ -3847,7 +3872,14 @@ AdapterProperties& AdapterProperties::operator=(AdapterProperties&& rhs) {
     return *this;
 }
 
-    // static
+void AdapterProperties::FreeMembers() {
+    if (this->vendorName != nullptr || this->architecture != nullptr || this->name != nullptr || this->driverDescription != nullptr) {
+        wgpuAdapterPropertiesFreeMembers(
+            *reinterpret_cast<WGPUAdapterProperties*>(this));
+    }
+}
+
+// static
 void AdapterProperties::Reset(AdapterProperties& value) {
     AdapterProperties defaultValue{};
     ::wgpu::detail::AsNonConstReference(value.vendorID) = defaultValue.vendorID;
@@ -5259,10 +5291,7 @@ static_assert(offsetof(SharedBufferMemoryDescriptor, label) == offsetof(WGPUShar
 // SharedBufferMemoryEndAccessState implementation
 SharedBufferMemoryEndAccessState::SharedBufferMemoryEndAccessState() = default;
 SharedBufferMemoryEndAccessState::~SharedBufferMemoryEndAccessState() {
-    if (this->fences != nullptr || this->signaledValues != nullptr) {
-        wgpuSharedBufferMemoryEndAccessStateFreeMembers(
-            *reinterpret_cast<WGPUSharedBufferMemoryEndAccessState*>(this));
-    }
+    FreeMembers();
 }
 
 SharedBufferMemoryEndAccessState::SharedBufferMemoryEndAccessState(SharedBufferMemoryEndAccessState&& rhs)
@@ -5277,7 +5306,7 @@ SharedBufferMemoryEndAccessState& SharedBufferMemoryEndAccessState::operator=(Sh
     if (&rhs == this) {
         return *this;
     }
-    this->~SharedBufferMemoryEndAccessState();
+    FreeMembers();
     ::wgpu::detail::AsNonConstReference(this->initialized) = std::move(rhs.initialized);
     ::wgpu::detail::AsNonConstReference(this->fenceCount) = std::move(rhs.fenceCount);
     ::wgpu::detail::AsNonConstReference(this->fences) = std::move(rhs.fences);
@@ -5286,7 +5315,14 @@ SharedBufferMemoryEndAccessState& SharedBufferMemoryEndAccessState::operator=(Sh
     return *this;
 }
 
-    // static
+void SharedBufferMemoryEndAccessState::FreeMembers() {
+    if (this->fences != nullptr || this->signaledValues != nullptr) {
+        wgpuSharedBufferMemoryEndAccessStateFreeMembers(
+            *reinterpret_cast<WGPUSharedBufferMemoryEndAccessState*>(this));
+    }
+}
+
+// static
 void SharedBufferMemoryEndAccessState::Reset(SharedBufferMemoryEndAccessState& value) {
     SharedBufferMemoryEndAccessState defaultValue{};
     ::wgpu::detail::AsNonConstReference(value.initialized) = defaultValue.initialized;
@@ -5713,10 +5749,7 @@ static_assert(offsetof(SharedTextureMemoryDmaBufPlane, stride) == offsetof(WGPUS
 // SharedTextureMemoryEndAccessState implementation
 SharedTextureMemoryEndAccessState::SharedTextureMemoryEndAccessState() = default;
 SharedTextureMemoryEndAccessState::~SharedTextureMemoryEndAccessState() {
-    if (this->fences != nullptr || this->signaledValues != nullptr) {
-        wgpuSharedTextureMemoryEndAccessStateFreeMembers(
-            *reinterpret_cast<WGPUSharedTextureMemoryEndAccessState*>(this));
-    }
+    FreeMembers();
 }
 
 SharedTextureMemoryEndAccessState::SharedTextureMemoryEndAccessState(SharedTextureMemoryEndAccessState&& rhs)
@@ -5731,7 +5764,7 @@ SharedTextureMemoryEndAccessState& SharedTextureMemoryEndAccessState::operator=(
     if (&rhs == this) {
         return *this;
     }
-    this->~SharedTextureMemoryEndAccessState();
+    FreeMembers();
     ::wgpu::detail::AsNonConstReference(this->initialized) = std::move(rhs.initialized);
     ::wgpu::detail::AsNonConstReference(this->fenceCount) = std::move(rhs.fenceCount);
     ::wgpu::detail::AsNonConstReference(this->fences) = std::move(rhs.fences);
@@ -5740,7 +5773,14 @@ SharedTextureMemoryEndAccessState& SharedTextureMemoryEndAccessState::operator=(
     return *this;
 }
 
-    // static
+void SharedTextureMemoryEndAccessState::FreeMembers() {
+    if (this->fences != nullptr || this->signaledValues != nullptr) {
+        wgpuSharedTextureMemoryEndAccessStateFreeMembers(
+            *reinterpret_cast<WGPUSharedTextureMemoryEndAccessState*>(this));
+    }
+}
+
+// static
 void SharedTextureMemoryEndAccessState::Reset(SharedTextureMemoryEndAccessState& value) {
     SharedTextureMemoryEndAccessState defaultValue{};
     ::wgpu::detail::AsNonConstReference(value.initialized) = defaultValue.initialized;
@@ -5951,10 +5991,7 @@ static_assert(offsetof(StorageTextureBindingLayout, viewDimension) == offsetof(W
 // SurfaceCapabilities implementation
 SurfaceCapabilities::SurfaceCapabilities() = default;
 SurfaceCapabilities::~SurfaceCapabilities() {
-    if (this->formats != nullptr || this->presentModes != nullptr || this->alphaModes != nullptr) {
-        wgpuSurfaceCapabilitiesFreeMembers(
-            *reinterpret_cast<WGPUSurfaceCapabilities*>(this));
-    }
+    FreeMembers();
 }
 
 SurfaceCapabilities::SurfaceCapabilities(SurfaceCapabilities&& rhs)
@@ -5972,7 +6009,7 @@ SurfaceCapabilities& SurfaceCapabilities::operator=(SurfaceCapabilities&& rhs) {
     if (&rhs == this) {
         return *this;
     }
-    this->~SurfaceCapabilities();
+    FreeMembers();
     ::wgpu::detail::AsNonConstReference(this->usages) = std::move(rhs.usages);
     ::wgpu::detail::AsNonConstReference(this->formatCount) = std::move(rhs.formatCount);
     ::wgpu::detail::AsNonConstReference(this->formats) = std::move(rhs.formats);
@@ -5984,7 +6021,14 @@ SurfaceCapabilities& SurfaceCapabilities::operator=(SurfaceCapabilities&& rhs) {
     return *this;
 }
 
-    // static
+void SurfaceCapabilities::FreeMembers() {
+    if (this->formats != nullptr || this->presentModes != nullptr || this->alphaModes != nullptr) {
+        wgpuSurfaceCapabilitiesFreeMembers(
+            *reinterpret_cast<WGPUSurfaceCapabilities*>(this));
+    }
+}
+
+// static
 void SurfaceCapabilities::Reset(SurfaceCapabilities& value) {
     SurfaceCapabilities defaultValue{};
     ::wgpu::detail::AsNonConstReference(value.usages) = defaultValue.usages;
@@ -6494,10 +6538,7 @@ AdapterPropertiesMemoryHeaps::AdapterPropertiesMemoryHeaps(AdapterPropertiesMemo
     heapCount(std::move(init.heapCount)), 
     heapInfo(std::move(init.heapInfo)){}
 AdapterPropertiesMemoryHeaps::~AdapterPropertiesMemoryHeaps() {
-    if (this->heapInfo != nullptr) {
-        wgpuAdapterPropertiesMemoryHeapsFreeMembers(
-            *reinterpret_cast<WGPUAdapterPropertiesMemoryHeaps*>(this));
-    }
+    FreeMembers();
 }
 
 AdapterPropertiesMemoryHeaps::AdapterPropertiesMemoryHeaps(AdapterPropertiesMemoryHeaps&& rhs)
@@ -6510,14 +6551,21 @@ AdapterPropertiesMemoryHeaps& AdapterPropertiesMemoryHeaps::operator=(AdapterPro
     if (&rhs == this) {
         return *this;
     }
-    this->~AdapterPropertiesMemoryHeaps();
+    FreeMembers();
     ::wgpu::detail::AsNonConstReference(this->heapCount) = std::move(rhs.heapCount);
     ::wgpu::detail::AsNonConstReference(this->heapInfo) = std::move(rhs.heapInfo);
     Reset(rhs);
     return *this;
 }
 
-    // static
+void AdapterPropertiesMemoryHeaps::FreeMembers() {
+    if (this->heapInfo != nullptr) {
+        wgpuAdapterPropertiesMemoryHeapsFreeMembers(
+            *reinterpret_cast<WGPUAdapterPropertiesMemoryHeaps*>(this));
+    }
+}
+
+// static
 void AdapterPropertiesMemoryHeaps::Reset(AdapterPropertiesMemoryHeaps& value) {
     AdapterPropertiesMemoryHeaps defaultValue{};
     ::wgpu::detail::AsNonConstReference(value.heapCount) = defaultValue.heapCount;
@@ -6664,10 +6712,7 @@ DrmFormatCapabilities::DrmFormatCapabilities(DrmFormatCapabilities::Init&& init)
     propertiesCount(std::move(init.propertiesCount)), 
     properties(std::move(init.properties)){}
 DrmFormatCapabilities::~DrmFormatCapabilities() {
-    if (this->properties != nullptr) {
-        wgpuDrmFormatCapabilitiesFreeMembers(
-            *reinterpret_cast<WGPUDrmFormatCapabilities*>(this));
-    }
+    FreeMembers();
 }
 
 DrmFormatCapabilities::DrmFormatCapabilities(DrmFormatCapabilities&& rhs)
@@ -6680,14 +6725,21 @@ DrmFormatCapabilities& DrmFormatCapabilities::operator=(DrmFormatCapabilities&&
     if (&rhs == this) {
         return *this;
     }
-    this->~DrmFormatCapabilities();
+    FreeMembers();
     ::wgpu::detail::AsNonConstReference(this->propertiesCount) = std::move(rhs.propertiesCount);
     ::wgpu::detail::AsNonConstReference(this->properties) = std::move(rhs.properties);
     Reset(rhs);
     return *this;
 }
 
-    // static
+void DrmFormatCapabilities::FreeMembers() {
+    if (this->properties != nullptr) {
+        wgpuDrmFormatCapabilitiesFreeMembers(
+            *reinterpret_cast<WGPUDrmFormatCapabilities*>(this));
+    }
+}
+
+// static
 void DrmFormatCapabilities::Reset(DrmFormatCapabilities& value) {
     DrmFormatCapabilities defaultValue{};
     ::wgpu::detail::AsNonConstReference(value.propertiesCount) = defaultValue.propertiesCount;

package/cpp/dawn/webgpu_cpp_print.h

@@ -610,6 +610,12 @@ namespace wgpu {
       case FeatureName::Float32Filterable:
         o << "FeatureName::Float32Filterable";
         break;
+      case FeatureName::Subgroups:
+        o << "FeatureName::Subgroups";
+        break;
+      case FeatureName::SubgroupsF16:
+        o << "FeatureName::SubgroupsF16";
+        break;
       case FeatureName::DawnInternalUsages:
         o << "FeatureName::DawnInternalUsages";
         break;