react-native-skia 2.15.0 → 3.0.0

package/android/CMakeLists.txt

@@ -85,6 +85,7 @@ add_library(
 
         "${PROJECT_SOURCE_DIR}/../cpp/rnskia/RNSkManager.cpp"
         "${PROJECT_SOURCE_DIR}/../cpp/rnskia/RNSkPictureView.cpp"
+        "${PROJECT_SOURCE_DIR}/../cpp/rnskia/RNSkGraphiteProducer.cpp"
 
         "${PROJECT_SOURCE_DIR}/../cpp/api/third_party/CSSColorParser.cpp"
         "${PROJECT_SOURCE_DIR}/../cpp/api/third_party/base64.cpp"

package/android/cpp/jni/include/JniSkiaBaseView.h

@@ -61,16 +61,21 @@ protected:
   }
 
   virtual void unregisterView() {
-    auto manager = getSkiaManager();
-    if (manager == nullptr || _skiaAndroidView == nullptr) {
+    if (_skiaAndroidView == nullptr) {
       return;
     }
     auto skiaView = _skiaAndroidView->getSkiaView();
     if (skiaView == nullptr) {
       return;
     }
-    manager->setSkiaView(skiaView->getNativeId(), nullptr);
-    manager->unregisterSkiaView(skiaView->getNativeId());
+    if (auto manager = getSkiaManager()) {
+      manager->setSkiaView(skiaView->getNativeId(), nullptr);
+      manager->unregisterSkiaView(skiaView->getNativeId());
+    }
+    // React drops the Java view here, but the native view behind it (and the
+    // content it owns) is only destroyed when the Java object is finalized.
+    // Release the content now so it does not wait for the garbage collector.
+    skiaView->releaseContent();
   }
 
   virtual jni::local_ref<jni::JArrayInt> getBitmap(int width, int height) {

package/android/cpp/jni/include/JniSkiaGraphiteView.h

@@ -59,8 +59,8 @@ protected:
                                       highBitDepth);
   }
 
-  void surfaceSizeChanged(jobject surface, int width, int height, bool isSurface,
-                          bool highBitDepth) override {
+  void surfaceSizeChanged(jobject surface, int width, int height,
+                          bool isSurface, bool highBitDepth) override {
     JniSkiaBaseView::surfaceSizeChanged(surface, width, height, isSurface,
                                         highBitDepth);
   }

package/android/cpp/jni/include/JniSkiaPictureView.h

@@ -83,18 +83,7 @@ protected:
     JniSkiaBaseView::registerView(nativeId);
   }
 
