rngine 0.7.2 → 0.8.1

package/shared/skia/include/docs/SkPDFJpegHelpers.h

@@ -0,0 +1,41 @@
+/*
+ * Copyright 2024 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+#ifndef SkPDFJPEGHelpers_DEFINED
+#define SkPDFJPEGHelpers_DEFINED
+
+#include "include/codec/SkJpegDecoder.h"
+#include "include/core/SkData.h"
+#include "include/core/SkRefCnt.h"
+#include "include/docs/SkPDFDocument.h"
+#include "include/encode/SkJpegEncoder.h"
+
+class SkPixmap;
+class SkWStream;
+
+#include <memory>
+
+namespace SkPDF::JPEG {
+inline std::unique_ptr<SkCodec> Decode(sk_sp<const SkData> data) {
+    return SkJpegDecoder::Decode(data, nullptr, nullptr);
+}
+
+inline bool Encode(SkWStream* dst, const SkPixmap& src, int quality) {
+    SkJpegEncoder::Options jOpts;
+    jOpts.fQuality = quality;
+    return SkJpegEncoder::Encode(dst, src, jOpts);
+}
+
+inline SkPDF::Metadata MetadataWithCallbacks() {
+    SkPDF::Metadata m;
+    m.jpegDecoder = SkPDF::JPEG::Decode;
+    m.jpegEncoder = SkPDF::JPEG::Encode;
+    return m;
+}
+
+}  // namespace SkPDF::JPEG
+
+#endif

package/shared/skia/include/docs/SkXPSDocument.h

@@ -0,0 +1,43 @@
+/*
+ * Copyright 2017 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkXPSDocument_DEFINED
+#define SkXPSDocument_DEFINED
+
+#include "include/core/SkTypes.h"
+
+#ifdef SK_BUILD_FOR_WIN
+
+#include "include/core/SkDocument.h"
+
+struct IXpsOMObjectFactory;
+class SKWStream;
+class SkPixmap;
+
+namespace SkXPS {
+
+using EncodePngCallback = bool (*)(SkWStream* dst, const SkPixmap& src);
+
+struct Options {
+    float dpi = SK_ScalarDefaultRasterDPI;
+
+    /** Clients can provide a way to encode png. */
+    EncodePngCallback pngEncoder = nullptr;
+
+    /** Skia's XPS support depends on having a png encoder registered to handle
+     *  XPS image brushes. Clients that create XPS documents without images may
+     *  set `allowNoPngs` to true to acknowledge this.
+     */
+    bool allowNoPngs = false;
+};
+
+SK_API sk_sp<SkDocument> MakeDocument(SkWStream* stream,
+                                      IXpsOMObjectFactory* xpsFactory,
+                                      Options opts);
+}  // namespace SkXPS
+#endif  // SK_BUILD_FOR_WIN
+#endif  // SkXPSDocument_DEFINED

package/shared/skia/include/effects/Sk1DPathEffect.h

@@ -0,0 +1,40 @@
+/*
+ * Copyright 2006 The Android Open Source Project
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef Sk1DPathEffect_DEFINED
+#define Sk1DPathEffect_DEFINED
+
+#include "include/core/SkRefCnt.h"
+#include "include/core/SkScalar.h"
+#include "include/core/SkTypes.h"
+
+class SkPath;
+class SkPathEffect;
+
+class SK_API SkPath1DPathEffect {
+public:
+    enum Style {
+        kTranslate_Style,   // translate the shape to each position
+        kRotate_Style,      // rotate the shape about its center
+        kMorph_Style,       // transform each point, and turn lines into curves
+
+        kLastEnum_Style = kMorph_Style,
+    };
+
+    /** Dash by replicating the specified path.
+        @param path The path to replicate (dash)
+        @param advance The space between instances of path
+        @param phase distance (mod advance) along path for its initial position
+        @param style how to transform path at each point (based on the current
+                     position and tangent)
+    */
+    static sk_sp<SkPathEffect> Make(const SkPath& path, SkScalar advance, SkScalar phase, Style);
+
+    static void RegisterFlattenables();
+};
+
+#endif

package/shared/skia/include/effects/Sk2DPathEffect.h

