react-native-skia 3.0.0 → 3.0.2

package/cpp/rnskia/RNSkCanvasProvider.h

@@ -0,0 +1,221 @@
+#pragma once
+
+#include <functional>
+#include <memory>
+#include <utility>
+#include <vector>
+
+#include "RNDawnContext.h"
+#include "RNDawnUtils.h"
+#include "RNSkPlatformContext.h"
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdocumentation"
+
+#include "include/core/SkCanvas.h"
+#include "include/core/SkImage.h"
+#include "include/core/SkSurface.h"
+#include "include/gpu/graphite/Recording.h"
+#include "include/gpu/graphite/TextureInfo.h"
+#include "include/gpu/graphite/dawn/DawnGraphiteTypes.h"
+
+#pragma clang diagnostic pop
+
+namespace RNSkia {
+
+/**
+ * Describes the texture a recording is replayed onto: the pixel size and the
+ * format of a window (or offscreen) surface. A deferred canvas is recorded
+ * against this description, so it can be created before the surface itself
+ * exists.
+ */
+struct RNSkGraphiteTargetInfo {
+  int width = 0;
+  int height = 0;
+  SkColorType colorType = kUnknown_SkColorType;
+  skgpu::graphite::TextureInfo textureInfo;
+};
+
+/**
+ * The surface a view presents into: a platform window (a CAMetalLayer, an
+ * ANativeWindow) or an offscreen surface. It describes its target texture to
+ * whoever records for the view and replays their recordings onto it.
+ */
+class RNSkCanvasProvider {
+public:
+  virtual ~RNSkCanvasProvider() = default;
+
+  /** Width of the surface, in pixels. */
+  virtual int getWidth() = 0;
+
+  /** Height of the surface, in pixels. */
+  virtual int getHeight() = 0;
+
+  /**
+   Describes the current target texture. Safe to call from any thread;
+   returns false while there is no surface to describe.
+   */
+  virtual bool getTargetInfo(RNSkGraphiteTargetInfo *info) = 0;
+
+  /**
+   The size in pixels the surface will have, known from the platform layout
+   before the surface itself exists (on Android the surface only appears a
+   frame after the view is laid out). Safe to call from any thread; returns
+   false until the view is laid out. A frame recorded against this size is
+   presented as is once the surface appears, where one recorded against a
+   size derived from the layout in points could be off by a pixel and would
+   not cover the surface.
+   */
+  virtual bool getLayoutSize(int *width, int *height) { return false; }
+
+  /**
+   Replays the recordings, in order, onto the target texture and presents
+   it. Called on the thread that owns the surface. Returns false when the
+   surface cannot present right now (there is none, or the app is in the
+   background): nothing was consumed.
+   */
+  virtual bool presentRecordings(
+      const std::vector<skgpu::graphite::Recording *> &recordings) = 0;
+
+  /**
+   Draws an image at the origin of the target texture and presents it. Same
+   thread and return value as presentRecordings(). Used for a recording whose
+   size differs from the target's: it is replayed into a texture of its own
+   size first (see RNSkView::present).
+   */
+  virtual bool presentImage(const sk_sp<SkImage> &image) = 0;
+
+  /**
+   Installed by the view owning the provider: asks it for a frame when the
+   surface appears or changes size.
+   */
+  void setRequestRedraw(std::function<void()> requestRedraw) {
+    _requestRedraw = std::move(requestRedraw);
+  }
+
+protected:
+  void requestRedraw() {
+    if (_requestRedraw) {
+      _requestRedraw();
+    }
+  }
+
+private:
+  std::function<void()> _requestRedraw;
+};
+
+/**
+ * An offscreen surface the content of a view is replayed into for a snapshot.
+ */
+class RNSkOffscreenCanvasProvider : public RNSkCanvasProvider {
+public:
+  RNSkOffscreenCanvasProvider(
+      const std::shared_ptr<RNSkPlatformContext> &context, int width,
+      int height)
+      : _width(width), _height(height), _pd(context->getPixelDensity()),
+        _surface(context->makeOffscreenSurface(width, height)) {}
+
+  virtual ~RNSkOffscreenCanvasProvider() = default;
+
+  /** The canvas of the surface, in pixels; nullptr without a surface. */
+  SkCanvas *getCanvas() { return _surface ? _surface->getCanvas() : nullptr; }
+
+  /**
+   A GPU image of the surface, usable by any recorder of the context once
+   this returns; nullptr without a surface.
+   */
+  sk_sp<SkImage> makeImage() {
+    if (_surface == nullptr) {
+      return nullptr;
+    }
+    auto image = _surface->makeImageSnapshot();
+    // The snapshot is a copy task on the surface's recorder: submitted here,
+    // so that the image is complete for whoever draws it next.
+    if (auto *recorder = _surface->recorder()) {
+      DawnContext::getInstance().submitRecording(recorder->snap().get());
+    }
+    return image;
+  }
+
+  /**
+   Returns a snapshot of the current surface/canvas
+   */
+  sk_sp<SkImage> makeSnapshot(SkRect *bounds) {
+    if (_surface == nullptr) {
+      return nullptr;
+    }
+    sk_sp<SkImage> image;
+    if (bounds != nullptr) {
+      SkIRect b =
+          SkIRect::MakeXYWH(bounds->x() * _pd, bounds->y() * _pd,
+                            bounds->width() * _pd, bounds->height() * _pd);
+      image = _surface->makeImageSnapshot(b);
+    } else {
+      image = _surface->makeImageSnapshot();
+    }
+    // Only Graphite-backed surfaces have a recorder to snap/submit; a raster
+    // surface's snapshot is already a valid CPU image.
+    if (auto *recorder = _surface->recorder()) {
+      DawnContext::getInstance().submitRecording(recorder->snap().get());
+    }
+    return DawnContext::getInstance().MakeRasterImage(image);
+  }
+
+  int getWidth() override { return _width; }
+
+  int getHeight() override { return _height; }
+
+  bool getTargetInfo(RNSkGraphiteTargetInfo *info) override {
+    if (_surface == nullptr || _surface->recorder() == nullptr) {
+      return false;
+    }
+    // Graphite gives its render targets the sampled+renderable usage, a
+    // superset of what a deferred canvas asks for.
+    auto colorType = _surface->imageInfo().colorType();
+    info->width = _width;
+    info->height = _height;
+    info->colorType = colorType;
+    info->textureInfo = skgpu::graphite::TextureInfos::MakeDawn(
+        skgpu::graphite::DawnTextureInfo(
+            skgpu::graphite::SampleCount::k1, skgpu::Mipmapped::kNo,
+            DawnUtils::textureFormatForColorType(colorType),
+            DawnUtils::DefaultTargetUsage, wgpu::TextureAspect::All));
+    return true;
+  }
+
+  bool presentRecordings(
+      const std::vector<skgpu::graphite::Recording *> &recordings) override {
+    auto *recorder = _surface ? _surface->recorder() : nullptr;
+    if (recorder == nullptr) {
+      return false;
+    }
+    // A new surface clears itself in its first pass, which its own recorder
+    // only records when it next snaps. The recordings go straight to the
+    // context, so that clear would run after them and wipe them: record and
+    // submit it first (the explicit clear makes sure the pass is emitted).
+    if (!_cleared) {
+      _surface->getCanvas()->clear(SK_ColorTRANSPARENT);
+      DawnContext::getInstance().submitRecording(recorder->snap().get());
+      _cleared = true;
+    }
+    return DawnContext::getInstance().insertRecordings(recordings,
+                                                       _surface.get());
+  }
+
+  bool presentImage(const sk_sp<SkImage> &image) override {
+    if (_surface == nullptr) {
+      return false;
+    }
+    _surface->getCanvas()->drawImage(image, 0, 0);
+    return true;
+  }
+
+private:
+  int _width;
+  int _height;
+  float _pd;
+  sk_sp<SkSurface> _surface;
+  bool _cleared = false;
+};
+
+} // namespace RNSkia

