@shopify/react-native-skia 0.1.158 → 0.1.159

package/cpp/rnskia/dom/props/TransformProp.h

@@ -0,0 +1,80 @@
+#pragma once
+
+#include "DerivedNodeProp.h"
+#include "JsiSkMatrix.h"
+
+#include <memory>
+#include <string>
+
+namespace RNSkia {
+
+static PropId PropNameTransform = JsiPropId::get("transform");
+
+static PropId PropNameTranslateX = JsiPropId::get("translateX");
+static PropId PropNameTranslateY = JsiPropId::get("translateY");
+static PropId PropNameScale = JsiPropId::get("scale");
+static PropId PropNameScaleX = JsiPropId::get("scaleX");
+static PropId PropNameScaleY = JsiPropId::get("scaleY");
+static PropId PropNameSkewX = JsiPropId::get("skewX");
+static PropId PropNameSkewY = JsiPropId::get("skewY");
+static PropId PropNameRotate = JsiPropId::get("rotate");
+static PropId PropNameRotateZ = JsiPropId::get("rotateZ");
+
+class TransformProp : public DerivedProp<SkMatrix> {
+public:
+  explicit TransformProp(PropId name) : DerivedProp<SkMatrix>() {
+    _transformProp = addProperty(std::make_shared<NodeProp>(name));
+  }
+
+  void updateDerivedValue() override {
+    if (!_transformProp->isSet()) {
+      setDerivedValue(nullptr);
+    } else if (_transformProp->value().getType() != PropType::Array) {
+      throw std::runtime_error(
+          "Expected array for transform property, got " +
+          JsiValue::getTypeAsString(_transformProp->value().getType()));
+    } else {
+      auto m = std::make_shared<SkMatrix>(SkMatrix());
+      for (auto &el : _transformProp->value().getAsArray()) {
+        auto keys = el.getKeys();
+        if (keys.size() == 0) {
+          throw std::runtime_error(
+              "Empty value in transform. Expected translateX, translateY, "
+              "scale, "
+              "scaleX, scaleY, skewX, skewY, rotate or rotateZ.");
+        }
+        auto key = el.getKeys().at(0);
+        auto value = el.getValue(key).getAsNumber();
+        if (key == PropNameTranslateX) {
+          m->preTranslate(value, 0);
+        } else if (key == PropNameTranslateY) {
+          m->preTranslate(0, value);
+        } else if (key == PropNameScale) {
+          m->preScale(value, value);
+        } else if (key == PropNameScaleX) {
+          m->preScale(value, 1);
+        } else if (key == PropNameScaleY) {
+          m->preScale(1, value);
+        } else if (key == PropNameSkewX) {
+          m->preScale(value, 0);
+        } else if (key == PropNameSkewY) {
+          m->preScale(value, 0);
+        } else if (key == PropNameRotate || key == PropNameRotateZ) {
+          m->preRotate(SkRadiansToDegrees(value));
+        } else {
+          throw std::runtime_error(
+              "Unknown key in transform. Expected translateX, translateY, "
+              "scale, "
+              "scaleX, scaleY, skewX, skewY, rotate or rotateZ - got " +
+              std::string(key) + ".");
+        }
+      }
+      setDerivedValue(m);
+    }
+  }
+
+private:
+  NodeProp *_transformProp;
+};
+
+} // namespace RNSkia

package/cpp/rnskia/dom/props/TransformsProps.h

