@shopify/react-native-skia 0.1.191 → 0.1.193

package/cpp/skia/include/gpu/graphite/CombinationBuilder.h

@@ -1,195 +0,0 @@
-/*
- * 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 skgpu_graphite_CombinationBuilder_DEFINED
-#define skgpu_graphite_CombinationBuilder_DEFINED
-
-#include "include/core/SkTypes.h"
-
-#ifdef SK_ENABLE_PRECOMPILE
-
-#include <functional>
-#include <memory>
-#include <vector>
-#include "include/core/SkBlendMode.h"
-#include "include/core/SkSpan.h"
-#include "include/core/SkTileMode.h"
-#include "include/private/SkTArray.h"
-#include "include/private/SkTHash.h"
-
-class SkArenaAllocWithReset;
-class SkKeyContext;
-class SkPaintParamsKeyBuilder;
-class SkShaderCodeDictionary;
-class SkUniquePaintParamsID;
-
-namespace skgpu::graphite {
-
-class CombinationBuilder;
-class CombinationBuilderTestAccess;
-class Context;
-class Option;
-
-enum class ShaderType : uint32_t {
-    kSolidColor,
-
-    kLinearGradient,
-    kRadialGradient,
-    kSweepGradient,
-    kConicalGradient,
-
-    kLocalMatrix,
-    kImage,
-    kPorterDuffBlendShader,
-    kBlendShader,
-
-    kLast          = kBlendShader
-};
-
-static constexpr int kShaderTypeCount = static_cast<int>(ShaderType::kLast) + 1;
-
-struct TileModePair {
-    SkTileMode fX;
-    SkTileMode fY;
-
-    bool operator==(const TileModePair& other) const { return fX == other.fX && fY == other.fY; }
-    bool operator!=(const TileModePair& other) const { return !(*this == other); }
-};
-
-// TODO: add ShaderID and ColorFilterID too
-class BlenderID {
-public:
-    BlenderID() : fID(0) {}  // 0 is an invalid blender ID
-    BlenderID(const BlenderID& src) : fID(src.fID) {}
-
-    bool isValid() const { return fID > 0; }
-
-    bool operator==(const BlenderID& other) const { return fID == other.fID; }
-
-    BlenderID& operator=(const BlenderID& src) {
-        fID = src.fID;
-        return *this;
-    }
-
-private:
-    friend class ::SkShaderCodeDictionary;   // for ctor and asUInt access
-    friend class CombinationBuilder;         // for asUInt access
-
-    BlenderID(uint32_t id) : fID(id) {}
-
-    uint32_t asUInt() const { return fID; }
-
-    uint32_t fID;
-};
-
-// When combination options are added to the combination builder an CombinationOption
-// object is frequently returned. This allows options to be added, recursively, to the
-// previously added options.
-// Note: CombinationOptions are stable memory-wise so, once returned, they are valid
-// until CombinationBuilder::reset is called.
-class CombinationOption {
-public:
-    CombinationOption addChildOption(int childIndex, ShaderType);
-
-    CombinationOption addChildOption(int childIndex, ShaderType,
-                                     int minNumStops, int maxNumStops);
-
-    CombinationOption addChildOption(int childIndex, ShaderType,
-                                     SkSpan<TileModePair> tileModes);
-
-    bool isValid() const { return fDataInArena; }
-
-private:
-    friend class CombinationBuilder; // for ctor
-    friend class CombinationBuilderTestAccess;
-
-    CombinationOption(CombinationBuilder* builder, Option* dataInArena)
-            : fBuilder(builder)
-            , fDataInArena(dataInArena) {}
-
-    ShaderType type() const;
-    int numChildSlots() const;
-    SkDEBUGCODE(int epoch() const;)
-
-    CombinationBuilder* fBuilder;
-    Option* fDataInArena;
-};
-
-class CombinationBuilder {
-public:
-    enum class BlendModeGroup {
-        kPorterDuff,         // [ kClear .. kScreen ]
-        kAdvanced,           // [ kOverlay .. kMultiply ]
-        kColorAware,         // [ kHue .. kLuminosity ]
-        kAll
-    };
-
-    CombinationBuilder(SkShaderCodeDictionary*);
-    ~CombinationBuilder();
-
-    // Blend Modes
-    void addOption(SkBlendMode);
-    void addOption(SkBlendMode rangeStart, SkBlendMode rangeEnd); // inclusive
-    void addOption(BlendModeGroup);
-
-    // TODO: have this variant return an CombinationOption object
-    void addOption(BlenderID);
-
-    // Shaders
-    CombinationOption addOption(ShaderType);
-    CombinationOption addOption(ShaderType, int minNumStops, int maxNumStops);  // inclusive
-    CombinationOption addOption(ShaderType, SkSpan<TileModePair> tileModes);
-
-    void reset();
-
-private:
-    friend class Context;                        // for access to 'buildCombinations'
-    friend class CombinationOption;              // for 'addOptionInternal' and 'arena'
-    friend class CombinationBuilderTestAccess;   // for 'num*Combinations' and 'epoch'
-
-    int numShaderCombinations() const;
-    int numBlendModeCombinations() const;
-    int numCombinations() {
-        return this->numShaderCombinations() * this->numBlendModeCombinations();
-    }
-
-    // 'desiredCombination' must be less than numCombinations
-    void createKey(const SkKeyContext&, int desiredCombination, SkPaintParamsKeyBuilder*);
-
-#ifdef SK_DEBUG
-    void dump() const;
-    int epoch() const { return fEpoch; }
-#endif
-
-    SkArenaAllocWithReset* arena() { return fArena.get(); }
-
-    template<typename T, typename... Args>
-    Option* allocInArena(Args&&... args);
-
-    Option* addOptionInternal(ShaderType);
-    Option* addOptionInternal(ShaderType, int minNumStops, int maxNumStops);
-    Option* addOptionInternal(ShaderType, SkSpan<TileModePair> tileModes);
-
-    void buildCombinations(SkShaderCodeDictionary*,
-                           const std::function<void(SkUniquePaintParamsID)>&);
-
-    SkShaderCodeDictionary* fDictionary;
-    std::unique_ptr<SkArenaAllocWithReset> fArena;
-    SkTArray<Option*> fShaderOptions;
-
-    uint32_t fBlendModes;
-    // TODO: store the SkBlender-based blenders in the arena
-    SkTHashSet<BlenderID> fBlenders;
-
-    SkDEBUGCODE(int fEpoch = 0;)
-};
-
-} // namespace skgpu::graphite
-
-#endif // SK_ENABLE_PRECOMPILE
-
-#endif // skgpu_graphite_CombinationBuilder_DEFINED

package/cpp/skia/include/private/SkHalf.h

@@ -1,38 +0,0 @@
-/*
- * Copyright 2014 Google Inc.
- *
- * Use of this source code is governed by a BSD-style license that can be
- * found in the LICENSE file.
- */
-
-#ifndef SkHalf_DEFINED
-#define SkHalf_DEFINED
-
-#include "include/core/SkTypes.h"
-#include "include/private/SkVx.h"
-
-// 16-bit floating point value
-// format is 1 bit sign, 5 bits exponent, 10 bits mantissa
-// only used for storage
-typedef uint16_t SkHalf;
-
-static constexpr uint16_t SK_HalfMin     = 0x0400; // 2^-14  (minimum positive normal value)
-static constexpr uint16_t SK_HalfMax     = 0x7bff; // 65504
-static constexpr uint16_t SK_HalfEpsilon = 0x1400; // 2^-10
-static constexpr uint16_t SK_Half1       = 0x3C00; // 1
-
-// convert between half and single precision floating point
-float SkHalfToFloat(SkHalf h);
-SkHalf SkFloatToHalf(float f);
-
-// Convert between half and single precision floating point,
-// assuming inputs and outputs are both finite, and may
-// flush values which would be denormal half floats to zero.
-static inline skvx::float4 SkHalfToFloat_finite_ftz(uint64_t rgba) {
-    return skvx::from_half(skvx::half4::Load(&rgba));
-}
-static inline skvx::half4 SkFloatToHalf_finite_ftz(const skvx::float4& c) {
-    return skvx::to_half(c);
-}
-
-#endif

