@shopify/react-native-skia 0.1.155 → 0.1.156

package/android/cpp/rnskia-android/SkiaOpenGLRenderer.h

@@ -2,13 +2,14 @@
 
 #include <RNSkLog.h>
 
+#include "EGL/egl.h"
+#include "GLES2/gl2.h"
 #include "android/native_window.h"
 #include <fbjni/fbjni.h>
 #include <jni.h>
-#include "EGL/egl.h"
-#include "GLES2/gl2.h"
 
 #include <condition_variable>
+#include <memory>
 #include <thread>
 #include <unordered_map>
 
@@ -17,116 +18,112 @@
 
 #include "include/gpu/GrDirectContext.h"
 #include "include/gpu/gl/GrGLInterface.h"
-#include <SkColorSpace.h>
 #include <SkCanvas.h>
-#include <SkSurface.h>
+#include <SkColorSpace.h>
 #include <SkPicture.h>
+#include <SkSurface.h>
 
 #pragma clang diagnostic pop
 
-
-namespace RNSkia
-{
-    using DrawingContext = struct
-    {
-        EGLContext glContext;
-        EGLDisplay glDisplay;
-        EGLConfig glConfig;
-        sk_sp<GrDirectContext> skContext;
-    };
-
-    static std::unordered_map<std::thread::id, std::shared_ptr<DrawingContext>> threadContexts;
-
-    enum RenderState : int {
-        Initializing,
-        Rendering,
-        Finishing,
-        Done,
-    };
-
-    class SkiaOpenGLRenderer
-    {
-    public:
-        SkiaOpenGLRenderer(jobject surface);
-        ~SkiaOpenGLRenderer();
-
-        /**
-         * Initializes, renders and tears down the render pipeline depending on the state of the
-         * renderer. All OpenGL/Skia context operations are done on a separate thread which must
-         * be the same for all calls to the render method.
-         *
-         * @param callback Render callback
-         * @param width Width of surface to render if there is a picture
-         * @param height Height of surface to render if there is a picture
-         */
-        void run(const std::function<void(SkCanvas*)> &cb, int width, int height);
-
-        /**
-         * Sets the state to finishing. Next time the renderer will be called it
-         * will tear down and release its resources. It is important that this
-         * is done on the same thread as the other OpenGL context stuff is handled.
-         *
-         * Teardown can be called fom whatever thread we want - but we must ensure that
-         * at least one call to render on the render thread is done after calling
-         * teardown.
-         */
-        void teardown();
-
-    private:
-        /**
-         * Initializes all required OpenGL and Skia objects
-         * @return True if initialization went well.
-         */
-        bool ensureInitialised();
-
-        /**
-         * Initializes the static OpenGL context that is shared between
-         * all instances of the renderer.
-         * @return True if initialization went well
-         */
-        bool initStaticGLContext();
-
-        /**
-         * Initializes the static Skia context that is shared between
-         * all instances of the renderer
-         * @return True if initialization went well
-         */
-        bool initStaticSkiaContext();
-
-        /**
-         * Inititalizes the OpenGL surface from the native view pointer we
-         * got on initialization. Each renderer has its own OpenGL surface to
-         * render on.
-         * @return True if initialization went well
-         */
-        bool initGLSurface();
-
-        /**
-         * Ensures that we have a valid Skia surface to draw to. The surface will
-         * be recreated if the width/height change.
-         * @param width Width of the underlying view
-         * @param height Height of the underlying view
-         * @return True if initialization went well
-         */
-        bool ensureSkiaSurface(int width, int height);
-
-        /**
-         * To be able to use static contexts (and avoid reloading the skia context for each
-         * new view, we track the OpenGL and Skia drawing context per thread.
-         * @return The drawing context for the current thread
-         */
-        static std::shared_ptr<DrawingContext> getThreadDrawingContext();
-
-        EGLSurface _glSurface = EGL_NO_SURFACE;
-
-        ANativeWindow *_nativeWindow = nullptr;
-        GrBackendRenderTarget _skRenderTarget;
-        sk_sp<SkSurface> _skSurface;
-
-        int _prevWidth = 0;
-        int _prevHeight = 0;
-
-        std::atomic<RenderState> _renderState = { RenderState::Initializing };
-    };
-
-}
+namespace RNSkia {
+using DrawingContext = struct {
+  EGLContext glContext;
+  EGLDisplay glDisplay;
+  EGLConfig glConfig;
+  sk_sp<GrDirectContext> skContext;
+};
+
+static std::unordered_map<std::thread::id, std::shared_ptr<DrawingContext>>
+    threadContexts;
+
+enum RenderState : int {
+  Initializing,
+  Rendering,
+  Finishing,
+  Done,
+};
+
+class SkiaOpenGLRenderer {
+public:
+  explicit SkiaOpenGLRenderer(jobject surface);
+  ~SkiaOpenGLRenderer();
+
+  /**
+   * Initializes, renders and tears down the render pipeline depending on the
+   * state of the renderer. All OpenGL/Skia context operations are done on a
+   * separate thread which must be the same for all calls to the render method.
+   *
+   * @param callback Render callback
+   * @param width Width of surface to render if there is a picture
+   * @param height Height of surface to render if there is a picture
+   */
+  void run(const std::function<void(SkCanvas *)> &cb, int width, int height);
+
+  /**
+   * Sets the state to finishing. Next time the renderer will be called it
+   * will tear down and release its resources. It is important that this
+   * is done on the same thread as the other OpenGL context stuff is handled.
+   *
+   * Teardown can be called fom whatever thread we want - but we must ensure
+   * that at least one call to render on the render thread is done after calling
+   * teardown.
+   */
+  void teardown();
+
+private:
+  /**
+   * Initializes all required OpenGL and Skia objects
+   * @return True if initialization went well.
+   */
+  bool ensureInitialised();
+
+  /**
+   * Initializes the static OpenGL context that is shared between
+   * all instances of the renderer.
+   * @return True if initialization went well
+   */
+  bool initStaticGLContext();
+
+  /**
+   * Initializes the static Skia context that is shared between
+   * all instances of the renderer
+   * @return True if initialization went well
+   */
+  bool initStaticSkiaContext();
+
+  /**
+   * Inititalizes the OpenGL surface from the native view pointer we
+   * got on initialization. Each renderer has its own OpenGL surface to
+   * render on.
+   * @return True if initialization went well
+   */
+  bool initGLSurface();
+
+  /**
+   * Ensures that we have a valid Skia surface to draw to. The surface will
+   * be recreated if the width/height change.
+   * @param width Width of the underlying view
+   * @param height Height of the underlying view
+   * @return True if initialization went well
+   */
+  bool ensureSkiaSurface(int width, int height);
+
+  /**
+   * To be able to use static contexts (and avoid reloading the skia context for
+   * each new view, we track the OpenGL and Skia drawing context per thread.
+   * @return The drawing context for the current thread
+   */
+  static std::shared_ptr<DrawingContext> getThreadDrawingContext();
+
+  EGLSurface _glSurface = EGL_NO_SURFACE;
+
+  ANativeWindow *_nativeWindow = nullptr;
+  GrBackendRenderTarget _skRenderTarget;
+  sk_sp<SkSurface> _skSurface;
+
+  int _prevWidth = 0;
+  int _prevHeight = 0;
+
+  std::atomic<RenderState> _renderState = {RenderState::Initializing};
+};
+} // namespace RNSkia

