react-native-skia 0.0.1 → 2.15.0

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

@@ -0,0 +1,159 @@
+/*
+ * Copyright 2022 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkColorType_DEFINED
+#define SkColorType_DEFINED
+
+#include "include/core/SkTypes.h"
+
+/** \enum SkColorType
+    Describes how pixel bits encode color. A pixel may be an alpha mask, a grayscale, RGB, or ARGB.
+
+    kN32_SkColorType selects the native 32-bit ARGB format for the current configuration. This can
+    lead to inconsistent results across platforms, so use with caution.
+
+    By default, Skia operates with the assumption of a little-Endian system. The names of each
+    SkColorType implicitly define the channel ordering and size in memory. Due to historical reasons
+    the names do not follow 100% identical convention, but are typically labeled from least
+    significant to most significant. To help clarify when the actual data layout differs from the
+    default convention, every SkColorType's comment includes a bit-labeled description of a pixel
+    in that color type on a LE system.
+
+    Unless specified otherwise, a channel's value is treated as an unsigned integer with a range of
+    of [0, 2^N-1] and this is mapped uniformly to a floating point value of [0.0, 1.0]. Some color
+    types instead store data directly in 32-bit floating point (assumed to be IEEE), or in 16-bit
+    "half" floating point values. A half float, or F16/float16, is interpreted as FP 1-5-10 or
+       Bits: [sign:15 exp:14..10 man:9..0]
+*/
+enum SkColorType : int {
+    // Unknown or unrepresentable as an SkColorType.
+    kUnknown_SkColorType,
+    // Single channel data (8-bit) interpreted as an alpha value. RGB are 0.
+    //   Bits: [A:7..0]
+    kAlpha_8_SkColorType,
+    // Three channel BGR data (5 bits red, 6 bits green, 5 bits blue) packed into a LE 16-bit word.
+    // NOTE: The name of this enum value does not match the standard convention for SkColorType.
+    //   Bits: [R:15..11 G:10..5 B:4..0]
+    kRGB_565_SkColorType,
+    // Four channel ABGR data (4 bits per channel) packed into a LE 16-bit word.
+    // NOTE: The name of this enum value does not match the standard convention for SkColorType.
+    //   Bits: [R:15..12 G:11..8 B:7..4 A:3..0]
+    kARGB_4444_SkColorType,
+    // Four channel RGBA data (8 bits per channel) packed into a LE 32-bit word.
+    //   Bits: [A:31..24 B:23..16 G:15..8 R:7..0]
+    kRGBA_8888_SkColorType,
+    // Three channel RGB data (8 bits per channel) packed into a LE 32-bit word. The remaining bits
+    // are ignored and alpha is forced to opaque.
+    //   Bits: [x:31..24 B:23..16 G:15..8 R:7..0]
+    kRGB_888x_SkColorType,
+    // Four channel BGRA data (8 bits per channel) packed into a LE 32-bit word. R and B are swapped
+    // relative to kRGBA_8888.
+    //   Bits: [A:31..24 R:23..16 G:15..8 B:7..0]
+    kBGRA_8888_SkColorType,
+    // Four channel RGBA data (10 bits per color, 2 bits for alpha) packed into a LE 32-bit word.
+    //   Bits: [A:31..30 B:29..20 G:19..10 R:9..0]
+    kRGBA_1010102_SkColorType,
+    // Four channel BGRA data (10 bits per color, 2 bits for alpha) packed into a LE 32-bit word.
+    // R and B are swapped relative to kRGBA_1010102.
+    //   Bits: [A:31..30 R:29..20 G:19..10 B:9..0]
+    kBGRA_1010102_SkColorType,
+    // Three channel RGB data (10 bits per channel) packed into a LE 32-bit word. The remaining bits
+    // are ignored and alpha is forced to opaque.
+    //   Bits: [x:31..30 B:29..20 G:19..10 R:9..0]
+    kRGB_101010x_SkColorType,
+    // Three channel BGR data (10 bits per channel) packed into a LE 32-bit word. The remaining bits
+    // are ignored and alpha is forced to opaque. R and B are swapped relative to kRGB_101010x.
+    //   Bits: [x:31..30 R:29..20 G:19..10 B:9..0]
+    kBGR_101010x_SkColorType,
+    // Three channel BGR data (10 bits per channel) packed into a LE 32-bit word. The remaining bits
+    // are ignored and alpha is forced to opaque. Instead of normalizing [0, 1023] to [0.0, 1.0] the
+    // color channels map to an extended range of [-0.752941, 1.25098], compatible with
+    // MTLPixelFormatBGR10_XR.
+    //   Bits: [x:31..30 R:29..20 G:19..10 B:9..0]
+    kBGR_101010x_XR_SkColorType,
+    // Four channel BGRA data (10 bits per channel) packed into a LE 64-bit word. Each channel is
+    // preceded by 6 bits of padding.  Instead of normalizing [0, 1023] to [0.0, 1.0] the color and
+    // alpha channels map to an extended range of [-0.752941, 1.25098], compatible with
+    // MTLPixelFormatBGRA10_XR.
+    //   Bits: [A:63..54 x:53..48 R:47..38 x:37..32 G:31..22 x:21..16 B:15..6 x:5..0]
+    kBGRA_10101010_XR_SkColorType,
+    // Four channel RGBA data (10 bits per channel) packed into a LE 64-bit word. Each channel is
+    // preceded by 6 bits of padding.
+    //   Bits: [A:63..54 x:53..48 B:47..38 x:37..32 G:31..22 x:21..16 R:15..6 x:5..0]
+    kRGBA_10x6_SkColorType,
+    // Single channel data (8-bit) interpreted as a grayscale value (e.g. replicated to RGB).
+    //   Bits: [G:7..0]
+    kGray_8_SkColorType,
+    // Four channel RGBA data (16-bit half-float per channel) packed into a LE 64-bit word. Values
+    // are assumed to be in [0.0,1.0] range, unlike kRGBA_F16.
+    //   Bits: [A:63..48 B:47..32 G:31..16 R:15..0]
+    kRGBA_F16Norm_SkColorType,
+    // Four channel RGBA data (16-bit half-float per channel) packed into a LE 64-bit word.
+    // This has extended range compared to kRGBA_F16Norm.
+    //   Bits: [A:63..48 B:47..32 G:31..16 R:15..0]
+    kRGBA_F16_SkColorType,
+    // Three channel RGB data (16-bit half-float per channel) packed into a LE 64-bit word. The last
+    // 16 bits are ignored and alpha is forced to opaque.
+    //   Bits: [x:63..48 B:47..32 G:31..16 R:15..0]
+    kRGB_F16F16F16x_SkColorType,
+    // Four channel RGBA data (32-bit float per channel) packed into a LE 128-bit word.
+    //   Bits: [A:127..96 B:95..64 G:63..32 R:31..0]
+    kRGBA_F32_SkColorType,
+    // Two channel RG data (8 bits per channel). Blue is forced to 0, alpha is forced to opaque.
+    //   Bits: [G:15..8 R:7..0]
+    kR8G8_unorm_SkColorType,
+    // Single channel data (16-bit half-float) interpreted as alpha. RGB are 0.
+    //   Bits: [A:15..0]
+    kA16_float_SkColorType,
+
+    // Single channel data (16 bits half-float) interpreted as red. G and B are forced to 0, alpha
+    // is forced to opaque.
+    //   Bits: [R:15..0]
+    kR16_float_SkColorType,
+    // Two channel RG data (16-bit half-float per channel) packed into a LE 32-bit word.
+    // Blue is forced to 0, alpha is forced to opaque.
+    //   Bits: [G:31..16 R:15..0]
+    kR16G16_float_SkColorType,
+    // Single channel data (16 bits) interpreted as alpha. RGB are 0.
+    //   Bits: [A:15..0]
+    kA16_unorm_SkColorType,
+    // Single channel data (16 bits) interpreted as red. G and B are forced to 0, alpha is forced to
+    // opaque.
+    //   Bits: [R:15..0]
+    kR16_unorm_SkColorType,
+    // Two channel RG data (16 bits per channel) packed into a LE 32-bit word. B is forced to 0,
+    // alpha is forced to opaque.
+    //   Bits: [G:31..16 R:15..0]
+    kR16G16_unorm_SkColorType,
+    // Four channel RGBA data (16 bits per channel) packed into a LE 64-bit word.
+    //   Bits: [A:63..48 B:47..32 G:31..16 R:15..0]
+    kR16G16B16A16_unorm_SkColorType,
+    // Four channel RGBA data (8 bits per channel) packed into a LE 32-bit word. The RGB values are
+    // assumed to be encoded with the sRGB transfer function, which can be decoded automatically
+    // by GPU hardware with certain texture formats.
+    //   Bits: [A:31..24 B:23..16 G:15..8 R:7..0]
+    kSRGBA_8888_SkColorType,
+    // Single channel data (8 bits) interpreted as red. G and B are forced to 0, alpha is forced to
+    // opaque.
+    //    Bits: [R:7..0]
+    kR8_unorm_SkColorType,
+
+    kLastEnum_SkColorType     = kR8_unorm_SkColorType, //!< last valid value
+
+#if SK_PMCOLOR_BYTE_ORDER(B,G,R,A)
+    kN32_SkColorType          = kBGRA_8888_SkColorType,//!< native 32-bit BGRA encoding
+
+#elif SK_PMCOLOR_BYTE_ORDER(R,G,B,A)
+    kN32_SkColorType          = kRGBA_8888_SkColorType,//!< native 32-bit RGBA encoding
+
+#else
+    #error "SK_*32_SHIFT values must correspond to BGRA or RGBA byte order"
+#endif
+};
+static constexpr int kSkColorTypeCnt = static_cast<int>(kLastEnum_SkColorType) + 1;
+
+#endif

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

