Merge branch 'main' into main

Author: scottmas

.github/workflows/build-dawn.yml

@@ -8,33 +8,30 @@ jobs:
         uses: actions/checkout@v2
         with:
           submodules: true
-
+      - name: Initialize Dawn's abseil-cpp submodule
+        run: |
+          cd externals/dawn
+          git submodule update --init third_party/abseil-cpp
       - name: Setup Android NDK
         id: setup-ndk
         uses: nttld/setup-ndk@v1
         with:
           ndk-version: r26d
-
       - name: Set ANDROID_NDK
         run: echo "ANDROID_NDK=$ANDROID_HOME/ndk-bundle" >> $GITHUB_ENV
-
       - name: Setup Ninja
         uses: seanmiddleditch/gha-setup-ninja@master
-
       - uses: actions/setup-node@v3
         with:
           cache: 'yarn'
           cache-dependency-path: yarn.lock
-
       - name: Install Package
         run: yarn install --frozen-lockfile
-
       - name: Build Dawn
         working-directory: packages/webgpu
         env:
           ANDROID_NDK: ${{ steps.setup-ndk.outputs.ndk-path }}
         run: yarn build-dawn
-
       - name: Upload artifacts - Dawn Library Files
         if: github.ref == 'refs/heads/main'
         uses: actions/upload-artifact@v4

.gitmodules

@@ -1,4 +1,4 @@
 [submodule "externals/dawn"]
   path = externals/dawn
   url = https://dawn.googlesource.com/dawn
-	branch = chromium/6793
+  branch = chromium/7213

apps/example/ios/Podfile.lock

@@ -1433,7 +1433,7 @@ PODS:
     - ReactCommon/turbomodule/bridging
     - ReactCommon/turbomodule/core
     - Yoga
-  - react-native-wgpu (0.1.23):
+  - react-native-wgpu (0.2.0):
     - DoubleConversion
     - glog
     - hermes-engine
@@ -2246,7 +2246,7 @@ SPEC CHECKSUMS:
   React-microtasksnativemodule: 054f34e9b82f02bd40f09cebd4083828b5b2beb6
   react-native-safe-area-context: 562163222d999b79a51577eda2ea8ad2c32b4d06
   react-native-skia: 99362ce77dff006719636c97f16c9713e3ec221e
-  react-native-wgpu: df332eefb5af27e261fadf5550ef228aaabf279e
+  react-native-wgpu: 7590eede723b37674adafbb94f0fd0f2acfa32c5
   React-NativeModulesApple: 2c4377e139522c3d73f5df582e4f051a838ff25e
   React-oscompat: ef5df1c734f19b8003e149317d041b8ce1f7d29c
   React-perflogger: 9a151e0b4c933c9205fd648c246506a83f31395d

externals/dawn