package/cpp/api/JsiSkApi.h

@@ -1,12 +1,16 @@
 #pragma once
 
+#include <memory>
+
 #include "RNSkPlatformContext.h"
 
 #include "JsiSkHostObjects.h"
 
-#include "JsiSkRuntimeEffect.h"
+#include "JsiSkColor.h"
 #include "JsiSkColorFilter.h"
 #include "JsiSkColorFilterFactory.h"
+#include "JsiSkContourMeasureIter.h"
+#include "JsiSkDataFactory.h"
 #include "JsiSkFont.h"
 #include "JsiSkImage.h"
 #include "JsiSkImageFactory.h"
@@ -16,86 +20,86 @@
 #include "JsiSkMaskFilterFactory.h"
 #include "JsiSkMatrix.h"
 #include "JsiSkPaint.h"
-#include "JsiSkRSXform.h"
 #include "JsiSkPath.h"
 #include "JsiSkPathEffect.h"
 #include "JsiSkPathEffectFactory.h"
 #include "JsiSkPathFactory.h"
+#include "JsiSkPictureFactory.h"
+#include "JsiSkPictureRecorder.h"
 #include "JsiSkPoint.h"
 #include "JsiSkRRect.h"
+#include "JsiSkRSXform.h"
 #include "JsiSkRect.h"