@@ -0,0 +1,62 @@
+/*
+ * Copyright 2026 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkContext_DEFINED
+#define SkContext_DEFINED
+
+#include "include/core/SkRefCnt.h"
+#include "include/private/SkAPI.h"
+
+class SkContextPriv;
+class SkResourceCache;
+class SkSharedContext;
+class SkStrikeCache;
+class SkTraceMemoryDump;
+class SkTypefaceCache;
+struct SkContextOptions;
+
+/**
+ * @brief SkContext is a central context object that serves as the mandatory first point of
+ * initialization for all Skia clients. SkContext consolidates global state, management of shared
+ * resources, and internal caches.
+ */
+class SK_API SkContext final {
+public:
+    SkContext(const SkContext&) = delete;
+    SkContext(SkContext&&) = delete;
+    SkContext& operator=(const SkContext&) = delete;
+    SkContext& operator=(SkContext&&) = delete;
+
+    ~SkContext();
+
+    SkContextPriv priv();
+    const SkContextPriv priv() const;
+
+private:
+    SkContext(sk_sp<SkSharedContext>);
+
+    SkResourceCache* resourceCache() const;
+    SkStrikeCache* fontCache() const;
+    SkTypefaceCache* typefaceCache() const;
+
+    size_t fontCacheLimit() const;
+    size_t setFontCacheLimit(size_t bytes);
+    size_t fontCacheUsed() const;
+
+    int fontCacheCountLimit() const;
+    int setFontCacheCountLimit(int count);
+    int fontCacheCountUsed() const;
+
+    void purgeFontCache();
+    void purgePinnedFontCache();
+
+    void dumpMemoryStatistics(SkTraceMemoryDump* dump);
+
+    sk_sp<SkSharedContext> fSharedContext;
+};
+
+#endif  // SkContext_DEFINED

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

