@shopify/react-native-skia 0.0.135

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

@@ -0,0 +1,321 @@
+/*
+ * Copyright 2020 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SKSL_DSL_VAR
+#define SKSL_DSL_VAR
+
+#include "include/sksl/DSLExpression.h"
+#include "include/sksl/DSLModifiers.h"
+#include "include/sksl/DSLType.h"
+#include "include/sksl/SkSLPosition.h"
+
+#include <stdint.h>
+#include <memory>
+#include <string_view>
+#include <utility>
+
+namespace SkSL {
+
+class Expression;
+class ExpressionArray;
+class IRGenerator;
+class SPIRVCodeGenerator;
+class Statement;
+class Variable;
+enum class VariableStorage : int8_t;
+
+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.
+     */
+    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,
+               DSLExpression initialValue, Position pos, Position namePos);
+
+    DSLVarBase(const DSLModifiers& modifiers, DSLType type, DSLExpression initialValue,
+               Position pos, Position namePos);
+
+    DSLVarBase(DSLVarBase&&) = default;
+
+    virtual ~DSLVarBase();
+
+    std::string_view name() const {
+        return fName;
+    }
+
+    const DSLModifiers& modifiers() const {
+        return fModifiers;
+    }
+
+    virtual VariableStorage storage() const = 0;
+
+    DSLExpression x() {
+        return DSLExpression(*this, Position()).x();
+    }
+
+    DSLExpression y() {
+        return DSLExpression(*this, Position()).y();
+    }
+
+    DSLExpression z() {
+        return DSLExpression(*this, Position()).z();
+    }
+
+    DSLExpression w() {
+        return DSLExpression(*this, Position()).w();
+    }
+
+    DSLExpression r() {
+        return DSLExpression(*this, Position()).r();
+    }
+
+    DSLExpression g() {
+        return DSLExpression(*this, Position()).g();
+    }
+
+    DSLExpression b() {
+        return DSLExpression(*this, Position()).b();
+    }
+
+    DSLExpression a() {
+        return DSLExpression(*this, Position()).a();
+    }
+
+    DSLExpression field(std::string_view name) {
+        return DSLExpression(*this, Position()).field(name);
+    }
+
+    DSLPossibleExpression operator[](DSLExpression&& index);
+
+    DSLPossibleExpression operator++() {
+        return ++DSLExpression(*this, Position());
+    }
+
+    DSLPossibleExpression operator++(int) {
+        return DSLExpression(*this, Position())++;
+    }
+
+    DSLPossibleExpression operator--() {
+        return --DSLExpression(*this, Position());
+    }
+
+    DSLPossibleExpression operator--(int) {
+        return DSLExpression(*this, Position())--;
+    }
+
+protected:
+    DSLPossibleExpression assign(DSLExpression other);
+
+    void swap(DSLVarBase& other);
+
+    DSLModifiers fModifiers;
+    // We only need to keep track of the type here so that we can create the SkSL::Variable. For
+    // predefined variables this field is unnecessary, so we don't bother tracking it and just set
+    // 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;
+    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;
+
+    friend class DSLCore;
+    friend class DSLExpression;
+    friend class DSLFunction;
+    friend class DSLWriter;
+    friend class ::SkSL::IRGenerator;
+    friend class ::SkSL::SPIRVCodeGenerator;
+};
+
+/**
+ * A local variable.
+ */
+class DSLVar : public DSLVarBase {
+public:
+    DSLVar() = default;
+
+    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, 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(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;
+};
+
+/**
+ * A global variable.
+ */
+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(DSLType type, DSLExpression initialValue,
+                 Position pos = {}, Position namePos = {})
+        : INHERITED(type, std::move(initialValue), pos, 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 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);
+     *     half4 colorFilter::eval(half4 input);
+     */
+    DSLExpression eval(DSLExpression x, Position pos = {});
+
+    /**
+     * Implements the following method call:
+     *     half4 blender::eval(half4 src, half4 dst);
+     */
+    DSLExpression eval(DSLExpression x, DSLExpression y,
+            Position pos = {});
+
+private:
+    DSLExpression eval(ExpressionArray args, Position pos);
+
+    std::unique_ptr<SkSL::Expression> methodCall(std::string_view methodName, Position pos);
+
+    using INHERITED = DSLVarBase;
+};
+
+/**
+ * A function parameter.
+ */
+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(DSLType type, const char* name, Position pos = {}, Position namePos = {})
+        : DSLParameter(type, std::string_view(name), pos, 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(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;
+};
+
+} // namespace dsl
+
+} // namespace SkSL
+
+
+#endif

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

@@ -0,0 +1,77 @@
+/*
+ * 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 SKSL_DSL_WRAPPER
+#define SKSL_DSL_WRAPPER
+
+#include <memory>
+
+namespace SkSL {
+
+namespace dsl {
+
+/**
+ * Several of the DSL classes override operator= in a non-standard fashion to allow for expressions
+ * like "x = 0" to compile into SkSL code. This makes it impossible to directly use these classes in
+ * C++ containers which expect standard behavior for operator=.
+ *
+ * Wrapper<T> contains a T, where T is a DSL class with non-standard operator=, and provides
+ * standard behavior for operator=, permitting it to be used in standard containers.
+ */
+template<typename T>
+class DSLWrapper {
+public:
+    DSLWrapper(T value) {
+        fValue.swap(value);
+    }
+
+    DSLWrapper(const DSLWrapper&) = delete;
+
+    DSLWrapper(DSLWrapper&& other) {
+        fValue.swap(other.fValue);
+    }
+
+    T& get() {
+        return fValue;
+    }
+
+    T& operator*() {
+        return fValue;
+    }
+
+    T* operator->() {
+        return &fValue;
+    }
+
+    const T& get() const {
+        return fValue;
+    }
+
+    const T& operator*() const {
+        return fValue;
+    }
+
+    const T* operator->() const {
+        return &fValue;
+    }
+
+    DSLWrapper& operator=(const DSLWrapper&) = delete;
+
+    DSLWrapper& operator=(DSLWrapper&& other) {
+        fValue.swap(other.fValue);
+        return *this;
+    }
+
+private:
+    T fValue;
+};
+
+} // namespace dsl
+
+} // namespace SkSL
+
+#endif

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