+#include "JsiSkRuntimeEffect.h"
 #include "JsiSkRuntimeEffectFactory.h"
-#include "JsiSkShader.h"
-#include "JsiSkShaderFactory.h"
+#include "JsiSkRuntimeShaderBuilder.h"
 #include "JsiSkSVG.h"
 #include "JsiSkSVGFactory.h"
-#include "JsiSkTypeface.h"
-#include "JsiSkVertices.h"
-#include "JsiSkTypefaceFactory.h"
-#include "JsiSkDataFactory.h"
+#include "JsiSkShader.h"
+#include "JsiSkShaderFactory.h"
 #include "JsiSkSurfaceFactory.h"
 #include "JsiSkTextBlobFactory.h"
-#include "JsiSkContourMeasureIter.h"
-#include "JsiSkPictureRecorder.h"
-#include "JsiSkPictureFactory.h"
-#include "JsiSkRuntimeShaderBuilder.h"
-#include "JsiSkColor.h"
+#include "JsiSkTypeface.h"
+#include "JsiSkTypefaceFactory.h"
+#include "JsiSkVertices.h"
 
-namespace RNSkia
-{
+namespace RNSkia {
 
-  using namespace facebook;
+namespace jsi = facebook::jsi;
 
-  class JsiSkApi : public JsiSkHostObject
-  {
-  public:
-    /**
+class JsiSkApi : public JsiSkHostObject {
+public:
+  /**
    * Constructs the Skia Api object that can be installed into a runtime
    * and provide functions for accessing and creating the Skia wrapper objects
    * @param context Platform context
    */
-    JsiSkApi(jsi::Runtime &runtime, std::shared_ptr<RNSkPlatformContext> context)
-        : JsiSkHostObject(context)
-    {
+  JsiSkApi(jsi::Runtime &runtime, std::shared_ptr<RNSkPlatformContext> context)
+      : JsiSkHostObject(context) {
 
-      installFunction("Font", JsiSkFont::createCtor(context));
-      installFunction("Paint", JsiSkPaint::createCtor(context));
-      installFunction("RSXform", JsiSkRSXform::createCtor(context));
-      installFunction("Matrix", JsiSkMatrix::createCtor(context));
-      installFunction("XYWHRect", JsiSkRect::createCtor(context));
-      installFunction("RRectXY", JsiSkRRect::createCtor(context));
-      installFunction("Point", JsiSkPoint::createCtor(context));
-      installFunction("RuntimeShaderBuilder", JsiSkRuntimeShaderBuilder::createCtor(context));
-      installFunction("ContourMeasureIter", JsiSkContourMeasureIter::createCtor(context));
-      installFunction("MakeVertices", JsiSkVertices::createCtor(context));
-      installFunction("PictureRecorder", JsiSkPictureRecorder::createCtor(context));
-      installFunction("Color", JsiSkColor::createCtor());
+    installFunction("Font", JsiSkFont::createCtor(context));
+    installFunction("Paint", JsiSkPaint::createCtor(context));
+    installFunction("RSXform", JsiSkRSXform::createCtor(context));
+    installFunction("Matrix", JsiSkMatrix::createCtor(context));
+    installFunction("XYWHRect", JsiSkRect::createCtor(context));
+    installFunction("RRectXY", JsiSkRRect::createCtor(context));
+    installFunction("Point", JsiSkPoint::createCtor(context));
+    installFunction("RuntimeShaderBuilder",
+                    JsiSkRuntimeShaderBuilder::createCtor(context));
+    installFunction("ContourMeasureIter",
+                    JsiSkContourMeasureIter::createCtor(context));
+    installFunction("MakeVertices", JsiSkVertices::createCtor(context));
+    installFunction("PictureRecorder",
+                    JsiSkPictureRecorder::createCtor(context));
+    installFunction("Color", JsiSkColor::createCtor());
 
-      installReadonlyProperty("SVG",
-                              std::make_shared<JsiSkSVGFactory>(context));
-      installReadonlyProperty("Image",
-                              std::make_shared<JsiSkImageFactory>(context));
-      installReadonlyProperty("Typeface",
-                              std::make_shared<JsiSkTypefaceFactory>(context));
-      installReadonlyProperty("Data",
-                              std::make_shared<JsiSkDataFactory>(context));
-      installReadonlyProperty("ImageFilter",
-                              std::make_shared<JsiSkImageFilterFactory>(context));
-      installReadonlyProperty("PathEffect",
-                              std::make_shared<JsiSkPathEffectFactory>(context));
-      installReadonlyProperty("Path",
-                              std::make_shared<JsiSkPathFactory>(context));
-      installReadonlyProperty("ColorFilter",
-                              std::make_shared<JsiSkColorFilterFactory>(context));
-      installReadonlyProperty("MaskFilter",
-                              std::make_shared<JsiSkMaskFilterFactory>(context));
-      installReadonlyProperty(
-          "RuntimeEffect", std::make_shared<JsiSkRuntimeEffectFactory>(context));
-      installReadonlyProperty("Shader",
-                              std::make_shared<JsiSkShaderFactory>(context));
-      installReadonlyProperty("TextBlob", std::make_shared<JsiSkTextBlobFactory>(context));
-      installReadonlyProperty("Surface", std::make_shared<JsiSkSurfaceFactory>(context));
-      installReadonlyProperty("Picture", std::make_shared<JsiSkPictureFactory>(context));
-    };
-  };
+    installReadonlyProperty("SVG", std::make_shared<JsiSkSVGFactory>(context));
+    installReadonlyProperty("Image",
+                            std::make_shared<JsiSkImageFactory>(context));
+    installReadonlyProperty("Typeface",
+                            std::make_shared<JsiSkTypefaceFactory>(context));
+    installReadonlyProperty("Data",
+                            std::make_shared<JsiSkDataFactory>(context));
+    installReadonlyProperty("ImageFilter",
+                            std::make_shared<JsiSkImageFilterFactory>(context));
+    installReadonlyProperty("PathEffect",
+                            std::make_shared<JsiSkPathEffectFactory>(context));
+    installReadonlyProperty("Path",
+                            std::make_shared<JsiSkPathFactory>(context));
+    installReadonlyProperty("ColorFilter",
+                            std::make_shared<JsiSkColorFilterFactory>(context));
+    installReadonlyProperty("MaskFilter",
+                            std::make_shared<JsiSkMaskFilterFactory>(context));
+    installReadonlyProperty(
+        "RuntimeEffect", std::make_shared<JsiSkRuntimeEffectFactory>(context));
+    installReadonlyProperty("Shader",
+                            std::make_shared<JsiSkShaderFactory>(context));
+    installReadonlyProperty("TextBlob",
+                            std::make_shared<JsiSkTextBlobFactory>(context));
+    installReadonlyProperty("Surface",
+                            std::make_shared<JsiSkSurfaceFactory>(context));
+    installReadonlyProperty("Picture",
+                            std::make_shared<JsiSkPictureFactory>(context));
+  }
+};
 } // namespace RNSkia