package/cpp/skia/include/private/SkImageInfoPriv.h

@@ -1,199 +0,0 @@
-/*
- * Copyright 2017 Google Inc.
- *
- * Use of this source code is governed by a BSD-style license that can be
- * found in the LICENSE file.
- */
-
-#ifndef SkImageInfoPriv_DEFINED
-#define SkImageInfoPriv_DEFINED
-
-#include "include/core/SkColor.h"
-#include "include/core/SkImageInfo.h"
-
-static inline uint32_t SkColorTypeChannelFlags(SkColorType ct) {
-    switch (ct) {
-        case kUnknown_SkColorType:            return 0;
-        case kAlpha_8_SkColorType:            return kAlpha_SkColorChannelFlag;
-        case kRGB_565_SkColorType:            return kRGB_SkColorChannelFlags;
-        case kARGB_4444_SkColorType:          return kRGBA_SkColorChannelFlags;
-        case kRGBA_8888_SkColorType:          return kRGBA_SkColorChannelFlags;
-        case kRGB_888x_SkColorType:           return kRGB_SkColorChannelFlags;
-        case kBGRA_8888_SkColorType:          return kRGBA_SkColorChannelFlags;
-        case kRGBA_1010102_SkColorType:       return kRGBA_SkColorChannelFlags;
-        case kRGB_101010x_SkColorType:        return kRGB_SkColorChannelFlags;
-        case kBGRA_1010102_SkColorType:       return kRGBA_SkColorChannelFlags;
-        case kBGR_101010x_SkColorType:        return kRGB_SkColorChannelFlags;
-        case kGray_8_SkColorType:             return kGray_SkColorChannelFlag;
-        case kRGBA_F16Norm_SkColorType:       return kRGBA_SkColorChannelFlags;
-        case kRGBA_F16_SkColorType:           return kRGBA_SkColorChannelFlags;
-        case kRGBA_F32_SkColorType:           return kRGBA_SkColorChannelFlags;
-        case kR8G8_unorm_SkColorType:         return kRG_SkColorChannelFlags;
-        case kA16_unorm_SkColorType:          return kAlpha_SkColorChannelFlag;
-        case kR16G16_unorm_SkColorType:       return kRG_SkColorChannelFlags;
-        case kA16_float_SkColorType:          return kAlpha_SkColorChannelFlag;
-        case kR16G16_float_SkColorType:       return kRG_SkColorChannelFlags;
-        case kR16G16B16A16_unorm_SkColorType: return kRGBA_SkColorChannelFlags;
-        case kSRGBA_8888_SkColorType:         return kRGBA_SkColorChannelFlags;
-        case kR8_unorm_SkColorType:           return kRed_SkColorChannelFlag;
-    }
-    SkUNREACHABLE;
-}
-
-static inline bool SkColorTypeIsAlphaOnly(SkColorType ct) {
-    return SkColorTypeChannelFlags(ct) == kAlpha_SkColorChannelFlag;
-}
-
-static inline bool SkAlphaTypeIsValid(unsigned value) {
-    return value <= kLastEnum_SkAlphaType;
-}
-
-static int SkColorTypeShiftPerPixel(SkColorType ct) {
-    switch (ct) {
-        case kUnknown_SkColorType:            return 0;
-        case kAlpha_8_SkColorType:            return 0;
-        case kRGB_565_SkColorType:            return 1;
-        case kARGB_4444_SkColorType:          return 1;
-        case kRGBA_8888_SkColorType:          return 2;
-        case kRGB_888x_SkColorType:           return 2;
-        case kBGRA_8888_SkColorType:          return 2;
-        case kRGBA_1010102_SkColorType:       return 2;
-        case kRGB_101010x_SkColorType:        return 2;
-        case kBGRA_1010102_SkColorType:       return 2;
-        case kBGR_101010x_SkColorType:        return 2;
-        case kGray_8_SkColorType:             return 0;
-        case kRGBA_F16Norm_SkColorType:       return 3;
-        case kRGBA_F16_SkColorType:           return 3;
-        case kRGBA_F32_SkColorType:           return 4;
-        case kR8G8_unorm_SkColorType:         return 1;
-        case kA16_unorm_SkColorType:          return 1;
-        case kR16G16_unorm_SkColorType:       return 2;
-        case kA16_float_SkColorType:          return 1;
-        case kR16G16_float_SkColorType:       return 2;
-        case kR16G16B16A16_unorm_SkColorType: return 3;
-        case kSRGBA_8888_SkColorType:         return 2;
-        case kR8_unorm_SkColorType:           return 0;
-    }
-    SkUNREACHABLE;
-}
-
-static inline size_t SkColorTypeMinRowBytes(SkColorType ct, int width) {
-    return (size_t)(width * SkColorTypeBytesPerPixel(ct));
-}
-
-static inline bool SkColorTypeIsValid(unsigned value) {
-    return value <= kLastEnum_SkColorType;
-}
-
-static inline size_t SkColorTypeComputeOffset(SkColorType ct, int x, int y, size_t rowBytes) {
-    if (kUnknown_SkColorType == ct) {
-        return 0;
-    }
-    return (size_t)y * rowBytes + ((size_t)x << SkColorTypeShiftPerPixel(ct));
-}
-
-static inline bool SkColorTypeIsNormalized(SkColorType ct) {
-    switch (ct) {
-        case kUnknown_SkColorType:
-        case kAlpha_8_SkColorType:
-        case kRGB_565_SkColorType:
-        case kARGB_4444_SkColorType:
-        case kRGBA_8888_SkColorType:
-        case kRGB_888x_SkColorType:
-        case kBGRA_8888_SkColorType:
-        case kRGBA_1010102_SkColorType:
-        case kRGB_101010x_SkColorType:
-        case kBGRA_1010102_SkColorType:
-        case kBGR_101010x_SkColorType:
-        case kGray_8_SkColorType:
-        case kRGBA_F16Norm_SkColorType:
-        case kR8G8_unorm_SkColorType:
-        case kA16_unorm_SkColorType:
-        case kA16_float_SkColorType:          /*subtle... alpha is always [0,1]*/
-        case kR16G16_unorm_SkColorType:
-        case kR16G16B16A16_unorm_SkColorType:
-        case kSRGBA_8888_SkColorType:
-        case kR8_unorm_SkColorType:
-            return true;
-
-        case kRGBA_F16_SkColorType:
-        case kRGBA_F32_SkColorType:
-        case kR16G16_float_SkColorType:
-            return false;
-    }
-    SkUNREACHABLE;
-}
-
-static inline int SkColorTypeMaxBitsPerChannel(SkColorType ct) {
-    switch (ct) {
-        case kUnknown_SkColorType:
-            return 0;
-
-        case kARGB_4444_SkColorType:
-            return 4;
-
-        case kRGB_565_SkColorType:
-            return 6;
-
-        case kAlpha_8_SkColorType:
-        case kRGBA_8888_SkColorType:
-        case kRGB_888x_SkColorType:
-        case kBGRA_8888_SkColorType:
-        case kGray_8_SkColorType:
-        case kR8G8_unorm_SkColorType:
-        case kSRGBA_8888_SkColorType:
-        case kR8_unorm_SkColorType:
-            return 8;
-
-        case kRGBA_1010102_SkColorType:
-        case kRGB_101010x_SkColorType:
-        case kBGRA_1010102_SkColorType:
-        case kBGR_101010x_SkColorType:
-            return 10;
-
-        case kRGBA_F16Norm_SkColorType:
-        case kA16_unorm_SkColorType:
-        case kA16_float_SkColorType:
-        case kR16G16_unorm_SkColorType:
-        case kR16G16B16A16_unorm_SkColorType:
-        case kRGBA_F16_SkColorType:
-        case kR16G16_float_SkColorType:
-            return 16;
-
-        case kRGBA_F32_SkColorType:
-            return 32;
-    }
-    SkUNREACHABLE;
-}
-
-/**
- *  Returns true if |info| contains a valid colorType and alphaType.
- */
-static inline bool SkColorInfoIsValid(const SkColorInfo& info) {
-    return info.colorType() != kUnknown_SkColorType && info.alphaType() != kUnknown_SkAlphaType;
-}
-
-/**
- *  Returns true if |info| contains a valid combination of width, height and colorInfo.
- */
-static inline bool SkImageInfoIsValid(const SkImageInfo& info) {
-    if (info.width() <= 0 || info.height() <= 0) {
-        return false;
-    }
-
-    const int kMaxDimension = SK_MaxS32 >> 2;
-    if (info.width() > kMaxDimension || info.height() > kMaxDimension) {
-        return false;
-    }
-
-    return SkColorInfoIsValid(info.colorInfo());
-}
-
-/**
- *  Returns true if Skia has defined a pixel conversion from the |src| to the |dst|.
- *  Returns false otherwise.
- */
-static inline bool SkImageInfoValidConversion(const SkImageInfo& dst, const SkImageInfo& src) {
-    return SkImageInfoIsValid(dst) && SkImageInfoIsValid(src);
-}
-#endif  // SkImageInfoPriv_DEFINED