@@ -0,0 +1,33 @@
+/*
+ * Copyright 2006 The Android Open Source Project
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef Sk2DPathEffect_DEFINED
+#define Sk2DPathEffect_DEFINED
+
+#include "include/core/SkRefCnt.h"
+#include "include/core/SkScalar.h"
+#include "include/core/SkTypes.h"
+
+class SkMatrix;
+class SkPath;
+class SkPathEffect;
+
+class SK_API SkLine2DPathEffect {
+public:
+    static sk_sp<SkPathEffect> Make(SkScalar width, const SkMatrix& matrix);
+
+    static void RegisterFlattenables();
+};
+
+class SK_API SkPath2DPathEffect {
+public:
+    static sk_sp<SkPathEffect> Make(const SkMatrix& matrix, const SkPath& path);
+
+    static void RegisterFlattenables();
+};
+
+#endif

package/shared/skia/include/effects/SkBlenders.h

@@ -0,0 +1,27 @@
+/*
+ * Copyright 2021 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkBlenders_DEFINED
+#define SkBlenders_DEFINED
+
+#include "include/core/SkBlender.h"
+
+class SK_API SkBlenders {
+public:
+    /**
+     *  Create a blender that implements the following:
+     *     k1 * src * dst + k2 * src + k3 * dst + k4
+     *  @param k1, k2, k3, k4 The four coefficients.
+     *  @param enforcePMColor If true, the RGB channels will be clamped to the calculated alpha.
+     */
+    static sk_sp<SkBlender> Arithmetic(float k1, float k2, float k3, float k4, bool enforcePremul);
+
+private:
+    SkBlenders() = delete;
+};
+
+#endif

package/shared/skia/include/effects/SkBlurMaskFilter.h

@@ -0,0 +1,35 @@
+/*
+ * Copyright 2006 The Android Open Source Project
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkBlurMaskFilter_DEFINED
+#define SkBlurMaskFilter_DEFINED
+
+// we include this since our callers will need to at least be able to ref/unref
+#include "include/core/SkBlurTypes.h"
+#include "include/core/SkMaskFilter.h"
+#include "include/core/SkRect.h"
+#include "include/core/SkScalar.h"
+
+class SkRRect;
+
+class SK_API SkBlurMaskFilter {
+public:
+#ifdef SK_SUPPORT_LEGACY_EMBOSSMASKFILTER
+    /** Create an emboss maskfilter
+        @param blurSigma    standard deviation of the Gaussian blur to apply
+                            before applying lighting (e.g. 3)
+        @param direction    array of 3 scalars [x, y, z] specifying the direction of the light source
+        @param ambient      0...1 amount of ambient light
+        @param specular     coefficient for specular highlights (e.g. 8)
+        @return the emboss maskfilter
+    */
+    static sk_sp<SkMaskFilter> MakeEmboss(SkScalar blurSigma, const SkScalar direction[3],
+                                          SkScalar ambient, SkScalar specular);
+#endif
+};
+
+#endif

package/shared/skia/include/effects/SkColorMatrix.h

