@shopify/react-native-skia 0.1.158 → 0.1.159

package/cpp/skia/include/sksl/DSLVar.h

@@ -8,12 +8,13 @@
 #ifndef SKSL_DSL_VAR
 #define SKSL_DSL_VAR
 
+#include "include/private/SkSLStatement.h"
 #include "include/sksl/DSLExpression.h"
 #include "include/sksl/DSLModifiers.h"
 #include "include/sksl/DSLType.h"
 #include "include/sksl/SkSLPosition.h"
 
-#include <stdint.h>
+#include <cstdint>
 #include <memory>
 #include <string_view>
 #include <utility>
@@ -22,9 +23,6 @@ namespace SkSL {
 
 class Expression;
 class ExpressionArray;
-class IRGenerator;
-class SPIRVCodeGenerator;
-class Statement;
 class Variable;
 enum class VariableStorage : int8_t;
 
@@ -33,31 +31,16 @@ namespace dsl {
 class DSLVarBase {
 public:
     /**
-     * Creates an empty, unpopulated var. Can be replaced with a real var later via `swap`.
-     */
-    DSLVarBase() : fType(kVoid_Type), fDeclared(true) {}
-
-    /**
-     * Constructs a new variable with the specified type and name. The name is used (in mangled
-     * form) in the resulting shader code; it is not otherwise important. Since mangling prevents
-     * name conflicts and the variable's name is only important when debugging shaders, the name
-     * parameter is optional.
+     * Constructs a new variable with the specified type and name.
      */
-    DSLVarBase(DSLType type, std::string_view name, DSLExpression initialValue, Position pos,
-            Position namePos);
-
-    DSLVarBase(DSLType type, DSLExpression initialValue, Position pos, Position namePos);
-
-    DSLVarBase(const DSLModifiers& modifiers, DSLType type, std::string_view name,
+    DSLVarBase(VariableStorage storage, DSLType type, std::string_view name,
                DSLExpression initialValue, Position pos, Position namePos);
 
-    DSLVarBase(const DSLModifiers& modifiers, DSLType type, DSLExpression initialValue,
-               Position pos, Position namePos);
+    DSLVarBase(VariableStorage storage, const DSLModifiers& modifiers, DSLType type,
+               std::string_view name, DSLExpression initialValue, Position pos, Position namePos);
 
     DSLVarBase(DSLVarBase&&) = default;
 
-    virtual ~DSLVarBase();
-
     std::string_view name() const {
         return fName;
     }
@@ -66,64 +49,75 @@ public:
         return fModifiers;
     }
 
-    virtual VariableStorage storage() const = 0;
+    VariableStorage storage() const {
+        return fStorage;
+    }
 
     DSLExpression x() {
-        return DSLExpression(*this, Position()).x();
+        return DSLExpression(*this).x();
     }
 
     DSLExpression y() {
-        return DSLExpression(*this, Position()).y();
+        return DSLExpression(*this).y();
     }
 
     DSLExpression z() {
-        return DSLExpression(*this, Position()).z();
+        return DSLExpression(*this).z();
     }
 
     DSLExpression w() {
-        return DSLExpression(*this, Position()).w();
+        return DSLExpression(*this).w();
     }
 
     DSLExpression r() {
-        return DSLExpression(*this, Position()).r();
+        return DSLExpression(*this).r();
     }
 
     DSLExpression g() {
-        return DSLExpression(*this, Position()).g();
+        return DSLExpression(*this).g();
     }
 
     DSLExpression b() {
-        return DSLExpression(*this, Position()).b();
+        return DSLExpression(*this).b();
     }
 
     DSLExpression a() {
-        return DSLExpression(*this, Position()).a();
+        return DSLExpression(*this).a();
     }
 
     DSLExpression field(std::string_view name) {
-        return DSLExpression(*this, Position()).field(name);
+        return DSLExpression(*this).field(name);
     }
 
-    DSLPossibleExpression operator[](DSLExpression&& index);
+    DSLExpression operator[](DSLExpression&& index);
 
-    DSLPossibleExpression operator++() {
-        return ++DSLExpression(*this, Position());
+    DSLExpression operator++() {
+        return ++DSLExpression(*this);
     }
 
-    DSLPossibleExpression operator++(int) {
-        return DSLExpression(*this, Position())++;
+    DSLExpression operator++(int) {
+        return DSLExpression(*this)++;
     }
 
-    DSLPossibleExpression operator--() {
-        return --DSLExpression(*this, Position());
+    DSLExpression operator--() {
+        return --DSLExpression(*this);
     }
 
-    DSLPossibleExpression operator--(int) {
-        return DSLExpression(*this, Position())--;
+    DSLExpression operator--(int) {
+        return DSLExpression(*this)--;
+    }
+
+    template <class T> DSLExpression assign(T&& param) {
+        return this->assignExpression(DSLExpression(std::forward<T>(param)));
     }
 
 protected:
-    DSLPossibleExpression assign(DSLExpression other);
+    /**
+     * Creates an empty, unpopulated var. Can be replaced with a real var later via `swap`.
+     */
+    DSLVarBase(VariableStorage storage) : fType(kVoid_Type), fStorage(storage) {}
+
+    DSLExpression assignExpression(DSLExpression other);
 
     void swap(DSLVarBase& other);
 
@@ -133,24 +127,18 @@ protected:
     // it to kVoid; in other words, you shouldn't generally be relying on this field to be correct.
     // If you need to determine the variable's type, look at DSLWriter::Var(...)->type() instead.
     DSLType fType;
-    int fUniformHandle = -1;
     std::unique_ptr<SkSL::Statement> fDeclaration;
-    const SkSL::Variable* fVar = nullptr;
+    SkSL::Variable* fVar = nullptr;
     Position fNamePosition;
-    std::string_view fRawName; // for error reporting
     std::string_view fName;
     DSLExpression fInitialValue;
-    // true if we have attempted to create the SkSL var
-    bool fInitialized = false;
-    bool fDeclared = false;
     Position fPosition;
+    VariableStorage fStorage;
+    bool fInitialized = false;
 
     friend class DSLCore;
-    friend class DSLExpression;
     friend class DSLFunction;
     friend class DSLWriter;
-    friend class ::SkSL::IRGenerator;
-    friend class ::SkSL::SPIRVCodeGenerator;
 };
 
 /**
@@ -158,45 +146,18 @@ protected:
  */
 class DSLVar : public DSLVarBase {
 public:
-    DSLVar() = default;
+    DSLVar();
 
-    DSLVar(DSLType type, std::string_view name = "var",
-           DSLExpression initialValue = DSLExpression(),
-           Position pos = {}, Position namePos = {})
-        : INHERITED(type, name, std::move(initialValue), pos, namePos) {}
+    DSLVar(DSLType type, std::string_view name, DSLExpression initialValue = DSLExpression(),
+           Position pos = {}, Position namePos = {});
 
-    DSLVar(DSLType type, const char* name, DSLExpression initialValue = DSLExpression(),
-           Position pos = {}, Position namePos = {})
-        : DSLVar(type, std::string_view(name), std::move(initialValue), pos, namePos) {}
-
-    DSLVar(DSLType type, DSLExpression initialValue, Position pos = {}, Position namePos = {})
-        : INHERITED(type, std::move(initialValue), pos, namePos) {}
-
-    DSLVar(const DSLModifiers& modifiers, DSLType type, std::string_view name = "var",
-           DSLExpression initialValue = DSLExpression(), Position pos = {}, Position namePos = {})
-        : INHERITED(modifiers, type, name, std::move(initialValue), pos, namePos) {}
-
-    DSLVar(const DSLModifiers& modifiers, DSLType type, const char* name,
-           DSLExpression initialValue = DSLExpression(), Position pos = {}, Position namePos = {})
-        : DSLVar(modifiers, type, std::string_view(name), std::move(initialValue), pos, namePos) {}
+    DSLVar(const DSLModifiers& modifiers, DSLType type, std::string_view name,
+           DSLExpression initialValue = DSLExpression(), Position pos = {}, Position namePos = {});
 
     DSLVar(DSLVar&&) = default;
 
-    VariableStorage storage() const override;
-
     void swap(DSLVar& other);
 
-    DSLPossibleExpression operator=(DSLExpression expr);
-
-    DSLPossibleExpression operator=(DSLVar& param) {
-        return this->operator=(DSLExpression(param));
-    }
-
-    template<class Param>
-    DSLPossibleExpression operator=(Param& param) {
-        return this->operator=(DSLExpression(param));
-    }
-
 private:
     using INHERITED = DSLVarBase;
 };
@@ -206,48 +167,21 @@ private:
  */
 class DSLGlobalVar : public DSLVarBase {
 public:
-    DSLGlobalVar() = default;
-
-    DSLGlobalVar(DSLType type, std::string_view name = "var",
-           DSLExpression initialValue = DSLExpression(), Position pos = {}, Position namePos = {})
-        : INHERITED(type, name, std::move(initialValue), pos, namePos) {}
-
-    DSLGlobalVar(DSLType type, const char* name, DSLExpression initialValue = DSLExpression(),
-                 Position pos = {}, Position namePos = {})
-        : DSLGlobalVar(type, std::string_view(name), std::move(initialValue), pos, namePos) {}
+    DSLGlobalVar();
 
-    DSLGlobalVar(DSLType type, DSLExpression initialValue,
-                 Position pos = {}, Position namePos = {})
-        : INHERITED(type, std::move(initialValue), pos, namePos) {}
+    DSLGlobalVar(DSLType type, std::string_view name, DSLExpression initialValue = DSLExpression(),
+                 Position pos = {}, Position namePos = {});
 
-    DSLGlobalVar(const DSLModifiers& modifiers, DSLType type, std::string_view name = "var",
-           DSLExpression initialValue = DSLExpression(), Position pos = {}, Position namePos = {})
-        : INHERITED(modifiers, type, name, std::move(initialValue), pos, namePos) {}
-
-    DSLGlobalVar(const DSLModifiers& modifiers, DSLType type, const char* name,
-           DSLExpression initialValue = DSLExpression(), Position pos = {}, Position namePos = {})
-        : DSLGlobalVar(modifiers, type, std::string_view(name), std::move(initialValue), pos,
-                       namePos) {}
+    DSLGlobalVar(const DSLModifiers& modifiers, DSLType type, std::string_view name,
+                 DSLExpression initialValue = DSLExpression(),
+                 Position pos = {}, Position namePos = {});
 
     DSLGlobalVar(const char* name);
 
     DSLGlobalVar(DSLGlobalVar&&) = default;
 
-    VariableStorage storage() const override;
-
     void swap(DSLGlobalVar& other);
 
-    DSLPossibleExpression operator=(DSLExpression expr);
-
-    DSLPossibleExpression operator=(DSLGlobalVar& param) {
-        return this->operator=(DSLExpression(param));
-    }
-
-    template<class Param>
-    DSLPossibleExpression operator=(Param& param) {
-        return this->operator=(DSLExpression(param));
-    }
-
     /**
      * Implements the following method calls:
      *     half4 shader::eval(float2 coords);
@@ -259,8 +193,7 @@ public:
      * Implements the following method call:
      *     half4 blender::eval(half4 src, half4 dst);
      */
-    DSLExpression eval(DSLExpression x, DSLExpression y,
-            Position pos = {});
+    DSLExpression eval(DSLExpression x, DSLExpression y, Position pos = {});
 
 private:
     DSLExpression eval(ExpressionArray args, Position pos);
@@ -275,40 +208,17 @@ private:
  */
 class DSLParameter : public DSLVarBase {
 public:
-    DSLParameter() = default;
-
-    DSLParameter(DSLType type, std::string_view name = "var",
-                 Position pos = {}, Position namePos = {})
-        : INHERITED(type, name, DSLExpression(), pos, namePos) {}
+    DSLParameter();
 
-    DSLParameter(DSLType type, const char* name, Position pos = {}, Position namePos = {})
-        : DSLParameter(type, std::string_view(name), pos, namePos) {}
+    DSLParameter(DSLType type, std::string_view name, Position pos = {}, Position namePos = {});
 
-    DSLParameter(const DSLModifiers& modifiers, DSLType type, std::string_view name = "var",
-                 Position pos = {}, Position namePos = {})
-        : INHERITED(modifiers, type, name, DSLExpression(), pos, namePos) {}
-
-    DSLParameter(const DSLModifiers& modifiers, DSLType type, const char* name,
-                 Position pos = {}, Position namePos = {})
-        : DSLParameter(modifiers, type, std::string_view(name), pos, namePos) {}
+    DSLParameter(const DSLModifiers& modifiers, DSLType type, std::string_view name,
+                 Position pos = {}, Position namePos = {});
 
     DSLParameter(DSLParameter&&) = default;
 
-    VariableStorage storage() const override;
-
     void swap(DSLParameter& other);
 
-    DSLPossibleExpression operator=(DSLExpression expr);
-
-    DSLPossibleExpression operator=(DSLParameter& param) {
-        return this->operator=(DSLExpression(param));
-    }
-
-    template<class Param>
-    DSLPossibleExpression operator=(Param& param) {
-        return this->operator=(DSLExpression(param));
-    }
-
 private:
     using INHERITED = DSLVarBase;
 };

package/cpp/skia/include/sksl/SkSLErrorReporter.h

@@ -10,9 +10,7 @@
 
 #include "include/core/SkTypes.h"
 
-#include <string>
 #include <string_view>
-#include <vector>
 
 namespace SkSL {
 
@@ -25,24 +23,14 @@ class ErrorReporter {
 public:
     ErrorReporter() {}
 
-    virtual ~ErrorReporter() {
-        SkASSERT(fPendingErrors.empty());
-    }
+    virtual ~ErrorReporter() {}
 
-    void error(std::string_view msg, Position position);
-
-    /**
-     * Reports an error message at the given line of the source text. Errors reported
-     * with a line of -1 will be queued until line number information can be determined.
-     */
-    void error(Position pos, std::string_view msg);
+    void error(Position position, std::string_view msg);
 
     std::string_view source() const { return fSource; }
 
     void setSource(std::string_view source) { fSource = source; }
 
-    void reportPendingErrors(Position pos);
-
     int errorCount() const {
         return fErrorCount;
     }
@@ -61,7 +49,6 @@ private:
     Position position(int offset) const;
 
     std::string_view fSource;
-    std::vector<std::string> fPendingErrors;
     int fErrorCount = 0;
 };
 

package/cpp/skia/include/sksl/SkSLOperator.h

@@ -8,6 +8,7 @@
 #ifndef SKSL_OPERATOR
 #define SKSL_OPERATOR
 
+#include <cstdint>
 #include <string_view>
 
 namespace SkSL {
@@ -15,66 +16,68 @@ namespace SkSL {
 class Context;
 class Type;
 
+enum class OperatorKind : uint8_t {
+    PLUS,
+    MINUS,
+    STAR,
+    SLASH,
+    PERCENT,
+    SHL,
+    SHR,
+    LOGICALNOT,
+    LOGICALAND,
+    LOGICALOR,
+    LOGICALXOR,
+    BITWISENOT,
+    BITWISEAND,
+    BITWISEOR,
+    BITWISEXOR,
+    EQ,
+    EQEQ,
+    NEQ,
+    LT,
+    GT,
+    LTEQ,
+    GTEQ,
+    PLUSEQ,
+    MINUSEQ,
+    STAREQ,
+    SLASHEQ,
+    PERCENTEQ,
+    SHLEQ,
+    SHREQ,
+    BITWISEANDEQ,
+    BITWISEOREQ,
+    BITWISEXOREQ,
+    PLUSPLUS,
+    MINUSMINUS,
+    COMMA
+};
+
+enum class OperatorPrecedence : uint8_t {
+    kParentheses    =  1,
+    kPostfix        =  2,
+    kPrefix         =  3,
+    kMultiplicative =  4,
+    kAdditive       =  5,
+    kShift          =  6,
+    kRelational     =  7,
+    kEquality       =  8,
+    kBitwiseAnd     =  9,
+    kBitwiseXor     = 10,
+    kBitwiseOr      = 11,
+    kLogicalAnd     = 12,
+    kLogicalXor     = 13,
+    kLogicalOr      = 14,
+    kTernary        = 15,
+    kAssignment     = 16,
+    kSequence       = 17,
+    kTopLevel       = kSequence
+};
+
 class Operator {
 public:
-    enum class Kind {
-        PLUS,
-        MINUS,
-        STAR,
-        SLASH,
-        PERCENT,
-        SHL,
-        SHR,
-        LOGICALNOT,
-        LOGICALAND,
-        LOGICALOR,
-        LOGICALXOR,
-        BITWISENOT,
-        BITWISEAND,
-        BITWISEOR,
-        BITWISEXOR,
-        EQ,
-        EQEQ,
-        NEQ,
-        LT,
-        GT,
-        LTEQ,
-        GTEQ,
-        PLUSEQ,
-        MINUSEQ,
-        STAREQ,
-        SLASHEQ,
-        PERCENTEQ,
-        SHLEQ,
-        SHREQ,
-        BITWISEANDEQ,
-        BITWISEOREQ,
-        BITWISEXOREQ,
-        PLUSPLUS,
-        MINUSMINUS,
-        COMMA
-    };
-
-    enum class Precedence {
-        kParentheses    =  1,
-        kPostfix        =  2,
-        kPrefix         =  3,
-        kMultiplicative =  4,
-        kAdditive       =  5,
-        kShift          =  6,
-        kRelational     =  7,
-        kEquality       =  8,
-        kBitwiseAnd     =  9,
-        kBitwiseXor     = 10,
-        kBitwiseOr      = 11,
-        kLogicalAnd     = 12,
-        kLogicalXor     = 13,
-        kLogicalOr      = 14,
-        kTernary        = 15,
-        kAssignment     = 16,
-        kSequence       = 17,
-        kTopLevel       = kSequence
-    };
+    using Kind = OperatorKind;
 
     Operator(Kind op) : fKind(op) {}
 
@@ -84,7 +87,7 @@ public:
         return fKind == Kind::EQEQ || fKind == Kind::NEQ;
     }
 
-    Precedence getBinaryPrecedence() const;
+    OperatorPrecedence getBinaryPrecedence() const;
 
     // Returns the operator name surrounded by the expected whitespace for a tidy binary expression.
     const char* operatorName() const;

package/cpp/skia/include/sksl/SkSLPosition.h

@@ -9,6 +9,8 @@
 #define SKSL_POSITION
 
 #include "include/core/SkTypes.h"
+
+#include <cstdint>
 #include <string_view>
 
 namespace SkSL {

package/cpp/skia/include/sksl/SkSLVersion.h

@@ -0,0 +1,27 @@
+/*
+ * 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 SkSLVersion_DEFINED
+#define SkSLVersion_DEFINED
+
+namespace SkSL {
+
+enum class Version {
+    /**
+     * Desktop GLSL 1.10, GLSL ES 1.00, WebGL 1.0
+     */
+    k100,
+
+    /**
+     * Desktop GLSL 3.30, GLSL ES 3.00, WebGL 2.0
+     */
+    k300,
+};
+
+}  // namespace SkSL
+
+#endif

package/cpp/skia/include/svg/SkSVGCanvas.h

@@ -10,6 +10,7 @@
 
 #include "include/core/SkTypes.h"
 
+#include <cstdint>
 #include <memory>
 
 class SkCanvas;

package/cpp/skia/include/utils/SkAnimCodecPlayer.h

@@ -13,7 +13,7 @@
 #include "include/core/SkRefCnt.h"
 #include "include/core/SkSize.h"
 
-#include <stdint.h>
+#include <cstdint>
 #include <memory>
 #include <vector>
 

package/cpp/skia/include/utils/SkBase64.h

@@ -10,6 +10,8 @@
 
 #include "include/core/SkTypes.h"
 
+#include <cstddef>
+
 struct SkBase64 {
 public:
     enum Error {

package/cpp/skia/include/utils/SkCustomTypeface.h

@@ -8,28 +8,25 @@
 #ifndef SkCustomTypeface_DEFINED
 #define SkCustomTypeface_DEFINED
 
+#include "include/core/SkDrawable.h"
 #include "include/core/SkFontMetrics.h"
 #include "include/core/SkFontStyle.h"
 #include "include/core/SkPath.h"
+#include "include/core/SkRect.h"
 #include "include/core/SkRefCnt.h"
 #include "include/core/SkTypes.h"
 
 #include <vector>
 
-class SkImage;
-class SkPaint;
-class SkPicture;
 class SkStream;
 class SkTypeface;
 
-class SkCustomTypefaceBuilder {
+class SK_API SkCustomTypefaceBuilder {
 public:
     SkCustomTypefaceBuilder();
 
     void setGlyph(SkGlyphID, float advance, const SkPath&);
-    void setGlyph(SkGlyphID, float advance, const SkPath&, const SkPaint&);
-    void setGlyph(SkGlyphID, float advance, sk_sp<SkImage>, float scale);
-    void setGlyph(SkGlyphID, float advance, sk_sp<SkPicture>);
+    void setGlyph(SkGlyphID, float advance, sk_sp<SkDrawable>, const SkRect& bounds);
 
     void setMetrics(const SkFontMetrics& fm, float scale = 1);
     void setFontStyle(SkFontStyle);
@@ -37,14 +34,30 @@ public:
     sk_sp<SkTypeface> detach();
 
 private:
-    std::vector<SkPath> fPaths;
-    std::vector<float>  fAdvances;
-    SkFontMetrics       fMetrics;
-    SkFontStyle         fStyle;
+    struct GlyphRec {
+        // logical union
+        SkPath            fPath;
+        sk_sp<SkDrawable> fDrawable;
+
+        SkRect            fBounds  = {0,0,0,0}; // only used for drawable glyphs atm
+        float             fAdvance = 0;
+
+        bool isDrawable() const {
+            SkASSERT(!fDrawable || fPath.isEmpty());
+            return fDrawable != nullptr;
+        }
+    };
+
+    std::vector<GlyphRec> fGlyphRecs;
+    SkFontMetrics         fMetrics;
+    SkFontStyle           fStyle;
+
+    GlyphRec& ensureStorage(SkGlyphID);
 
     static sk_sp<SkTypeface> Deserialize(SkStream*);
 
     friend class SkTypeface;
+    friend class SkUserTypeface;
 };
 
 #endif