package/cpp/skia/include/private/SkSLIRNode.h

@@ -1,64 +0,0 @@
-/*
- * Copyright 2016 Google Inc.
- *
- * Use of this source code is governed by a BSD-style license that can be
- * found in the LICENSE file.
- */
-
-#ifndef SKSL_IRNODE
-#define SKSL_IRNODE
-
-#include "include/private/SkSLString.h"
-#include "include/private/SkTArray.h"
-#include "include/sksl/SkSLPosition.h"
-#include "src/sksl/SkSLLexer.h"
-#include "src/sksl/SkSLModifiersPool.h"
-#include "src/sksl/SkSLPool.h"
-
-#include <algorithm>
-#include <atomic>
-#include <unordered_set>
-#include <vector>
-
-namespace SkSL {
-
-class Expression;
-class FunctionDeclaration;
-class FunctionDefinition;
-class Statement;
-class Symbol;
-class SymbolTable;
-class Type;
-class Variable;
-class VariableReference;
-enum class VariableRefKind : int8_t;
-enum class VariableStorage : int8_t;
-
-/**
- * Represents a node in the intermediate representation (IR) tree. The IR is a fully-resolved
- * version of the program (all types determined, everything validated), ready for code generation.
- */
-class IRNode : public Poolable {
-public:
-    virtual ~IRNode() {}
-
-    virtual std::string description() const = 0;
-
-    // No copy construction or assignment
-    IRNode(const IRNode&) = delete;
-    IRNode& operator=(const IRNode&) = delete;
-
-    // position of this element within the program being compiled, for error reporting purposes
-    Position fPosition;
-
-protected:
-    IRNode(Position position, int kind)
-        : fPosition(position)
-        , fKind(kind) {}
-
-    int fKind;
-};
-
-}  // namespace SkSL
-
-#endif