@@ -0,0 +1,57 @@
+/*
+ * Copyright 2007 The Android Open Source Project
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkColorMatrix_DEFINED
+#define SkColorMatrix_DEFINED
+
+#include "include/core/SkTypes.h"
+
+#include <algorithm>
+#include <array>
+
+enum SkYUVColorSpace : int;
+
+class SK_API SkColorMatrix {
+public:
+    constexpr SkColorMatrix() : SkColorMatrix(1, 0, 0, 0, 0,
+                                              0, 1, 0, 0, 0,
+                                              0, 0, 1, 0, 0,
+                                              0, 0, 0, 1, 0) {}
+
+    constexpr SkColorMatrix(float m00, float m01, float m02, float m03, float m04,
+                            float m10, float m11, float m12, float m13, float m14,
+                            float m20, float m21, float m22, float m23, float m24,
+                            float m30, float m31, float m32, float m33, float m34)
+        : fMat { m00, m01, m02, m03, m04,
+                 m10, m11, m12, m13, m14,
+                 m20, m21, m22, m23, m24,
+                 m30, m31, m32, m33, m34 } {}
+
+    static SkColorMatrix RGBtoYUV(SkYUVColorSpace);
+    static SkColorMatrix YUVtoRGB(SkYUVColorSpace);
+
+    void setIdentity();
+    void setScale(float rScale, float gScale, float bScale, float aScale = 1.0f);
+
+    void postTranslate(float dr, float dg, float db, float da);
+
+    void setConcat(const SkColorMatrix& a, const SkColorMatrix& b);
+    void preConcat(const SkColorMatrix& mat) { this->setConcat(*this, mat); }
+    void postConcat(const SkColorMatrix& mat) { this->setConcat(mat, *this); }
+
+    void setSaturation(float sat);
+
+    void setRowMajor(const float src[20]) { std::copy_n(src, 20, fMat.begin()); }
+    void getRowMajor(float dst[20]) const { std::copy_n(fMat.begin(), 20, dst); }
+
+private:
+    std::array<float, 20> fMat;
+
+    friend class SkColorFilters;
+};
+
+#endif

package/shared/skia/include/effects/SkColorMatrixFilter.h

@@ -0,0 +1,22 @@
+/*
+ * Copyright 2007 The Android Open Source Project
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkColorMatrixFilter_DEFINED
+#define SkColorMatrixFilter_DEFINED
+
+#include "include/core/SkColorFilter.h"
+
+// (DEPRECATED) This factory function is deprecated. Please use the one in
+// SkColorFilters (i.e., Lighting).
+class SK_API SkColorMatrixFilter : public SkColorFilter {
+public:
+    static sk_sp<SkColorFilter> MakeLightingFilter(SkColor mul, SkColor add) {
+        return SkColorFilters::Lighting(mul, add);
+    }
+};
+
+#endif

package/shared/skia/include/effects/SkCornerPathEffect.h

@@ -0,0 +1,32 @@
+/*
+ * Copyright 2006 The Android Open Source Project
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkCornerPathEffect_DEFINED
+#define SkCornerPathEffect_DEFINED
+
+#include "include/core/SkRefCnt.h"
+#include "include/core/SkScalar.h"
+#include "include/core/SkTypes.h"
+
+class SkPathEffect;
+
+/** \class SkCornerPathEffect
+
+    SkCornerPathEffect is a subclass of SkPathEffect that can turn sharp corners
+    into various treatments (e.g. rounded corners)
+*/
+class SK_API SkCornerPathEffect {
+public:
+    /** radius must be > 0 to have an effect. It specifies the distance from each corner
+        that should be "rounded".
+    */
+    static sk_sp<SkPathEffect> Make(SkScalar radius);
+
+    static void RegisterFlattenables();
+};
+
+#endif

package/shared/skia/include/effects/SkDashPathEffect.h

@@ -0,0 +1,43 @@
+/*
+ * Copyright 2006 The Android Open Source Project
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkDashPathEffect_DEFINED
+#define SkDashPathEffect_DEFINED
+
+#include "include/core/SkPathEffect.h"  // IWYU pragma: keep    (for unspanned apis)
+#include "include/core/SkRefCnt.h"
+#include "include/core/SkScalar.h"
+#include "include/core/SkSpan.h"
+#include "include/core/SkTypes.h"
+
+class SK_API SkDashPathEffect {
+public:
+    /** intervals: array containing an even number of entries (>=2), with
+         the even indices specifying the length of "on" intervals, and the odd
+         indices specifying the length of "off" intervals. This array will be
+         copied in Make, and can be disposed of freely after.
+        count: number of elements in the intervals array
+        phase: offset into the intervals array (mod the sum of all of the
+         intervals).
+
+        For example: if intervals[] = {10, 20}, count = 2, and phase = 25,
+         this will set up a dashed path like so:
+         5 pixels off
+         10 pixels on
+         20 pixels off
+         10 pixels on
+         20 pixels off
+         ...
+        A phase of -5, 25, 55, 85, etc. would all result in the same path,
+         because the sum of all the intervals is 30.
+
+        Note: only affects stroked paths.
+    */
+    static sk_sp<SkPathEffect> Make(SkSpan<const SkScalar> intervals, SkScalar phase);
+};
+
+#endif

package/shared/skia/include/effects/SkDiscretePathEffect.h

@@ -0,0 +1,37 @@
+/*
+ * Copyright 2006 The Android Open Source Project
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkDiscretePathEffect_DEFINED
+#define SkDiscretePathEffect_DEFINED
+
+#include "include/core/SkPathEffect.h"
+
+/** \class SkDiscretePathEffect
+
+    This path effect chops a path into discrete segments, and randomly displaces them.
+*/
+class SK_API SkDiscretePathEffect {
+public:
+    /** Break the path into segments of segLength length, and randomly move the endpoints
+        away from the original path by a maximum of deviation.
+        Note: works on filled or framed paths
+
+        @param seedAssist This is a caller-supplied seedAssist that modifies
+                          the seed value that is used to randomize the path
+                          segments' endpoints. If not supplied it defaults to 0,
+                          in which case filtering a path multiple times will
+                          result in the same set of segments (this is useful for
+                          testing). If a caller does not want this behaviour
+                          they can pass in a different seedAssist to get a
+                          different set of path segments.
+    */
+    static sk_sp<SkPathEffect> Make(SkScalar segLength, SkScalar dev, uint32_t seedAssist = 0);
+
+    static void RegisterFlattenables();
+};
+
+#endif

