react-native-webgpu 0.15.1 → 0.16.0

package/android/CMakeLists.txt

@@ -46,6 +46,8 @@ add_library(${PACKAGE_NAME} SHARED
     ../cpp/rnwgpu/api/GPUSharedFence.cpp
     ../cpp/rnwgpu/api/GPUSharedTextureMemory.cpp
     ../cpp/rnwgpu/api/GPUExternalTexture.cpp
+    ../cpp/rnwgpu/api/GPUNativeBufferWrapper.cpp
+    ../cpp/rnwgpu/api/NativeFrameImport.cpp
     ../cpp/rnwgpu/api/GPURenderBundleEncoder.cpp
     ../cpp/rnwgpu/api/GPURenderPassEncoder.cpp
     ../cpp/rnwgpu/api/GPURenderPipeline.cpp
@@ -96,6 +98,8 @@ if(ReactAndroid_VERSION_MINOR GREATER_EQUAL 76)
             log
             jnigraphics
             android
+            # sync_merge, for the one fence endAccess() returns
+            sync
             fbjni::fbjni
             ReactAndroid::jsi
             ReactAndroid::reactnative
@@ -108,6 +112,7 @@ else()
         log
         jnigraphics
         android
+        sync
         fbjni::fbjni
         ReactAndroid::jsi
         ReactAndroid::reactnativejni

package/android/cpp/cpp-adapter.cpp

@@ -1,7 +1,11 @@
 #include <unistd.h>
 
+#include <atomic>
+#include <chrono>
+#include <cstdint>
 #include <cstring>
 #include <memory>
+#include <mutex>
 #include <string>
 #include <unordered_map>
 #include <utility>
@@ -156,9 +160,131 @@ extern "C" JNIEXPORT void JNICALL Java_com_webgpu_WebGPUView_onSurfaceChanged(
   }
 }
 