@@ -0,0 +1,122 @@
+#include <sstream>
+#include <string>
+
+#ifdef __ANDROID__
+#include <android/log.h>
+#elif defined(__APPLE__)
+#include <os/log.h>
+#endif
+
+namespace dawn {
+
+enum class LogSeverity {
+    Debug,
+    Info,
+    Warning,
+    Error,
+};
+
+// Forward declare to match Dawn's exact interface
+class LogMessage {
+public:
+    explicit LogMessage(LogSeverity severity);
+    ~LogMessage();
+    
+    LogMessage(LogMessage&& other);
+    LogMessage& operator=(LogMessage&& other);
+    
+    template <typename T>
+    LogMessage& operator<<(T&& value) {
+        mStream << value;
+        return *this;
+    }
+
+private:
+    LogMessage(const LogMessage& other) = delete;
+    LogMessage& operator=(const LogMessage& other) = delete;
+    
+    LogSeverity mSeverity;
+    std::ostringstream mStream;
+};
+
+// Implementation of LogMessage methods
+LogMessage::LogMessage(LogSeverity severity) : mSeverity(severity) {}
+
+LogMessage::LogMessage(LogMessage&& other) 
+    : mSeverity(other.mSeverity), mStream(std::move(other.mStream)) {}
+
+LogMessage& LogMessage::operator=(LogMessage&& other) {
+    if (this != &other) {
+        mSeverity = other.mSeverity;
+        mStream = std::move(other.mStream);
+    }
+    return *this;
+}
+
+LogMessage::~LogMessage() {
+    std::string fullMessage = mStream.str();
+    
+    if (fullMessage.empty()) {
+        return;
+    }
+    
+    const char* severityName;
+    switch (mSeverity) {
+        case LogSeverity::Debug: severityName = "Debug"; break;
+        case LogSeverity::Info: severityName = "Info"; break;
+        case LogSeverity::Warning: severityName = "Warning"; break;
+        case LogSeverity::Error: severityName = "Error"; break;
+        default: severityName = "Unknown"; break;
+    }
+    
+#ifdef __ANDROID__
+    int androidPriority;
+    switch (mSeverity) {
+        case LogSeverity::Debug: androidPriority = ANDROID_LOG_DEBUG; break;
+        case LogSeverity::Info: androidPriority = ANDROID_LOG_INFO; break;
+        case LogSeverity::Warning: androidPriority = ANDROID_LOG_WARN; break;
+        case LogSeverity::Error: androidPriority = ANDROID_LOG_ERROR; break;
+        default: androidPriority = ANDROID_LOG_ERROR; break;
+    }
+    __android_log_print(androidPriority, "ReactNativeWebGPU", "%s: %s", severityName, fullMessage.c_str());
+#elif defined(__APPLE__)
+    os_log_type_t logType;
+    switch (mSeverity) {
+        case LogSeverity::Debug: logType = OS_LOG_TYPE_DEBUG; break;
+        case LogSeverity::Info: logType = OS_LOG_TYPE_INFO; break;
+        case LogSeverity::Warning: logType = OS_LOG_TYPE_DEFAULT; break;
+        case LogSeverity::Error: logType = OS_LOG_TYPE_ERROR; break;
+        default: logType = OS_LOG_TYPE_ERROR; break;
+    }
+    os_log_with_type(OS_LOG_DEFAULT, logType, "[ReactNativeWebGPU] %s: %s", severityName, fullMessage.c_str());
+#else
+    FILE* outputStream = (mSeverity == LogSeverity::Warning || mSeverity == LogSeverity::Error) ? stderr : stdout;
+    fprintf(outputStream, "[ReactNativeWebGPU] %s: %s\n", severityName, fullMessage.c_str());
+    fflush(outputStream);
+#endif
+}
+
+// Factory functions
+LogMessage DebugLog() {
+    return LogMessage(LogSeverity::Debug);
+}
+
+LogMessage InfoLog() {
+    return LogMessage(LogSeverity::Info);
+}
+
+LogMessage WarningLog() {
+    return LogMessage(LogSeverity::Warning);
+}
+
+LogMessage ErrorLog() {
+    return LogMessage(LogSeverity::Error);
+}
+
+LogMessage DebugLog(const char* file, const char* function, int line) {
+    LogMessage message = DebugLog();
+    message << file << ":" << line << "(" << function << ")";
+    return message;
+}
+
+} // namespace dawn

packages/webgpu/cpp/dawn_logging.cpp

@@ -38,6 +38,7 @@ class SurfaceInfo {
     config = newConfig;
     config.width = width;
     config.height = height;
+    config.presentMode = wgpu::PresentMode::Fifo;
     _configure();
   }
 