@@ -0,0 +1,15 @@
+/*
+ * Copyright 2026 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkContextOptions_DEFINED
+#define SkContextOptions_DEFINED
+
+#include "include/private/SkAPI.h"
+
+struct SK_API SkContextOptions {};
+
+#endif  // SkContextOptions_DEFINED

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

@@ -0,0 +1,215 @@
+/*
+ * Copyright 2018 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkContourMeasure_DEFINED
+#define SkContourMeasure_DEFINED
+
+#include "include/core/SkPathTypes.h" // IWYU pragma: keep
+#include "include/core/SkPoint.h"
+#include "include/core/SkRefCnt.h"
+#include "include/core/SkScalar.h"
+#include "include/core/SkSpan.h"
+#include "include/core/SkTypes.h"
+#include "include/private/SkTDArray.h"
+
+#include <cstddef>
+#include <memory>
+
+class SkMatrix;
+class SkPath;
+class SkPathBuilder;
+
+class SK_API SkContourMeasure : public SkRefCnt {
+public:
+    /** Return the length of the contour.
+     */
+    SkScalar length() const { return fLength; }
+
+    /** Pins distance to 0 <= distance <= length(), and then computes the corresponding
+     *  position and tangent.
+     */
+    [[nodiscard]] bool getPosTan(SkScalar distance, SkPoint* position, SkVector* tangent) const;
+
+    enum MatrixFlags {
+        kGetPosition_MatrixFlag     = 0x01,
+        kGetTangent_MatrixFlag      = 0x02,
+        kGetPosAndTan_MatrixFlag    = kGetPosition_MatrixFlag | kGetTangent_MatrixFlag
+    };
+
+    /** Pins distance to 0 <= distance <= getLength(), and then computes
+     the corresponding matrix (by calling getPosTan).
+     Returns false if there is no path, or a zero-length path was specified, in which case
+     matrix is unchanged.
+     */
+    [[nodiscard]] bool getMatrix(SkScalar distance, SkMatrix* matrix,
+                                 MatrixFlags flags = kGetPosAndTan_MatrixFlag) const;
+
+    /** Given a start and stop distance, append to dst the intervening segment(s).
+     If the segment is zero-length, return false, else return true.
+     startD and stopD are pinned to legal values (0..getLength()). If startD > stopD
+     then return false (and leave dst untouched).
+     Begin the segment with a moveTo if startWithMoveTo is true
+     */
+    [[nodiscard]] bool getSegment(SkScalar startD, SkScalar stopD, SkPathBuilder* dst,
+                                  bool startWithMoveTo) const;
+
+    /** Return true if the contour is closed()
+     */
+    bool isClosed() const { return fIsClosed; }
+
+    /** Measurement data for individual verbs.
+     */
+    struct VerbMeasure {
+        SkScalar              fDistance; // Cumulative distance along the current contour.
+        SkPathVerb            fVerb;     // Verb type.
+        SkSpan<const SkPoint> fPts;      // Verb points.
+    };
+
+private:
+    struct Segment;
+
+public:
+    /** Utility for iterating over the current contour verbs:
+     *
+     *   for (const auto verb_measure : contour_measure) {
+     *     ...
+     *   }
+     */
+    class ForwardVerbIterator final {
+    public:
+        VerbMeasure operator*() const;
+
+        ForwardVerbIterator& operator++() {
+            SkASSERT(!fSegments.empty());
+
+            fSegments = LastSegForCurrentVerb(fSegments.subspan(1));
+
+            return *this;
+        }
+
+        bool operator==(const ForwardVerbIterator& other) const {
+            SkASSERT(fSegments.data() != other.fSegments.data() ||
+                     fSegments.size() == other.fSegments.size());
+            return fSegments.data() == other.fSegments.data();
+        }
+
+        bool operator!=(const ForwardVerbIterator& other) const {
+            return !((*this) == other);
+        }
+
+    private:
+        friend class SkContourMeasure;
+
+        ForwardVerbIterator(SkSpan<const Segment> segs, SkSpan<const SkPoint> pts)
+            : fSegments(LastSegForCurrentVerb(segs))
+            , fPts(pts) {}
+
+        static SkSpan<const Segment> LastSegForCurrentVerb(const SkSpan<const Segment>& segs) {
+            size_t i = 1;
+            while (i < segs.size() && segs[0].fPtIndex == segs[i].fPtIndex) {
+                ++i;
+            }
+
+            return segs.subspan(i - 1);
+        }
+
+        // Remaining segments for forward iteration. The first segment in the span is
+        // adjusted to always point to the last segment of the current verb, such that its distance
+        // corresponds to the verb distance.
+        SkSpan<const Segment> fSegments;
+
+        // All path points (indexed in segments).
+        SkSpan<const SkPoint> fPts;
+    };
+
+    ForwardVerbIterator begin() const {
+        return ForwardVerbIterator(fSegments, fPts);
+    }
+    ForwardVerbIterator end() const {
+        return ForwardVerbIterator(SkSpan(fSegments.end(), 0), fPts);
+    }
+
+private:
+    struct Segment {
+        SkScalar    fDistance;  // total distance up to this point
+        unsigned    fPtIndex; // index into the fPts array
+        unsigned    fTValue : 30;
+        unsigned    fType : 2;  // actually the enum SkSegType
+        // See SkPathMeasurePriv.h
+
+        SkScalar getScalarT() const;
+
+        static const Segment* Next(const Segment* seg) {
+            unsigned ptIndex = seg->fPtIndex;
+            do {
+                ++seg;
+            } while (seg->fPtIndex == ptIndex);
+            return seg;
+        }
+
+    };
+
+    const SkTDArray<Segment>  fSegments;
+    const SkTDArray<SkPoint>  fPts; // Points used to define the segments
+
+    const SkScalar fLength;
+    const bool fIsClosed;
+
+    SkContourMeasure(SkTDArray<Segment>&& segs, SkTDArray<SkPoint>&& pts,
+                     SkScalar length, bool isClosed);
+    ~SkContourMeasure() override {}
+
+    const Segment* distanceToSegment(SkScalar distance, SkScalar* t) const;
+
+    friend class SkContourMeasureIter;
+    friend class SkPathMeasurePriv;
+};
+
+class SK_API SkContourMeasureIter {
+public:
+    SkContourMeasureIter();
+    /**
+     *  Initialize the Iter with a path.
+     *  The parts of the path that are needed are copied, so the client is free to modify/delete
+     *  the path after this call.
+     *
+     *  resScale controls the precision of the measure. values > 1 increase the
+     *  precision (and possibly slow down the computation).
+     */
+    SkContourMeasureIter(const SkPath& path, bool forceClosed, SkScalar resScale = 1);
+    ~SkContourMeasureIter();
+
+    SkContourMeasureIter(SkContourMeasureIter&&);
+    SkContourMeasureIter& operator=(SkContourMeasureIter&&);
+
+    /**
+     *  Reset the Iter with a path.
+     *  The parts of the path that are needed are copied, so the client is free to modify/delete
+     *  the path after this call.
+     */
+    void reset(const SkPath& path, bool forceClosed, SkScalar resScale = 1);
+
+    /**
+     *  Iterates through contours in path, returning a contour-measure object for each contour
+     *  in the path. Returns null when it is done.
+     *
+     *  This only returns non-zero length contours, where a contour is the segments between
+     *  a kMove_Verb and either ...
+     *      - the next kMove_Verb
+     *      - kClose_Verb (1 or more)
+     *      - kDone_Verb
+     *  If it encounters a zero-length contour, it is skipped.
+     */
+    sk_sp<SkContourMeasure> next();
+
+private:
+    class Impl;
+
+    std::unique_ptr<Impl> fImpl;
+};
+
+#endif

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

