react-native-wgpu 0.2.0 → 0.2.2

package/android/CMakeLists.txt

@@ -106,4 +106,4 @@ else()
         ReactAndroid::reactnativejni
         webgpu_dawn
     )
-endif()
+endif()

package/android/build.gradle

@@ -81,7 +81,8 @@ android {
         cppFlags "-fexceptions", "-frtti", "-std=c++1y", "-DONANDROID"
         abiFilters (*reactNativeArchitectures())
         arguments '-DANDROID_STL=c++_shared',
-          "-DNODE_MODULES_DIR=${nodeModules}"
+          "-DNODE_MODULES_DIR=${nodeModules}",
+          "-DANDROID_SUPPORT_FLEXIBLE_PAGE_SIZES=ON"
       }
     }
   }

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

@@ -4,93 +4,295 @@ import android.annotation.SuppressLint;
 import android.content.Context;
 import android.graphics.Bitmap;
 import android.graphics.Canvas;
-import android.graphics.Matrix;
+import android.graphics.Paint;
 import android.graphics.PixelFormat;
+import android.graphics.Rect;
 import android.hardware.HardwareBuffer;
 import android.media.Image;
 import android.media.ImageReader;
 import android.os.Build;
+import android.os.Handler;
+import android.os.Looper;
+import android.view.Surface;
 import android.view.View;
 
 import androidx.annotation.NonNull;
 import androidx.annotation.RequiresApi;
 
-@SuppressLint("ViewConstructor")
+import java.nio.ByteBuffer;
+
 @RequiresApi(api = Build.VERSION_CODES.Q)