package/cpp/rnskia/RNSkGraphiteProducer.cpp

@@ -1,15 +1,13 @@
 // Everything that needs a complete Recorder lives here rather than in
 // RNSkGraphiteProducer.h (which the view headers include on their own).
-#if defined(SK_GRAPHITE)
-
 #include "RNSkGraphiteProducer.h"
 
 #include <memory>
 #include <utility>
 
-#include "RNSkGraphiteView.h"
-#include "RNSkPictureView.h"
+#include "RNSkGraphiteTarget.h"
 #include "RNSkThreadPool.h"
+#include "api/recorder/DrawingCtx.h"
 #include "api/recorder/RNRecorder.h"
 #include "utils/RNSkLog.h"
 
@@ -20,6 +18,21 @@ namespace RNSkia {
 
 RNSkGraphiteProducer::~RNSkGraphiteProducer() = default;
 
+void RNSkGraphiteProducer::drawContent(SkCanvas *canvas, Recorder *recorder,
+                                       const sk_sp<SkPicture> &picture,
+                                       float pixelDensity) {
+  canvas->clear(SK_ColorTRANSPARENT);
+  canvas->save();
+  canvas->scale(pixelDensity, pixelDensity);
+  if (recorder != nullptr) {
+    DrawingCtx ctx(canvas);
+    recorder->play(&ctx);
+  } else if (picture != nullptr) {
+    canvas->drawPicture(picture);
+  }
+  canvas->restore();
+}
+
 void RNSkGraphiteProducer::setTarget(
     std::shared_ptr<RNSkGraphiteTarget> target) {
   std::lock_guard<std::mutex> lock(_mutex);
@@ -67,6 +80,18 @@ bool RNSkGraphiteProducer::hasContent() {
   return _recorder != nullptr || _picture != nullptr;
 }
 
+bool RNSkGraphiteProducer::applyUpdatesTo(
+    const std::shared_ptr<Recorder> &recorder, jsi::Runtime &runtime,
+    double recorderId, const jsi::Array &values) {
+  if (recorder == nullptr || recorder->id != recorderId) {
+    return false;
+  }
+  // The values are written into the commands by the next replay, which the
+  // caller schedules: the mapper never waits for a draw.
+  recorder->readUpdates(runtime, values);
+  return true;
+}
+
 bool RNSkGraphiteProducer::applyUpdates(jsi::Runtime &runtime,
                                         double recorderId,
                                         const jsi::Array &values) {
@@ -75,13 +100,12 @@ bool RNSkGraphiteProducer::applyUpdates(jsi::Runtime &runtime,
     std::lock_guard<std::mutex> lock(_mutex);
     recorder = _recorder;
   }
-  if (recorder == nullptr || recorder->id != recorderId) {
-    return false;
-  }
   // Outside the lock: a commit replacing the recorder must not wait for the
   // read. Should it land while this runs, the values go into the retired
   // recorder and the commit's own frame draws the new one.
-  recorder->readUpdates(runtime, values);
+  if (!applyUpdatesTo(recorder, runtime, recorderId, values)) {
+    return false;
+  }
   std::lock_guard<std::mutex> lock(_mutex);
   _dirty = true;
   kickLocked();
@@ -142,14 +166,14 @@ void RNSkGraphiteProducer::produce() {
         // The deferred canvas already draws in points.
         drawContent(canvas, recorder.get(), picture, /* pixelDensity= */ 1.0f);
       } catch (const std::exception &e) {
-        RNSkLogger::logToConsole(
-            "GraphiteCanvas: replaying the scene failed: %s", e.what());
+        RNSkLogger::logToConsole("Canvas: replaying the scene failed: %s",
+                                 e.what());
       }
       try {
         recording = target->finishRecording();
       } catch (const std::exception &e) {
-        RNSkLogger::logToConsole(
-            "GraphiteCanvas: recording the frame failed: %s", e.what());
+        RNSkLogger::logToConsole("Canvas: recording the frame failed: %s",
+                                 e.what());
       }
     }
   }
@@ -185,5 +209,3 @@ void RNSkGraphiteProducer::renderInto(SkCanvas *canvas, float pixelDensity) {
 }
 
 } // namespace RNSkia