@@ -0,0 +1,28 @@
+/*
+ * Copyright 2018 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkCoverageMode_DEFINED
+#define SkCoverageMode_DEFINED
+
+/**
+ *  Describes geometric operations (ala SkRegion::Op) that can be applied to coverage bytes.
+ *  These can be thought of as variants of porter-duff (SkBlendMode) modes, but only applied
+ *  to the alpha channel.
+ *
+ *  See SkMaskFilter for ways to use these when combining two different masks.
+ */
+enum class SkCoverageMode {
+    kUnion,             // A ∪ B    A+B-A*B
+    kIntersect,         // A ∩ B    A*B
+    kDifference,        // A - B    A*(1-B)
+    kReverseDifference, // B - A    B*(1-A)
+    kXor,               // A ⊕ B    A+B-2*A*B
+
+    kLast = kXor,
+};
+
+#endif

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

@@ -0,0 +1,47 @@
+/*
+ * Copyright 2018 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkCubicMap_DEFINED
+#define SkCubicMap_DEFINED
+
+#include "include/core/SkPoint.h"
+#include "include/core/SkScalar.h"
+#include "include/core/SkTypes.h"
+
+/**
+ *  Fast evaluation of a cubic ease-in / ease-out curve. This is defined as a parametric cubic
+ *  curve inside the unit square.
+ *
+ *  pt[0] is implicitly { 0, 0 }
+ *  pt[3] is implicitly { 1, 1 }
+ *  pts[1,2].X are inside the unit [0..1]
+ */
+class SK_API SkCubicMap {
+public:
+    SkCubicMap(SkPoint p1, SkPoint p2);
+
+    static bool IsLinear(SkPoint p1, SkPoint p2) {
+        return SkScalarNearlyEqual(p1.fX, p1.fY) && SkScalarNearlyEqual(p2.fX, p2.fY);
+    }
+
+    float computeYFromX(float x) const;
+
+    SkPoint computeFromT(float t) const;
+
+private:
+    enum Type {
+        kLine_Type,     // x == y
+        kCubeRoot_Type, // At^3 == x
+        kSolver_Type,   // general monotonic cubic solver
+    };
+
+    SkPoint fCoeff[3];
+    Type    fType;
+};
+
+#endif
+