npm - @shopify/react-native-skia - Versions diffs - 0.1.128 → 0.1.131 - Mend

@shopify/react-native-skia 0.1.128 → 0.1.131

Files changed (1659) hide show

package/cpp/skia/include/core/SkCustomMesh.h DELETED Viewed

@@ -1,202 +0,0 @@
-/*
- * 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 SkCustomMesh_DEFINED
-#define SkCustomMesh_DEFINED
-#include "include/core/SkTypes.h"
-#ifdef SK_ENABLE_SKSL
-#include "include/core/SkColorSpace.h"
-#include "include/core/SkImageInfo.h"
-#include "include/core/SkRect.h"
-#include "include/core/SkRefCnt.h"
-#include "include/core/SkSpan.h"
-#include "include/core/SkString.h"
-#include <vector>
-namespace SkSL { struct Program; }
-/**
- * A specification for custom meshes. Specifies the vertex buffer attributes and stride, the
- * vertex program that produces a user-defined set of varyings, a fragment program that ingests
- * the interpolated varyings and produces local coordinates and optionally a color.
- *
- * The signature of the vertex program must be:
- *   float2 main(Attributes, out Varyings)
- * where the return value is a local position that will be transformed by SkCanvas's matrix.
- *
- * The signature of the fragment program must be either:
- *   (float2|void) main(Varyings)
- * or
- *   (float2|void) main(Varyings, out (half4|float4) color)
- *
- * where the return value is the local coordinates that will be used to access SkShader. If the
- * return type is void then the interpolated position from vertex shader return is used as the local
- * coordinate. If the color variant is used it will be blended with SkShader (or SkPaint color in
- * absence of a shader) using the SkBlender provided to the SkCanvas draw call.
- */
-class SkCustomMeshSpecification : public SkNVRefCnt<SkCustomMeshSpecification> {
-public:
-    /** These values are enforced when creating a specification. */
-    static constexpr size_t kMaxStride       = 1024;
-    static constexpr size_t kMaxAttributes   = 8;
-    static constexpr size_t kStrideAlignment = 4;
-    static constexpr size_t kOffsetAlignment = 4;
-    static constexpr size_t kMaxVaryings     = 6;
-    struct Attribute {
-        enum class Type : uint32_t {  // CPU representation     Shader Type
-            kFloat,                   // float                  float
-            kFloat2,                  // two floats             float2
-            kFloat3,                  // three floats           float3
-            kFloat4,                  // four floats            float4
-            kUByte4_unorm,            // four bytes             half4
-            kLast = kUByte4_unorm
-        };
-        Type     type;
-        size_t   offset;
-        SkString name;
-    };
-    struct Varying {
-        enum class Type : uint32_t {
-            kFloat,   // "float"
-            kFloat2,  // "float2"
-            kFloat3,  // "float3"
-            kFloat4,  // "float4"
-            kHalf,    // "half"
-            kHalf2,   // "half2"
-            kHalf3,   // "half3"
-            kHalf4,   // "half4"
-            kLast = kHalf4
-        };
-        Type     type;
-        SkString name;
-    };
-    ~SkCustomMeshSpecification();
-    struct Result {
-        sk_sp<SkCustomMeshSpecification> specification;
-        SkString                         error;
-    };
-    /**
-     * If successful the return is a specification and an empty error string. Otherwise, it is a
-     * null specification a non-empty error string.
-     *
-     * @param attributes     The vertex attributes that will be consumed by 'vs'. Attributes need
-     *                       not be tightly packed but attribute offsets must be aligned to
-     *                       kOffsetAlignment and offset + size may not be greater than
-     *                       'vertexStride'. At least one attribute is required.
-     * @param vertexStride   The offset between successive attribute values. This must be aligned to
-     *                       kStrideAlignment.
-     * @param varyings       The varyings that will be written by 'vs' and read by 'fs'. This may
-     *                       be empty.
-     * @param vs             The vertex shader code that computes a vertex position and the varyings
-     *                       from the attributes.
-     * @param fs             The fragment code that computes a local coordinate and optionally a
-     *                       color from the varyings. The local coordinate is used to sample
-     *                       SkShader.
-     * @param cs             The colorspace of the color produced by 'fs'. Ignored if 'fs's main()
-     *                       function does not have a color out param.
-     * @param at             The alpha type of the color produced by 'fs'. Ignored if 'fs's main()
-     *                       function does not have a color out param. Cannot be kUnknown.
-     */
-    static Result Make(SkSpan<const Attribute> attributes,
-                       size_t                  vertexStride,
-                       SkSpan<const Varying>   varyings,
-                       const SkString&         vs,
-                       const SkString&         fs,
-                       sk_sp<SkColorSpace>     cs = SkColorSpace::MakeSRGB(),
-                       SkAlphaType             at = kPremul_SkAlphaType);
-    SkSpan<const Attribute> attributes() const { return SkMakeSpan(fAttributes); }
-    size_t stride() const { return fStride; }
-private:
-    friend struct SkCustomMeshSpecificationPriv;
-    enum class ColorType {
-        kNone,
-        kHalf4,
-        kFloat4,
-    };
-    static Result MakeFromSourceWithStructs(SkSpan<const Attribute> attributes,
-                                            size_t                  stride,
-                                            SkSpan<const Varying>   varyings,
-                                            const SkString&         vs,
-                                            const SkString&         fs,
-                                            sk_sp<SkColorSpace>     cs,
-                                            SkAlphaType             at);
-    SkCustomMeshSpecification(SkSpan<const Attribute>,
-                              size_t,
-                              SkSpan<const Varying>,
-                              std::unique_ptr<SkSL::Program>,
-                              std::unique_ptr<SkSL::Program>,
-                              ColorType,
-                              bool hasLocalCoords,
-                              sk_sp<SkColorSpace>,
-                              SkAlphaType);
-    SkCustomMeshSpecification(const SkCustomMeshSpecification&) = delete;
-    SkCustomMeshSpecification(SkCustomMeshSpecification&&) = delete;
-    SkCustomMeshSpecification& operator=(const SkCustomMeshSpecification&) = delete;
-    SkCustomMeshSpecification& operator=(SkCustomMeshSpecification&&) = delete;
-    const std::vector<Attribute>       fAttributes;
-    const std::vector<Varying>         fVaryings;
-    std::unique_ptr<SkSL::Program>     fVS;
-    std::unique_ptr<SkSL::Program>     fFS;
-    size_t                             fStride;
-    uint32_t                           fHash;
-    ColorType                          fColorType;
-    bool                               fHasLocalCoords;
-    sk_sp<SkColorSpace>                fColorSpace;
-    SkAlphaType                        fAlphaType;
-};
-/**
- * This is a placeholder object. We will want something that allows the client to incrementally
- * update the mesh that can be synchronized with the GPU backend without requiring extra copies.
- *
- * A buffer of vertices, a topology, optionally indices, and a compatible SkCustomMeshSpecification.
- * The data in 'vb' is expected to contain the attributes described in 'spec' for 'vcount' vertices.
- * The size of the buffer must be at least spec->stride()*vcount (even if vertex attributes contains
- * pad at the end of the stride). If 'bounds' does not contain all points output by 'spec''s vertex
- * program when applied to the vertices in 'vb' a draw of the custom mesh produces undefined
- * results.
- *
- * If indices is null then then 'icount' must be <= 0. 'vcount' vertices will be selected from 'vb'
- * to create the topology indicated by 'mode'.
- *
- * If indices is not null then icount must be >= 3. 'vb' will be indexed by 'icount' successive
- * values in 'indices' to create the topology indicated by 'mode'. The values in 'indices' must be
- * less than 'vcount'
- */
-struct SkCustomMesh {
-    enum class Mode { kTriangles, kTriangleStrip };
-    sk_sp<SkCustomMeshSpecification>  spec;
-    Mode                              mode     = Mode::kTriangles;
-    SkRect                            bounds   = SkRect::MakeEmpty();
-    const void*                       vb       = nullptr;
-    int                               vcount   = 0;
-    const uint16_t*                   indices  = nullptr;
-    int                               icount   = 0;
-};
-#endif  // SK_ENABLE_SKSL
-#endif