package/cpp/api/JsiSkCanvas.h

@@ -10,12 +10,12 @@
 #include "JsiSkMatrix.h"
 #include "JsiSkPaint.h"
 #include "JsiSkPath.h"
+#include "JsiSkPicture.h"
 #include "JsiSkPoint.h"
 #include "JsiSkRRect.h"
 #include "JsiSkSVG.h"
-#include "JsiSkVertices.h"
 #include "JsiSkTextBlob.h"
-#include "JsiSkPicture.h"
+#include "JsiSkVertices.h"
 
 #include <jsi/jsi.h>
 
@@ -26,15 +26,15 @@
 #include <SkFont.h>
 #include <SkPaint.h>
 #include <SkPath.h>
+#include <SkPicture.h>
 #include <SkRegion.h>
 #include <SkSurface.h>
 #include <SkTypeface.h>
-#include <SkPicture.h>
 
 #pragma clang diagnostic pop
 
 namespace RNSkia {
-using namespace facebook;
+namespace jsi = facebook::jsi;
 
 class JsiSkCanvas : public JsiSkHostObject {
 public:
@@ -97,7 +97,7 @@ public:
         paint = JsiSkPaint::fromValue(runtime, arguments[5]);
       }
     }
-    _canvas->drawImage(image, x, y, SkSamplingOptions({ B, C }), paint.get());
+    _canvas->drawImage(image, x, y, SkSamplingOptions({B, C}), paint.get());
     return jsi::Value::undefined();
   }
 