package/cpp/skia/include/private/SkSLLayout.h

@@ -1,144 +0,0 @@
-/*
- * Copyright 2016 Google Inc.
- *
- * Use of this source code is governed by a BSD-style license that can be
- * found in the LICENSE file.
- */
-
-#ifndef SKSL_LAYOUT
-#define SKSL_LAYOUT
-
-#include "include/private/SkSLString.h"
-
-namespace SkSL {
-
-/**
- * Represents a layout block appearing before a variable declaration, as in:
- *
- * layout (location = 0) int x;
- */
-struct Layout {
-    enum Flag {
-        kOriginUpperLeft_Flag            = 1 <<  0,
-        kPushConstant_Flag               = 1 <<  1,
-        kBlendSupportAllEquations_Flag   = 1 <<  2,
-        kColor_Flag                      = 1 <<  3,
-
-        // These flags indicate if the qualifier appeared, regardless of the accompanying value.
-        kLocation_Flag                   = 1 <<  4,
-        kOffset_Flag                     = 1 <<  5,
-        kBinding_Flag                    = 1 <<  6,
-        kIndex_Flag                      = 1 <<  7,
-        kSet_Flag                        = 1 <<  8,
-        kBuiltin_Flag                    = 1 <<  9,
-        kInputAttachmentIndex_Flag       = 1 << 10,
-    };
-
-    Layout(int flags, int location, int offset, int binding, int index, int set, int builtin,
-           int inputAttachmentIndex)
-    : fFlags(flags)
-    , fLocation(location)
-    , fOffset(offset)
-    , fBinding(binding)
-    , fIndex(index)
-    , fSet(set)
-    , fBuiltin(builtin)
-    , fInputAttachmentIndex(inputAttachmentIndex) {}
-
-    Layout()
-    : fFlags(0)
-    , fLocation(-1)
-    , fOffset(-1)
-    , fBinding(-1)
-    , fIndex(-1)
-    , fSet(-1)
-    , fBuiltin(-1)
-    , fInputAttachmentIndex(-1) {}
-
-    static Layout builtin(int builtin) {
-        Layout result;
-        result.fBuiltin = builtin;
-        return result;
-    }
-
-    std::string description() const {
-        std::string result;
-        auto separator = [firstSeparator = true]() mutable -> std::string {
-            if (firstSeparator) {
-                firstSeparator = false;
-                return "";
-            } else {
-                return ", ";
-            }};
-        if (fLocation >= 0) {
-            result += separator() + "location = " + std::to_string(fLocation);
-        }
-        if (fOffset >= 0) {
-            result += separator() + "offset = " + std::to_string(fOffset);
-        }
-        if (fBinding >= 0) {
-            result += separator() + "binding = " + std::to_string(fBinding);
-        }
-        if (fIndex >= 0) {
-            result += separator() + "index = " + std::to_string(fIndex);
-        }
-        if (fSet >= 0) {
-            result += separator() + "set = " + std::to_string(fSet);
-        }
-        if (fBuiltin >= 0) {
-            result += separator() + "builtin = " + std::to_string(fBuiltin);
-        }
-        if (fInputAttachmentIndex >= 0) {
-            result += separator() + "input_attachment_index = " +
-                      std::to_string(fInputAttachmentIndex);
-        }
-        if (fFlags & kOriginUpperLeft_Flag) {
-            result += separator() + "origin_upper_left";
-        }
-        if (fFlags & kBlendSupportAllEquations_Flag) {
-            result += separator() + "blend_support_all_equations";
-        }
-        if (fFlags & kPushConstant_Flag) {
-            result += separator() + "push_constant";
-        }
-        if (fFlags & kColor_Flag) {
-            result += separator() + "color";
-        }
-        if (result.size() > 0) {
-            result = "layout (" + result + ")";
-        }
-        return result;
-    }
-
-    bool operator==(const Layout& other) const {
-        return fFlags                == other.fFlags &&
-               fLocation             == other.fLocation &&
-               fOffset               == other.fOffset &&
-               fBinding              == other.fBinding &&
-               fIndex                == other.fIndex &&
-               fSet                  == other.fSet &&
-               fBuiltin              == other.fBuiltin &&
-               fInputAttachmentIndex == other.fInputAttachmentIndex;
-    }
-
-    bool operator!=(const Layout& other) const {
-        return !(*this == other);
-    }
-
-    int fFlags;
-    int fLocation;
-    int fOffset;
-    int fBinding;
-    int fIndex;
-    int fSet;
-    // builtin comes from SPIR-V and identifies which particular builtin value this object
-    // represents.
-    int fBuiltin;
-    // input_attachment_index comes from Vulkan/SPIR-V to connect a shader variable to the a
-    // corresponding attachment on the subpass in which the shader is being used.
-    int fInputAttachmentIndex;
-};
-
-}  // namespace SkSL
-
-#endif