@shopify/react-native-skia 0.1.115

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

@@ -0,0 +1,310 @@
+/*
+ * 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"
+
+namespace SkSL {
+
+class Expression;
+class IRGenerator;
+class SPIRVCodeGenerator;
+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, skstd::string_view name, DSLExpression initialValue, PositionInfo pos);
+
+    DSLVarBase(DSLType type, DSLExpression initialValue, PositionInfo pos);
+
+    DSLVarBase(const DSLModifiers& modifiers, DSLType type, skstd::string_view name,
+               DSLExpression initialValue, PositionInfo pos);
+
+    DSLVarBase(const DSLModifiers& modifiers, DSLType type, DSLExpression initialValue,
+               PositionInfo pos);
+
+    DSLVarBase(DSLVarBase&&) = default;
+
+    virtual ~DSLVarBase();
+
+    skstd::string_view name() const {
+        return fName;
+    }
+
+    const DSLModifiers& modifiers() const {
+        return fModifiers;
+    }
+
+    virtual VariableStorage storage() const = 0;
+
+    DSLExpression x() {
+        return DSLExpression(*this, PositionInfo()).x();
+    }
+
+    DSLExpression y() {
+        return DSLExpression(*this, PositionInfo()).y();
+    }
+
+    DSLExpression z() {
+        return DSLExpression(*this, PositionInfo()).z();
+    }
+
+    DSLExpression w() {
+        return DSLExpression(*this, PositionInfo()).w();
+    }
+
+    DSLExpression r() {
+        return DSLExpression(*this, PositionInfo()).r();
+    }
+
+    DSLExpression g() {
+        return DSLExpression(*this, PositionInfo()).g();
+    }
+
+    DSLExpression b() {
+        return DSLExpression(*this, PositionInfo()).b();
+    }
+
+    DSLExpression a() {
+        return DSLExpression(*this, PositionInfo()).a();
+    }
+
+    DSLExpression field(skstd::string_view name) {
+        return DSLExpression(*this, PositionInfo()).field(name);
+    }
+
+    DSLPossibleExpression operator[](DSLExpression&& index);
+
+    DSLPossibleExpression operator++() {
+        return ++DSLExpression(*this, PositionInfo());
+    }
+
+    DSLPossibleExpression operator++(int) {
+        return DSLExpression(*this, PositionInfo())++;
+    }
+
+    DSLPossibleExpression operator--() {
+        return --DSLExpression(*this, PositionInfo());
+    }
+
+    DSLPossibleExpression operator--(int) {
+        return DSLExpression(*this, PositionInfo())--;
+    }
+
+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;
+    skstd::string_view fRawName; // for error reporting
+    skstd::string_view fName;
+    DSLExpression fInitialValue;
+    // true if we have attempted to create the SkSL var
+    bool fInitialized = false;
+    bool fDeclared = false;
+    PositionInfo 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, skstd::string_view name = "var",
+           DSLExpression initialValue = DSLExpression(),
+           PositionInfo pos = PositionInfo::Capture())
+        : INHERITED(type, name, std::move(initialValue), pos) {}
+
+    DSLVar(DSLType type, const char* name, DSLExpression initialValue = DSLExpression(),
+           PositionInfo pos = PositionInfo::Capture())
+        : DSLVar(type, skstd::string_view(name), std::move(initialValue), pos) {}
+
+    DSLVar(DSLType type, DSLExpression initialValue, PositionInfo pos = PositionInfo::Capture())
+        : INHERITED(type, std::move(initialValue), pos) {}
+
+    DSLVar(const DSLModifiers& modifiers, DSLType type, skstd::string_view name = "var",
+           DSLExpression initialValue = DSLExpression(), PositionInfo pos = PositionInfo::Capture())
+        : INHERITED(modifiers, type, name, std::move(initialValue), pos) {}
+
+    DSLVar(const DSLModifiers& modifiers, DSLType type, const char* name,
+           DSLExpression initialValue = DSLExpression(), PositionInfo pos = PositionInfo::Capture())
+        : DSLVar(modifiers, type, skstd::string_view(name), std::move(initialValue), pos) {}
+
+    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, skstd::string_view name = "var",
+           DSLExpression initialValue = DSLExpression(), PositionInfo pos = PositionInfo::Capture())
+        : INHERITED(type, name, std::move(initialValue), pos) {}
+
+    DSLGlobalVar(DSLType type, const char* name, DSLExpression initialValue = DSLExpression(),
+                 PositionInfo pos = PositionInfo::Capture())
+        : DSLGlobalVar(type, skstd::string_view(name), std::move(initialValue), pos) {}
+
+    DSLGlobalVar(DSLType type, DSLExpression initialValue,
+                 PositionInfo pos = PositionInfo::Capture())
+        : INHERITED(type, std::move(initialValue), pos) {}
+
+    DSLGlobalVar(const DSLModifiers& modifiers, DSLType type, skstd::string_view name = "var",
+           DSLExpression initialValue = DSLExpression(), PositionInfo pos = PositionInfo::Capture())
+        : INHERITED(modifiers, type, name, std::move(initialValue), pos) {}
+
+    DSLGlobalVar(const DSLModifiers& modifiers, DSLType type, const char* name,
+           DSLExpression initialValue = DSLExpression(), PositionInfo pos = PositionInfo::Capture())
+        : DSLGlobalVar(modifiers, type, skstd::string_view(name), std::move(initialValue), pos) {}
+
+    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, PositionInfo pos = PositionInfo::Capture());
+
+    /**
+     * Implements the following method call:
+     *     half4 blender::eval(half4 src, half4 dst);
+     */
+    DSLExpression eval(DSLExpression x, DSLExpression y,
+            PositionInfo pos = PositionInfo::Capture());
+
+private:
+    DSLExpression eval(ExpressionArray args, PositionInfo pos);
+
+    std::unique_ptr<SkSL::Expression> methodCall(skstd::string_view methodName, PositionInfo pos);
+
+    using INHERITED = DSLVarBase;
+};
+
+/**
+ * A function parameter.
+ */
+class DSLParameter : public DSLVarBase {
+public:
+    DSLParameter() = default;
+
+    DSLParameter(DSLType type, skstd::string_view name = "var",
+                 PositionInfo pos = PositionInfo::Capture())
+        : INHERITED(type, name, DSLExpression(), pos) {}
+
+    DSLParameter(DSLType type, const char* name, PositionInfo pos = PositionInfo::Capture())
+        : DSLParameter(type, skstd::string_view(name), pos) {}
+
+    DSLParameter(const DSLModifiers& modifiers, DSLType type, skstd::string_view name = "var",
+                 PositionInfo pos = PositionInfo::Capture())
+        : INHERITED(modifiers, type, name, DSLExpression(), pos) {}
+
+    DSLParameter(const DSLModifiers& modifiers, DSLType type, const char* name,
+                 PositionInfo pos = PositionInfo::Capture())
+        : DSLParameter(modifiers, type, skstd::string_view(name), pos) {}
+
+    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,115 @@
+/*
+ * 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/SkStringView.h"
+#include "include/core/SkTypes.h"
+#include "include/private/SkSLString.h"
+
+#include <string>
+#include <vector>
+
+namespace SkSL {
+
+#ifndef __has_builtin
+    #define __has_builtin(x) 0
+#endif
+
+class PositionInfo {
+public:
+    PositionInfo(const char* file = nullptr, int line = -1)
+        : fFile(file)
+        , fLine(line) {}
+
+#if __has_builtin(__builtin_FILE) && __has_builtin(__builtin_LINE)
+    static PositionInfo Capture(const char* file = __builtin_FILE(), int line = __builtin_LINE()) {
+        return PositionInfo(file, line);
+    }
+#else
+    static PositionInfo Capture() { return PositionInfo(); }
+#endif // __has_builtin(__builtin_FILE) && __has_builtin(__builtin_LINE)
+
+    const char* file_name() const {
+        return fFile;
+    }
+
+    int line() const {
+        return fLine;
+    }
+
+private:
+    const char* fFile = nullptr;
+    int32_t fLine = -1;
+};
+
+/**
+ * Class which is notified in the event of an error.
+ */
+class ErrorReporter {
+public:
+    ErrorReporter() {}
+
+    virtual ~ErrorReporter() {
+        SkASSERT(fPendingErrors.empty());
+    }
+
+    void error(skstd::string_view msg, PositionInfo 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(int line, skstd::string_view msg);
+
+    const char* source() const { return fSource; }
+
+    void setSource(const char* source) { fSource = source; }
+
+    void reportPendingErrors(PositionInfo pos) {
+        for (const String& msg : fPendingErrors) {
+            this->handleError(msg, pos);
+        }
+        fPendingErrors.clear();
+    }
+
+    int errorCount() const {
+        return fErrorCount;
+    }
+
+    void resetErrorCount() {
+        fErrorCount = 0;
+    }
+
+protected:
+    /**
+     * Called when an error is reported.
+     */
+    virtual void handleError(skstd::string_view msg, PositionInfo position) = 0;
+
+private:
+    PositionInfo position(int offset) const;
+
+    const char* fSource = nullptr;
+    std::vector<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(skstd::string_view msg, PositionInfo pos) override {
+        SK_ABORT("%.*s", (int)msg.length(), msg.data());
+    }
+};
+
+} // namespace SkSL
+
+#endif

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

@@ -0,0 +1,37 @@
+/*
+ * Copyright 2015 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkSVGCanvas_DEFINED
+#define SkSVGCanvas_DEFINED
+
+#include "include/core/SkCanvas.h"
+
+class SkWStream;
+
+class SK_API SkSVGCanvas {
+public:
+    enum {
+        kConvertTextToPaths_Flag   = 0x01, // emit text as <path>s
+        kNoPrettyXML_Flag          = 0x02, // suppress newlines and tabs in output
+        kRelativePathEncoding_Flag = 0x04, // use relative commands for path encoding
+    };
+
+    /**
+     *  Returns a new canvas that will generate SVG commands from its draw calls, and send
+     *  them to the provided stream. Ownership of the stream is not transfered, and it must
+     *  remain valid for the lifetime of the returned canvas.
+     *
+     *  The canvas may buffer some drawing calls, so the output is not guaranteed to be valid
+     *  or complete until the canvas instance is deleted.
+     *
+     *  The 'bounds' parameter defines an initial SVG viewport (viewBox attribute on the root
+     *  SVG element).
+     */
+    static std::unique_ptr<SkCanvas> Make(const SkRect& bounds, SkWStream*, uint32_t flags = 0);
+};
+
+#endif

package/cpp/skia/include/third_party/skcms/LICENSE

@@ -0,0 +1,29 @@
+// Copyright (c) 2018 Google Inc. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+--------------------------------------------------------------------------------