@@ -128,7 +128,8 @@ public:
         paint = JsiSkPaint::fromValue(runtime, arguments[4]);
       }
     }
-    _canvas->drawImageNine(image.get(), center->round(), *dest, fm, paint.get());
+    _canvas->drawImageNine(image.get(), center->round(), *dest, fm,
+                           paint.get());
     return jsi::Value::undefined();
   }
 
@@ -144,8 +145,10 @@ public:
         paint = JsiSkPaint::fromValue(runtime, arguments[5]);
       }
     }
-    auto constraint = SkCanvas::kStrict_SrcRectConstraint;  // TODO: get from caller
-    _canvas->drawImageRect(image.get(), *src, *dest, SkSamplingOptions({ B, C }), paint.get(), constraint);
+    auto constraint =
+        SkCanvas::kStrict_SrcRectConstraint; // TODO: get from caller
+    _canvas->drawImageRect(image.get(), *src, *dest, SkSamplingOptions({B, C}),
+                           paint.get(), constraint);
     return jsi::Value::undefined();
   }
 
@@ -162,7 +165,8 @@ public:
       }
     }
     auto constraint = SkCanvas::kStrict_SrcRectConstraint;
-    _canvas->drawImageRect(image.get(), *src, *dest, {filter, mipmap}, paint.get(), constraint);
+    _canvas->drawImageRect(image.get(), *src, *dest, {filter, mipmap},
+                           paint.get(), constraint);
     return jsi::Value::undefined();
   }
 
@@ -250,7 +254,6 @@ public:
     return jsi::Value::undefined();
   }
 
-
   JSI_HOST_FUNCTION(drawVertices) {
     auto vertices = JsiSkVertices::fromValue(runtime, arguments[0]);
     auto blendMode = (SkBlendMode)arguments[1].getNumber();
@@ -278,7 +281,8 @@ public:
       auto colorsSize = jsiColors.size(runtime);
       colors.reserve(colorsSize);
       for (int i = 0; i < colorsSize; i++) {
-        SkColor color = JsiSkColor::fromValue(runtime, jsiColors.getValueAtIndex(runtime, i));
+        SkColor color = JsiSkColor::fromValue(
+            runtime, jsiColors.getValueAtIndex(runtime, i));
         colors.push_back(color);
       }
     }
@@ -289,14 +293,16 @@ public:
       texs.reserve(texsSize);
       for (int i = 0; i < texsSize; i++) {
         auto point = JsiSkPoint::fromValue(
-                runtime, jsiTexs.getValueAtIndex(runtime, i).asObject(runtime));
+            runtime, jsiTexs.getValueAtIndex(runtime, i).asObject(runtime));
         texs.push_back(*point.get());
       }
     }
 
-    auto paint = count >= 4 ? JsiSkPaint::fromValue(runtime, arguments[4]) : nullptr;
+    auto paint =
+        count >= 4 ? JsiSkPaint::fromValue(runtime, arguments[4]) : nullptr;
     auto blendMode = static_cast<SkBlendMode>(arguments[3].asNumber());