+@SuppressLint("ViewConstructor")
 public class WebGPUAHBView extends View implements ImageReader.OnImageAvailableListener {
 
-  private ImageReader mReader;
-
-  private Bitmap mBitmap = null;
-
-  private final Matrix matrix = new Matrix();
+  private static final int MAX_IMAGES = 3;
+  private static final String TAG = "WebGPUAHBView";
 
-  WebGPUAPI mApi;
+  private final WebGPUAPI mApi;
+  private ImageReader mImageReader;
+  private Surface mSurface;
+  private Image mCurrentImage;
+  private Bitmap mCachedBitmap;
+  private final Paint mPaint;
+  private final Handler mHandler;
+  private final Object mImageLock = new Object();
+  private boolean mSurfaceCreated = false;
+  private int mConfiguredWidth = 0;
+  private int mConfiguredHeight = 0;
 
   public WebGPUAHBView(Context context, WebGPUAPI api) {
     super(context);
     mApi = api;
-  }
+    mPaint = new Paint(Paint.FILTER_BITMAP_FLAG);
+    mHandler = new Handler(Looper.getMainLooper());
+
+    // Enable hardware acceleration for this view
+    setLayerType(LAYER_TYPE_HARDWARE, null);
 
-  private ImageReader createReader() {
-    ImageReader reader = ImageReader.newInstance(getWidth(), getHeight(), PixelFormat.RGBA_8888, 2, HardwareBuffer.USAGE_GPU_SAMPLED_IMAGE |
-      HardwareBuffer.USAGE_GPU_COLOR_OUTPUT);
-    reader.setOnImageAvailableListener(this, null);
-    return reader;
+    // Make sure we get drawn
+    setWillNotDraw(false);
   }
 
   @Override
-  protected void onLayout(boolean changed, int left, int top, int right, int bottom) {
-    super.onLayout(changed, left, top, right, bottom);
-    if (mReader == null) {
-      mReader = createReader();
-      mApi.surfaceCreated(mReader.getSurface());
-    } else {
-      mApi.surfaceChanged(mReader.getSurface());
+  protected void onSizeChanged(int w, int h, int oldw, int oldh) {
+    super.onSizeChanged(w, h, oldw, oldh);
+
+    if (w > 0 && h > 0) {
+      // Recreate ImageReader with new dimensions
+      setupImageReader(w, h);
+    }
+  }
+
+  private void setupImageReader(int width, int height) {
+    // Don't recreate if dimensions haven't changed
+    if (width == mConfiguredWidth && height == mConfiguredHeight && mImageReader != null) {
+      return;
+    }
+
+    // Clean up previous ImageReader
+    cleanupImageReader();
+
+    try {
+      // Create ImageReader with HardwareBuffer support
+      mImageReader = ImageReader.newInstance(
+        width,
+        height,
+        PixelFormat.RGBA_8888,
+        MAX_IMAGES,
+        HardwareBuffer.USAGE_GPU_SAMPLED_IMAGE |
+          HardwareBuffer.USAGE_GPU_COLOR_OUTPUT |
+          HardwareBuffer.USAGE_COMPOSER_OVERLAY |
+          HardwareBuffer.USAGE_CPU_READ_RARELY // For fallback to Bitmap if needed
+      );
+
+      mImageReader.setOnImageAvailableListener(this, mHandler);
+
+      // Get the Surface for WebGPU to render to
+      mSurface = mImageReader.getSurface();
+
+      mConfiguredWidth = width;
+      mConfiguredHeight = height;
+
+      // Notify WebGPU about the new surface
+      if (!mSurfaceCreated) {
+        mApi.surfaceCreated(mSurface);
+        mSurfaceCreated = true;
+      } else {
+        mApi.surfaceChanged(mSurface);
+      }
+
+    } catch (Exception e) {
+      e.printStackTrace();
+      // Fallback to offscreen if ImageReader creation fails
+      mApi.surfaceOffscreen();
     }
   }
 
   @Override
   public void onImageAvailable(ImageReader reader) {
-    try (Image image = reader.acquireLatestImage()) {
-      if (image != null) {
-        HardwareBuffer hb = image.getHardwareBuffer();
-        if (hb != null) {
-          Bitmap bitmap = Bitmap.wrapHardwareBuffer(hb, null);
-          if (bitmap != null) {
-            mBitmap = bitmap;
-            hb.close();
-            invalidate();
-          }
+    synchronized (mImageLock) {
+      // Close previous image if exists
+      if (mCurrentImage != null) {
+        mCurrentImage.close();
+        mCurrentImage = null;
+      }
+
+      try {
+        // Get the latest image
+        mCurrentImage = reader.acquireLatestImage();
+
+        if (mCurrentImage != null) {
+          // Request a redraw on the UI thread
+          postInvalidateOnAnimation();
         }
+      } catch (Exception e) {
+        e.printStackTrace();
       }
     }
   }
 
   @Override
-  protected void onDraw(@NonNull Canvas canvas) {
+  protected void onDraw(Canvas canvas) {
     super.onDraw(canvas);
-    if (mBitmap != null) {
-      float viewWidth = getWidth();
-      float viewHeight = getHeight();
-      float bitmapWidth = mBitmap.getWidth();
-      float bitmapHeight = mBitmap.getHeight();
 
-      // Calculate the scale factors
-      float scaleX = viewWidth / bitmapWidth;
-      float scaleY = viewHeight / bitmapHeight;
+    synchronized (mImageLock) {
+      if (mCurrentImage == null) {
+        return;
+      }
+
+      try {
+        // Try to use HardwareBuffer directly (most efficient path)
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+          HardwareBuffer hardwareBuffer = mCurrentImage.getHardwareBuffer();
 
-      // Reset the matrix and apply scaling
-      matrix.reset();
-      matrix.setScale(scaleX, scaleY);
+          if (hardwareBuffer != null) {
+            // Draw using HardwareBuffer
+            drawHardwareBuffer(canvas, hardwareBuffer);
+            return;
+          }
+        }
 
-      canvas.drawBitmap(mBitmap, matrix, null);
+        // Fallback: Convert Image to Bitmap
+        drawImageAsBitmap(canvas, mCurrentImage);
+
+      } catch (Exception e) {
+        e.printStackTrace();
+      }
+    }
+  }
+
+  private void drawHardwareBuffer(Canvas canvas, HardwareBuffer hardwareBuffer) {
+    // On Android Q+, we can create a Bitmap from HardwareBuffer
+    try {
+      // Create or reuse bitmap with matching dimensions
+      if (mCachedBitmap == null ||
+        mCachedBitmap.getWidth() != hardwareBuffer.getWidth() ||
+        mCachedBitmap.getHeight() != hardwareBuffer.getHeight()) {
+
+        if (mCachedBitmap != null) {
+          mCachedBitmap.recycle();
+        }
+
+        // Create a hardware-backed Bitmap from the HardwareBuffer
+        mCachedBitmap = Bitmap.wrapHardwareBuffer(hardwareBuffer, null);
+      } else {
+        // Reuse existing bitmap and update with new HardwareBuffer content
+        mCachedBitmap = Bitmap.wrapHardwareBuffer(hardwareBuffer, null);
+      }
+
+      if (mCachedBitmap != null) {
+        // Draw the bitmap to canvas
+        canvas.drawBitmap(mCachedBitmap, 0, 0, mPaint);
+      }
+    } catch (Exception e) {
+      e.printStackTrace();
+      // Fallback to Image-based rendering
+      drawImageAsBitmap(canvas, mCurrentImage);
+    }
+  }
+
+  private void drawImageAsBitmap(Canvas canvas, Image image) {
+    // Fallback method: manually convert Image to Bitmap
+    if (image.getFormat() != PixelFormat.RGBA_8888) {
+      return;
+    }
+
+    Image.Plane[] planes = image.getPlanes();
+    if (planes.length == 0) {
+      return;
+    }
+
+    ByteBuffer buffer = planes[0].getBuffer();
+    int pixelStride = planes[0].getPixelStride();
+    int rowStride = planes[0].getRowStride();
+    int rowPadding = rowStride - pixelStride * image.getWidth();
+
+    // Create or reuse bitmap
+    int bitmapWidth = image.getWidth() + rowPadding / pixelStride;
+    if (mCachedBitmap == null ||
+      mCachedBitmap.getWidth() != bitmapWidth ||
+      mCachedBitmap.getHeight() != image.getHeight()) {
+
+      if (mCachedBitmap != null) {
+        mCachedBitmap.recycle();
+      }
+      mCachedBitmap = Bitmap.createBitmap(
+        bitmapWidth,
+        image.getHeight(),
+        Bitmap.Config.ARGB_8888
+      );
+    }
+
+    mCachedBitmap.copyPixelsFromBuffer(buffer);
+
+    // Draw only the valid portion (without padding)
+    Rect src = new Rect(0, 0, image.getWidth(), image.getHeight());
+    Rect dst = new Rect(0, 0, getWidth(), getHeight());
+    canvas.drawBitmap(mCachedBitmap, src, dst, mPaint);
+  }
+
+  private void cleanupImageReader() {
+    synchronized (mImageLock) {
+      if (mCurrentImage != null) {
+        mCurrentImage.close();
+        mCurrentImage = null;
+      }
+
+      if (mImageReader != null) {
+        mImageReader.close();
+        mImageReader = null;
+      }
+
+      if (mSurface != null) {
+        mSurface.release();
+        mSurface = null;
+      }
     }
   }
 
   @Override
   protected void onDetachedFromWindow() {
     super.onDetachedFromWindow();
-    mApi.surfaceDestroyed();
+
+    // Notify WebGPU that surface is being destroyed
+    if (mSurfaceCreated) {
+      mApi.surfaceDestroyed();
+      mSurfaceCreated = false;
+    }
+
+    // Clean up resources
+    cleanupImageReader();
+
+    if (mCachedBitmap != null) {
+      mCachedBitmap.recycle();
+      mCachedBitmap = null;
+    }
+  }
+
+  @Override
+  protected void onAttachedToWindow() {
+    super.onAttachedToWindow();
+
+    // Re-setup if we have valid dimensions
+    if (getWidth() > 0 && getHeight() > 0) {
+      setupImageReader(getWidth(), getHeight());
+    }
+  }
+
+  @Override
+  public void setAlpha(float alpha) {
+    super.setAlpha(alpha);
+    mPaint.setAlpha((int) (alpha * 255));
+    invalidate();
+  }
+
+  @Override
+  protected void onVisibilityChanged(@NonNull View changedView, int visibility) {
+    super.onVisibilityChanged(changedView, visibility);
+
+    if (visibility == VISIBLE && mSurface == null && getWidth() > 0 && getHeight() > 0) {
+      // Re-create surface if needed when becoming visible
+      setupImageReader(getWidth(), getHeight());
+    }
   }
 }

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

@@ -39,11 +39,11 @@ public class WebGPUView extends ReactViewGroup implements WebGPUAPI {
       }
       mTransparent = value;
       if (mTransparent) {
-        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
-          mView = new WebGPUAHBView(ctx, this);
-        } else {
+//        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+//          mView = new WebGPUAHBView(ctx, this);
+//        } else {
           mView = new WebGPUTextureView(ctx, this);
-        }
+//        }
       } else {
         mView = new WebGPUSurfaceView(ctx, this);
       }

package/apple/ApplePlatformContext.h

@@ -1,6 +1,7 @@
 #pragma once
 
 #include "PlatformContext.h"
+#include <string>
 
 namespace rnwgpu {
 

package/apple/RNWGUIKit.h

@@ -1,3 +1,6 @@
+#ifndef PACKAGES_WEBGPU_APPLE_RNWGUIKIT_H_
+#define PACKAGES_WEBGPU_APPLE_RNWGUIKIT_H_
+
 #if !TARGET_OS_OSX
 #import <UIKit/UIKit.h>
 #else
@@ -9,3 +12,5 @@ typedef UIView RNWGPlatformView;
 #else
 typedef NSView RNWGPlatformView;
 #endif
+
+#endif  // PACKAGES_WEBGPU_APPLE_RNWGUIKIT_H_

package/apple/platform/ThreadUtils.cpp

@@ -8,6 +8,7 @@
 #include "ThreadUtils.h"
 #include <pthread.h>
 #include <sstream>
+#include <string>
 #include <thread>
 
 namespace margelo {

package/cpp/WGPULogger.h

@@ -4,6 +4,7 @@
 
 #pragma once
 
+#include <cstdio>
 #include <jsi/jsi.h>
 #include <string>
 

package/cpp/dawn/dawn_proc_table.h

@@ -6,18 +6,11 @@
 
 // Note: Often allocated as a static global. Do not add a complex constructor.
 typedef struct DawnProcTable {
-    WGPUProcAdapterInfoFreeMembers adapterInfoFreeMembers;
-    WGPUProcAdapterPropertiesMemoryHeapsFreeMembers adapterPropertiesMemoryHeapsFreeMembers;
-    WGPUProcAdapterPropertiesSubgroupMatrixConfigsFreeMembers adapterPropertiesSubgroupMatrixConfigsFreeMembers;
     WGPUProcCreateInstance createInstance;
-    WGPUProcDawnDrmFormatCapabilitiesFreeMembers dawnDrmFormatCapabilitiesFreeMembers;
-    WGPUProcGetInstanceCapabilities getInstanceCapabilities;
+    WGPUProcGetInstanceFeatures getInstanceFeatures;
+    WGPUProcGetInstanceLimits getInstanceLimits;
+    WGPUProcHasInstanceFeature hasInstanceFeature;
     WGPUProcGetProcAddress getProcAddress;
-    WGPUProcSharedBufferMemoryEndAccessStateFreeMembers sharedBufferMemoryEndAccessStateFreeMembers;
-    WGPUProcSharedTextureMemoryEndAccessStateFreeMembers sharedTextureMemoryEndAccessStateFreeMembers;
-    WGPUProcSupportedFeaturesFreeMembers supportedFeaturesFreeMembers;
-    WGPUProcSupportedWGSLLanguageFeaturesFreeMembers supportedWGSLLanguageFeaturesFreeMembers;
-    WGPUProcSurfaceCapabilitiesFreeMembers surfaceCapabilitiesFreeMembers;
 
     WGPUProcAdapterCreateDevice adapterCreateDevice;
     WGPUProcAdapterGetFeatures adapterGetFeatures;
@@ -30,6 +23,13 @@ typedef struct DawnProcTable {
     WGPUProcAdapterAddRef adapterAddRef;
     WGPUProcAdapterRelease adapterRelease;
 
+    WGPUProcAdapterInfoFreeMembers adapterInfoFreeMembers;
+
+    WGPUProcAdapterPropertiesMemoryHeapsFreeMembers adapterPropertiesMemoryHeapsFreeMembers;
+
+    WGPUProcAdapterPropertiesSubgroupMatrixConfigsFreeMembers adapterPropertiesSubgroupMatrixConfigsFreeMembers;
+
+    WGPUProcBindGroupDestroy bindGroupDestroy;
     WGPUProcBindGroupSetLabel bindGroupSetLabel;
     WGPUProcBindGroupAddRef bindGroupAddRef;
     WGPUProcBindGroupRelease bindGroupRelease;
@@ -38,6 +38,7 @@ typedef struct DawnProcTable {
     WGPUProcBindGroupLayoutAddRef bindGroupLayoutAddRef;
     WGPUProcBindGroupLayoutRelease bindGroupLayoutRelease;
 
+    WGPUProcBufferCreateTexelView bufferCreateTexelView;
     WGPUProcBufferDestroy bufferDestroy;
     WGPUProcBufferGetConstMappedRange bufferGetConstMappedRange;
     WGPUProcBufferGetMappedRange bufferGetMappedRange;
@@ -94,6 +95,8 @@ typedef struct DawnProcTable {
     WGPUProcComputePipelineAddRef computePipelineAddRef;
     WGPUProcComputePipelineRelease computePipelineRelease;
 
+    WGPUProcDawnDrmFormatCapabilitiesFreeMembers dawnDrmFormatCapabilitiesFreeMembers;
+
     WGPUProcDeviceCreateBindGroup deviceCreateBindGroup;
     WGPUProcDeviceCreateBindGroupLayout deviceCreateBindGroupLayout;
     WGPUProcDeviceCreateBuffer deviceCreateBuffer;
@@ -245,6 +248,8 @@ typedef struct DawnProcTable {
     WGPUProcSharedBufferMemoryAddRef sharedBufferMemoryAddRef;
     WGPUProcSharedBufferMemoryRelease sharedBufferMemoryRelease;
 
+    WGPUProcSharedBufferMemoryEndAccessStateFreeMembers sharedBufferMemoryEndAccessStateFreeMembers;
+
     WGPUProcSharedFenceExportInfo sharedFenceExportInfo;
     WGPUProcSharedFenceAddRef sharedFenceAddRef;
     WGPUProcSharedFenceRelease sharedFenceRelease;
@@ -258,6 +263,14 @@ typedef struct DawnProcTable {
     WGPUProcSharedTextureMemoryAddRef sharedTextureMemoryAddRef;
     WGPUProcSharedTextureMemoryRelease sharedTextureMemoryRelease;
 
+    WGPUProcSharedTextureMemoryEndAccessStateFreeMembers sharedTextureMemoryEndAccessStateFreeMembers;
+
+    WGPUProcSupportedFeaturesFreeMembers supportedFeaturesFreeMembers;
+
+    WGPUProcSupportedInstanceFeaturesFreeMembers supportedInstanceFeaturesFreeMembers;
+
+    WGPUProcSupportedWGSLLanguageFeaturesFreeMembers supportedWGSLLanguageFeaturesFreeMembers;
+
     WGPUProcSurfaceConfigure surfaceConfigure;
     WGPUProcSurfaceGetCapabilities surfaceGetCapabilities;
     WGPUProcSurfaceGetCurrentTexture surfaceGetCurrentTexture;
@@ -267,6 +280,12 @@ typedef struct DawnProcTable {
     WGPUProcSurfaceAddRef surfaceAddRef;
     WGPUProcSurfaceRelease surfaceRelease;
 
+    WGPUProcSurfaceCapabilitiesFreeMembers surfaceCapabilitiesFreeMembers;
+
+    WGPUProcTexelBufferViewSetLabel texelBufferViewSetLabel;
+    WGPUProcTexelBufferViewAddRef texelBufferViewAddRef;
+    WGPUProcTexelBufferViewRelease texelBufferViewRelease;
+
     WGPUProcTextureCreateErrorView textureCreateErrorView;
     WGPUProcTextureCreateView textureCreateView;
     WGPUProcTextureDestroy textureDestroy;
@@ -278,7 +297,9 @@ typedef struct DawnProcTable {
     WGPUProcTextureGetSampleCount textureGetSampleCount;
     WGPUProcTextureGetUsage textureGetUsage;
     WGPUProcTextureGetWidth textureGetWidth;
+    WGPUProcTexturePin texturePin;
     WGPUProcTextureSetLabel textureSetLabel;
+    WGPUProcTextureUnpin textureUnpin;
     WGPUProcTextureAddRef textureAddRef;
     WGPUProcTextureRelease textureRelease;
 

package/cpp/dawn/native/D3D11Backend.h

@@ -32,6 +32,7 @@
 #include <wrl/client.h>
 
 #include <memory>
+#include <optional>
 
 #include "dawn/native/D3DBackend.h"
 
@@ -61,9 +62,14 @@ struct DAWN_NATIVE_EXPORT SharedTextureMemoryD3D11Texture2DDescriptor : wgpu::Ch
     // 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
+    // Notes:
+    // - This flag is not relevant if the feature SharedFenceDXGISharedHandle is disabled/not
     // supported.
-    bool requiresEndAccessFence = true;
+    // - This flag if present will override the requiresEndAccessFence flag in
+    // SharedTextureMemoryD3D11BeginState
+    // TODO(chromium:335003893): This flag is deprecated. Remove it once clients are updated to use
+    // SharedTextureMemoryD3D11BeginState's requiresEndAccessFence.
+    std::optional<bool> requiresEndAccessFence;
 };
 
 }  // namespace dawn::native::d3d11

package/cpp/dawn/native/D3DBackend.h

@@ -30,7 +30,6 @@
 
 #include <dxgi1_4.h>
 #include <webgpu/webgpu_cpp_chained_struct.h>
-#include <windows.h>
 #include <wrl/client.h>
 
 #include <memory>
@@ -40,8 +39,6 @@
 
 namespace dawn::native::d3d {
 
-class ExternalImageDXGIImpl;
-
 DAWN_NATIVE_EXPORT Microsoft::WRL::ComPtr<IDXGIAdapter> GetDXGIAdapter(WGPUAdapter adapter);
 
 // Can be chained in WGPURequestAdapterOptions

package/cpp/dawn/native/DawnNative.h

@@ -340,6 +340,8 @@ DAWN_NATIVE_EXPORT MemoryUsageInfo ComputeEstimatedMemoryUsageInfo(WGPUDevice de
 struct DAWN_NATIVE_EXPORT AllocatorMemoryInfo {
     uint64_t totalUsedMemory = 0;
     uint64_t totalAllocatedMemory = 0;
+    uint64_t totalLazyAllocatedMemory = 0;
+    uint64_t totalLazyUsedMemory = 0;
 };
 DAWN_NATIVE_EXPORT AllocatorMemoryInfo GetAllocatorMemoryInfo(WGPUDevice device);
 
@@ -352,6 +354,8 @@ DAWN_NATIVE_EXPORT bool ReduceMemoryUsage(WGPUDevice device);
 // caches, etc.
 DAWN_NATIVE_EXPORT void PerformIdleTasks(const wgpu::Device& device);
 
+DAWN_NATIVE_EXPORT bool IsDeviceLost(WGPUDevice device);
+
 }  // namespace dawn::native
 
 #endif  // INCLUDE_DAWN_NATIVE_DAWNNATIVE_H_

package/cpp/dawn/platform/DawnPlatform.h

@@ -99,8 +99,9 @@ class DAWN_PLATFORM_EXPORT WorkerTaskPool {
 // in `namespace features`.
 enum class Features {
     kWebGPUUseDXC,
-    kWebGPUUseTintIR,
     kWebGPUUseVulkanMemoryModel,
+    kWebGPUEnableRangeAnalysisForRobustness,
+    kWebGPUUseSpirv14,
 };
 
 class DAWN_PLATFORM_EXPORT Platform {