-
-#endif // SK_GRAPHITE

package/cpp/rnskia/RNSkGraphiteProducer.h

@@ -1,7 +1,5 @@
 #pragma once
 
-#if defined(SK_GRAPHITE)
-
 #include <memory>
 #include <mutex>
 
@@ -20,9 +18,9 @@ class Recorder;
 class RNSkGraphiteTarget;
 
 /**
- * Records the declarative content of a SkiaGraphiteView (a Recorder handed
- * over by <GraphiteCanvas>, or a picture) into Graphite recordings, on the
- * render thread pool.
+ * Records the declarative content of a view (a Recorder handed over by
+ * <Canvas>, or a picture) into Graphite recordings, on the render thread
+ * pool.
  *
  * Three threads meet here. The JS thread hands over the content. A Reanimated
  * mapper, on the UI runtime, reads the shared values into the recorder's
@@ -50,7 +48,11 @@ public:
   /**
    Takes ownership of the recorder (or releases it with nullptr). A recording
    without shared values is played once into a picture: nothing will ever
-   update it, and drawing a picture is cheaper than replaying commands.
+   update it, and drawing a picture is cheaper than replaying commands. The
+   recorder is owned here rather than by a JS wrapper: its commands hold
+   every native resource the canvas draws (images, pictures, paths), and
+   tying their lifetime to the garbage collector of a runtime that rarely
+   allocates (the UI runtime) kept them resident long after unmount.
    */
   void setRecorder(std::shared_ptr<Recorder> recorder);
 
@@ -73,6 +75,14 @@ public:
   bool applyUpdates(jsi::Runtime &runtime, double recorderId,
                     const jsi::Array &values);
 
+  /**
+   Same as applyUpdates(), for a recording that no view owns yet (one queued
+   in the view registry until its view registers).
+   */
+  static bool applyUpdatesTo(const std::shared_ptr<Recorder> &recorder,
+                             jsi::Runtime &runtime, double recorderId,
+                             const jsi::Array &values);
+
   /**
    Marks the content dirty and schedules a frame if one can start. Returns
    whether a frame is coming at all: there is content and a target to record
@@ -90,6 +100,13 @@ public:
   void renderInto(SkCanvas *canvas, float pixelDensity);
 
 private:
+  /**
+   Replays declarative content, a recorder if there is one, else a picture,
+   into a canvas: clears it and applies the density.
+   */
+  static void drawContent(SkCanvas *canvas, Recorder *recorder,
+                          const sk_sp<SkPicture> &picture, float pixelDensity);
+
   /**
    Swaps the content under the lock and releases the previous one outside of
    it: the recorder's destructor hands the commands to the main thread, and a
@@ -112,5 +129,3 @@ private:
 };
 
 } // namespace RNSkia
-
-#endif // SK_GRAPHITE