react-native-skia 3.0.0 → 3.0.2

package/apple/SkiaView.h

@@ -0,0 +1,20 @@
+#pragma once
+
+#import <CoreFoundation/CoreFoundation.h>
+#if !TARGET_OS_OSX
+#import <UIKit/UIKit.h>
+#else
+#import <React/RCTUIKit.h>
+#endif // !TARGET_OS_OSX
+
+#import <React/RCTViewComponentView.h>
+
+/**
+ * The Fabric component behind <Canvas>, <SkiaPictureView> and
+ * <SkiaGraphiteView>: a CAMetalLayer presenting Graphite recordings on the
+ * display link. The frames are recorded by the native render thread pool
+ * (declarative content) or by JS (SkiaViewApi.makeGraphiteContext).
+ */
+@interface SkiaView : RCTViewComponentView
+
+@end

package/apple/SkiaView.mm

@@ -0,0 +1,210 @@
+#import "SkiaView.h"
+
+#import <QuartzCore/CADisplayLink.h>
+#import <QuartzCore/CATransaction.h>
+
+#import <React/RCTConversions.h>
+#import <React/RCTConvert.h>
+#import <React/RCTFabricComponentsPlugins.h>
+
+#import <react/renderer/components/rnskia/ComponentDescriptors.h>
+#import <react/renderer/components/rnskia/EventEmitters.h>
+#import <react/renderer/components/rnskia/Props.h>
+#import <react/renderer/components/rnskia/RCTComponentViewHelpers.h>
+
+#include <memory>
+
+#import "RNSkManager.h"
+#import "RNSkMetalCanvasProvider.h"
+#import "RNSkView.h"
+#import "RNSkiaModule.h"
+
+using namespace facebook::react;
+
+@implementation SkiaView {
+  // The native view and the layer it presents into. Both exist while the
+  // view is in the hierarchy (see willMoveToSuperview:).
+  std::shared_ptr<RNSkia::RNSkView> _view;
+  std::shared_ptr<RNSkMetalCanvasProvider> _provider;
+  // Owned by the module, which outlives its views (see finalizeUpdates:).
+  RNSkia::RNSkManager *_manager;
+  size_t _nativeId;
+  bool _highBitDepth;
+#if !TARGET_OS_OSX
+  CADisplayLink *_displayLink;
+#endif
+}
+
+- (instancetype)initWithFrame:(CGRect)frame {
+  if (self = [super initWithFrame:frame]) {
+    _manager = [RNSkiaModule latestActiveSkManager].get();
+    _nativeId = 0;
+    _highBitDepth = false;
+    static const auto defaultProps = std::make_shared<const SkiaViewProps>();
+    _props = defaultProps;
+  }
+  return self;
+}
+
+#pragma mark - Lifecycle
+
+// The native view lives while the view is in the hierarchy: it is created
+// when the view gets a superview and torn down when it leaves it, so that a
+// view kept around by a transition does not keep a surface.
+#if !TARGET_OS_OSX
+- (void)willMoveToSuperview:(UIView *)newSuperView {
+  [super willMoveToSuperview:newSuperView];
+#else
+- (void)viewWillMoveToSuperview:(NSView *)newSuperView {
+  [super viewWillMoveToSuperview:newSuperView];
+#endif // !TARGET_OS_OSX
+  if (newSuperView == nullptr || _view != nullptr || _manager == nullptr) {
+    return;
+  }
+  auto context = _manager->getPlatformContext();
+  _provider = std::make_shared<RNSkMetalCanvasProvider>(context);
+  _view = std::make_shared<RNSkia::RNSkView>(context, _provider);
+  [self.layer addSublayer:_provider->getLayer()];
+  if (_nativeId != 0) {
+    _manager->setSkiaView(_nativeId, _view);
+  }
+  _provider->setHighBitDepth(_highBitDepth);
+  __weak SkiaView *weakSelf = self;
+  _view->setFrameScheduler([weakSelf]() { [weakSelf scheduleFrame]; });
+}
+
+- (void)removeFromSuperview {
+  [self stopDisplayLink];
+  if (_view != nullptr) {
+    [_provider->getLayer() removeFromSuperlayer];
+    if (_nativeId != 0 && _manager != nullptr) {
+      _manager->setSkiaView(_nativeId, nullptr);
+    }
+    _view = nullptr;
+    _provider = nullptr;
+  }
+  [super removeFromSuperview];
+}
+
+- (void)dealloc {
+  [self stopDisplayLink];
+  [self unregisterView];
+}
+
+- (void)prepareForRecycle {
+  [super prepareForRecycle];
+  [self stopDisplayLink];
+  [self unregisterView];
+}
+
+- (void)finalizeUpdates:(RNComponentViewUpdateMask)updateMask {
+  [super finalizeUpdates:updateMask];
+  if (updateMask == RNComponentViewUpdateMaskAll) {
+    // this flag is only set when the view is inserted and we want to set the
+    // manager here since the view could be recycled or the app could be
+    // refreshed and we would have a stale manager then
+    _manager = [RNSkiaModule latestActiveSkManager].get();
+  }
+}
+
+- (void)unregisterView {
+  if (_manager != nullptr && _nativeId != 0) {
+    _manager->unregisterSkiaView(_nativeId);
+  }
+}
+
+#pragma mark - Frames
+
+// Presents on the display link: armed when a recording is submitted, paused
+// again once the queue is empty. macOS has no CADisplayLink on the minimum
+// deployment target, so frames are presented as soon as the main thread gets
+// to them there.
+- (void)scheduleFrame {
+#if !TARGET_OS_OSX
+  if (_displayLink == nil) {
+    _displayLink = [CADisplayLink displayLinkWithTarget:self
+                                               selector:@selector(onFrame:)];
+    [_displayLink addToRunLoop:[NSRunLoop mainRunLoop]
+                       forMode:NSRunLoopCommonModes];
+  }
+  _displayLink.paused = NO;
+#else
+  if (_view != nullptr) {
+    _view->presentFrame();
+  }
+#endif
+}
+
+#if !TARGET_OS_OSX
+- (void)onFrame:(CADisplayLink *)link {
+  if (_view == nullptr || !_view->presentFrame()) {
+    link.paused = YES;
+  }
+}
+#endif
+
+- (void)stopDisplayLink {
+#if !TARGET_OS_OSX
+  [_displayLink invalidate];
+  _displayLink = nil;
+#endif
+}
+
+#pragma mark - Render
+
+- (void)drawRect:(CGRect)rect {
+  // The OS asked for a draw: present what the view holds right away.
+  if (_view != nullptr) {
+    _view->redraw();
+  }
+}
+
+#pragma mark - Layout
+
+- (void)layoutSubviews {
+  [super layoutSubviews];
+  if (_provider != nullptr) {
+    [CATransaction begin];
+    [CATransaction setDisableActions:YES];
+    _provider->setSize(self.bounds.size.width, self.bounds.size.height);
+    [CATransaction commit];
+  }
+}
+
+#pragma mark - Props
+
++ (ComponentDescriptorProvider)componentDescriptorProvider {
+  return concreteComponentDescriptorProvider<SkiaViewComponentDescriptor>();
+}
+
+- (void)updateProps:(const Props::Shared &)props
+           oldProps:(const Props::Shared &)oldProps {
+  const auto &newProps = *std::static_pointer_cast<const SkiaViewProps>(props);
+  [super updateProps:props oldProps:oldProps];
+  int nativeId =
+      [[RCTConvert NSString:RCTNSStringFromString(newProps.nativeId)] intValue];
+  [self bindNativeId:nativeId];
+  [self setHighBitDepth:newProps.highBitDepth];
+  // opaque, androidSurfaceType and androidZOrderOnTop select the backing view
+  // on Android; a CAMetalLayer composites like any other layer.
+}
+
+// Not setNativeId:, which is the setter of RCTViewComponentView's nativeId
+// (the string Fabric assigns from the nativeID prop).
+- (void)bindNativeId:(size_t)nativeId {
+  _nativeId = nativeId;
+  if (_view != nullptr) {
+    _manager->registerSkiaView(nativeId, _view);
+  }
+}
+
+- (void)setHighBitDepth:(bool)highBitDepth {
+  _highBitDepth = highBitDepth;
+  if (_provider != nullptr) {
+    _provider->setHighBitDepth(highBitDepth);
+  }
+}
+
+@end
+
+Class<RCTComponentViewProtocol> SkiaViewCls(void) { return SkiaView.class; }

package/cpp/api/JsiSkApi.h

@@ -6,9 +6,7 @@
 
 #include "JsiSkNativeObjects.h"
 
-#ifdef SK_GRAPHITE
 #include "rnskia/RNDawnContext.h"
-#endif
 
 #include "JsiNativeBuffer.h"
 #include "JsiSkAnimatedImage.h"
@@ -167,19 +165,12 @@ public:
     return JsiSkColor::createCtor()(runtime, thisValue, arguments, count);
   }
   JSI_HOST_FUNCTION(getNativeDevice) {
-#ifdef SK_GRAPHITE
     // Raw WGPUDevice pointer of the Graphite device, as a BigInt. Consumed by
     // react-native-webgpu's importDevice(), which AddRefs it; the pointer
     // stays owned by DawnContext and is valid for the process lifetime.
     auto &dawnContext = DawnContext::getInstance();
     return jsi::BigInt::fromUint64(
-        runtime,
-        reinterpret_cast<uint64_t>(dawnContext.getWGPUDevice().Get()));
-#else
-    throw jsi::JSError(runtime,
-                       "getNativeDevice() is only available with the Graphite "
-                       "backend. Rebuild with SK_GRAPHITE enabled.");
-#endif
+        runtime, reinterpret_cast<uint64_t>(dawnContext.getWGPUDevice().Get()));
   }
 
   JSI_HOST_FUNCTION(Recorder) {
@@ -191,9 +182,7 @@ public:
   // property access returns a fresh JS wrapper around the shared factory
   // instance.
   std::shared_ptr<JsiSkSVGFactory> getSVGFactory() { return _svgFactory; }
-  std::shared_ptr<JsiSkImageFactory> getImageFactory() {
-    return _imageFactory;
-  }
+  std::shared_ptr<JsiSkImageFactory> getImageFactory() { return _imageFactory; }
   std::shared_ptr<JsiSkAnimatedImageFactory> getAnimatedImageFactory() {
     return _animatedImageFactory;
   }

package/cpp/api/JsiSkCanvas.h

@@ -24,9 +24,7 @@
 
 #include "utils/RNSkTypedArray.h"
 
-#if defined(SK_GRAPHITE)
 #include "rnskia/RNDawnContext.h"
-#endif
 
 #include <jsi/jsi.h>
 
@@ -42,10 +40,6 @@
 #include "include/core/SkSurface.h"
 #include "include/core/SkTypeface.h"
 
-#if !defined(SK_GRAPHITE)
-#include "include/gpu/ganesh/GrDirectContext.h"
-#endif
-
 #pragma clang diagnostic pop
 
 namespace RNSkia {
@@ -56,9 +50,7 @@ class JsiSkCanvas : public JsiSkNativeObject<JsiSkCanvas> {
 public:
   static constexpr const char *CLASS_NAME = "Canvas";
 
-  void drawPaint(std::shared_ptr<SkPaint> paint) {
-    _canvas->drawPaint(*paint);
-  }
+  void drawPaint(std::shared_ptr<SkPaint> paint) { _canvas->drawPaint(*paint); }
 
   void drawLine(double x1, double y1, double x2, double y2,
                 std::shared_ptr<SkPaint> paint) {
@@ -355,8 +347,7 @@ public:
 
   void clipPath(std::shared_ptr<SkPathBuilder> path, double op,
                 bool doAntiAlias) {
-    _canvas->clipPath(path->snapshot(), static_cast<SkClipOp>(op),
-                      doAntiAlias);
+    _canvas->clipPath(path->snapshot(), static_cast<SkClipOp>(op), doAntiAlias);
   }
 
   void clipRect(std::shared_ptr<SkRect> rect, double op, bool doAntiAlias) {
@@ -410,9 +401,7 @@ public:
 
   void concat(std::shared_ptr<SkMatrix> matrix) { _canvas->concat(*matrix); }
 
-  void drawPicture(sk_sp<SkPicture> picture) {
-    _canvas->drawPicture(picture);
-  }
+  void drawPicture(sk_sp<SkPicture> picture) { _canvas->drawPicture(picture); }
 
   JSI_HOST_FUNCTION(drawAtlas) {
     auto atlas = JsiSkImage::fromValue(runtime, arguments[0]);
@@ -518,7 +507,6 @@ public:
             .getArrayBuffer(runtime);
     auto bfrPtr = reinterpret_cast<void *>(buffer.data(runtime));
 
-#if defined(SK_GRAPHITE)
     // Graphite records draws lazily and offers no synchronous GPU readback. If
     // this canvas belongs to a surface, snap & submit its recording, snapshot
     // it to a CPU raster image and read from that (mirroring
@@ -540,7 +528,6 @@ public:
       }
       return dest;
     }
-#endif
 
     if (!_canvas->readPixels(*info, bfrPtr, bytesPerRow, srcX, srcY)) {
       return jsi::Value::null();
@@ -599,8 +586,7 @@ public:
     installMethod(runtime, prototype, "drawColor", &JsiSkCanvas::drawColor);
     installMethod(runtime, prototype, "clear", &JsiSkCanvas::clear);
     installMethod(runtime, prototype, "concat", &JsiSkCanvas::concat);
-    installMethod(runtime, prototype, "drawPicture",
-                  &JsiSkCanvas::drawPicture);
+    installMethod(runtime, prototype, "drawPicture", &JsiSkCanvas::drawPicture);
     installHostMethod(runtime, prototype, "drawAtlas", &JsiSkCanvas::drawAtlas);
     installHostMethod(runtime, prototype, "readPixels",
                       &JsiSkCanvas::readPixels);

package/cpp/api/JsiSkGraphiteContext.h

@@ -1,7 +1,5 @@
 #pragma once
 
-#if defined(SK_GRAPHITE)
-
 #include <memory>
 #include <utility>
 
@@ -10,7 +8,7 @@
 #include "JsiSkCanvas.h"
 #include "JsiSkGraphiteRecording.h"
 #include "JsiSkNativeObjects.h"
-#include "rnskia/RNSkGraphiteView.h"
+#include "rnskia/RNSkGraphiteTarget.h"
 
 namespace RNSkia {
 
@@ -78,5 +76,3 @@ private:
 };
 
 } // namespace RNSkia
-
-#endif // SK_GRAPHITE

package/cpp/api/JsiSkGraphiteRecording.h

@@ -1,14 +1,12 @@
 #pragma once
 
-#if defined(SK_GRAPHITE)
-
 #include <memory>
 #include <utility>
 
 #include <jsi/jsi.h>
 
 #include "JsiSkNativeObjects.h"
-#include "rnskia/RNSkGraphiteView.h"
+#include "rnskia/RNSkGraphiteTarget.h"
 
 namespace RNSkia {
 
@@ -40,5 +38,3 @@ public:
 };
 
 } // namespace RNSkia
-
-#endif // SK_GRAPHITE

package/cpp/api/JsiSkImage.h

@@ -17,12 +17,8 @@
 #include "JsiTextureInfo.h"
 #include "utils/RNSkTypedArray.h"
 
-#if defined(SK_GRAPHITE)
 #include "include/gpu/graphite/Context.h"
 #include "rnskia/RNDawnContext.h"
-#else
-#include "include/gpu/ganesh/GrDirectContext.h"
-#endif
 
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wdocumentation"
@@ -187,18 +183,7 @@ public:
                       ? static_cast<SkEncodedImageFormat>(*formatParam)
                       : SkEncodedImageFormat::kPNG;
     auto quality = qualityParam.has_value() ? *qualityParam : 100.0;
-    auto image = getObject();
-#if defined(SK_GRAPHITE)
-    image = DawnContext::getInstance().MakeRasterImage(image);
-#else
-    if (image->isTextureBacked()) {
-      auto grContext = getContext()->getDirectContext();
-      image = image->makeRasterImage(grContext);
-      if (!image) {
-        return nullptr;
-      }
-    }
-#endif
+    auto image = DawnContext::getInstance().MakeRasterImage(getObject());
     sk_sp<SkData> data;
 
     if (format == SkEncodedImageFormat::kJPEG) {
@@ -236,10 +221,10 @@ public:
         count >= 1 && !arguments[0].isUndefined() && !arguments[0].isNull()
             ? JsiOptional<double>(arguments[0].asNumber())
             : JsiOptional<double>();
-    JsiOptional<double> quality = count >= 2 && arguments[1].isNumber()
-                                      ? JsiOptional<double>(
-                                            arguments[1].asNumber())
-                                      : JsiOptional<double>();
+    JsiOptional<double> quality =
+        count >= 2 && arguments[1].isNumber()
+            ? JsiOptional<double>(arguments[1].asNumber())
+            : JsiOptional<double>();
     auto data = encodeImageData(format, quality);
     if (!data) {
       return jsi::Value::null();
@@ -310,38 +295,19 @@ public:
             .getArrayBuffer(runtime);
     auto bfrPtr = reinterpret_cast<void *>(buffer.data(runtime));
 
-#if defined(SK_GRAPHITE)
-    // Graphite offers no synchronous GPU readback, so fall back to a CPU raster
-    // copy of the image (a no-op when the image is already raster) and read the
-    // pixels from that. This matches the Ganesh behaviour for non-texture and
-    // texture-backed images alike.
+    // Graphite offers no synchronous GPU readback, so read from a CPU raster
+    // copy of the image (a no-op when the image is already raster).
     auto image = DawnContext::getInstance().MakeRasterImage(getObject());
     if (!image ||
         !image->readPixels(nullptr, info, bfrPtr, bytesPerRow, srcX, srcY)) {
       return jsi::Value::null();
     }
-#else
-    auto grContext = getContext()->getDirectContext();
-    if (!getObject()->readPixels(grContext, info, bfrPtr, bytesPerRow, srcX,
-                                 srcY)) {
-      return jsi::Value::null();
-    }
-#endif
     return dest;
   }
 
   std::variant<std::nullptr_t, std::shared_ptr<JsiSkImage>>
   makeNonTextureImage() {
-#if defined(SK_GRAPHITE)
     auto rasterImage = DawnContext::getInstance().MakeRasterImage(getObject());
-#else
-    auto grContext = getContext()->getDirectContext();
-    auto image = getObject();
-    if (!grContext) {
-      throw std::runtime_error("No GPU context available.");
-    }
-    auto rasterImage = image->makeRasterImage(grContext);
-#endif
     if (!rasterImage) {
       return nullptr;
     }

package/cpp/api/JsiSkImageFactory.h

@@ -13,9 +13,7 @@
 #include "JsiSkNativeObjects.h"
 #include "jsi/JsiPromises.h"
 
-#ifdef SK_GRAPHITE
 #include "rnskia/RNDawnContext.h"
-#endif
 
 namespace RNSkia {
 
@@ -109,7 +107,6 @@ public:
   // device: both packages link one Dawn and share one wgpu::Instance.
 
   JSI_HOST_FUNCTION(MakeImageFromNativeTexture) {
-#ifdef SK_GRAPHITE
     if (count < 1 || !arguments[0].isBigInt()) {
       throw std::runtime_error("MakeImageFromNativeTexture requires a "
                                "WGPUTexture pointer (BigInt), e.g. "
@@ -137,15 +134,9 @@ public:
     }
     return makeJsiObject(
         runtime, std::make_shared<JsiSkImage>(getContext(), std::move(image)));
-#else
-    throw std::runtime_error(
-        "MakeImageFromNativeTexture is only available with the Graphite "
-        "backend. Rebuild with SK_GRAPHITE enabled.");
-#endif
   }
 
   JSI_HOST_FUNCTION(MakeNativeTextureFromImage) {
-#ifdef SK_GRAPHITE
     if (count < 1) {
       throw std::runtime_error(
           "MakeNativeTextureFromImage requires an SkImage argument");
@@ -165,11 +156,6 @@ public:
     // releases it when the JS GPUTexture is destroyed.
     return jsi::BigInt::fromUint64(
         runtime, reinterpret_cast<uint64_t>(texture.MoveToCHandle()));
-#else
-    throw std::runtime_error(
-        "MakeNativeTextureFromImage is only available with the Graphite "
-        "backend. Rebuild with SK_GRAPHITE enabled.");
-#endif
   }
 
   size_t getMemoryPressure() override { return 1024; }

package/cpp/api/JsiSkSurface.h

@@ -15,15 +15,12 @@
 #include "JsiSkCanvas.h"
 #include "JsiSkImage.h"
 
-#if defined(SK_GRAPHITE)
 #include "rnskia/RNDawnContext.h"
-#endif
 
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wdocumentation"
 
 #include "include/core/SkSurface.h"
-#include "include/gpu/ganesh/GrDirectContext.h"
 
 #pragma clang diagnostic pop
 
@@ -87,7 +84,6 @@ public:
     // submitted work. Required before a native consumer on a different command
     // queue reads this surface's texture via getNativeTextureUnstable(). #3916
     bool sync = syncParam.has_value() && *syncParam;
-#if defined(SK_GRAPHITE)
     // A raster surface (e.g. Skia.Surface.Make) has no Graphite recorder;
     // only Graphite-backed surfaces need to snap and submit a recording.
     if (auto *recorder = surface->recorder()) {
@@ -96,11 +92,6 @@ public:
           recording.get(), sync ? skgpu::graphite::SyncToCpu::kYes
                                 : skgpu::graphite::SyncToCpu::kNo);
     }
-#else
-    if (auto dContext = GrAsDirectContext(surface->recordingContext())) {
-      dContext->flushAndSubmit(sync ? GrSyncCpu::kYes : GrSyncCpu::kNo);
-    }
-#endif
   }
 
   JSI_HOST_FUNCTION(makeImageSnapshot) {
@@ -113,14 +104,12 @@ public:
     } else {
       image = surface->makeImageSnapshot();
     }
-#if defined(SK_GRAPHITE)
     // A raster surface (e.g. Skia.Surface.Make) has no Graphite recorder; its
     // snapshot is already a valid CPU image, so skip the recording submit.
     if (auto *recorder = surface->recorder()) {
       auto recording = recorder->snap();
       DawnContext::getInstance().submitRecording(recording.get());
     }
-#endif
     if (count > 1 && arguments[1].isObject()) {
       auto jsiImage = getJsiObject<JsiSkImage>(runtime, arguments[1]);
       jsiImage->setObject(image);
@@ -173,11 +162,8 @@ public:
     size_t estimated = pixelBytes;
 
     auto canvas = surface->getCanvas();
-    const bool isGpuBacked =
-        surface->recordingContext() != nullptr ||
-        surface->recorder() != nullptr ||
-        (canvas && (canvas->recordingContext() != nullptr ||
-                    canvas->recorder() != nullptr));
+    const bool isGpuBacked = surface->recorder() != nullptr ||
+                             (canvas && canvas->recorder() != nullptr);
 
     if (isGpuBacked) {
       // Account for a resolved texture and depth/stencil attachments.

package/cpp/api/JsiSkSurfaceFactory.h

@@ -10,9 +10,7 @@
 
 #include "JsiSkSurface.h"
 
-#ifdef SK_GRAPHITE
 #include "rnskia/RNDawnContext.h"
-#endif
 
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wdocumentation"
@@ -68,7 +66,6 @@ public:
   // directly into a texture created on the shared device, so WebGPU can
   // sample what Skia drew without any copy.
   JSI_HOST_FUNCTION(MakeFromNativeTexture) {
-#ifdef SK_GRAPHITE
     if (count < 1 || !arguments[0].isBigInt()) {
       throw std::runtime_error("MakeFromNativeTexture requires a WGPUTexture "
                                "pointer (BigInt), e.g. texture.nativePointer");
@@ -91,11 +88,6 @@ public:
     }
     return makeJsiObject(runtime, std::make_shared<JsiSkSurface>(
                                       getContext(), std::move(surface)));
-#else
-    throw std::runtime_error(
-        "MakeFromNativeTexture is only available with the Graphite backend. "
-        "Rebuild with SK_GRAPHITE enabled.");
-#endif
   }
 
   size_t getMemoryPressure() override { return 2048; }

package/cpp/rnskia/RNDawnContext.h

@@ -144,6 +144,11 @@ public:
   }
 
   sk_sp<SkImage> MakeImageFromBuffer(void *buffer) {
+#if defined(__ANDROID__) && __ANDROID_API__ < 26
+    // AHardwareBuffer is only available from API 26
+    (void)buffer;
+    return nullptr;
+#else
 #ifdef __APPLE__
     wgpu::SharedTextureMemoryIOSurfaceDescriptor platformDesc;
     auto ioSurface = CVPixelBufferGetIOSurface((CVPixelBufferRef)buffer);
@@ -213,6 +218,7 @@ public:
       return nullptr;
     }
     return nullptr;
+#endif
   }
 
   // Create offscreen surface

package/cpp/rnskia/RNDawnInterop.cpp

@@ -1,5 +1,3 @@
-#ifdef SK_GRAPHITE
-
 #include "RNDawnContext.h"
 
 // Runtime discovery surface for react-native-webgpu.
@@ -15,5 +13,3 @@ extern "C" __attribute__((visibility("default"))) WGPUInstance
 rnskia_getWGPUInstance() {
   return RNSkia::DawnContext::getInstance().getWGPUInstance().Get();
 }
-
-#endif

package/cpp/rnskia/RNDawnUtils.h

@@ -137,7 +137,6 @@ requestDevice(dawn::native::Adapter &nativeAdapter,
 #endif
       "disable_lazy_clear_for_mapped_at_creation_buffer",
       "allow_unsafe_apis",
-      "use_user_defined_labels_in_backend",
       "disable_robustness",
   };
   wgpu::DawnTogglesDescriptor togglesDesc;

package/cpp/rnskia/RNDawnWindowContext.cpp

@@ -42,4 +42,14 @@ bool DawnWindowContext::presentRecordings(
   return success;
 }
 
+bool DawnWindowContext::presentImage(const sk_sp<SkImage> &image) {
+  auto surface = getSurface();
+  if (!surface) {
+    return false;
+  }
+  surface->getCanvas()->drawImage(image, 0, 0);
+  present();
+  return true;
+}
+
 } // namespace RNSkia

package/cpp/rnskia/RNDawnWindowContext.h

@@ -74,6 +74,10 @@ public:
   bool presentRecordings(
       const std::vector<skgpu::graphite::Recording *> &recordings);
 
+  // Draws an image at the origin of the current swapchain texture (on the
+  // window's own recorder) and presents it.
+  bool presentImage(const sk_sp<SkImage> &image);
+
   SkColorType getColorType() const { return _colorType; }
 
   // The texture description a deferred canvas must be recorded with to be