@shopify/react-native-skia 0.1.172 → 0.1.173

package/android/CMakeLists.txt

@@ -56,6 +56,7 @@ add_library(
         "${PROJECT_SOURCE_DIR}/cpp/rnskia/RNSkDispatchQueue.cpp"
 
         "${PROJECT_SOURCE_DIR}/cpp/rnskia/dom/base/DrawingContext.cpp"
+        "${PROJECT_SOURCE_DIR}/cpp/rnskia/dom/base/ConcatablePaint.cpp"
 
         "${PROJECT_SOURCE_DIR}/cpp/api/third_party/CSSColorParser.cpp"
         

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

@@ -7,6 +7,7 @@
 
 #include <JniPlatformContext.h>
 #include <RNSkPlatformContext.h>
+#include <SkiaOpenGLRenderer.h>
 
 namespace RNSkia {
 namespace jsi = facebook::jsi;
@@ -36,6 +37,10 @@ public:
     _jniPlatformContext->raiseError(err);
   }
 
+  sk_sp<SkSurface> makeOffscreenSurface(int width, int height) override {
+    return MakeOffscreenGLSurface(width, height);
+  }
+
   void startDrawLoop() override { _jniPlatformContext->startDrawLoop(); }
 
   void stopDrawLoop() override { _jniPlatformContext->stopDrawLoop(); }

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

@@ -6,6 +6,112 @@
 
 namespace RNSkia {
 /** Static members */
+sk_sp<SkSurface> MakeOffscreenGLSurface(int width, int height) {
+  EGLDisplay eglDisplay = eglGetDisplay(EGL_DEFAULT_DISPLAY);
+  if (eglDisplay == EGL_NO_DISPLAY) {
+    RNSkLogger::logToConsole("eglGetdisplay failed : %i", glGetError());
+    return nullptr;
+  }
+
+  EGLint major;
+  EGLint minor;
+  if (!eglInitialize(eglDisplay, &major, &minor)) {
+    RNSkLogger::logToConsole("eglInitialize failed : %i", glGetError());
+    return nullptr;
+  }
+
+  EGLint att[] = {EGL_RENDERABLE_TYPE,
+                  EGL_OPENGL_ES2_BIT,
+                  EGL_SURFACE_TYPE,
+                  EGL_PBUFFER_BIT,
+                  EGL_ALPHA_SIZE,
+                  8,
+                  EGL_BLUE_SIZE,
+                  8,
+                  EGL_GREEN_SIZE,
+                  8,
+                  EGL_RED_SIZE,
+                  8,
+                  EGL_DEPTH_SIZE,
+                  0,
+                  EGL_STENCIL_SIZE,
+                  0,
+                  EGL_NONE};
+
+  EGLint numConfigs;
+  EGLConfig eglConfig;
+  eglConfig = 0;
+  if (!eglChooseConfig(eglDisplay, att, &eglConfig, 1, &numConfigs) ||
+      numConfigs == 0) {
+    RNSkLogger::logToConsole("Failed to choose a config %d\n", eglGetError());
+    return nullptr;
+  }
+
+  EGLint contextAttribs[] = {EGL_CONTEXT_CLIENT_VERSION, 2, EGL_NONE};
+
+  EGLContext eglContext =
+      eglCreateContext(eglDisplay, eglConfig, NULL, contextAttribs);
+
+  if (eglContext == EGL_NO_CONTEXT) {
+    RNSkLogger::logToConsole("eglCreateContext failed: %d\n", eglGetError());
+    return nullptr;
+  }
+
+  const EGLint offScreenSurfaceAttribs[] = {EGL_WIDTH, width, EGL_HEIGHT,
+                                            height, EGL_NONE};
+  EGLSurface eglSurface =
+      eglCreatePbufferSurface(eglDisplay, eglConfig, offScreenSurfaceAttribs);
+  if (!eglMakeCurrent(eglDisplay, eglSurface, eglSurface, eglContext)) {
+    RNSkLogger::logToConsole("eglMakeCurrent failed: %d\n", eglGetError());
+    return nullptr;
+  }
+  GLint buffer;
+  glGetIntegerv(GL_FRAMEBUFFER_BINDING, &buffer);
+
+  GLint stencil;
+  glGetIntegerv(GL_STENCIL_BITS, &stencil);
+
+  GLint samples;
+  glGetIntegerv(GL_SAMPLES, &samples);
+
+  // Create the Skia backend context
+  auto backendInterface = GrGLMakeNativeInterface();
+  auto grContext = GrDirectContext::MakeGL(backendInterface);
+  if (grContext == nullptr) {
+    RNSkLogger::logToConsole("GrDirectContext::MakeGL failed");
+    return nullptr;
+  }
+  auto maxSamples =
+      grContext->maxSurfaceSampleCountForColorType(kRGBA_8888_SkColorType);
+
+  if (samples > maxSamples)
+    samples = maxSamples;
+
+  GrGLFramebufferInfo fbInfo;
+  fbInfo.fFBOID = buffer;
+  fbInfo.fFormat = 0x8058;
+
+  auto renderTarget =
+      GrBackendRenderTarget(width, height, samples, stencil, fbInfo);
+
+  struct OffscreenRenderContext {
+    EGLDisplay display;
+    EGLSurface surface;
+  };
+  auto ctx = new OffscreenRenderContext({eglDisplay, eglSurface});
+
+  auto surface = SkSurface::MakeFromBackendRenderTarget(
+      grContext.get(), renderTarget, kBottomLeft_GrSurfaceOrigin,
+      kRGBA_8888_SkColorType, nullptr, nullptr,
+      [](void *addr) {
+        auto ctx = reinterpret_cast<OffscreenRenderContext *>(addr);
+        eglDestroySurface(ctx->display, ctx->surface);
+        delete ctx;
+      },
+      reinterpret_cast<void *>(ctx));
+  return surface;
+}
+
 std::shared_ptr<OpenGLDrawingContext>
 SkiaOpenGLRenderer::getThreadDrawingContext() {
   auto threadId = std::this_thread::get_id();
@@ -57,13 +163,8 @@ void SkiaOpenGLRenderer::run(const std::function<void(SkCanvas *)> &cb,
       // during rendering.
       getThreadDrawingContext()->skContext->resetContext();
 
-      // Clear with transparent
-      glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
-      glClear(GL_COLOR_BUFFER_BIT);
-
       // Draw picture into surface
       cb(_skSurface->getCanvas());
-
       // Flush
       _skSurface->flushAndSubmit();
 

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

@@ -26,6 +26,8 @@
 #pragma clang diagnostic pop
 
 namespace RNSkia {
+sk_sp<SkSurface> MakeOffscreenGLSurface(int width, int height);
+
 using OpenGLDrawingContext = struct {
   EGLContext glContext;
   EGLDisplay glDisplay;
@@ -127,4 +129,4 @@ private:
 
   std::atomic<RenderState> _renderState = {RenderState::Initializing};
 };
-} // namespace RNSkia
+} // namespace RNSkia

package/cpp/api/JsiSkSurface.h

@@ -40,6 +40,11 @@ public:
         std::make_shared<JsiSkCanvas>(getContext(), getObject()->getCanvas()));
   }
 
+  JSI_HOST_FUNCTION(flush) {
+    getObject()->flush();
+    return jsi::Value::undefined();
+  }
+
   JSI_HOST_FUNCTION(makeImageSnapshot) {
     sk_sp<SkImage> image;
     if (count == 1) {
@@ -55,7 +60,8 @@ public:
 
   JSI_EXPORT_PROPERTY_GETTERS(JSI_EXPORT_PROP_GET(JsiSkSurface, __typename__))
   JSI_EXPORT_FUNCTIONS(JSI_EXPORT_FUNC(JsiSkSurface, getCanvas),
-                       JSI_EXPORT_FUNC(JsiSkSurface, makeImageSnapshot))
+                       JSI_EXPORT_FUNC(JsiSkSurface, makeImageSnapshot),
+                       JSI_EXPORT_FUNC(JsiSkSurface, flush))
 
   /**
     Returns the underlying object from a host object of this type

package/cpp/api/JsiSkSurfaceFactory.h

@@ -12,7 +12,6 @@
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wdocumentation"
 
-#include "SkImage.h"
 #include "SkSurface.h"
 
 #pragma clang diagnostic pop
@@ -35,7 +34,21 @@ public:
         std::make_shared<JsiSkSurface>(getContext(), std::move(surface)));
   }
 
-  JSI_EXPORT_FUNCTIONS(JSI_EXPORT_FUNC(JsiSkSurfaceFactory, Make))
+  JSI_HOST_FUNCTION(MakeOffscreen) {
+    auto width = static_cast<int>(arguments[0].asNumber());
+    auto height = static_cast<int>(arguments[1].asNumber());
+    auto context = getContext();
+    auto surface = context->makeOffscreenSurface(width, height);
+    if (surface == nullptr) {
+      return jsi::Value::null();
+    }
+    return jsi::Object::createFromHostObject(
+        runtime,
+        std::make_shared<JsiSkSurface>(getContext(), std::move(surface)));
+  }
+
+  JSI_EXPORT_FUNCTIONS(JSI_EXPORT_FUNC(JsiSkSurfaceFactory, Make),
+                       JSI_EXPORT_FUNC(JsiSkSurfaceFactory, MakeOffscreen))
 
   explicit JsiSkSurfaceFactory(std::shared_ptr<RNSkPlatformContext> context)
       : JsiSkHostObject(std::move(context)) {}

package/cpp/rnskia/RNSkDomView.cpp

@@ -79,14 +79,12 @@ void RNSkDomRenderer::renderCanvas(SkCanvas *canvas, float scaledWidth,
   _renderTimingInfo.beginTiming();
 
   auto pd = _platformContext->getPixelDensity();
-
+  canvas->clear(SK_ColorTRANSPARENT);
   canvas->save();
   canvas->scale(pd, pd);
 
   if (_drawingContext == nullptr) {
-    auto paint = std::make_shared<SkPaint>();
-    paint->setAntiAlias(true);
-    _drawingContext = std::make_shared<DrawingContext>(paint);
+    _drawingContext = std::make_shared<DrawingContext>();
 
     _drawingContext->setRequestRedraw([weakSelf = weak_from_this()]() {
       auto self = weakSelf.lock();

package/cpp/rnskia/RNSkJsView.cpp

@@ -197,11 +197,14 @@ void RNSkJsRenderer::drawInJsiCanvas(std::shared_ptr<JsiSkCanvas> jsiCanvas,
   if (_drawCallback != nullptr && skCanvas != nullptr) {
     // Make sure to scale correctly
     auto pd = _platformContext->getPixelDensity();
+    skCanvas->clear(SK_ColorTRANSPARENT);
     skCanvas->save();
     skCanvas->scale(pd, pd);
 
     // Call draw function.
     callJsDrawCallback(jsiCanvas, width / pd, height / pd, time);
+
+    skCanvas->restore();
   }
 }
 

package/cpp/rnskia/RNSkPictureView.h

@@ -72,10 +72,13 @@ private:
     canvasProvider->renderToCanvas([=](SkCanvas *canvas) {
       // Make sure to scale correctly
       auto pd = _platformContext->getPixelDensity();
+      canvas->clear(SK_ColorTRANSPARENT);
       canvas->save();
       canvas->scale(pd, pd);
 
       canvas->drawPicture(_picture->getObject());
+
+      canvas->restore();
     });
   }
 

package/cpp/rnskia/RNSkPlatformContext.h

@@ -15,6 +15,7 @@
 #pragma clang diagnostic ignored "-Wdocumentation"
 
 #include "SkStream.h"
+#include "SkSurface.h"
 
 #pragma clang diagnostic pop
 
@@ -109,6 +110,14 @@ public:
    */
   virtual void raiseError(const std::exception &err) = 0;
 
+  /**
+   * Creates an offscreen surface
+   * @param width
+   * @param height
+   * @return sk_sp<SkSurface>
+   */
+  virtual sk_sp<SkSurface> makeOffscreenSurface(int width, int height) = 0;
+
   /**
    * Raises an exception on the platform. This function does not necessarily
    * throw an exception and stop execution, so it is important to stop execution

package/cpp/rnskia/dom/JsiDomApi.h

@@ -2,6 +2,7 @@
 
 /* Enable output of dom trees and paint contexts */
 #define SKIA_DOM_DEBUG 0
+#define SKIA_DOM_DEBUG_VERBOSE 0
 
 #include <memory>
 

package/cpp/rnskia/dom/base/ConcatablePaint.cpp

@@ -0,0 +1,117 @@
+#include "ConcatablePaint.h"
+
+#include "DeclarationContext.h"
+#include "JsiDomNode.h"
+#include "PaintProps.h"
+
+namespace RNSkia {
+
+ConcatablePaint::ConcatablePaint(
+    DeclarationContext *declarationContext, PaintProps *paintProps,
+    const std::vector<std::shared_ptr<JsiDomNode>> &children)
+    : _declarationContext(declarationContext), _paintProps(paintProps),
+      _children(children) {
+
+  auto hasPropertyValues = _paintProps->getColor()->isSet() ||
+                           _paintProps->getStrokeWidth()->isSet() ||
+                           _paintProps->getBlendMode()->isSet() ||
+                           _paintProps->getStyle()->isSet() ||
+                           _paintProps->getStrokeJoin()->isSet() ||
+                           _paintProps->getStrokeCap()->isSet() ||
+                           _paintProps->getStrokeMiter()->isSet() ||
+                           _paintProps->getOpacity()->isSet() ||
+                           _paintProps->getAntiAlias()->isSet();
+
+  _declarationContext->save();
+
+  for (auto &child : _children) {
+    child->decorateContext(_declarationContext);
+  }
+
+  _imageFilter = declarationContext->getImageFilters()->popAsOne();
+  _colorFilter = declarationContext->getColorFilters()->popAsOne();
+  _shader = declarationContext->getShaders()->pop();
+  _maskFilter = declarationContext->getMaskFilters()->pop();
+  _pathEffect = declarationContext->getPathEffects()->popAsOne();
+
+  _declarationContext->restore();
+
+  _isEmpty = !hasPropertyValues && _imageFilter == nullptr &&
+             _colorFilter == nullptr && _shader == nullptr &&
+             _maskFilter == nullptr && _pathEffect == nullptr;
+}
+
+bool ConcatablePaint::isEmpty() { return _isEmpty; }
+
+void ConcatablePaint::concatTo(std::shared_ptr<SkPaint> paint) {
+
+  if (_paintProps->getOpacity()->isSet()) {
+    paint->setAlphaf(paint->getAlphaf() *
+                     _paintProps->getOpacity()->value().getAsNumber());
+  }
+
+  if (_paintProps->getColor()->isSet()) {
+    auto currentOpacity = paint->getAlphaf();
+    paint->setShader(nullptr);
+    paint->setColor(*_paintProps->getColor()->getDerivedValue());
+    paint->setAlphaf(paint->getAlphaf() * currentOpacity);
+  }
+
+  if (_paintProps->getStrokeWidth()->isSet()) {
+    paint->setStrokeWidth(_paintProps->getStrokeWidth()->value().getAsNumber());
+  }
+
+  if (_paintProps->getBlendMode()->isSet()) {
+    paint->setBlendMode(*_paintProps->getBlendMode()->getDerivedValue());
+  }
+
+  if (_paintProps->getStyle()->isSet()) {
+    auto styleValue = _paintProps->getStyle()->value().getAsString();
+    if (styleValue == "stroke") {
+      paint->setStyle(SkPaint::Style::kStroke_Style);
+    } else if (styleValue == "fill") {
+      paint->setStyle(SkPaint::Style::kFill_Style);
+    } else {
+      throw std::runtime_error(styleValue +
+                               " is not a valud value for the style property.");
+    }
+  }
+
+  if (_paintProps->getStrokeJoin()->isSet()) {
+    paint->setStrokeJoin(*_paintProps->getStrokeJoin()->getDerivedValue());
+  }
+
+  if (_paintProps->getStrokeCap()->isSet()) {
+    paint->setStrokeCap(*_paintProps->getStrokeCap()->getDerivedValue());
+  }
+
+  if (_paintProps->getStrokeMiter()->isSet()) {
+    paint->setStrokeMiter(_paintProps->getStrokeMiter()->value().getAsNumber());
+  }
+
+  if (_paintProps->getAntiAlias()->isSet()) {
+    paint->setAntiAlias(_paintProps->getAntiAlias()->value().getAsBool());
+  }
+
+  if (_imageFilter) {
+    paint->setImageFilter(_imageFilter);
+  }
+
+  if (_colorFilter) {
+    paint->setColorFilter(_colorFilter);
+  }
+
+  if (_shader) {
+    paint->setShader(_shader);
+  }
+
+  if (_maskFilter) {
+    paint->setMaskFilter(_maskFilter);
+  }
+
+  if (_pathEffect) {
+    paint->setPathEffect(_pathEffect);
+  }
+}
+
+} // namespace RNSkia

package/cpp/rnskia/dom/base/ConcatablePaint.h

@@ -0,0 +1,49 @@
+#pragma once
+
+#include <memory>
+#include <vector>
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdocumentation"
+
+#include <SkColorFilter.h>
+#include <SkImageFilter.h>
+#include <SkMaskFilter.h>
+#include <SkPaint.h>
+#include <SkPathEffect.h>
+#include <SkShader.h>
+
+#pragma clang diagnostic pop
+
+namespace RNSkia {
+
+class JsiDomNode;
+class PaintProps;
+class DeclarationContext;
+
+/**
+ Class for concatenating SkPaint objects.
+ */
+class ConcatablePaint {
+public:
+  ConcatablePaint(DeclarationContext *context, PaintProps *paintProps,
+                  const std::vector<std::shared_ptr<JsiDomNode>> &children);
+
+  void concatTo(std::shared_ptr<SkPaint> paint);
+  bool isEmpty();
+
+private:
+  DeclarationContext *_declarationContext;
+  const std::vector<std::shared_ptr<JsiDomNode>> _children;
+  PaintProps *_paintProps;
+
+  bool _isEmpty{true};
+
+  sk_sp<SkImageFilter> _imageFilter;
+  sk_sp<SkColorFilter> _colorFilter;
+  sk_sp<SkPathEffect> _pathEffect;
+  sk_sp<SkMaskFilter> _maskFilter;
+  sk_sp<SkShader> _shader;
+};
+
+} // namespace RNSkia

package/cpp/rnskia/dom/base/Declaration.h

@@ -0,0 +1,88 @@
+#pragma once
+
+#include <algorithm>
+#include <numeric>
+#include <stack>
+#include <utility>
+#include <vector>
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdocumentation"
+
+#include <SkRefCnt.h>
+
+#pragma clang diagnostic pop
+
+namespace RNSkia {
+
+/**
+ Small container for shaders, filters, masks and effects
+ */
+template <typename T> class Declaration {
+public:
+  // Pushes to the stack
+  void push(T el) { _elements.push(el); }
+
+  // Clears and returns all elements
+  std::vector<T> popAll() { return popMultiple(_elements.size()); }
+
+  // Pops the number of items up to limit
+  std::vector<T> popMultiple(size_t limit) {
+    auto size = std::min(limit, _elements.size());
+    std::vector<T> tmp;
+    tmp.reserve(size);
+    for (size_t i = 0; i < size; ++i) {
+      tmp.push_back(_elements.top());
+      _elements.pop();
+    }
+    return tmp;
+  }
+
+  T pop() {
+    if (_elements.size() == 0) {
+      return nullptr;
+    }
+    auto tmp = _elements.top();
+    _elements.pop();
+    return tmp;
+  }
+
+  // Clears and returns through reducer function in reversed order
+  T popAsOne(std::function<T(T inner, T outer)> composer) {
+    auto tmp = popAll();
+    // std::reverse(std::begin(tmp), std::end(tmp));
+    return std::accumulate(std::begin(tmp), std::end(tmp),
+                           static_cast<T>(nullptr), [=](T inner, T outer) {
+                             if (inner == nullptr) {
+                               return outer;
+                             }
+                             return composer(inner, outer);
+                           });
+  }
+
+  // Returns the size of the elements
+  size_t size() { return _elements.size(); }
+
+protected:
+  std::stack<T> _elements;
+};
+
+/**
+ Small container for shaders, filters, masks and effects
+ */
+template <typename T> class ComposableDeclaration : public Declaration<T> {
+public:
+  /**
+   Constructor
+   */
+  explicit ComposableDeclaration(std::function<T(T inner, T outer)> composer)
+      : Declaration<T>(), _composer(composer) {}
+
+  // Clears and returns through reducer function in reversed order
+  T popAsOne() { return Declaration<T>::popAsOne(_composer); }
+
+private:
+  std::function<T(T inner, T outer)> _composer;
+};
+
+} // namespace RNSkia

package/cpp/rnskia/dom/base/DeclarationContext.h

@@ -0,0 +1,79 @@
+#pragma once
+
+#include "Declaration.h"
+
+#include <memory>
+#include <stack>
+#include <vector>
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdocumentation"
+
+#include <SkColorFilter.h>
+#include <SkImageFilter.h>
+#include <SkImageFilters.h>
+#include <SkMaskFilter.h>
+#include <SkPaint.h>
+#include <SkPathEffect.h>
+#include <SkShader.h>
+
+#pragma clang diagnostic pop
+
+namespace RNSkia {
+
+class DeclarationContext {
+public:
+  DeclarationContext() { save(); }
+
+  Declaration<sk_sp<SkShader>> *getShaders() { return &_shaders.top(); }
+  ComposableDeclaration<sk_sp<SkImageFilter>> *getImageFilters() {
+    return &_imageFilters.top();
+  }
+  ComposableDeclaration<sk_sp<SkColorFilter>> *getColorFilters() {
+    return &_colorFilters.top();
+  }
+  ComposableDeclaration<sk_sp<SkPathEffect>> *getPathEffects() {
+    return &_pathEffects.top();
+  }
+  Declaration<sk_sp<SkMaskFilter>> *getMaskFilters() {
+    return &_maskFilters.top();
+  }
+  Declaration<std::shared_ptr<SkPaint>> *getPaints() { return &_paints.top(); }
+
+  void save() {
+    _paints.emplace();
+    _shaders.emplace();
+    _imageFilters.emplace(
+        [](sk_sp<SkImageFilter> inner, sk_sp<SkImageFilter> outer) {
+          return SkImageFilters::Compose(outer, inner);
+        });
+    _colorFilters.emplace(
+        [](sk_sp<SkColorFilter> inner, sk_sp<SkColorFilter> outer) {
+          return SkColorFilters::Compose(outer, inner);
+        });
+    _pathEffects.emplace(
+        [](sk_sp<SkPathEffect> inner, sk_sp<SkPathEffect> outer) {
+          return SkPathEffect::MakeCompose(outer, inner);
+        });
+    _maskFilters.emplace();
+  }
+
+  void restore() {
+    _shaders.pop();
+    _imageFilters.pop();
+    _colorFilters.pop();
+    _pathEffects.pop();
+    _maskFilters.pop();
+    _paints.pop();
+  }
+
+private:
+  std::stack<Declaration<sk_sp<SkShader>>> _shaders;
+  std::stack<ComposableDeclaration<sk_sp<SkImageFilter>>> _imageFilters;
+  std::stack<ComposableDeclaration<sk_sp<SkColorFilter>>> _colorFilters;
+  std::stack<ComposableDeclaration<sk_sp<SkPathEffect>>> _pathEffects;
+  std::stack<Declaration<sk_sp<SkMaskFilter>>> _maskFilters;
+  std::stack<Declaration<std::shared_ptr<SkPaint>>> _paints;
+};
+
+} // namespace RNSkia