@@ -0,0 +1,68 @@
+#pragma once
+
+#include "MatrixProp.h"
+#include "NodeProp.h"
+#include "PointProp.h"
+#include "TransformProp.h"
+
+#include <memory>
+#include <utility>
+
+namespace RNSkia {
+
+class TransformsProps : public DerivedProp<SkMatrix> {
+public:
+  TransformsProps() : DerivedProp<SkMatrix>() {
+    _transformProp = addProperty(
+        std::make_shared<TransformProp>(JsiPropId::get("transform")));
+    _originProp =
+        addProperty(std::make_shared<PointProp>(JsiPropId::get("origin")));
+    _matrixProp =
+        addProperty(std::make_shared<MatrixProp>(JsiPropId::get("matrix")));
+  }
+
+  void updateDerivedValue() override {
+    if (_transformProp->isSet() || _originProp->isSet() ||
+        _matrixProp->isSet()) {
+
+      auto matrix =
+          _matrixProp->isSet() ? _matrixProp->getDerivedValue() : nullptr;
+      auto origin =
+          _originProp->isSet() ? _originProp->getDerivedValue() : nullptr;
+      auto transform =
+          _transformProp->isSet() ? _transformProp->getDerivedValue() : nullptr;
+
+      auto lm = SkMatrix();
+      if (matrix) {
+        if (origin) {
+          lm.preTranslate(origin->x(), origin->y());
+          lm.preConcat(*matrix);
+          lm.preTranslate(-origin->x(), -origin->y());
+        } else {
+          lm.setIdentity();
+          lm.preConcat(*matrix);
+        }
+      } else if (transform) {
+        lm.setIdentity();
+        if (origin) {
+          lm.preTranslate(origin->x(), origin->y());
+        }
+        lm.preConcat(*transform);
+        if (origin) {
+          lm.preTranslate(-origin->x(), -origin->y());
+        }
+      }
+      setDerivedValue(std::move(lm));
+
+    } else {
+      setDerivedValue(nullptr);
+    }
+  }
+
+private:
+  TransformProp *_transformProp;
+  PointProp *_originProp;
+  MatrixProp *_matrixProp;
+};
+
+} // namespace RNSkia

package/cpp/rnskia/dom/props/UniformsProp.h

