react-native-wgpu 0.1.23 → 0.2.0

package/cpp/dawn/dawn_proc_table.h

@@ -8,24 +8,25 @@
 typedef struct DawnProcTable {
     WGPUProcAdapterInfoFreeMembers adapterInfoFreeMembers;
     WGPUProcAdapterPropertiesMemoryHeapsFreeMembers adapterPropertiesMemoryHeapsFreeMembers;
+    WGPUProcAdapterPropertiesSubgroupMatrixConfigsFreeMembers adapterPropertiesSubgroupMatrixConfigsFreeMembers;
     WGPUProcCreateInstance createInstance;
-    WGPUProcDrmFormatCapabilitiesFreeMembers drmFormatCapabilitiesFreeMembers;
-    WGPUProcGetInstanceFeatures getInstanceFeatures;
+    WGPUProcDawnDrmFormatCapabilitiesFreeMembers dawnDrmFormatCapabilitiesFreeMembers;
+    WGPUProcGetInstanceCapabilities getInstanceCapabilities;
     WGPUProcGetProcAddress getProcAddress;
     WGPUProcSharedBufferMemoryEndAccessStateFreeMembers sharedBufferMemoryEndAccessStateFreeMembers;
     WGPUProcSharedTextureMemoryEndAccessStateFreeMembers sharedTextureMemoryEndAccessStateFreeMembers;
+    WGPUProcSupportedFeaturesFreeMembers supportedFeaturesFreeMembers;
+    WGPUProcSupportedWGSLLanguageFeaturesFreeMembers supportedWGSLLanguageFeaturesFreeMembers;
     WGPUProcSurfaceCapabilitiesFreeMembers surfaceCapabilitiesFreeMembers;
 
     WGPUProcAdapterCreateDevice adapterCreateDevice;
-    WGPUProcAdapterEnumerateFeatures adapterEnumerateFeatures;
+    WGPUProcAdapterGetFeatures adapterGetFeatures;
     WGPUProcAdapterGetFormatCapabilities adapterGetFormatCapabilities;
     WGPUProcAdapterGetInfo adapterGetInfo;
     WGPUProcAdapterGetInstance adapterGetInstance;
     WGPUProcAdapterGetLimits adapterGetLimits;
     WGPUProcAdapterHasFeature adapterHasFeature;
     WGPUProcAdapterRequestDevice adapterRequestDevice;
-    WGPUProcAdapterRequestDevice2 adapterRequestDevice2;
-    WGPUProcAdapterRequestDeviceF adapterRequestDeviceF;
     WGPUProcAdapterAddRef adapterAddRef;
     WGPUProcAdapterRelease adapterRelease;
 
@@ -39,15 +40,15 @@ typedef struct DawnProcTable {
 
     WGPUProcBufferDestroy bufferDestroy;
     WGPUProcBufferGetConstMappedRange bufferGetConstMappedRange;
-    WGPUProcBufferGetMapState bufferGetMapState;
     WGPUProcBufferGetMappedRange bufferGetMappedRange;
+    WGPUProcBufferGetMapState bufferGetMapState;
     WGPUProcBufferGetSize bufferGetSize;
     WGPUProcBufferGetUsage bufferGetUsage;
     WGPUProcBufferMapAsync bufferMapAsync;
-    WGPUProcBufferMapAsync2 bufferMapAsync2;
-    WGPUProcBufferMapAsyncF bufferMapAsyncF;
+    WGPUProcBufferReadMappedRange bufferReadMappedRange;
     WGPUProcBufferSetLabel bufferSetLabel;
     WGPUProcBufferUnmap bufferUnmap;
+    WGPUProcBufferWriteMappedRange bufferWriteMappedRange;
     WGPUProcBufferAddRef bufferAddRef;
     WGPUProcBufferRelease bufferRelease;
 
@@ -81,6 +82,7 @@ typedef struct DawnProcTable {
     WGPUProcComputePassEncoderPopDebugGroup computePassEncoderPopDebugGroup;
     WGPUProcComputePassEncoderPushDebugGroup computePassEncoderPushDebugGroup;
     WGPUProcComputePassEncoderSetBindGroup computePassEncoderSetBindGroup;
+    WGPUProcComputePassEncoderSetImmediateData computePassEncoderSetImmediateData;
     WGPUProcComputePassEncoderSetLabel computePassEncoderSetLabel;
     WGPUProcComputePassEncoderSetPipeline computePassEncoderSetPipeline;
     WGPUProcComputePassEncoderWriteTimestamp computePassEncoderWriteTimestamp;
@@ -98,8 +100,6 @@ typedef struct DawnProcTable {
     WGPUProcDeviceCreateCommandEncoder deviceCreateCommandEncoder;
     WGPUProcDeviceCreateComputePipeline deviceCreateComputePipeline;
     WGPUProcDeviceCreateComputePipelineAsync deviceCreateComputePipelineAsync;
-    WGPUProcDeviceCreateComputePipelineAsync2 deviceCreateComputePipelineAsync2;
-    WGPUProcDeviceCreateComputePipelineAsyncF deviceCreateComputePipelineAsyncF;
     WGPUProcDeviceCreateErrorBuffer deviceCreateErrorBuffer;
     WGPUProcDeviceCreateErrorExternalTexture deviceCreateErrorExternalTexture;
     WGPUProcDeviceCreateErrorShaderModule deviceCreateErrorShaderModule;
@@ -110,17 +110,17 @@ typedef struct DawnProcTable {
     WGPUProcDeviceCreateRenderBundleEncoder deviceCreateRenderBundleEncoder;
     WGPUProcDeviceCreateRenderPipeline deviceCreateRenderPipeline;
     WGPUProcDeviceCreateRenderPipelineAsync deviceCreateRenderPipelineAsync;
-    WGPUProcDeviceCreateRenderPipelineAsync2 deviceCreateRenderPipelineAsync2;
-    WGPUProcDeviceCreateRenderPipelineAsyncF deviceCreateRenderPipelineAsyncF;
     WGPUProcDeviceCreateSampler deviceCreateSampler;
     WGPUProcDeviceCreateShaderModule deviceCreateShaderModule;
     WGPUProcDeviceCreateTexture deviceCreateTexture;
     WGPUProcDeviceDestroy deviceDestroy;
-    WGPUProcDeviceEnumerateFeatures deviceEnumerateFeatures;
     WGPUProcDeviceForceLoss deviceForceLoss;
-    WGPUProcDeviceGetAHardwareBufferProperties deviceGetAHardwareBufferProperties;
     WGPUProcDeviceGetAdapter deviceGetAdapter;
+    WGPUProcDeviceGetAdapterInfo deviceGetAdapterInfo;
+    WGPUProcDeviceGetAHardwareBufferProperties deviceGetAHardwareBufferProperties;
+    WGPUProcDeviceGetFeatures deviceGetFeatures;
     WGPUProcDeviceGetLimits deviceGetLimits;
+    WGPUProcDeviceGetLostFuture deviceGetLostFuture;
     WGPUProcDeviceGetQueue deviceGetQueue;
     WGPUProcDeviceHasFeature deviceHasFeature;
     WGPUProcDeviceImportSharedBufferMemory deviceImportSharedBufferMemory;
@@ -128,13 +128,9 @@ typedef struct DawnProcTable {
     WGPUProcDeviceImportSharedTextureMemory deviceImportSharedTextureMemory;
     WGPUProcDeviceInjectError deviceInjectError;
     WGPUProcDevicePopErrorScope devicePopErrorScope;
-    WGPUProcDevicePopErrorScope2 devicePopErrorScope2;
-    WGPUProcDevicePopErrorScopeF devicePopErrorScopeF;
     WGPUProcDevicePushErrorScope devicePushErrorScope;
-    WGPUProcDeviceSetDeviceLostCallback deviceSetDeviceLostCallback;
     WGPUProcDeviceSetLabel deviceSetLabel;
     WGPUProcDeviceSetLoggingCallback deviceSetLoggingCallback;
-    WGPUProcDeviceSetUncapturedErrorCallback deviceSetUncapturedErrorCallback;
     WGPUProcDeviceTick deviceTick;
     WGPUProcDeviceValidateTextureDescriptor deviceValidateTextureDescriptor;
     WGPUProcDeviceAddRef deviceAddRef;
@@ -148,12 +144,10 @@ typedef struct DawnProcTable {
     WGPUProcExternalTextureRelease externalTextureRelease;
 
     WGPUProcInstanceCreateSurface instanceCreateSurface;
-    WGPUProcInstanceEnumerateWGSLLanguageFeatures instanceEnumerateWGSLLanguageFeatures;
+    WGPUProcInstanceGetWGSLLanguageFeatures instanceGetWGSLLanguageFeatures;
     WGPUProcInstanceHasWGSLLanguageFeature instanceHasWGSLLanguageFeature;
     WGPUProcInstanceProcessEvents instanceProcessEvents;
     WGPUProcInstanceRequestAdapter instanceRequestAdapter;
-    WGPUProcInstanceRequestAdapter2 instanceRequestAdapter2;
-    WGPUProcInstanceRequestAdapterF instanceRequestAdapterF;
     WGPUProcInstanceWaitAny instanceWaitAny;
     WGPUProcInstanceAddRef instanceAddRef;
     WGPUProcInstanceRelease instanceRelease;
@@ -172,8 +166,6 @@ typedef struct DawnProcTable {
     WGPUProcQueueCopyExternalTextureForBrowser queueCopyExternalTextureForBrowser;
     WGPUProcQueueCopyTextureForBrowser queueCopyTextureForBrowser;
     WGPUProcQueueOnSubmittedWorkDone queueOnSubmittedWorkDone;
-    WGPUProcQueueOnSubmittedWorkDone2 queueOnSubmittedWorkDone2;
-    WGPUProcQueueOnSubmittedWorkDoneF queueOnSubmittedWorkDoneF;
     WGPUProcQueueSetLabel queueSetLabel;
     WGPUProcQueueSubmit queueSubmit;
     WGPUProcQueueWriteBuffer queueWriteBuffer;
@@ -194,6 +186,7 @@ typedef struct DawnProcTable {
     WGPUProcRenderBundleEncoderPopDebugGroup renderBundleEncoderPopDebugGroup;
     WGPUProcRenderBundleEncoderPushDebugGroup renderBundleEncoderPushDebugGroup;
     WGPUProcRenderBundleEncoderSetBindGroup renderBundleEncoderSetBindGroup;
+    WGPUProcRenderBundleEncoderSetImmediateData renderBundleEncoderSetImmediateData;
     WGPUProcRenderBundleEncoderSetIndexBuffer renderBundleEncoderSetIndexBuffer;
     WGPUProcRenderBundleEncoderSetLabel renderBundleEncoderSetLabel;
     WGPUProcRenderBundleEncoderSetPipeline renderBundleEncoderSetPipeline;
@@ -217,6 +210,7 @@ typedef struct DawnProcTable {
     WGPUProcRenderPassEncoderPushDebugGroup renderPassEncoderPushDebugGroup;
     WGPUProcRenderPassEncoderSetBindGroup renderPassEncoderSetBindGroup;
     WGPUProcRenderPassEncoderSetBlendConstant renderPassEncoderSetBlendConstant;
+    WGPUProcRenderPassEncoderSetImmediateData renderPassEncoderSetImmediateData;
     WGPUProcRenderPassEncoderSetIndexBuffer renderPassEncoderSetIndexBuffer;
     WGPUProcRenderPassEncoderSetLabel renderPassEncoderSetLabel;
     WGPUProcRenderPassEncoderSetPipeline renderPassEncoderSetPipeline;
@@ -238,8 +232,6 @@ typedef struct DawnProcTable {
     WGPUProcSamplerRelease samplerRelease;
 
     WGPUProcShaderModuleGetCompilationInfo shaderModuleGetCompilationInfo;
-    WGPUProcShaderModuleGetCompilationInfo2 shaderModuleGetCompilationInfo2;
-    WGPUProcShaderModuleGetCompilationInfoF shaderModuleGetCompilationInfoF;
     WGPUProcShaderModuleSetLabel shaderModuleSetLabel;
     WGPUProcShaderModuleAddRef shaderModuleAddRef;
     WGPUProcShaderModuleRelease shaderModuleRelease;

package/cpp/dawn/native/D3D11Backend.h

@@ -57,6 +57,13 @@ struct DAWN_NATIVE_EXPORT SharedTextureMemoryD3D11Texture2DDescriptor : wgpu::Ch
     // This ID3D11Texture2D object must be created from the same ID3D11Device used in the
     // WGPUDevice.
     Microsoft::WRL::ComPtr<ID3D11Texture2D> texture;
+
+    // If this flag is true, Dawn is required to signal a fence before EndAccess() and return it in
+    // SharedTextureMemoryEndAccessState's fences list.
+    // If it's false, no fence signaling is needed and EndAccess() might return empty fence list.
+    // Note: this flag is not relevant if the feature SharedFenceDXGISharedHandle is disabled/not
+    // supported.
+    bool requiresEndAccessFence = true;
 };
 
 }  // namespace dawn::native::d3d11

package/cpp/dawn/native/DawnNative.h

@@ -89,13 +89,6 @@ class DAWN_NATIVE_EXPORT Adapter {
     Adapter(const Adapter& other);
     Adapter& operator=(const Adapter& other);
 
-    // TODO(crbug.com/347047627): These methods are historical duplicates of
-    // those in webgpu_cpp.h. Update uses of these methods and remove them.
-    wgpu::Status GetInfo(wgpu::AdapterInfo* info) const;
-    wgpu::Status GetInfo(WGPUAdapterInfo* info) const;
-    std::vector<const char*> GetSupportedFeatures() const;
-    wgpu::ConvertibleStatus GetLimits(WGPUSupportedLimits* limits) const;
-
     void SetUseTieredLimits(bool useTieredLimits);
 
     // Check that the Adapter is able to support importing external images. This is necessary
@@ -108,18 +101,6 @@ class DAWN_NATIVE_EXPORT Adapter {
     WGPUDevice CreateDevice(const wgpu::DeviceDescriptor* deviceDescriptor);
     WGPUDevice CreateDevice(const WGPUDeviceDescriptor* deviceDescriptor = nullptr);
 
-    void RequestDevice(const wgpu::DeviceDescriptor* descriptor,
-                       WGPURequestDeviceCallback callback,
-                       void* userdata);
-    void RequestDevice(const WGPUDeviceDescriptor* descriptor,
-                       WGPURequestDeviceCallback callback,
-                       void* userdata);
-    void RequestDevice(std::nullptr_t descriptor,
-                       WGPURequestDeviceCallback callback,
-                       void* userdata) {
-        RequestDevice(static_cast<const wgpu::DeviceDescriptor*>(descriptor), callback, userdata);
-    }
-
     // Returns the underlying WGPUAdapter object.
     WGPUAdapter Get() const;
 
@@ -142,8 +123,40 @@ struct DAWN_NATIVE_EXPORT DawnInstanceDescriptor : wgpu::ChainedStruct {
     BackendValidationLevel backendValidationLevel = BackendValidationLevel::Disabled;
     bool beginCaptureOnStartup = false;
 
-    WGPULoggingCallback loggingCallback = nullptr;
-    void* loggingCallbackUserdata = nullptr;
+    WGPULoggingCallbackInfo loggingCallbackInfo = WGPU_LOGGING_CALLBACK_INFO_INIT;
+
+    template <typename F,
+              typename T,
+              typename Cb = wgpu::LoggingCallback<T>,
+              typename = std::enable_if_t<std::is_convertible_v<F, Cb*>>>
+    void SetLoggingCallback(F callback, T userdata) {
+        assert(loggingCallbackInfo.callback == nullptr);
+
+        loggingCallbackInfo.callback = [](WGPULoggingType type, struct WGPUStringView message,
+                                          void* callback_param, void* userdata_param) {
+            auto cb = reinterpret_cast<Cb*>(callback_param);
+            (*cb)(static_cast<wgpu::LoggingType>(type), message, static_cast<T>(userdata_param));
+        };
+        loggingCallbackInfo.userdata1 = reinterpret_cast<void*>(+callback);
+        loggingCallbackInfo.userdata2 = reinterpret_cast<void*>(userdata);
+    }
+
+    template <typename L,
+              typename Cb = wgpu::LoggingCallback<>,
+              typename = std::enable_if_t<std::is_convertible_v<L, Cb>>>
+    void SetLoggingCallback(L callback) {
+        assert(loggingCallbackInfo.callback == nullptr);
+        using F = wgpu::LoggingCallback<void>;
+        static_assert(std::is_convertible_v<L, F*>, "Logging callback cannot be a binding lambda");
+
+        loggingCallbackInfo.callback = [](WGPULoggingType type, struct WGPUStringView message,
+                                          void* callback_param, void*) {
+            auto cb = reinterpret_cast<F*>(callback_param);
+            (*cb)(static_cast<wgpu::LoggingType>(type), message);
+        };
+        loggingCallbackInfo.userdata1 = reinterpret_cast<void*>(+callback);
+        loggingCallbackInfo.userdata2 = nullptr;
+    }
 
     // Equality operators, mostly for testing. Note that this tests
     // strict pointer-pointer equality if the struct contains member pointers.
@@ -158,6 +171,7 @@ struct DAWN_NATIVE_EXPORT DawnInstanceDescriptor : wgpu::ChainedStruct {
 class DAWN_NATIVE_EXPORT Instance {
   public:
     explicit Instance(const WGPUInstanceDescriptor* desc = nullptr);
+    explicit Instance(const wgpu::InstanceDescriptor* desc);
     explicit Instance(InstanceBase* impl);
     ~Instance();
 
@@ -301,12 +315,42 @@ class DAWN_NATIVE_EXPORT MemoryDump {
 };
 DAWN_NATIVE_EXPORT void DumpMemoryStatistics(WGPUDevice device, MemoryDump* dump);
 
-// Unlike memory dumps which include detailed information about allocations, this only returns the
-// total estimated memory usage, and is intended for background tracing for UMA.
-DAWN_NATIVE_EXPORT uint64_t ComputeEstimatedMemoryUsage(WGPUDevice device);
+// Intended for background tracing for UMA that returns the estimated memory usage.
+struct DAWN_NATIVE_EXPORT MemoryUsageInfo {
+    // Total memory usage.
+    uint64_t totalUsage;
+    // Total depth stencil textures' memory.
+    uint64_t depthStencilTexturesUsage;
+    // Total MSAA textures' memory.
+    uint64_t msaaTexturesUsage;
+    // Number of MSAA textures.
+    uint64_t msaaTexturesCount;
+    // Largest MSAA texture's memory.
+    uint64_t largestMsaaTextureUsage;
+    // Total textures' memory.
+    uint64_t texturesUsage;
+    // Total buffers' memory.
+    uint64_t buffersUsage;
+};
+DAWN_NATIVE_EXPORT MemoryUsageInfo ComputeEstimatedMemoryUsageInfo(WGPUDevice device);
+
+// Memory information gathered from backend specific allocators.
+// - memory allocated by clients for objects such as buffers, textures.
+// - heap memory used by the allocator for allocations.
+struct DAWN_NATIVE_EXPORT AllocatorMemoryInfo {
+    uint64_t totalUsedMemory = 0;
+    uint64_t totalAllocatedMemory = 0;
+};
+DAWN_NATIVE_EXPORT AllocatorMemoryInfo GetAllocatorMemoryInfo(WGPUDevice device);
+
+// Free any unused GPU memory like staging buffers, cached resources, etc. Returns true if there are
+// still objects to delete and ReduceMemoryUsage() should be run again after a short delay to allow
+// submitted work to complete.
+DAWN_NATIVE_EXPORT bool ReduceMemoryUsage(WGPUDevice device);
 
-// Free any unused GPU memory like staging buffers, cached resources, etc.
-DAWN_NATIVE_EXPORT void ReduceMemoryUsage(WGPUDevice device);
+// Perform tasks that are appropriate to do when idle like serializing pipeline
+// caches, etc.
+DAWN_NATIVE_EXPORT void PerformIdleTasks(const wgpu::Device& device);
 
 }  // namespace dawn::native
 

package/cpp/dawn/native/WebGPUBackend.h

@@ -0,0 +1,35 @@
+// Copyright 2025 The Dawn & Tint Authors
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//
+// 1. Redistributions of source code must retain the above copyright notice, this
+//    list of conditions and the following disclaimer.
+//
+// 2. Redistributions in binary form must reproduce the above copyright notice,
+//    this list of conditions and the following disclaimer in the documentation
+//    and/or other materials provided with the distribution.
+//
+// 3. Neither the name of the copyright holder nor the names of its
+//    contributors may be used to endorse or promote products derived from
+//    this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+// 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.
+
+#ifndef INCLUDE_DAWN_NATIVE_WEBGPUBACKEND_H_
+#define INCLUDE_DAWN_NATIVE_WEBGPUBACKEND_H_
+
+#include "dawn/native/DawnNative.h"
+
+namespace dawn::native::webgpu {}  // namespace dawn::native::webgpu
+
+#endif  // INCLUDE_DAWN_NATIVE_WEBGPUBACKEND_H_

package/cpp/dawn/platform/DawnPlatform.h

@@ -100,6 +100,7 @@ class DAWN_PLATFORM_EXPORT WorkerTaskPool {
 enum class Features {
     kWebGPUUseDXC,
     kWebGPUUseTintIR,
+    kWebGPUUseVulkanMemoryModel,
 };
 
 class DAWN_PLATFORM_EXPORT Platform {