-  void unregisterView() override {
-    JniSkiaBaseView::unregisterView();
-    // React drops the Java view here, but the native view behind it (and the
-    // recording it owns) is only destroyed when the Java object is finalized.
-    // Release the content now so it does not wait for the Java garbage
-    // collector.
-    if (_skiaAndroidView != nullptr) {
-      auto renderer = std::static_pointer_cast<RNSkia::RNSkPictureRenderer>(
-          _skiaAndroidView->getSkiaView()->getRenderer());
-      renderer->clear();
-    }
-  }
+  void unregisterView() override { JniSkiaBaseView::unregisterView(); }
 
   jni::local_ref<jni::JArrayInt> getBitmap(int width, int height) override {
     // Get the RNSkPictureView from the android view

package/cpp/api/recorder/ColorFilters.h

@@ -6,6 +6,7 @@
 #include <vector>
 
 #include <include/core/SkColorFilter.h>
+#include <include/effects/SkLumaColorFilter.h>
 
 #include "Command.h"
 #include "Convertor.h"

package/cpp/api/recorder/Convertor.h

@@ -10,12 +10,25 @@
 #include <include/core/SkPaint.h>
 #include <include/core/SkPathEffect.h>
 #include <include/core/SkPoint.h>
+#include <include/effects/Sk1DPathEffect.h>
 #include <include/effects/SkRuntimeEffect.h>
 #include <modules/skparagraph/include/Paragraph.h>
 #include <modules/skparagraph/include/ParagraphBuilder.h>
 #include <modules/skparagraph/include/ParagraphStyle.h>
 
 #include "../CustomBlendModes.h"
+#include "api/JsiSkFont.h"
+#include "api/JsiSkImage.h"
+#include "api/JsiSkImageFilter.h"
+#include "api/JsiSkMatrix.h"
+#include "api/JsiSkPaint.h"
+#include "api/JsiSkParagraph.h"
+#include "api/JsiSkPicture.h"
+#include "api/JsiSkRSXform.h"
+#include "api/JsiSkRuntimeEffect.h"
+#include "api/JsiSkSVG.h"
+#include "api/JsiSkSkottie.h"
+#include "api/JsiSkTextBlob.h"
 #include "api/third_party/CSSColorParser.h"
 
 #include "DataTypes.h"
@@ -29,8 +42,13 @@ struct Radius {
   float rY;
 };
 
-using ConversionFunction =
-    std::function<void(jsi::Runtime &runtime, const jsi::Object &object)>;
+// A value read from a shared value, waiting to be written into a command
+// property. Reading needs the runtime the shared value lives on; writing does
+// not, so the thread that replays the commands writes it right before.
+// Empty when there is nothing to write.
+using PendingWrite = std::function<void()>;
+using ConversionFunction = std::function<PendingWrite(
+    jsi::Runtime &runtime, const jsi::Object &object)>;
 using Variables = std::map<std::string, std::vector<ConversionFunction>>;
 
 using Patch = std::array<SkPoint, 12>;
@@ -91,27 +109,32 @@ bool convertSelectorProperty(jsi::Runtime &runtime, const jsi::Value &prop,
       sharedValue.getProperty(runtime, "name").asString(runtime).utf8(runtime);
 
   auto conv = [target = &target, key](jsi::Runtime &runtime,
-                                      const jsi::Object &val) {
+                                      const jsi::Object &val) -> PendingWrite {
     auto value = val.getProperty(runtime, "value");
     if (!value.isObject()) {
-      return;
+      return nullptr;
     }
     auto values = value.asObject(runtime);
     if (!values.hasProperty(runtime, key.c_str())) {
-      return;
+      return nullptr;
     }
 
     auto selected = values.getProperty(runtime, key.c_str());
     if (selected.isUndefined() || selected.isNull() ||
         (selected.isObject() &&
          selected.asObject(runtime).isFunction(runtime))) {
-      return;
+      return nullptr;
     }
-    *target = getPropertyValue<T>(runtime, selected);
+    return
+        [target, converted = getPropertyValue<T>(runtime, selected)]() mutable {
+          *target = std::move(converted);
+        };
   };
 
   variables[name].push_back(conv);
-  conv(runtime, sharedValue);
+  if (auto write = conv(runtime, sharedValue)) {
+    write();
+  }
   return true;
 }
 
@@ -135,12 +158,17 @@ void convertPropertyImpl(jsi::Runtime &runtime, const jsi::Object &object,
                     .asString(runtime)
                     .utf8(runtime);
     auto conv = [target = &target](jsi::Runtime &runtime,
-                                   const jsi::Object &val) {
+                                   const jsi::Object &val) -> PendingWrite {
       auto value = val.getProperty(runtime, "value");
-      *target = getPropertyValue<T>(runtime, value);
+      return
+          [target, converted = getPropertyValue<T>(runtime, value)]() mutable {
+            *target = std::move(converted);
+          };
     };
     variables[name].push_back(conv);
-    conv(runtime, sharedValue);
+    if (auto write = conv(runtime, sharedValue)) {
+      write();
+    }
     return;
   }
 

package/cpp/api/recorder/DataTypes.h

@@ -1,7 +1,19 @@
 #pragma once
 
+#include <memory>
+#include <string>
+#include <vector>
+
 #include <jsi/jsi.h>
 
+#include "include/core/SkData.h"
+#include "include/utils/SkParsePath.h"
+
+#include "api/JsiSkPath.h"
+#include "api/JsiSkRRect.h"
+#include "api/JsiSkRect.h"
+#include "api/JsiSkRuntimeEffect.h"
+
 namespace RNSkia {
 
 using Uniforms = std::map<std::string, std::vector<float>>;

package/cpp/api/recorder/DrawingCtx.h

@@ -1,8 +1,22 @@
 #pragma once
 
+#include <algorithm>
+#include <functional>
 #include <memory>
+#include <numeric>
+#include <stdexcept>
+#include <utility>
 #include <vector>
 
+#include "include/core/SkCanvas.h"
+#include "include/core/SkColorFilter.h"
+#include "include/core/SkImageFilter.h"
+#include "include/core/SkMaskFilter.h"
+#include "include/core/SkPaint.h"
+#include "include/core/SkPathEffect.h"
+#include "include/core/SkShader.h"
+#include "include/effects/SkImageFilters.h"
+
 namespace RNSkia {
 
 // Generic composer type using std::function

package/cpp/api/recorder/Drawings.h

@@ -1,6 +1,10 @@
 #pragma once
 
+#include <algorithm>
+#include <memory>
 #include <optional>
+#include <string>
+#include <vector>
 
 #include "Command.h"
 #include "Convertor.h"
@@ -8,6 +12,7 @@
 #include "ImageFit.h"
 #include "rnskia/RNSkPlatformContext.h"
 
+#include "include/core/SkContourMeasure.h"
 #include "include/core/SkPathBuilder.h"
 #include "include/core/SkStrokeRec.h"
 

package/cpp/api/recorder/PathEffects.h

@@ -2,7 +2,15 @@
 
 #include <optional>
 #include <string>
+#include <utility>
 #include <variant>
+#include <vector>
+
+#include <include/effects/Sk1DPathEffect.h>
+#include <include/effects/Sk2DPathEffect.h>
+#include <include/effects/SkCornerPathEffect.h>
+#include <include/effects/SkDashPathEffect.h>
+#include <include/effects/SkDiscretePathEffect.h>
 
 #include "Command.h"
 #include "Convertor.h"

package/cpp/api/recorder/RNRecorder.h

@@ -4,6 +4,7 @@
 #include <atomic>
 #include <cmath>
 #include <cstdint>
+#include <map>
 #include <memory>
 #include <mutex>
 #include <optional>
@@ -45,12 +46,51 @@ private:
   CommandList commands;
   std::vector<CommandList *> commandStack;
 
-  // Once a view owns the recording, the Reanimated mapper writes the shared
-  // values into the commands (applyUpdates, UI thread) while the view replays
-  // them (play, main thread). Both hold this lock; nothing else does, so it
-  // never nests with the view's lock.
+  // Once a view owns the recording, the Reanimated mapper reads the shared
+  // values into pending writes (readUpdates, UI thread) and whoever replays
+  // the commands writes them into the commands first (play, under this
+  // lock). Nothing else holds this lock, so it never nests with a view's
+  // lock.
   std::mutex _commandsMutex;
 
+  // The pending writes, one slot per conversion function: a value read
+  // several times between two replays is written once (the last read wins),
+  // and the memory stays bounded whatever the ratio of updates to replays.
+  // The slots are assigned on the first read, once the recording, and thus
+  // `variables`, is complete.
+  std::mutex _pendingMutex;
+  std::vector<PendingWrite> _pendingWrites;
+  std::map<std::string, size_t> _slotBase;
+  bool _hasPendingWrites = false;
+
+  size_t slotBase(const std::string &name) {
+    std::lock_guard<std::mutex> lock(_pendingMutex);
+    if (_slotBase.empty()) {
+      size_t count = 0;
+      for (const auto &entry : variables) {
+        _slotBase[entry.first] = count;
+        count += entry.second.size();
+      }
+      _pendingWrites.resize(count);
+    }
+    return _slotBase.at(name);
+  }
+
+  /** Writes the pending values into the commands. Under _commandsMutex. */
+  void flushPendingWritesLocked() {
+    std::lock_guard<std::mutex> lock(_pendingMutex);
+    if (!_hasPendingWrites) {
+      return;
+    }
+    for (auto &write : _pendingWrites) {
+      if (write) {
+        write();
+        write = nullptr;
+      }
+    }
+    _hasPendingWrites = false;
+  }
+
   CommandList &currentCommands() { return *commandStack.back(); }
 
   void pushCommand(std::unique_ptr<Command> command) {
@@ -404,6 +444,7 @@ public:
 
   void play(DrawingCtx *ctx) {
     std::lock_guard<std::mutex> lock(_commandsMutex);
+    flushPendingWritesLocked();
     for (const auto &cmd : commands) {
       playCommand(ctx, cmd.get());
     }
@@ -425,23 +466,39 @@ public:
 
   /**
    * Reads the current value of each shared value (in the order they were
-   * registered as variable0, variable1, ...) on the calling runtime and
-   * writes it into the recorded commands.
+   * registered as variable0, variable1, ...) on the calling runtime into the
+   * pending writes. The writes do not need the runtime: the next replay
+   * (play, on whichever thread owns the commands) writes them into the
+   * commands first, so the caller never waits for a replay.
    */
-  void applyUpdates(jsi::Runtime &runtime, const jsi::Array &values) {
-    std::lock_guard<std::mutex> lock(_commandsMutex);
+  void readUpdates(jsi::Runtime &runtime, const jsi::Array &values) {
     auto size = values.size(runtime);
     for (size_t i = 0; i < size; i++) {
       auto sharedValue = values.getValueAtIndex(runtime, i).asObject(runtime);
       auto name = "variable" + std::to_string(i);
       auto it = variables.find(name);
-      if (it != variables.end()) {
-        for (const auto &conversionFunc : it->second) {
-          conversionFunc(runtime, sharedValue);
+      if (it == variables.end()) {
+        continue;
+      }
+      auto base = slotBase(name);
+      for (size_t j = 0; j < it->second.size(); j++) {
+        if (auto write = it->second[j](runtime, sharedValue)) {
+          std::lock_guard<std::mutex> lock(_pendingMutex);
+          _pendingWrites[base + j] = std::move(write);
+          _hasPendingWrites = true;
         }
       }
     }
   }
+
+  /**
+   * Reads the shared values and writes them into the commands right away.
+   */
+  void applyUpdates(jsi::Runtime &runtime, const jsi::Array &values) {
+    readUpdates(runtime, values);
+    std::lock_guard<std::mutex> lock(_commandsMutex);
+    flushPendingWritesLocked();
+  }
 };
 
 inline void Recorder::playCommand(DrawingCtx *ctx, Command *cmd) {

package/cpp/api/recorder/Shaders.h

@@ -2,10 +2,13 @@
 
 #include <optional>
 #include <string>
+#include <utility>
 #include <variant>
+#include <vector>
 
 #include <include/core/SkSamplingOptions.h>
 #include <include/effects/SkGradient.h>
+#include <include/effects/SkPerlinNoiseShader.h>
 
 #include "Command.h"
 #include "Convertor.h"

package/cpp/dawn/include/dawn/dawn_proc.h

@@ -0,0 +1,53 @@
+// Copyright 2019 The Dawn & Tint Authors
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//
+// 1. Redistributions of source code must retain the above copyright notice, this
+//    list of conditions and the following disclaimer.
+//
+// 2. Redistributions in binary form must reproduce the above copyright notice,
+//    this list of conditions and the following disclaimer in the documentation
+//    and/or other materials provided with the distribution.
+//
+// 3. Neither the name of the copyright holder nor the names of its
+//    contributors may be used to endorse or promote products derived from
+//    this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef INCLUDE_DAWN_DAWN_PROC_H_
+#define INCLUDE_DAWN_DAWN_PROC_H_
+
+#include <webgpu/webgpu.h>
+
+#include "dawn/dawn_proc_table.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// Sets the static proctable used by libdawn_proc to implement the Dawn entrypoints. Passing NULL
+// for `procs` sets up the null proctable that contains only null function pointers. It is the
+// default value of the proctable. Setting the proctable back to null is good practice when you
+// are done using libdawn_proc since further usage will cause a segfault instead of calling an
+// unexpected function.
+WGPU_EXPORT void dawnProcSetProcs(const DawnProcTable* procs);
+
+// Returns the static array of uint8_t of size 20 representing the Dawn version.
+WGPU_EXPORT const uint8_t* dawnProcGetVersion();
+
+#ifdef __cplusplus
+}  // extern "C"
+#endif
+
+#endif  // INCLUDE_DAWN_DAWN_PROC_H_