package/cpp/skia/include/core/SkStringView.h DELETED Viewed

@@ -1,185 +0,0 @@
-/*
- * 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 SkStringView_DEFINED
-#define SkStringView_DEFINED
-#include <algorithm>
-#include <cstring>
-#include <string>
-namespace skstd {
-class string_view {
-public:
-    using value_type = char;
-    using traits_type = std::char_traits<value_type>;
-    using const_pointer = const value_type*;
-    using const_reference = const value_type&;
-    using iterator = const_pointer;
-    using const_iterator = iterator;
-    using size_type = size_t;
-    static constexpr size_type npos = size_type(-1);
-    constexpr string_view()
-        : fData(nullptr)
-        , fLength(0) {}
-    constexpr string_view(const string_view&) = default;
-    constexpr string_view(const_pointer data, size_type length)
-        : fData(data)
-        , fLength(length) {}
-    string_view(const_pointer data)
-        : string_view(data, strlen(data)) {}
-    string_view(const std::string& str)
-        : string_view(str.data(), str.length()) {}
-    constexpr string_view& operator=(const string_view&) = default;
-    constexpr iterator begin() const {
-        return fData;
-    }
-    constexpr iterator end() const {
-        return fData + fLength;
-    }
-    constexpr const_reference operator[](size_type idx) const {
-        return fData[idx];
-    }
-    constexpr const_reference front() const {
-        return fData[0];
-    }
-    constexpr const_reference back() const {
-        return fData[fLength - 1];
-    }
-    constexpr const_pointer data() const {
-        return fData;
-    }
-    constexpr size_type size() const {
-        return fLength;
-    }
-    constexpr size_type length() const {
-        return fLength;
-    }
-    constexpr bool empty() const {
-        return fLength == 0;
-    }
-    constexpr bool starts_with(string_view s) const {
-        if (s.length() > fLength) {
-            return false;
-        }
-        return s.length() == 0 || !memcmp(fData, s.fData, s.length());
-    }
-    constexpr bool starts_with(value_type c) const {
-        return !this->empty() && this->front() == c;
-    }
-    constexpr bool ends_with(string_view s) const {
-        if (s.length() > fLength) {
-            return false;
-        }
-        return s.length() == 0 || !memcmp(this->end() - s.length(), s.fData, s.length());
-    }
-    constexpr bool ends_with(value_type c) const {
-        return !this->empty() && this->back() == c;
-    }
-    size_type find(string_view needle, size_type pos = 0) const {
-        if (needle.length() == 0) {
-            return 0;
-        }
-        if (this->length() < needle.length()) {
-            return npos;
-        }
-        const char* match = nullptr;
-        const char* start = this->data() + pos;
-        const char* end = start + this->length() - needle.length() + 1;
-        while ((match = (const char*)(memchr(start, needle[0], (size_t)(end - start))))) {
-            if (!memcmp(match, needle.data(), needle.length())) {
-                return (size_type)(match - this->data());
-            } else {
-                start = match + 1;
-            }
-        }
-        return npos;
-    }
-    bool contains(string_view needle) const {
-        return this->find(needle) != npos;
-    }
-    constexpr string_view substr(size_type pos = 0, size_type count = npos) const {
-        if (pos > fLength) {
-            return {};
-        }
-        return string_view{fData + pos, std::min(count, fLength - pos)};
-    }
-    constexpr void swap(string_view& other) {
-        const_pointer tempData = fData;
-        fData = other.fData;
-        other.fData = tempData;
-        size_type tempLength = fLength;
-        fLength = other.fLength;
-        other.fLength = tempLength;
-    }
-    constexpr void remove_prefix(size_type n) {
-        fData += n;
-        fLength -= n;
-    }
-    constexpr void remove_suffix(size_type n) {
-        fLength -= n;
-    }
-private:
-    const_pointer fData;
-    size_type fLength;
-};
-bool operator==(string_view left, string_view right);
-bool operator!=(string_view left, string_view right);
-bool operator<(string_view left, string_view right);
-bool operator<=(string_view left, string_view right);
-bool operator>(string_view left, string_view right);
-bool operator>=(string_view left, string_view right);
-} // namespace skstd
-namespace std {
-    template<> struct hash<skstd::string_view> {
-        size_t operator()(const skstd::string_view& s) const {
-            size_t result = 0;
-            for (auto iter = s.begin(); iter != s.end(); ++iter) {
-                result = result * 101 + (size_t) *iter;
-            }
-            return result;
-        }
-    };
-} // namespace std
-#endif

package/cpp/skia/include/private/GrContext_Base.h DELETED Viewed

@@ -1,92 +0,0 @@
-/*
- * Copyright 2019 Google Inc.
- *
- * Use of this source code is governed by a BSD-style license that can be
- * found in the LICENSE file.
- */
-#ifndef GrContext_Base_DEFINED
-#define GrContext_Base_DEFINED
-#include "include/core/SkRefCnt.h"
-#include "include/gpu/GrBackendSurface.h"
-#include "include/gpu/GrContextOptions.h"
-#include "include/gpu/GrTypes.h"
-class GrBaseContextPriv;
-class GrCaps;
-class GrContextThreadSafeProxy;
-class GrDirectContext;
-class GrImageContext;
-class GrRecordingContext;
-class GrContext_Base : public SkRefCnt {
-public:
-    ~GrContext_Base() override;
-    /*
-     * Safely downcast to a GrDirectContext.
-     */
-    virtual GrDirectContext* asDirectContext() { return nullptr; }
-    /*
-     * The 3D API backing this context
-     */
-    SK_API GrBackendApi backend() const;
-    /*
-     * Retrieve the default GrBackendFormat for a given SkColorType and renderability.
-     * It is guaranteed that this backend format will be the one used by the GrContext
-     * SkColorType and SkSurfaceCharacterization-based createBackendTexture methods.
-     *
-     * The caller should check that the returned format is valid.
-     */
-    SK_API GrBackendFormat defaultBackendFormat(SkColorType, GrRenderable) const;
-    SK_API GrBackendFormat compressedBackendFormat(SkImage::CompressionType) const;
-    // TODO: When the public version is gone, rename to refThreadSafeProxy and add raw ptr ver.
-    sk_sp<GrContextThreadSafeProxy> threadSafeProxy();
-    // Provides access to functions that aren't part of the public API.
-    GrBaseContextPriv priv();
-    const GrBaseContextPriv priv() const;  // NOLINT(readability-const-return-type)
-protected:
-    friend class GrBaseContextPriv; // for hidden functions
-    GrContext_Base(sk_sp<GrContextThreadSafeProxy>);
-    virtual bool init();
-    /**
-     * An identifier for this context. The id is used by all compatible contexts. For example,
-     * if SkImages are created on one thread using an image creation context, then fed into a
-     * DDL Recorder on second thread (which has a recording context) and finally replayed on
-     * a third thread with a direct context, then all three contexts will report the same id.
-     * It is an error for an image to be used with contexts that report different ids.
-     */
-    uint32_t contextID() const;
-    bool matches(GrContext_Base* candidate) const {
-        return candidate && candidate->contextID() == this->contextID();
-    }
-    /*
-     * The options in effect for this context
-     */
-    const GrContextOptions& options() const;
-    const GrCaps* caps() const;
-    sk_sp<const GrCaps> refCaps() const;
-    virtual GrImageContext* asImageContext() { return nullptr; }
-    virtual GrRecordingContext* asRecordingContext() { return nullptr; }
-    sk_sp<GrContextThreadSafeProxy>         fThreadSafeProxy;
-private:
-    using INHERITED = SkRefCnt;
-};
-#endif