package/shared/skia/include/effects/SkGradient.h

@@ -0,0 +1,206 @@
+/*
+ * Copyright 2025 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkGradient_DEFINED
+#define SkGradient_DEFINED
+
+#include "include/core/SkColor.h"
+#include "include/core/SkColorSpace.h"
+#include "include/core/SkPoint.h"
+#include "include/core/SkShader.h"
+#include "include/core/SkSpan.h"
+#include "include/core/SkTileMode.h"
+#include "include/private/SkAPI.h"
+
+class SkMatrix;
+
+class SkGradient {
+public:
+    struct Interpolation {
+        enum class InPremul : bool { kNo = false, kYes = true };
+
+        enum class ColorSpace : uint8_t {
+            // Default Skia behavior: interpolate in the color space of the destination surface
+            kDestination,
+
+            // https://www.w3.org/TR/css-color-4/#interpolation-space
+            kSRGBLinear,
+            kLab,
+            kOKLab,
+            // This is the same as kOKLab, except it has a simplified version of the CSS gamut
+            // mapping algorithm (https://www.w3.org/TR/css-color-4/#css-gamut-mapping)
+            // into Rec2020 space applied to it.
+            // Warning: This space is experimental and should not be used in production.
+            kOKLabGamutMap,
+            kLCH,
+            kOKLCH,
+            // This is the same as kOKLCH, except it has the same gamut mapping applied to it
+            // as kOKLabGamutMap does.
+            // Warning: This space is experimental and should not be used in production.
+            kOKLCHGamutMap,
+            kSRGB,
+            kHSL,
+            kHWB,
+
+            kDisplayP3,
+            kRec2020,
+            kProphotoRGB,
+            kA98RGB,
+
+            kLastColorSpace = kA98RGB,
+        };
+        static constexpr int kColorSpaceCount = static_cast<int>(ColorSpace::kLastColorSpace) + 1;
+
+        enum class HueMethod : uint8_t {
+            // https://www.w3.org/TR/css-color-4/#hue-interpolation
+            kShorter,
+            kLonger,
+            kIncreasing,
+            kDecreasing,
+
+            kLastHueMethod = kDecreasing,
+        };
+        static constexpr int kHueMethodCount = static_cast<int>(HueMethod::kLastHueMethod) + 1;
+
+        InPremul fInPremul = InPremul::kNo;
+        ColorSpace fColorSpace = ColorSpace::kDestination;
+        HueMethod fHueMethod = HueMethod::kShorter;  // Only relevant for LCH, OKLCH, HSL, or HWB
+
+        // legacy compatibility -- remove when we can
+        static Interpolation FromFlags(uint32_t flags) {
+            return {flags & 1 ? InPremul::kYes : InPremul::kNo,
+                    ColorSpace::kDestination,
+                    HueMethod::kShorter};
+        }
+    };
+
+    /**
+     *  Specification for the colors in a gradient.
+     *
+     *  @param  colors  The span of colors for the gradient.
+     *  @param  pos     Relative positions of each color across the gradient. If empty,
+     *                  the the colors are distributed evenly. If this is not null, the values
+     *                  must lie between 0.0 and 1.0, and be strictly increasing. If the first
+     *                  value is not 0.0, then an additional color stop is added at position 0.0,
+     *                  with the same color as colors[0]. If the the last value is less than 1.0,
+     *                  then an additional color stop is added at position 1.0, with the same color
+     *                  as colors[count - 1].
+     *  @param mode     Tiling mode for the gradient.
+     *  @param cs       Optional colorspace associated with the span of colors. If this is null,
+     *                  the colors are treated as sRGB.
+     */
+    class Colors {
+    public:
+        Colors() {}
+        Colors(SkSpan<const SkColor4f> colors,
+               SkSpan<const float> pos,
+               SkTileMode mode,
+               sk_sp<SkColorSpace> cs = nullptr)
+                : fColors(colors), fPos(pos), fColorSpace(std::move(cs)), fTileMode(mode) {
+            SkASSERT(fPos.size() == 0 || fPos.size() == fColors.size());
+
+            // throw away inconsistent inputs
+            if (fPos.size() != fColors.size()) {
+                fPos = {};
+            }
+        }
+
+        Colors(SkSpan<const SkColor4f> colors, SkTileMode tm, sk_sp<SkColorSpace> cs = nullptr)
+                : Colors(colors, {}, tm, std::move(cs)) {}
+
+        SkSpan<const SkColor4f> colors() const { return fColors; }
+        SkSpan<const float> positions() const { return fPos; }
+        const sk_sp<SkColorSpace>& colorSpace() const { return fColorSpace; }
+        SkTileMode tileMode() const { return fTileMode; }
+
+    private:
+        SkSpan<const SkColor4f> fColors;
+        SkSpan<const float> fPos;
+        sk_sp<SkColorSpace> fColorSpace;
+        SkTileMode fTileMode = SkTileMode::kClamp;
+    };
+
+    SkGradient() {}
+    SkGradient(const Colors& colors, const Interpolation& interp)
+            : fColors(colors), fInterpolation(interp) {}
+
+    const Colors& colors() const { return fColors; }
+    const Interpolation& interpolation() const { return fInterpolation; }
+
+private:
+    Colors fColors;
+    Interpolation fInterpolation;
+};
+
+namespace SkShaders {
+/** Returns a shader that generates a linear gradient between the two specified points.
+ *  If the inputs are invalid, this will return nullptr.
+ *  @param points  Array of 2 points, the end-points of the line segment
+ *  @param grad    Description of the colors and interpolation method
+ *  @param lm      Optional local matrix, may be null
+ */
+SK_API sk_sp<SkShader> LinearGradient(const SkPoint pts[2],
+                                      const SkGradient&,
+                                      const SkMatrix* lm = nullptr);
+
+/** Returns a shader that generates a radial gradient given the center and radius.
+ *  @param center  The center of the circle for this gradient
+ *  @param radius  Must be positive. The radius of the circle for this gradient
+ *  @param grad    Description of the colors and interpolation method
+ *  @param lm      Optional local matrix, may be null
+ */
+SK_API sk_sp<SkShader> RadialGradient(SkPoint center,
+                                      float radius,
+                                      const SkGradient& grad,
+                                      const SkMatrix* lm = nullptr);
+
+/** Returns a shader that generates a conical gradient given two circles, or
+ *  returns null if the inputs are invalid. The gradient interprets the
+ *  two circles according to the following HTML spec.
+ *  http://dev.w3.org/html5/2dcontext/#dom-context-2d-createradialgradient
+ *  @param start        The center of the circle for this gradient
+ *  @param startRadius  Must be positive. The radius of the circle for this gradient
+ *  @param end          The center of the circle for this gradient
+ *  @param startRadius  Must be positive. The radius of the circle for this gradient
+ *  @param grad         Description of the colors and interpolation method
+ *  @param lm           Optional local matrix, may be null
+ */
+SK_API sk_sp<SkShader> TwoPointConicalGradient(SkPoint start,
+                                               float startRadius,
+                                               SkPoint end,
+                                               float endRadius,
+                                               const SkGradient& grad,
+                                               const SkMatrix* lm = nullptr);
+
+/** Returns a shader that generates a sweep gradient given a center.
+ *  The shader accepts negative angles and angles larger than 360, draws
+ *  between 0 and 360 degrees, similar to the CSS conic-gradient
+ *  semantics. 0 degrees means horizontal positive x axis. The start angle
+ *  must be less than the end angle, otherwise a null pointer is
+ *  returned. If color stops do not contain 0 and 1 but are within this
+ *  range, the respective outer color stop is repeated for 0 and 1. Color
+ *  stops less than 0 are clamped to 0, and greater than 1 are clamped to 1.
+ *  @param center      The center of the sweep
+ *  @param startAngle  Start of the angular range, corresponding to pos == 0.
+ *  @param endAngle    End of the angular range, corresponding to pos == 1.
+ *  @param grad        Description of the colors and interpolation method
+ *  @param lm          Optional local matrix, may be null
+ */
+SK_API sk_sp<SkShader> SweepGradient(SkPoint center,
+                                     float startAngle,
+                                     float endAngle,
+                                     const SkGradient&,
+                                     const SkMatrix* lm = nullptr);
+static inline sk_sp<SkShader> SweepGradient(SkPoint center,
+                                     const SkGradient& grad,
+                                     const SkMatrix* lm = nullptr) {
+    return SweepGradient(center, 0, 360, grad, lm);
+}
+
+}  // namespace SkShaders
+
+#endif