@@ -0,0 +1,194 @@
+#pragma once
+
+#include "DerivedNodeProp.h"
+#include "JsiSkRuntimeEffect.h"
+
+#include <memory>
+#include <string>
+#include <vector>
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdocumentation"
+
+#include <SkRuntimeEffect.h>
+
+#pragma clang diagnostic pop
+
+namespace RNSkia {
+
+class UniformsProp : public DerivedSkProp<SkData> {
+public:
+  UniformsProp(PropId name, NodeProp *sourceProp) : DerivedSkProp<SkData>() {
+    _uniformsProp = addProperty(std::make_shared<NodeProp>(name));
+    _sourceProp = sourceProp;
+  }
+
+  void updateDerivedValue() override {
+    if (!_uniformsProp->isSet()) {
+      return;
+    }
+
+    // Get the effect
+    auto source = _sourceProp->value().getAs<JsiSkRuntimeEffect>()->getObject();
+
+    // Flatten uniforms from property
+    auto uniformValues = flattenUniforms(source.get(), _uniformsProp->value());
+
+    // Cast uniforms according to the declaration in the shader
+    auto uniformsData = castUniforms(source.get(), uniformValues);
+
+    // Save derived value
+    setDerivedValue(uniformsData);
+  }
+
+private:
+  sk_sp<SkData> castUniforms(SkRuntimeEffect *source,
+                             const std::vector<SkScalar> &values) {
+    // Create memory for uniforms
+    auto uniformsData = SkData::MakeUninitialized(source->uniformSize());
+
+    // Loop through all uniforms in the effect and load data from the flattened
+    // array of values
+    const auto &u = source->uniforms();
+    for (std::size_t i = 0; i < u.size(); i++) {
+      auto it = source->uniforms().begin() + i;
+      RuntimeEffectUniform reu = JsiSkRuntimeEffect::fromUniform(*it);
+      for (std::size_t j = 0; j < reu.columns * reu.rows; ++j) {
+        const std::size_t offset = reu.slot + j;
+        float fValue = values.at(offset);
+        int iValue = static_cast<int>(fValue);
+        auto value = reu.isInteger ? iValue : fValue;
+        memcpy(SkTAddOffset<void>(uniformsData->writable_data(),
+                                  offset * sizeof(value)),
+               &value, sizeof(value));
+      }
+    }
+
+    return uniformsData;
+  }
+
+  std::vector<SkScalar> flattenUniforms(SkRuntimeEffect *source,
+                                        const JsiValue &propObject) {
+    auto uniformsCount = source->uniforms().size();
+    std::vector<SkScalar> uniformValues;
+
+    for (size_t i = 0; i < uniformsCount; ++i) {
+      auto it = source->uniforms().begin() + i;
+      auto name = JsiPropId::get(std::string(it->name));
+
+      if (!propObject.hasValue(name)) {
+        throw std::runtime_error("The runtime effect has the uniform value \"" +
+                                 std::string(name) +
+                                 "\" declared, but it is missing from the "
+                                 "uniforms property of the Runtime effect.");
+      }
+
+      auto value = propObject.getValue(name);
+
+      // A uniform value can be a single number, a vector or an array of numbers
+      // Or an array of the above
+      if (value.getType() == PropType::Number) {
+        // Set numeric uniform
+        uniformValues.push_back(value.getAsNumber());
+      } else if (value.getType() == PropType::Array) {
+        // Array
+        auto arrayValue = value.getAsArray();
+        for (size_t n = 0; n < arrayValue.size(); ++n) {
+          auto a = arrayValue[n];
+          if (a.getType() == PropType::Number) {
+            uniformValues.push_back(a.getAsNumber());
+          } else {
+            for (size_t j = 0; j < a.getAsArray().size(); ++j) {
+              uniformValues.push_back(a.getAsArray()[j].getAsNumber());
+            }
+          }
+        }
+      } else if (value.getType() == PropType::HostObject ||
+                 value.getType() == PropType::Object) {
+        // Vector (JsiSkPoint / JsiSkRect)
+        auto pointValue = PointProp::processValue(value);
+        uniformValues.push_back(pointValue.x());
+        uniformValues.push_back(pointValue.y());
+      }
+    }
+    return uniformValues;
+  }
+
+  NodeProp *_uniformsProp;
+  NodeProp *_sourceProp;
+};
+
+class SimpleUniformsProp : public BaseDerivedProp {
+public:
+  SimpleUniformsProp(PropId name, NodeProp *sourceProp) : BaseDerivedProp() {
+    _uniformsProp = addProperty(std::make_shared<NodeProp>(name));
+    _sourceProp = sourceProp;
+  }
+
+  void processUniforms(SkRuntimeShaderBuilder &rtb) {
+    if (!_uniformsProp->isSet()) {
+      return;
+    }
+
+    auto propObject = _uniformsProp->value();
+    auto source = _sourceProp->value().getAs<JsiSkRuntimeEffect>()->getObject();
+
+    auto uniformsCount = source->uniforms().size();
+
+    for (size_t i = 0; i < uniformsCount; ++i) {
+      auto it = source->uniforms().begin() + i;
+      auto name = JsiPropId::get(std::string(it->name));
+
+      if (!propObject.hasValue(name)) {
+        throw std::runtime_error("The runtime effect has the uniform value \"" +
+                                 std::string(name) +
+                                 "\" declared, but it is missing from the "
+                                 "uniforms property of the Runtime effect.");
+      }
+
+      auto value = propObject.getValue(name);
+
+      // A uniform value can be a single number, a vector or an array of numbers
+      // Or an array of the above
+      if (value.getType() == PropType::Number) {
+        // Set numeric uniform
+        rtb.uniform(name) = value.getAsNumber();
+      } else if (value.getType() == PropType::Array) {
+        // Array
+        auto arrayValue = value.getAsArray();
+        std::vector<SkScalar> set;
+        for (size_t n = 0; n < arrayValue.size(); ++n) {
+          auto a = arrayValue[n];
+          if (a.getType() == PropType::Number) {
+            set.push_back(a.getAsNumber());
+          } else {
+            for (size_t j = 0; j < a.getAsArray().size(); ++j) {
+              set.push_back(a.getAsArray()[j].getAsNumber());
+            }
+          }
+        }
+        rtb.uniform(name).set(set.data(), static_cast<int>(set.size()));
+
+      } else if (value.getType() == PropType::HostObject ||
+                 value.getType() == PropType::Object) {
+        // Vector (JsiSkPoint / JsiSkRect)
+        auto pointValue = PointProp::processValue(value);
+        std::vector<SkScalar> set = {pointValue.x(), pointValue.y()};
+
+        rtb.uniform(name).set(set.data(), static_cast<int>(set.size()));
+      } else {
+        throw std::runtime_error("Unexpected type for uniform prop \"" +
+                                 std::string(name) + "\". Got " +
+                                 value.getTypeAsString(value.getType()));
+      }
+    }
+  }
+
+  void updateDerivedValue() override {}
+
+private:
+  NodeProp *_uniformsProp;
+  NodeProp *_sourceProp;
+};
+
+} // namespace RNSkia