package/cpp/skia/include/private/GrGLTypesPriv.h DELETED Viewed

@@ -1,107 +0,0 @@
-/*
- * Copyright 2019 Google LLC
- *
- * Use of this source code is governed by a BSD-style license that can be
- * found in the LICENSE file.
- */
-#include "include/core/SkRefCnt.h"
-#include "include/gpu/gl/GrGLTypes.h"
-#ifndef GrGLTypesPriv_DEFINED
-#define GrGLTypesPriv_DEFINED
-static constexpr int kGrGLColorFormatCount = static_cast<int>(GrGLFormat::kLastColorFormat) + 1;
-class GrGLTextureParameters : public SkNVRefCnt<GrGLTextureParameters> {
-public:
-    // We currently consider texture parameters invalid on all textures
-    // GrContext::resetContext(). We use this type to track whether instances of
-    // GrGLTextureParameters were updated before or after the most recent resetContext(). At 10
-    // resets / frame and 60fps a 64bit timestamp will overflow in about a billion years.
-    // TODO: Require clients to use GrBackendTexture::glTextureParametersModified() to invalidate
-    // texture parameters and get rid of timestamp checking.
-    using ResetTimestamp = uint64_t;
-    // This initializes the params to have an expired timestamp. They'll be considered invalid the
-    // first time the texture is used unless set() is called.
-    GrGLTextureParameters() = default;
-    // This is texture parameter state that is overridden when a non-zero sampler object is bound.
-    struct SamplerOverriddenState {
-        SamplerOverriddenState();
-        void invalidate();
-        GrGLenum fMinFilter;
-        GrGLenum fMagFilter;
-        GrGLenum fWrapS;
-        GrGLenum fWrapT;
-        GrGLfloat fMinLOD;
-        GrGLfloat fMaxLOD;
-        // We always want the border color to be transparent black, so no need to store 4 floats.
-        // Just track if it's been invalidated and no longer the default
-        bool fBorderColorInvalid;
-    };
-    // Texture parameter state that is not overridden by a bound sampler object.
-    struct NonsamplerState {
-        NonsamplerState();
-        void invalidate();
-        GrGLint fBaseMipMapLevel;
-        GrGLint fMaxMipmapLevel;
-        bool    fSwizzleIsRGBA;
-    };
-    void invalidate();
-    ResetTimestamp resetTimestamp() const { return fResetTimestamp; }
-    const SamplerOverriddenState& samplerOverriddenState() const { return fSamplerOverriddenState; }
-    const NonsamplerState& nonsamplerState() const { return fNonsamplerState; }
-    // SamplerOverriddenState is optional because we don't track it when we're using sampler
-    // objects.
-    void set(const SamplerOverriddenState* samplerState,
-             const NonsamplerState& nonsamplerState,
-             ResetTimestamp currTimestamp);
-private:
-    static constexpr ResetTimestamp kExpiredTimestamp = 0;
-    SamplerOverriddenState fSamplerOverriddenState;
-    NonsamplerState fNonsamplerState;
-    ResetTimestamp fResetTimestamp = kExpiredTimestamp;
-};
-class GrGLBackendTextureInfo {
-public:
-    GrGLBackendTextureInfo(const GrGLTextureInfo& info, GrGLTextureParameters* params)
-            : fInfo(info), fParams(params) {}
-    GrGLBackendTextureInfo(const GrGLBackendTextureInfo&) = delete;
-    GrGLBackendTextureInfo& operator=(const GrGLBackendTextureInfo&) = delete;
-    const GrGLTextureInfo& info() const { return fInfo; }
-    GrGLTextureParameters* parameters() const { return fParams; }
-    sk_sp<GrGLTextureParameters> refParameters() const { return sk_ref_sp(fParams); }
-    void cleanup();
-    void assign(const GrGLBackendTextureInfo&, bool thisIsValid);
-private:
-    GrGLTextureInfo fInfo;
-    GrGLTextureParameters* fParams;
-};
-struct GrGLTextureSpec {
-    GrGLTextureSpec() : fTarget(0), fFormat(0) {}
-    GrGLTextureSpec(const GrGLSurfaceInfo& info) : fTarget(info.fTarget), fFormat(info.fFormat) {}
-    GrGLenum fTarget;
-    GrGLenum fFormat;
-};
-GrGLSurfaceInfo GrGLTextureSpecToSurfaceInfo(const GrGLTextureSpec& glSpec,
-                                             uint32_t sampleCount,
-                                             uint32_t levelCount,
-                                             GrProtected isProtected);
-#endif