@@ -83,10 +84,10 @@ class SurfaceInfo {
       auto device = config.device;
       wgpu::CommandEncoder encoder = device.CreateCommandEncoder(&encoderDesc);
 
-      wgpu::ImageCopyTexture sourceTexture = {};
+      wgpu::TexelCopyTextureInfo sourceTexture = {};
       sourceTexture.texture = texture;
 
-      wgpu::ImageCopyTexture destinationTexture = {};
+      wgpu::TexelCopyTextureInfo destinationTexture = {};
       wgpu::SurfaceTexture surfaceTexture;
       surface.GetCurrentTexture(&surfaceTexture);
       destinationTexture.texture = surfaceTexture.texture;

packages/webgpu/cpp/rnwgpu/SurfaceRegistry.h

@@ -309,7 +309,7 @@ class Convertor {
            Convert(out.label, in.label);
   }
 
-  [[nodiscard]] bool Convert(wgpu::ComputePassTimestampWrites &out,
+  [[nodiscard]] bool Convert(wgpu::PassTimestampWrites &out,
                              const GPUComputePassTimestampWrites &in) {
     return Convert(out.querySet, in.querySet) &&
            Convert(out.beginningOfPassWriteIndex,
@@ -348,74 +348,70 @@ class Convertor {
 
     if (in.requiredLimits.has_value()) {
       const auto &limits = in.requiredLimits.value();
-      auto *requiredLimits = Allocate<wgpu::RequiredLimits>();
+      auto *requiredLimits = Allocate<wgpu::Limits>();
       for (const auto &[key, value] : limits) {
         if (key == "maxTextureDimension1D") {
-          requiredLimits->limits.maxTextureDimension1D = value;
+          requiredLimits->maxTextureDimension1D = value;
         } else if (key == "maxTextureDimension2D") {
-          requiredLimits->limits.maxTextureDimension2D = value;
+          requiredLimits->maxTextureDimension2D = value;
         } else if (key == "maxTextureDimension3D") {
-          requiredLimits->limits.maxTextureDimension3D = value;
+          requiredLimits->maxTextureDimension3D = value;
         } else if (key == "maxTextureArrayLayers") {
-          requiredLimits->limits.maxTextureArrayLayers = value;
+          requiredLimits->maxTextureArrayLayers = value;
         } else if (key == "maxBindGroups") {
-          requiredLimits->limits.maxBindGroups = value;
+          requiredLimits->maxBindGroups = value;
         } else if (key == "maxBindGroupsPlusVertexBuffers") {
-          requiredLimits->limits.maxBindGroupsPlusVertexBuffers = value;
+          requiredLimits->maxBindGroupsPlusVertexBuffers = value;
         } else if (key == "maxBindingsPerBindGroup") {
-          requiredLimits->limits.maxBindingsPerBindGroup = value;
+          requiredLimits->maxBindingsPerBindGroup = value;
         } else if (key == "maxDynamicUniformBuffersPerPipelineLayout") {
-          requiredLimits->limits.maxDynamicUniformBuffersPerPipelineLayout =
-              value;
+          requiredLimits->maxDynamicUniformBuffersPerPipelineLayout = value;
         } else if (key == "maxDynamicStorageBuffersPerPipelineLayout") {
-          requiredLimits->limits.maxDynamicStorageBuffersPerPipelineLayout =
-              value;
+          requiredLimits->maxDynamicStorageBuffersPerPipelineLayout = value;
         } else if (key == "maxSampledTexturesPerShaderStage") {
-          requiredLimits->limits.maxSampledTexturesPerShaderStage = value;
+          requiredLimits->maxSampledTexturesPerShaderStage = value;
         } else if (key == "maxSamplersPerShaderStage") {
-          requiredLimits->limits.maxSamplersPerShaderStage = value;
+          requiredLimits->maxSamplersPerShaderStage = value;
         } else if (key == "maxStorageBuffersPerShaderStage") {
-          requiredLimits->limits.maxStorageBuffersPerShaderStage = value;
+          requiredLimits->maxStorageBuffersPerShaderStage = value;
         } else if (key == "maxStorageTexturesPerShaderStage") {
-          requiredLimits->limits.maxStorageTexturesPerShaderStage = value;
+          requiredLimits->maxStorageTexturesPerShaderStage = value;
         } else if (key == "maxUniformBuffersPerShaderStage") {
-          requiredLimits->limits.maxUniformBuffersPerShaderStage = value;
+          requiredLimits->maxUniformBuffersPerShaderStage = value;
         } else if (key == "maxUniformBufferBindingSize") {
-          requiredLimits->limits.maxUniformBufferBindingSize = value;
+          requiredLimits->maxUniformBufferBindingSize = value;
         } else if (key == "maxStorageBufferBindingSize") {
-          requiredLimits->limits.maxStorageBufferBindingSize = value;
+          requiredLimits->maxStorageBufferBindingSize = value;
         } else if (key == "minUniformBufferOffsetAlignment") {
-          requiredLimits->limits.minUniformBufferOffsetAlignment = value;
+          requiredLimits->minUniformBufferOffsetAlignment = value;
         } else if (key == "minStorageBufferOffsetAlignment") {
-          requiredLimits->limits.minStorageBufferOffsetAlignment = value;
+          requiredLimits->minStorageBufferOffsetAlignment = value;
         } else if (key == "maxVertexBuffers") {
-          requiredLimits->limits.maxVertexBuffers = value;
+          requiredLimits->maxVertexBuffers = value;
         } else if (key == "maxBufferSize") {
-          requiredLimits->limits.maxBufferSize = value;
+          requiredLimits->maxBufferSize = value;
         } else if (key == "maxVertexAttributes") {
-          requiredLimits->limits.maxVertexAttributes = value;
+          requiredLimits->maxVertexAttributes = value;
         } else if (key == "maxVertexBufferArrayStride") {
-          requiredLimits->limits.maxVertexBufferArrayStride = value;
-        } else if (key == "maxInterStageShaderComponents") {
-          requiredLimits->limits.maxInterStageShaderComponents = value;
+          requiredLimits->maxVertexBufferArrayStride = value;
         } else if (key == "maxInterStageShaderVariables") {
-          requiredLimits->limits.maxInterStageShaderVariables = value;
+          requiredLimits->maxInterStageShaderVariables = value;
         } else if (key == "maxColorAttachments") {
-          requiredLimits->limits.maxColorAttachments = value;
+          requiredLimits->maxColorAttachments = value;
         } else if (key == "maxColorAttachmentBytesPerSample") {
-          requiredLimits->limits.maxColorAttachmentBytesPerSample = value;
+          requiredLimits->maxColorAttachmentBytesPerSample = value;
         } else if (key == "maxComputeWorkgroupStorageSize") {
-          requiredLimits->limits.maxComputeWorkgroupStorageSize = value;
+          requiredLimits->maxComputeWorkgroupStorageSize = value;
         } else if (key == "maxComputeInvocationsPerWorkgroup") {
-          requiredLimits->limits.maxComputeInvocationsPerWorkgroup = value;
+          requiredLimits->maxComputeInvocationsPerWorkgroup = value;
         } else if (key == "maxComputeWorkgroupSizeX") {
-          requiredLimits->limits.maxComputeWorkgroupSizeX = value;
+          requiredLimits->maxComputeWorkgroupSizeX = value;
         } else if (key == "maxComputeWorkgroupSizeY") {
-          requiredLimits->limits.maxComputeWorkgroupSizeY = value;
+          requiredLimits->maxComputeWorkgroupSizeY = value;
         } else if (key == "maxComputeWorkgroupSizeZ") {
-          requiredLimits->limits.maxComputeWorkgroupSizeZ = value;
+          requiredLimits->maxComputeWorkgroupSizeZ = value;
         } else if (key == "maxComputeWorkgroupsPerDimension") {
-          requiredLimits->limits.maxComputeWorkgroupsPerDimension = value;
+          requiredLimits->maxComputeWorkgroupsPerDimension = value;
         }
       }
       out.requiredLimits = requiredLimits;
@@ -452,7 +448,7 @@ class Convertor {
            Convert(out.constants, out.constantCount, in.constants);
   }
 
-  [[nodiscard]] bool Convert(wgpu::ImageCopyBuffer &out,
+  [[nodiscard]] bool Convert(wgpu::TexelCopyBufferInfo &out,
                              const GPUImageCopyBuffer &in) {
     out = {};
     out.buffer = in.buffer->get();
@@ -461,13 +457,13 @@ class Convertor {
            Convert(out.layout.rowsPerImage, in.rowsPerImage);
   }
 
-  [[nodiscard]] bool Convert(wgpu::ImageCopyTexture &out,
+  [[nodiscard]] bool Convert(wgpu::TexelCopyTextureInfo &out,
                              const GPUImageCopyTexture &in) {
     return Convert(out.origin, in.origin) && Convert(out.texture, in.texture) &&
            Convert(out.mipLevel, in.mipLevel) && Convert(out.aspect, in.aspect);
   }
 
-  [[nodiscard]] bool Convert(wgpu::TextureDataLayout &out,
+  [[nodiscard]] bool Convert(wgpu::TexelCopyBufferLayout &out,
                              const GPUImageDataLayout &in) {
     out = {};
     return Convert(out.bytesPerRow, in.bytesPerRow) &&
@@ -502,7 +498,7 @@ class Convertor {
            Convert(out.cullMode, in.cullMode);
   }
 
-  [[nodiscard]] bool Convert(wgpu::ProgrammableStageDescriptor &out,
+  [[nodiscard]] bool Convert(wgpu::ComputeState &out,
                              const GPUProgrammableStage &in) {
     out = {};
     out.module = in.module->get();
@@ -554,7 +550,7 @@ class Convertor {
            Convert(out.stencilReadOnly, in.stencilReadOnly);
   }
 
-  [[nodiscard]] bool Convert(wgpu::RenderPassTimestampWrites &out,
+  [[nodiscard]] bool Convert(wgpu::PassTimestampWrites &out,
                              const GPURenderPassTimestampWrites &in) {
     return Convert(out.querySet, in.querySet) &&
            Convert(out.beginningOfPassWriteIndex,