@@ -0,0 +1,28 @@
+/*
+ * 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 SKSL_DEBUG_TRACE
+#define SKSL_DEBUG_TRACE
+
+#include "include/core/SkRefCnt.h"
+
+class SkWStream;
+
+namespace SkSL {
+
+class DebugTrace : public SkRefCnt {
+public:
+    /** Serializes a debug trace to JSON which can be parsed by our debugger. */
+    virtual void writeTrace(SkWStream* w) const = 0;
+
+    /** Generates a human-readable dump of the debug trace. */
+    virtual void dump(SkWStream* o) const = 0;
+};
+
+} // namespace SkSL
+
+#endif

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

@@ -0,0 +1,78 @@
+/*
+ * 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 SKSL_ERROR_REPORTER
+#define SKSL_ERROR_REPORTER
+
+#include "include/core/SkTypes.h"
+
+#include <string>
+#include <string_view>
+#include <vector>
+
+namespace SkSL {
+
+class Position;
+
+/**
+ * Class which is notified in the event of an error.
+ */
+class ErrorReporter {
+public:
+    ErrorReporter() {}
+
+    virtual ~ErrorReporter() {
+        SkASSERT(fPendingErrors.empty());
+    }
+
+    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);
+
+    std::string_view source() const { return fSource; }
+
+    void setSource(std::string_view source) { fSource = source; }
+
+    void reportPendingErrors(Position pos);
+
+    int errorCount() const {
+        return fErrorCount;
+    }
+
+    void resetErrorCount() {
+        fErrorCount = 0;
+    }
+
+protected:
+    /**
+     * Called when an error is reported.
+     */
+    virtual void handleError(std::string_view msg, Position position) = 0;
+
+private:
+    Position position(int offset) const;
+
+    std::string_view fSource;
+    std::vector<std::string> fPendingErrors;
+    int fErrorCount = 0;
+};
+
+/**
+ * Error reporter for tests that need an SkSL context; aborts immediately if an error is reported.
+ */
+class TestingOnly_AbortErrorReporter : public ErrorReporter {
+public:
+    void handleError(std::string_view msg, Position pos) override;
+};
+
+} // namespace SkSL
+
+#endif

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

@@ -0,0 +1,151 @@
+/*
+ * 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 SKSL_OPERATOR
+#define SKSL_OPERATOR
+
+#include <string_view>
+
+namespace SkSL {
+
+class Context;
+class Type;
+
+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
+    };
+
+    Operator(Kind op) : fKind(op) {}
+
+    Kind kind() const { return fKind; }
+
+    bool isEquality() const {
+        return fKind == Kind::EQEQ || fKind == Kind::NEQ;
+    }
+
+    Precedence getBinaryPrecedence() const;
+
+    // Returns the operator name surrounded by the expected whitespace for a tidy binary expression.
+    const char* operatorName() const;
+
+    // Returns the operator name without any surrounding whitespace.
+    std::string_view tightOperatorName() const;
+
+    // Returns true if op is '=' or any compound assignment operator ('+=', '-=', etc.)
+    bool isAssignment() const;
+
+    // Given a compound assignment operator, returns the non-assignment version of the operator
+    // (e.g. '+=' becomes '+')
+    Operator removeAssignment() const;
+
+    /**
+     * Defines the set of relational (comparison) operators:
+     *     <  <=  >  >=
+     */
+    bool isRelational() const;
+
+    /**
+     * Defines the set of operators which are only valid on integral types:
+     *   <<  <<=  >>  >>=  &  &=  |  |=  ^  ^=  %  %=
+     */
+    bool isOnlyValidForIntegralTypes() const;
+
+    /**
+     * Defines the set of operators which perform vector/matrix math.
+     *   +  +=  -  -=  *  *=  /  /=  %  %=  <<  <<=  >>  >>=  &  &=  |  |=  ^  ^=
+     */
+    bool isValidForMatrixOrVector() const;
+
+    /*
+     * Defines the set of operators allowed by The OpenGL ES Shading Language 1.00, Section 5.1.
+     * The set of illegal (reserved) operators are the ones that only make sense with integral
+     * types. This is not a coincidence: It's because ES2 doesn't require 'int' to be anything but
+     * syntactic sugar for floats with truncation after each operation.
+     */
+    bool isAllowedInStrictES2Mode() const {
+        return !this->isOnlyValidForIntegralTypes();
+    }
+
+    /**
+     * Determines the operand and result types of a binary expression. Returns true if the
+     * expression is legal, false otherwise. If false, the values of the out parameters are
+     * undefined.
+     */
+    bool determineBinaryType(const Context& context,
+                             const Type& left,
+                             const Type& right,
+                             const Type** outLeftType,
+                             const Type** outRightType,
+                             const Type** outResultType) const;
+
+private:
+    bool isOperator() const;
+    bool isMatrixMultiply(const Type& left, const Type& right) const;
+
+    Kind fKind;
+};
+
+}  // namespace SkSL
+
+#endif