package/cpp/skia/include/private/GrImageContext.h DELETED Viewed

@@ -1,55 +0,0 @@
-/*
- * Copyright 2019 Google Inc.
- *
- * Use of this source code is governed by a BSD-style license that can be
- * found in the LICENSE file.
- */
-#ifndef GrImageContext_DEFINED
-#define GrImageContext_DEFINED
-#include "include/private/GrContext_Base.h"
-#include "include/private/GrSingleOwner.h"
-class GrImageContextPriv;
-// This is now just a view on a ThreadSafeProxy, that SkImages can attempt to
-// downcast to a GrDirectContext as a backdoor to some operations. Once we remove the backdoors,
-// this goes away and SkImages just hold ThreadSafeProxies.
-class GrImageContext : public GrContext_Base {
-public:
-    ~GrImageContext() override;
-    // Provides access to functions that aren't part of the public API.
-    GrImageContextPriv priv();
-    const GrImageContextPriv priv() const;  // NOLINT(readability-const-return-type)
-protected:
-    friend class GrImageContextPriv; // for hidden functions
-    GrImageContext(sk_sp<GrContextThreadSafeProxy>);
-    SK_API virtual void abandonContext();
-    SK_API virtual bool abandoned();
-    /** This is only useful for debug purposes */
-    GrSingleOwner* singleOwner() const { return &fSingleOwner; }
-    GrImageContext* asImageContext() override { return this; }
-private:
-    // When making promise images, we currently need a placeholder GrImageContext instance to give
-    // to the SkImage that has no real power, just a wrapper around the ThreadSafeProxy.
-    // TODO: De-power SkImage to ThreadSafeProxy or at least figure out a way to share one instance.
-    static sk_sp<GrImageContext> MakeForPromiseImage(sk_sp<GrContextThreadSafeProxy>);
-    // In debug builds we guard against improper thread handling
-    // This guard is passed to the GrDrawingManager and, from there to all the
-    // GrSurfaceDrawContexts.  It is also passed to the GrResourceProvider and SkGpuDevice.
-    // TODO: Move this down to GrRecordingContext.
-    mutable GrSingleOwner            fSingleOwner;
-    using INHERITED = GrContext_Base;
-};
-#endif