package/cpp/rnskia/dom/props/VertexModeProp.h

@@ -0,0 +1,47 @@
+#pragma once
+
+#include "DerivedNodeProp.h"
+
+#include <memory>
+#include <string>
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdocumentation"
+
+#include <SkVertices.h>
+
+#pragma clang diagnostic pop
+
+namespace RNSkia {
+
+class VertexModeProp : public DerivedProp<SkVertices::VertexMode> {
+public:
+  explicit VertexModeProp(PropId name) : DerivedProp<SkVertices::VertexMode>() {
+    _vertexModeProp = addProperty(std::make_shared<NodeProp>(name));
+  }
+
+  void updateDerivedValue() override {
+    if (_vertexModeProp->isSet() && (_vertexModeProp->isChanged())) {
+      auto vertexModeValue = _vertexModeProp->value().getAsString();
+      setDerivedValue(getVertexModeFromStringValue(vertexModeValue));
+    }
+  }
+
+private:
+  SkVertices::VertexMode
+  getVertexModeFromStringValue(const std::string &value) {
+    if (value == "triangles") {
+      return SkVertices::VertexMode::kTriangles_VertexMode;
+    } else if (value == "triangleStrip") {
+      return SkVertices::VertexMode::kTriangleStrip_VertexMode;
+    } else if (value == "triangleFan") {
+      return SkVertices::VertexMode::kTriangleFan_VertexMode;
+    }
+    throw std::runtime_error("Property value \"" + value +
+                             "\" is not a legal blend mode.");
+  }
+
+  NodeProp *_vertexModeProp;
+};
+
+} // namespace RNSkia

package/cpp/rnskia/dom/props/VerticesProps.h

@@ -0,0 +1,67 @@
+#pragma once
+
+#include "DerivedNodeProp.h"
+
+#include "ColorProp.h"
+#include "NumbersProp.h"
+#include "PointsProp.h"
+#include "VertexModeProp.h"
+
+#include <memory>
+#include <vector>
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdocumentation"
+
+#include <SkVertices.h>
+
+#pragma clang diagnostic pop
+
+namespace RNSkia {
+
+class VerticesProps : public DerivedSkProp<SkVertices> {
+public:
+  VerticesProps() : DerivedSkProp<SkVertices>() {
+    _vertexModeProp =
+        addProperty(std::make_shared<VertexModeProp>(JsiPropId::get("mode")));
+    _colorsProp =
+        addProperty(std::make_shared<ColorsProp>(JsiPropId::get("colors")));
+    _verticesProp =
+        addProperty(std::make_shared<PointsProp>(JsiPropId::get("vertices")));
+    _texturesProp =
+        addProperty(std::make_shared<PointsProp>(JsiPropId::get("textures")));
+    _indicesProp =
+        addProperty(std::make_shared<Numbers16Prop>(JsiPropId::get("indices")));
+
+    _vertexModeProp->require();
+    _verticesProp->require();
+  }
+
+  bool hasColors() { return _colorsProp->isSet(); }
+
+  void updateDerivedValue() override {
+    SkVertices::VertexMode *vertextMode =
+        _vertexModeProp->getDerivedValue().get();
+    std::vector<SkColor> *colors = _colorsProp->getDerivedValue().get();
+    auto vertices = _verticesProp->getDerivedValue();
+    auto textures = _texturesProp->getDerivedValue();
+    auto indices = _indicesProp->getDerivedValue();
+
+    setDerivedValue(SkVertices::MakeCopy(
+        *vertextMode, static_cast<int>(vertices->size()),
+        _verticesProp->isSet() ? vertices->data() : nullptr,
+        _texturesProp->isSet() ? textures->data() : nullptr,
+        _colorsProp->isSet() ? colors->data() : nullptr,
+        _indicesProp->isSet() ? static_cast<int>(indices->size()) : 0,
+        _indicesProp->isSet() ? indices->data() : nullptr));
+  }
+
+private:
+  VertexModeProp *_vertexModeProp;
+  ColorsProp *_colorsProp;
+  PointsProp *_verticesProp;
+  PointsProp *_texturesProp;
+  Numbers16Prop *_indicesProp;
+};
+
+} // namespace RNSkia