+namespace {
+
+// Weak handle on a Java view and one of its no-argument methods, for native
+// threads to call into it: the fence waiter wakes a WebGPUHardwareBufferView
+// when a frame is ready, the presenting thread tells a SurfaceView it is
+// animating (AnimationReporter). Holding the view weakly means a view that RN
+// has dropped is not kept alive by a SurfaceInfo that outlives it (the
+// registry keeps the SurfaceInfo until onDropViewInstance).
+struct WeakViewCall {
+  jweak view = nullptr;
+  jmethodID method = nullptr;
+
+  WeakViewCall(JNIEnv *env, jobject thiz, const char *methodName) {
+    view = env->NewWeakGlobalRef(thiz);
+    jclass cls = env->GetObjectClass(thiz);
+    method = env->GetMethodID(cls, methodName, "()V");
+    env->DeleteLocalRef(cls);
+  }
+
+  ~WeakViewCall() {
+    // May run on any thread; ThreadScope attaches if needed.
+    facebook::jni::ThreadScope scope;
+    JNIEnv *env = facebook::jni::Environment::current();
+    if (env != nullptr && view != nullptr) {
+      env->DeleteWeakGlobalRef(view);
+    }
+  }
+
+  // Called on a native thread, outside the SurfaceInfo locks.
+  void operator()() const {
+    facebook::jni::ThreadScope scope;
+    JNIEnv *env = facebook::jni::Environment::current();
+    if (env == nullptr || method == nullptr) {
+      return;
+    }
+    jobject local = env->NewLocalRef(view);
+    if (local == nullptr) {
+      return; // the view was garbage collected
+    }
+    env->CallVoidMethod(local, method);
+    if (env->ExceptionCheck()) {
+      env->ExceptionClear();
+    }
+    env->DeleteLocalRef(local);
+  }
+};
+
+// Tells a SurfaceView it starts animating, for its refresh rate vote
+// (WebGPUView.onAnimating), from the frames presented to its surface. A call
+// into Java on the render path costs a JNI transition and attaches a presenting
+// thread the JVM doesn't know for the length of the call, so there is one call
+// per animation: the first frame presented right after its predecessor calls,
+// the frames after it only record the time. The view polls that time from the
+// main thread (releaseIfIdle) and, once the animation has stopped, takes its
+// vote back and re-arms the call for the next animation. Lock-free, since it
+// runs on every present.
+class AnimationReporter {
+public:
+  AnimationReporter(JNIEnv *env, jobject view)
+      : _onAnimating(env, view, "onAnimating") {}
+
+  void onFramePresented() {
+    const int64_t now = nowNanos();
+    const int64_t previous = _lastPresent.exchange(now);
+    if (now - previous > kAnimatingIntervalNanos) {
+      return;
+    }
+    _lastAnimating.store(now);
+    if (!_reported.exchange(true)) {
+      _onAnimating();
+    }
+  }
+
+  // Main thread. Returns how much longer the animation must stay stopped
+  // before it counts as idle, or 0 once it has: the next animating frame then
+  // calls into Java again.
+  int64_t releaseIfIdle(int64_t idleAfterNanos) {
+    const int64_t idle = nowNanos() - _lastAnimating.load();
+    if (idle < idleAfterNanos) {
+      return idleAfterNanos - idle;
+    }
+    _reported.store(false);
+    return 0;
+  }
+
+private:
+  // Presents this close together are an animation (faster than 40 fps).
+  static constexpr int64_t kAnimatingIntervalNanos = 25'000'000;
+
+  static int64_t nowNanos() {
+    return std::chrono::duration_cast<std::chrono::nanoseconds>(
+               std::chrono::steady_clock::now().time_since_epoch())
+        .count();
+  }
+
+  WeakViewCall _onAnimating;
+  // INT64_MIN / 2 rather than a sentinel: the first present is never "right
+  // after" it, and the subtractions above don't overflow.
+  std::atomic<int64_t> _lastPresent{INT64_MIN / 2};
+  std::atomic<int64_t> _lastAnimating{INT64_MIN / 2};
+  // Java has been told about the current animation.
+  std::atomic<bool> _reported{false};
+};
+
+// The reporters by contextId, for WebGPUView.releaseFrameRateVoteIfIdle. The
+// surface callbacks and the idle check all run on the main thread; the lock
+// only guards against a caller that doesn't.
+std::mutex animationReportersMutex;
+std::unordered_map<int, std::shared_ptr<AnimationReporter>> animationReporters;
+
+void setAnimationReporter(int contextId,
+                          std::shared_ptr<AnimationReporter> reporter) {
+  std::lock_guard<std::mutex> lock(animationReportersMutex);
+  if (reporter) {
+    animationReporters[contextId] = std::move(reporter);
+  } else {
+    animationReporters.erase(contextId);
+  }
+}
+
+} // namespace
+
 extern "C" JNIEXPORT void JNICALL Java_com_webgpu_WebGPUView_onSurfaceCreate(
     JNIEnv *env, jobject thiz, jobject jSurface, jint contextId, jfloat width,
-    jfloat height) {
+    jfloat height, jboolean reportAnimation) {
   if (manager == nullptr) {
     return;
   }
@@ -179,6 +305,17 @@ extern "C" JNIEXPORT void JNICALL Java_com_webgpu_WebGPUView_onSurfaceCreate(
       surface, [](void *nativeSurface) {
         ANativeWindow_release(static_cast<ANativeWindow *>(nativeSurface));
       });
+  // A SurfaceView asks to hear when it animates, for its refresh rate vote
+  // (WebGPUView.onAnimating).
+  if (reportAnimation) {
+    auto reporter = std::make_shared<AnimationReporter>(env, thiz);
+    setAnimationReporter(contextId, reporter);
+    info->setFramePresentedCallback(
+        [reporter]() { reporter->onFramePresented(); });
+  } else {
+    setAnimationReporter(contextId, nullptr);
+    info->setFramePresentedCallback(nullptr);
+  }
   // The attach is adopted at the next frame boundary by the rendering thread;
   // schedule a flush so contexts that are not currently rendering still pick
   // it up (and present their last offscreen frame).
@@ -188,20 +325,41 @@ extern "C" JNIEXPORT void JNICALL Java_com_webgpu_WebGPUView_onSurfaceCreate(
 extern "C" JNIEXPORT void JNICALL
 Java_com_webgpu_WebGPUView_switchToOffscreenSurface(JNIEnv *env, jobject thiz,
                                                     jint contextId) {
+  setAnimationReporter(contextId, nullptr);
   auto &registry = rnwgpu::SurfaceRegistry::getInstance();
   if (auto info = registry.getSurfaceInfo(contextId)) {
+    info->setFramePresentedCallback(nullptr);
     info->switchToOffscreen();
   }
 }
 
+// See AnimationReporter::releaseIfIdle; 0 when the surface reports nothing.
+extern "C" JNIEXPORT jlong JNICALL
+Java_com_webgpu_WebGPUView_releaseFrameRateVoteIfIdle(JNIEnv *env, jobject thiz,
+                                                      jint contextId,
+                                                      jlong idleAfterNanos) {
+  std::shared_ptr<AnimationReporter> reporter;
+  {
+    std::lock_guard<std::mutex> lock(animationReportersMutex);
+    auto it = animationReporters.find(contextId);
+    if (it == animationReporters.end()) {
+      return 0;
+    }
+    reporter = it->second;
+  }
+  return static_cast<jlong>(reporter->releaseIfIdle(idleAfterNanos));
+}
+
 extern "C" JNIEXPORT void JNICALL Java_com_webgpu_WebGPUView_onViewDestroyed(
     JNIEnv *env, jobject thiz, jint contextId) {
   // The view dies with its Canvas (contextIds are never reused), so view
   // teardown retires the registry entry. The JS-side cleanup
   // (RNWebGPU.destroyContext) only handles entries that never had a native
   // surface; see RNWebGPU::destroyContext for the ownership split.
+  setAnimationReporter(contextId, nullptr);
   auto &registry = rnwgpu::SurfaceRegistry::getInstance();
   if (auto info = registry.getSurfaceInfo(contextId)) {
+    info->setFramePresentedCallback(nullptr);
     info->detachSurface();
   }
   registry.removeSurfaceInfo(contextId);
@@ -210,53 +368,6 @@ extern "C" JNIEXPORT void JNICALL Java_com_webgpu_WebGPUView_onViewDestroyed(
 // --- WebGPUHardwareBufferView (AHB-pool presentation)
 // ---------------------------------
 
-namespace {
-
-// Weak handle on a WebGPUHardwareBufferView used by the native fence waiter to
-// wake the UI thread when a frame is ready. Holding it weakly means a view that
-// RN has dropped is not kept alive by a SurfaceInfo that outlives it (the
-// registry keeps the SurfaceInfo until onDropViewInstance).
-struct HardwareBufferViewWaker {
-  jweak view = nullptr;
-  jmethodID onFrameReady = nullptr;
-
-  HardwareBufferViewWaker(JNIEnv *env, jobject thiz) {
-    view = env->NewWeakGlobalRef(thiz);
-    jclass cls = env->GetObjectClass(thiz);
-    onFrameReady = env->GetMethodID(cls, "onNativeFrameReady", "()V");
-    env->DeleteLocalRef(cls);
-  }
-
-  ~HardwareBufferViewWaker() {
-    // May run on the waiter or JS thread; ThreadScope attaches if needed.
-    facebook::jni::ThreadScope scope;
-    JNIEnv *env = facebook::jni::Environment::current();
-    if (env != nullptr && view != nullptr) {
-      env->DeleteWeakGlobalRef(view);
-    }
-  }
-
-  // Called on the waiter thread, outside the pool lock.
-  void operator()() const {
-    facebook::jni::ThreadScope scope;
-    JNIEnv *env = facebook::jni::Environment::current();
-    if (env == nullptr || onFrameReady == nullptr) {
-      return;
-    }
-    jobject local = env->NewLocalRef(view);
-    if (local == nullptr) {
-      return; // the view was garbage collected
-    }
-    env->CallVoidMethod(local, onFrameReady);
-    if (env->ExceptionCheck()) {
-      env->ExceptionClear();
-    }
-    env->DeleteLocalRef(local);
-  }
-};
-
-} // namespace
-
 // Turn on pool mode for this context. dpW/dpH is the canvas-client (dp) size;
 // the native pool buffers are sized from the canvas drawing buffer lazily.
 extern "C" JNIEXPORT void JNICALL
@@ -267,7 +378,7 @@ Java_com_webgpu_WebGPUHardwareBufferView_nEnablePool(JNIEnv *env, jobject thiz,
   auto info = registry.getSurfaceInfoOrCreate(
       contextId, rnwgpu::WebGPURuntime::shared().instance(),
       static_cast<int>(dpW), static_cast<int>(dpH));
-  auto waker = std::make_shared<HardwareBufferViewWaker>(env, thiz);
+  auto waker = std::make_shared<WeakViewCall>(env, thiz, "onNativeFrameReady");
   info->setPoolFrameReadyCallback([waker]() { (*waker)(); });
   info->enablePool(static_cast<int>(dpW), static_cast<int>(dpH));
 }

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

@@ -0,0 +1,196 @@
+package com.webgpu;
+
+import android.os.Build;
+import android.os.Handler;
+import android.os.Looper;
+import android.util.Log;
+import android.view.Display;
+import android.view.Surface;
+import android.view.View;
+
+import androidx.annotation.Nullable;
+
+/**
+ * Votes the display's refresh rate for a SurfaceView canvas while it animates.
+ *
+ * A SurfaceView is composited in a layer of its own, outside the window that
+ * votes for the app's views, so SurfaceFlinger picks the layer's refresh rate
+ * from its present history alone: a canvas drawing every frame on a display
+ * idling at 60 Hz looks like 60 Hz content and never gets more. Since Android
+ * 11 a layer can say what it wants with Surface.setFrameRate. Once the canvas
+ * presents frames back to back, this asks for the highest rate the display can
+ * switch to seamlessly, as the window does for its own views, and takes the
+ * vote back once the animation stops, whether the canvas stops drawing or
+ * drops back to a few redraws a second: a layer with a vote counts as active
+ * for SurfaceFlinger even when it no longer draws.
+ *
+ * Native code tells onAnimating() once per animation, on the thread that
+ * presents (the JS thread, the Reanimated UI runtime or a worklet runtime),
+ * and the vote is cast right there, with no hop to a main thread that may be
+ * busy. The rate is resolved ahead of time on the main thread, where the
+ * view's display can be read. The idle check runs on the main thread and asks
+ * native code how long ago the canvas last animated; once it has stopped, it
+ * takes the vote back and native code calls onAnimating() again at the next
+ * animation. The lock only guards the state: the binder calls
+ * (Surface.setFrameRate) are made outside it.
+ */
+final class SurfaceFrameRateVote {
+  private static final String TAG = "SurfaceFrameRateVote";
+
+  // The vote is taken back once the canvas has not animated for this long,
+  // whether it stops drawing or drops back to a few redraws a second. Native
+  // code decides what animating means (presents faster than 40 fps, see
+  // AnimationReporter in cpp-adapter.cpp). The threshold is absolute rather
+  // than relative to the current refresh rate, so that a canvas that only
+  // manages 60 fps at 120 Hz keeps its vote rather than oscillating between
+  // the two rates. A canvas that redraws a few times a second never votes.
+  static final long IDLE_AFTER_NANOS = 500_000_000L;
+
+  /** Native side of the vote, see AnimationReporter in cpp-adapter.cpp. */
+  interface AnimationSource {
+    /**
+     * How much longer the canvas must stay still before it counts as idle,
+     * or 0 once it does, in which case the next animation calls
+     * onAnimating() again. Main thread.
+     */
+    long releaseIfIdle(long idleAfterNanos);
+  }
+
+  private final View mView;
+  private final AnimationSource mSource;
+  private final Handler mHandler = new Handler(Looper.getMainLooper());
+  private final Runnable mIdleCheck = this::checkIdle;
+
+  @Nullable
+  private Surface mSurface;
+  private boolean mVoting = false;
+  // The rate to ask for, resolved on the main thread; 0 when unknown, in
+  // which case animations don't vote until the next idle check resolves it.
+  private float mRefreshRate = 0f;
+
+  /** The view the surface belongs to; its display decides the rate to ask for. */
+  SurfaceFrameRateVote(View view, AnimationSource source) {
+    mView = view;
+    mSource = source;
+  }
+
+  /** The surface was created: it is voted on until detach(). Main thread. */
+  void attach(Surface surface) {
+    detach();
+    if (Build.VERSION.SDK_INT < Build.VERSION_CODES.R) {
+      return;
+    }
+    float refreshRate = resolveMaxRefreshRate();
+    synchronized (this) {
+      mSurface = surface;
+      mRefreshRate = refreshRate;
+    }
+  }
+
+  /**
+   * The canvas started animating (presenting frames back to back). Called
+   * once per animation, on the presenting thread.
+   */
+  void onAnimating() {
+    Surface surface;
+    float refreshRate;
+    synchronized (this) {
+      if (mSurface == null) {
+        return;
+      }
+      surface = mSurface;
+      refreshRate = mRefreshRate;
+      mVoting = refreshRate > 0;
+    }
+    // Whether it votes or not, the idle check re-arms native code once the
+    // animation stops.
+    mHandler.postDelayed(mIdleCheck, IDLE_AFTER_NANOS / 1_000_000);
+    if (refreshRate > 0) {
+      // This form only switches when the display can do so seamlessly, like
+      // the vote the window casts for its own views: a canvas animation is
+      // not worth a blank screen. Surface.setFrameRate is thread-safe.
+      setFrameRate(surface, refreshRate);
+    }
+  }
+
+  /** The surface is going away (it is still valid here) or the view left its window. Main thread. */
+  void detach() {
+    Surface surface;
+    boolean voting;
+    synchronized (this) {
+      surface = mSurface;
+      voting = mVoting;
+      mSurface = null;
+      mVoting = false;
+    }
+    mHandler.removeCallbacks(mIdleCheck);
+    // A vote cast concurrently on the presenting thread may land after this;
+    // it dies with the surface, which is going away.
+    if (surface != null && voting) {
+      setFrameRate(surface, 0);
+    }
+  }
+
+  private void checkIdle() {
+    long remainingNanos = mSource.releaseIfIdle(IDLE_AFTER_NANOS);
+    if (remainingNanos > 0) {
+      mHandler.postDelayed(mIdleCheck, (remainingNanos + 999_999) / 1_000_000);
+      return;
+    }
+    // Native code is re-armed: the next onAnimating() can only come after
+    // this point, so it doesn't race with the withdrawal below.
+    float refreshRate = resolveMaxRefreshRate();
+    Surface surface;
+    boolean voting;
+    synchronized (this) {
+      surface = mSurface;
+      voting = mVoting;
+      mVoting = false;
+      if (surface != null) {
+        // Follows the display the view is on, for the next animation.
+        mRefreshRate = refreshRate;
+      }
+    }
+    if (surface != null && voting) {
+      setFrameRate(surface, 0);
+    }
+  }
+
+  private static void setFrameRate(Surface surface, float refreshRate) {
+    if (!surface.isValid()) {
+      return;
+    }
+    try {
+      surface.setFrameRate(refreshRate, Surface.FRAME_RATE_COMPATIBILITY_DEFAULT);
+    } catch (RuntimeException e) {
+      Log.w(TAG, "Could not set the surface's frame rate, leaving it to the display", e);
+    }
+  }
+
+  // The highest rate a seamless switch from the current mode can reach, which
+  // is all the vote may ask for. Resolved when the vote is cast, so that it
+  // follows the display the view is on.
+  private float resolveMaxRefreshRate() {
+    Display display = mView.getDisplay();
+    if (display == null) {
+      return 0f;
+    }
+    Display.Mode current = display.getMode();
+    float maxRefreshRate = current.getRefreshRate();
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+      for (float refreshRate : current.getAlternativeRefreshRates()) {
+        maxRefreshRate = Math.max(maxRefreshRate, refreshRate);
+      }
+    } else {
+      // Android 11 does not tell which modes are a seamless switch away: the
+      // ones at the current resolution usually are.
+      for (Display.Mode mode : display.getSupportedModes()) {
+        if (mode.getPhysicalWidth() == current.getPhysicalWidth()
+            && mode.getPhysicalHeight() == current.getPhysicalHeight()) {
+          maxRefreshRate = Math.max(maxRefreshRate, mode.getRefreshRate());
+        }
+      }
+    }
+    return maxRefreshRate;
+  }
+}

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

@@ -24,6 +24,10 @@ public class WebGPUView extends ReactViewGroup implements WebGPUAPI {
   private boolean mAppliedZOrderOnTop;
   private WebGPUModule mModule;
   private View mView = null;
+  // Only a SurfaceView votes: a TextureView or HardwareBufferView is
+  // composited into the window, which votes for it.
+  private final SurfaceFrameRateVote mFrameRateVote = new SurfaceFrameRateVote(
+    this, idleAfterNanos -> releaseFrameRateVoteIfIdle(mContextId, idleAfterNanos));
 
   WebGPUView(Context context) {
     super(context);
@@ -134,7 +138,11 @@ public class WebGPUView extends ReactViewGroup implements WebGPUAPI {
     float density = getResources().getDisplayMetrics().density;
     float width = getWidth() / density;
     float height = getHeight() / density;
-    onSurfaceCreate(surface, mContextId, width, height);
+    boolean votesFrameRate = mAppliedKind == KIND_SURFACE_VIEW;
+    if (votesFrameRate) {
+      mFrameRateVote.attach(surface);
+    }
+    onSurfaceCreate(surface, mContextId, width, height, votesFrameRate);
   }
 
   @Override
@@ -147,9 +155,20 @@ public class WebGPUView extends ReactViewGroup implements WebGPUAPI {
 
   @Override
   public void surfaceOffscreen() {
+    // The surface is still valid here, so the vote can be taken back.
+    mFrameRateVote.detach();
     switchToOffscreenSurface(mContextId);
   }
 
+  /**
+   * Called from native (AnimationReporter in cpp-adapter.cpp) on the thread
+   * that presents to the surface, once per animation, only for a SurfaceView.
+   */
+  @DoNotStrip
+  void onAnimating() {
+    mFrameRateVote.onAnimating();
+  }
+
   @Override
   public int getContextId() {
     return mContextId;
@@ -160,15 +179,19 @@ public class WebGPUView extends ReactViewGroup implements WebGPUAPI {
    * view: the view dies with its Canvas, so it retires the registry entry.
    */
   public void destroy() {
+    mFrameRateVote.detach();
     onViewDestroyed(mContextId);
   }
 
+  // reportAnimation asks native to call onAnimating() when frames start being
+  // presented to this surface back to back.
   @DoNotStrip
   private native void onSurfaceCreate(
     Surface surface,
     int contextId,
     float width,
-    float height
+    float height,
+    boolean reportAnimation
   );
 
   @DoNotStrip
@@ -185,4 +208,8 @@ public class WebGPUView extends ReactViewGroup implements WebGPUAPI {
   @DoNotStrip
   private native void onViewDestroyed(int contextId);
 
+  // See SurfaceFrameRateVote.AnimationSource.
+  @DoNotStrip
+  private native long releaseFrameRateVoteIfIdle(int contextId, long idleAfterNanos);
+
 }

package/apple/ApplePlatformContext.h

@@ -2,6 +2,7 @@
 
 #include "PlatformContext.h"
 #include <functional>
+#include <memory>
 #include <string>
 
 namespace rnwgpu {

package/cpp/jsi/JSICache.cpp

@@ -2,8 +2,10 @@
 
 #include <algorithm>
 #include <iterator>
+#include <memory>
 #include <stdexcept>
 #include <string>
+#include <unordered_map>
 #include <utility>
 
 namespace rnwgpu {

package/cpp/jsi/NativeObject.h

@@ -14,6 +14,7 @@
 #include <typeindex>
 #include <unordered_map>
 #include <utility>
+#include <vector>
 
 #include "EnforceRange.h"
 #include "JSICache.h"
@@ -640,19 +641,26 @@ protected:
                 rt, std::move(result));
           }
         });
+    defineGetter(runtime, prototype, name, getterFunc);
+  }
 
-    // Use Object.defineProperty to create a proper getter
-    auto objectCtor = runtime.global().getPropertyAsObject(runtime, "Object");
-    auto defineProperty =
-        objectCtor.getPropertyAsFunction(runtime, "defineProperty");
-
-    jsi::Object descriptor(runtime);
-    descriptor.setProperty(runtime, "get", getterFunc);
-    descriptor.setProperty(runtime, "enumerable", true);
-    descriptor.setProperty(runtime, "configurable", true);
-
-    defineProperty.call(runtime, prototype,
-                        jsi::String::createFromUtf8(runtime, name), descriptor);
+  /**
+   * Install a getter whose native implementation builds the JS value itself,
+   * from the calling jsi::Runtime: for values no JSIConverter produces (null
+   * or a BigInt, say).
+   */
+  static void installGetter(jsi::Runtime &runtime, jsi::Object &prototype,
+                            const char *name,
+                            jsi::Value (Derived::*getter)(jsi::Runtime &)) {
+    auto getterFunc = jsi::Function::createFromHostFunction(
+        runtime, jsi::PropNameID::forUtf8(runtime, std::string("get_") + name),
+        0,
+        [getter](jsi::Runtime &rt, const jsi::Value &thisVal,
+                 const jsi::Value *args, size_t count) -> jsi::Value {
+          auto native = Derived::fromValue(rt, thisVal);
+          return (native.get()->*getter)(rt);
+        });
+    defineGetter(runtime, prototype, name, getterFunc);
   }
 
   /**
@@ -757,6 +765,22 @@ protected:
   }
 
 private:
+  // Use Object.defineProperty to create a proper getter
+  static void defineGetter(jsi::Runtime &runtime, jsi::Object &prototype,
+                           const char *name, const jsi::Function &getterFunc) {
+    auto objectCtor = runtime.global().getPropertyAsObject(runtime, "Object");
+    auto defineProperty =
+        objectCtor.getPropertyAsFunction(runtime, "defineProperty");
+
+    jsi::Object descriptor(runtime);
+    descriptor.setProperty(runtime, "get", getterFunc);
+    descriptor.setProperty(runtime, "enumerable", true);
+    descriptor.setProperty(runtime, "configurable", true);
+
+    defineProperty.call(runtime, prototype,
+                        jsi::String::createFromUtf8(runtime, name), descriptor);
+  }
+
   // Helper to call a method that takes the calling jsi::Runtime as its first
   // parameter, with JSI argument conversion for the rest and JSI conversion of
   // the result.

package/cpp/rnwgpu/RNWebGPUManager.cpp

@@ -22,6 +22,8 @@
 #include "GPUError.h"
 #include "GPUExternalTexture.h"
 #include "GPUInternalError.h"
+#include "GPUNativeBufferExternalTexture.h"
+#include "GPUNativeBufferTexture.h"
 #include "GPUOutOfMemoryError.h"
 #include "GPUPipelineLayout.h"
 #include "GPUQuerySet.h"
@@ -102,6 +104,8 @@ RNWebGPUManager::RNWebGPUManager(
   GPUDeviceLostInfo::installConstructor(*_jsRuntime);
   GPUError::installConstructor(*_jsRuntime);
   GPUExternalTexture::installConstructor(*_jsRuntime);
+  GPUNativeBufferExternalTexture::installConstructor(*_jsRuntime);
+  GPUNativeBufferTexture::installConstructor(*_jsRuntime);
   GPUInternalError::installConstructor(*_jsRuntime);
   GPUOutOfMemoryError::installConstructor(*_jsRuntime);
   GPUValidationError::installConstructor(*_jsRuntime);