-    _canvas->drawPatch(cubics.data(), colors.data(), texs.data(), blendMode, *paint);
+    _canvas->drawPatch(cubics.data(), colors.data(), texs.data(), blendMode,
+                       *paint);
     return jsi::Value::undefined();
   }
 
@@ -347,7 +353,7 @@ public:
     positions.reserve(pointsSize);
     for (int i = 0; i < pointsSize; i++) {
       std::shared_ptr<SkPoint> point = JsiSkPoint::fromValue(
-              runtime, jsiPositions.getValueAtIndex(runtime, i).asObject(runtime));
+          runtime, jsiPositions.getValueAtIndex(runtime, i).asObject(runtime));
       positions.push_back(*point.get());
     }
 
@@ -358,14 +364,8 @@ public:
       glyphs.push_back(jsiGlyphs.getValueAtIndex(runtime, i).asNumber());
     }
 
-    _canvas->drawGlyphs(
-            glyphsSize,
-            glyphs.data(),
-            positions.data(),
-            origin,
-            *font,
-            *paint
-    );
+    _canvas->drawGlyphs(glyphsSize, glyphs.data(), positions.data(), origin,
+                        *font, *paint);
 
     return jsi::Value::undefined();
   }
@@ -412,10 +412,17 @@ public:
   JSI_HOST_FUNCTION(save) { return jsi::Value(_canvas->save()); }
 
   JSI_HOST_FUNCTION(saveLayer) {
-    SkPaint *paint = (count >= 1 && !arguments[0].isUndefined()) ?
-                         JsiSkPaint::fromValue(runtime, arguments[0]).get() : nullptr;
-    SkRect *bounds = count >= 2 && !arguments[1].isNull() && !arguments[1].isUndefined() ? JsiSkRect::fromValue(runtime, arguments[1]).get() : nullptr;
-    SkImageFilter *backdrop = count >= 3 && !arguments[2].isNull() && !arguments[2].isUndefined() ? JsiSkImageFilter::fromValue(runtime, arguments[2]).get() : nullptr;
+    SkPaint *paint = (count >= 1 && !arguments[0].isUndefined())
+                         ? JsiSkPaint::fromValue(runtime, arguments[0]).get()
+                         : nullptr;
+    SkRect *bounds =
+        count >= 2 && !arguments[1].isNull() && !arguments[1].isUndefined()
+            ? JsiSkRect::fromValue(runtime, arguments[1]).get()
+            : nullptr;
+    SkImageFilter *backdrop =
+        count >= 3 && !arguments[2].isNull() && !arguments[2].isUndefined()
+            ? JsiSkImageFilter::fromValue(runtime, arguments[2]).get()
+            : nullptr;
     SkCanvas::SaveLayerFlags flags = count >= 4 ? arguments[3].asNumber() : 0;
     return jsi::Value(_canvas->saveLayer(
         SkCanvas::SaveLayerRec(bounds, paint, backdrop, flags)));
@@ -477,7 +484,7 @@ public:
     _canvas->concat(*matrix.get());
     return jsi::Value::undefined();
   }
-  
+
   JSI_HOST_FUNCTION(drawPicture) {
     auto picture = JsiSkPicture::fromValue(runtime, arguments[0]);
     _canvas->drawPicture(picture);
@@ -524,10 +531,11 @@ public:
                        JSI_EXPORT_FUNC(JsiSkCanvas, concat),
                        JSI_EXPORT_FUNC(JsiSkCanvas, drawPicture))
 
-  JsiSkCanvas(std::shared_ptr<RNSkPlatformContext> context)
+  explicit JsiSkCanvas(std::shared_ptr<RNSkPlatformContext> context)
       : JsiSkHostObject(std::move(context)) {}
 
-  JsiSkCanvas(std::shared_ptr<RNSkPlatformContext> context, SkCanvas* canvas): JsiSkCanvas(std::move(context)) {
+  JsiSkCanvas(std::shared_ptr<RNSkPlatformContext> context, SkCanvas *canvas)
+      : JsiSkCanvas(std::move(context)) {
     setCanvas(canvas);
   }