package/cpp/rnskia/values/RNSkReadonlyValue.h

@@ -10,8 +10,8 @@
 
 #include <jsi/jsi.h>
 
-#include <JsiSimpleValueWrapper.h>
 #include <JsiSkHostObjects.h>
+#include <JsiValueWrapper.h>
 #include <RNSkPlatformContext.h>
 
 namespace RNSkia {
@@ -29,7 +29,7 @@ public:
   explicit RNSkReadonlyValue(
       std::shared_ptr<RNSkPlatformContext> platformContext)
       : JsiSkHostObject(platformContext),
-        _valueHolder(std::make_unique<RNJsi::JsiSimpleValueWrapper>(
+        _valueHolder(std::make_shared<RNJsi::JsiValueWrapper>(
             *platformContext->getJsRuntime())) {}
 
   virtual ~RNSkReadonlyValue() { invalidate(); }
@@ -108,8 +108,8 @@ public:
    */
   virtual void update(jsi::Runtime &runtime, const jsi::Value &value) {
     auto equal = _valueHolder->equals(runtime, value);
-    _valueHolder->setCurrent(runtime, value);
     if (!equal) {
+      _valueHolder->setCurrent(runtime, value);
       notifyListeners(runtime);
     }
   }
@@ -123,10 +123,19 @@ public:
     _listeners.clear();
   }
 
+  /**
+   Returns the current value as a jsi::Value
+   */
   jsi::Value getCurrent(jsi::Runtime &runtime) {
     return _valueHolder->getCurrent(runtime);
   }
 
+  /**
+   Returns the underlying current value wrapper. This can be used to query the
+   holder for data type and get pointers to elements in the holder.
+   */
+  std::shared_ptr<RNJsi::JsiValueWrapper> getCurrent() { return _valueHolder; }
+
 protected:
   /**
     Notifies listeners about changes
@@ -153,7 +162,7 @@ protected:
   }
 
 private:
-  std::unique_ptr<RNJsi::JsiSimpleValueWrapper> _valueHolder;
+  std::shared_ptr<RNJsi::JsiValueWrapper> _valueHolder;
 
   long _listenerId = 0;
   std::unordered_map<long, std::function<void(jsi::Runtime &)>> _listeners;

package/cpp/skia/include/android/SkAndroidFrameworkUtils.h

@@ -8,8 +8,10 @@
 #ifndef SkAndroidFrameworkUtils_DEFINED
 #define SkAndroidFrameworkUtils_DEFINED
 
+#include "include/core/SkColor.h"
+#include "include/core/SkPoint.h"
 #include "include/core/SkRefCnt.h"
-#include "include/core/SkTypes.h"
+#include "include/core/SkTileMode.h"
 
 #ifdef SK_BUILD_FOR_ANDROID_FRAMEWORK
 
@@ -17,6 +19,7 @@ class SkCanvas;
 struct SkIRect;
 struct SkRect;
 class SkSurface;
+class SkShader;
 
 /**
  *  SkAndroidFrameworkUtils expose private APIs used only by Android framework.
@@ -54,6 +57,37 @@ public:
      *  @return SkCanvas that was found in the innermost SkPaintFilterCanvas.
      */
     static SkCanvas* getBaseWrappedCanvas(SkCanvas* canvas);
+
+    /**
+     * Skia will change the order in which local matrices concatenate. In order to not break Android
+     * apps targeting older API levels we offer this function to use the legacy concatenation order.
+     */
+    static void UseLegacyLocalMatrixConcatenation();
+
+    /**
+     *  If the shader represents a linear gradient ShaderAsALinearGradient
+     *  returns true and if info is not null, ShaderAsALinearGradient populates
+     *  info with the parameters for the gradient. fColorCount is both an input
+     *  and output parameter. On input, it indicates how many entries in
+     *  fColors and fColorOffsets can be used, if they are not nullptr. After
+     *  asAGradient has run, fColorCount indicates how many color-offset pairs
+     *  there are in the gradient. fColorOffsets specifies where on the range of
+     *  0 to 1 to transition to the given color. fPoints represent the endpoints
+     *  of the gradient.
+     */
+    struct LinearGradientInfo {
+        int         fColorCount    = 0;        //!< In-out parameter, specifies passed size
+                                               //   of fColors/fColorOffsets on input, and
+                                               //   actual number of colors/offsets on
+                                               //   output.
+        SkColor*    fColors        = nullptr;  //!< The colors in the gradient.
+        SkScalar*   fColorOffsets  = nullptr;  //!< The unit offset for color transitions.
+        SkPoint     fPoints[2];                //!< Type specific, see above.
+        SkTileMode  fTileMode;
+        uint32_t    fGradientFlags = 0;        //!< see SkGradientShader::Flags
+    };
+
+    static bool ShaderAsALinearGradient(SkShader* shader, LinearGradientInfo*);
 };
 
 #endif // SK_BUILD_FOR_ANDROID_ANDROID

package/cpp/skia/include/codec/SkAndroidCodec.h

@@ -9,9 +9,25 @@
 #define SkAndroidCodec_DEFINED
 
 #include "include/codec/SkCodec.h"
+#include "include/core/SkAlphaType.h"
+#include "include/core/SkColorSpace.h"
+#include "include/core/SkColorType.h"
 #include "include/core/SkEncodedImageFormat.h"
-#include "include/core/SkStream.h"
+#include "include/core/SkImageInfo.h"
+#include "include/core/SkRefCnt.h"
+#include "include/core/SkSize.h"
 #include "include/core/SkTypes.h"
+#include "include/private/SkEncodedInfo.h"
+#include "include/private/SkNoncopyable.h"
+#include "modules/skcms/skcms.h"
+
+#include <cstddef>
+#include <memory>
+
+class SkData;
+class SkPngChunkReader;
+class SkStream;
+struct SkIRect;
 
 /**
  *  Abstract interface defining image codec functionality that is necessary for

package/cpp/skia/include/codec/SkCodec.h

@@ -10,31 +10,34 @@
 
 #include "include/codec/SkCodecAnimation.h"
 #include "include/codec/SkEncodedOrigin.h"
-#include "include/core/SkColor.h"
+#include "include/core/SkAlphaType.h"
 #include "include/core/SkEncodedImageFormat.h"
 #include "include/core/SkImageInfo.h"
 #include "include/core/SkPixmap.h"
+#include "include/core/SkRect.h"
+#include "include/core/SkRefCnt.h"
 #include "include/core/SkSize.h"
-#include "include/core/SkStream.h"
 #include "include/core/SkTypes.h"
 #include "include/core/SkYUVAPixmaps.h"
 #include "include/private/SkEncodedInfo.h"
 #include "include/private/SkNoncopyable.h"
-#include "include/private/SkTemplates.h"
+#include "modules/skcms/skcms.h"
 
+#include <cstddef>
+#include <memory>
+#include <tuple>
 #include <vector>
 
 class SkAndroidCodec;
-class SkColorSpace;
 class SkData;
 class SkFrameHolder;
 class SkImage;
 class SkPngChunkReader;
 class SkSampler;
+class SkStream;
 
 namespace DM {
 class CodecSrc;
-class ColorCodecSrc;
 } // namespace DM
 
 /**

package/cpp/skia/include/core/SkAnnotation.h

@@ -19,6 +19,8 @@ class SkCanvas;
  *  Annotate the canvas by associating the specified URL with the
  *  specified rectangle (in local coordinates, just like drawRect).
  *
+ *  The URL is expected to be escaped and be valid 7-bit ASCII.
+ *
  *  If the backend of this canvas does not support annotations, this call is
  *  safely ignored.
  *