@shopify/react-native-skia 0.1.115

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

@@ -0,0 +1,299 @@
+/*
+ * 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_EXPRESSION
+#define SKSL_DSL_EXPRESSION
+
+#include "include/core/SkStringView.h"
+#include "include/core/SkTypes.h"
+#include "include/private/SkTArray.h"
+#include "include/sksl/DSLWrapper.h"
+#include "include/sksl/SkSLErrorReporter.h"
+
+#include <cstdint>
+#include <memory>
+
+#if defined(__has_cpp_attribute) && __has_cpp_attribute(clang::reinitializes)
+#define SK_CLANG_REINITIALIZES [[clang::reinitializes]]
+#else
+#define SK_CLANG_REINITIALIZES
+#endif
+
+namespace SkSL {
+
+class Expression;
+class Type;
+
+namespace dsl {
+
+class DSLPossibleExpression;
+class DSLStatement;
+class DSLType;
+class DSLVarBase;
+
+/**
+ * Represents an expression such as 'cos(x)' or 'a + b'.
+ */
+class DSLExpression {
+public:
+    DSLExpression(const DSLExpression&) = delete;
+
+    DSLExpression(DSLExpression&&);
+
+    DSLExpression();
+
+    /**
+     * Creates an expression representing a literal float.
+     */
+    DSLExpression(float value, PositionInfo pos = PositionInfo::Capture());
+
+    /**
+     * Creates an expression representing a literal float.
+     */
+    DSLExpression(double value, PositionInfo pos = PositionInfo::Capture())
+        : DSLExpression((float) value) {}
+
+    /**
+     * Creates an expression representing a literal int.
+     */
+    DSLExpression(int value, PositionInfo pos = PositionInfo::Capture());
+
+    /**
+     * Creates an expression representing a literal int.
+     */
+    DSLExpression(int64_t value, PositionInfo pos = PositionInfo::Capture());
+
+    /**
+     * Creates an expression representing a literal uint.
+     */
+    DSLExpression(unsigned int value, PositionInfo pos = PositionInfo::Capture());
+
+    /**
+     * Creates an expression representing a literal bool.
+     */
+    DSLExpression(bool value, PositionInfo pos = PositionInfo::Capture());
+
+    /**
+     * Creates an expression representing a variable reference.
+     */
+    DSLExpression(DSLVarBase& var, PositionInfo pos = PositionInfo::Capture());
+
+    DSLExpression(DSLVarBase&& var, PositionInfo pos = PositionInfo::Capture());
+
+    DSLExpression(DSLPossibleExpression expr, PositionInfo pos = PositionInfo::Capture());
+
+    explicit DSLExpression(std::unique_ptr<SkSL::Expression> expression);
+
+    static DSLExpression Poison(PositionInfo pos = PositionInfo::Capture());
+
+    ~DSLExpression();
+
+    DSLType type();
+
+    /**
+     * Overloads the '=' operator to create an SkSL assignment statement.
+     */
+    DSLPossibleExpression operator=(DSLExpression other);
+
+    DSLExpression x(PositionInfo pos = PositionInfo::Capture());
+
+    DSLExpression y(PositionInfo pos = PositionInfo::Capture());
+
+    DSLExpression z(PositionInfo pos = PositionInfo::Capture());
+
+    DSLExpression w(PositionInfo pos = PositionInfo::Capture());
+
+    DSLExpression r(PositionInfo pos = PositionInfo::Capture());
+
+    DSLExpression g(PositionInfo pos = PositionInfo::Capture());
+
+    DSLExpression b(PositionInfo pos = PositionInfo::Capture());
+
+    DSLExpression a(PositionInfo pos = PositionInfo::Capture());
+
+    /**
+     * Creates an SkSL struct field access expression.
+     */
+    DSLExpression field(skstd::string_view name, PositionInfo pos = PositionInfo::Capture());
+
+    /**
+     * Creates an SkSL array index expression.
+     */
+    DSLPossibleExpression operator[](DSLExpression index);
+
+    DSLPossibleExpression operator()(SkTArray<DSLWrapper<DSLExpression>> args,
+                                     PositionInfo pos = PositionInfo::Capture());
+
+    DSLPossibleExpression operator()(ExpressionArray args,
+                                     PositionInfo pos = PositionInfo::Capture());
+
+    /**
+     * Returns true if this object contains an expression. DSLExpressions which were created with
+     * the empty constructor or which have already been release()ed do not have a value.
+     * DSLExpressions created with errors are still considered to have a value (but contain poison).
+     */
+    bool hasValue() const {
+        return fExpression != nullptr;
+    }
+
+    /**
+     * Returns true if this object contains an expression which is not poison.
+     */
+    bool isValid() const;
+
+    SK_CLANG_REINITIALIZES void swap(DSLExpression& other);
+
+    /**
+     * Invalidates this object and returns the SkSL expression it represents. It is an error to call
+     * this on an invalid DSLExpression.
+     */
+    std::unique_ptr<SkSL::Expression> release();
+
+private:
+    /**
+     * Calls release if this expression has a value, otherwise returns null.
+     */
+    std::unique_ptr<SkSL::Expression> releaseIfPossible();
+
+    std::unique_ptr<SkSL::Expression> fExpression;
+
+    friend DSLExpression SampleChild(int index, DSLExpression coords);
+
+    friend class DSLCore;
+    friend class DSLFunction;
+    friend class DSLPossibleExpression;
+    friend class DSLType;
+    friend class DSLVarBase;
+    friend class DSLWriter;
+    template<typename T> friend class DSLWrapper;
+};
+
+DSLPossibleExpression operator+(DSLExpression left, DSLExpression right);
+DSLPossibleExpression operator+(DSLExpression expr);
+DSLPossibleExpression operator+=(DSLExpression left, DSLExpression right);
+DSLPossibleExpression operator-(DSLExpression left, DSLExpression right);
+DSLPossibleExpression operator-(DSLExpression expr);
+DSLPossibleExpression operator-=(DSLExpression left, DSLExpression right);
+DSLPossibleExpression operator*(DSLExpression left, DSLExpression right);
+DSLPossibleExpression operator*=(DSLExpression left, DSLExpression right);
+DSLPossibleExpression operator/(DSLExpression left, DSLExpression right);
+DSLPossibleExpression operator/=(DSLExpression left, DSLExpression right);
+DSLPossibleExpression operator%(DSLExpression left, DSLExpression right);
+DSLPossibleExpression operator%=(DSLExpression left, DSLExpression right);
+DSLPossibleExpression operator<<(DSLExpression left, DSLExpression right);
+DSLPossibleExpression operator<<=(DSLExpression left, DSLExpression right);
+DSLPossibleExpression operator>>(DSLExpression left, DSLExpression right);
+DSLPossibleExpression operator>>=(DSLExpression left, DSLExpression right);
+DSLPossibleExpression operator&&(DSLExpression left, DSLExpression right);
+DSLPossibleExpression operator||(DSLExpression left, DSLExpression right);
+DSLPossibleExpression operator&(DSLExpression left, DSLExpression right);
+DSLPossibleExpression operator&=(DSLExpression left, DSLExpression right);
+DSLPossibleExpression operator|(DSLExpression left, DSLExpression right);
+DSLPossibleExpression operator|=(DSLExpression left, DSLExpression right);
+DSLPossibleExpression operator^(DSLExpression left, DSLExpression right);
+DSLPossibleExpression operator^=(DSLExpression left, DSLExpression right);
+DSLPossibleExpression LogicalXor(DSLExpression left, DSLExpression right);
+DSLPossibleExpression operator,(DSLExpression left, DSLExpression right);
+DSLPossibleExpression operator,(DSLPossibleExpression left, DSLExpression right);
+DSLPossibleExpression operator,(DSLExpression left, DSLPossibleExpression right);
+DSLPossibleExpression operator,(DSLPossibleExpression left, DSLPossibleExpression right);
+DSLPossibleExpression operator==(DSLExpression left, DSLExpression right);
+DSLPossibleExpression operator!=(DSLExpression left, DSLExpression right);
+DSLPossibleExpression operator>(DSLExpression left, DSLExpression right);
+DSLPossibleExpression operator<(DSLExpression left, DSLExpression right);
+DSLPossibleExpression operator>=(DSLExpression left, DSLExpression right);
+DSLPossibleExpression operator<=(DSLExpression left, DSLExpression right);
+DSLPossibleExpression operator!(DSLExpression expr);
+DSLPossibleExpression operator~(DSLExpression expr);
+DSLPossibleExpression operator++(DSLExpression expr);
+DSLPossibleExpression operator++(DSLExpression expr, int);
+DSLPossibleExpression operator--(DSLExpression expr);
+DSLPossibleExpression operator--(DSLExpression expr, int);
+
+/**
+ * Represents an Expression which may have failed and/or have pending errors to report. Converting a
+ * PossibleExpression into an Expression requires PositionInfo so that any pending errors can be
+ * reported at the correct position.
+ *
+ * PossibleExpression is used instead of Expression in situations where it is not possible to
+ * capture the PositionInfo at the time of Expression construction (notably in operator overloads,
+ * where we cannot add default parameters).
+ */
+class DSLPossibleExpression {
+public:
+    DSLPossibleExpression(std::unique_ptr<SkSL::Expression> expression);
+
+    DSLPossibleExpression(DSLPossibleExpression&& other);
+
+    ~DSLPossibleExpression();
+
+    bool valid() const {
+        return fExpression != nullptr;
+    }
+
+    /**
+     * Reports any pending errors at the specified position.
+     */
+    void reportErrors(PositionInfo pos);
+
+    DSLType type();
+
+    DSLExpression x(PositionInfo pos = PositionInfo::Capture());
+
+    DSLExpression y(PositionInfo pos = PositionInfo::Capture());
+
+    DSLExpression z(PositionInfo pos = PositionInfo::Capture());
+
+    DSLExpression w(PositionInfo pos = PositionInfo::Capture());
+
+    DSLExpression r(PositionInfo pos = PositionInfo::Capture());
+
+    DSLExpression g(PositionInfo pos = PositionInfo::Capture());
+
+    DSLExpression b(PositionInfo pos = PositionInfo::Capture());
+
+    DSLExpression a(PositionInfo pos = PositionInfo::Capture());
+
+    DSLExpression field(skstd::string_view name, PositionInfo pos = PositionInfo::Capture());
+
+    DSLPossibleExpression operator=(DSLExpression expr);
+
+    DSLPossibleExpression operator=(int expr);
+
+    DSLPossibleExpression operator=(float expr);
+
+    DSLPossibleExpression operator=(double expr);
+
+    DSLPossibleExpression operator[](DSLExpression index);
+
+    DSLPossibleExpression operator()(SkTArray<DSLWrapper<DSLExpression>> args,
+                                     PositionInfo pos = PositionInfo::Capture());
+
+    DSLPossibleExpression operator()(ExpressionArray args,
+                                     PositionInfo pos = PositionInfo::Capture());
+
+    DSLPossibleExpression operator++();
+
+    DSLPossibleExpression operator++(int);
+
+    DSLPossibleExpression operator--();
+
+    DSLPossibleExpression operator--(int);
+
+    std::unique_ptr<SkSL::Expression> release(PositionInfo pos = PositionInfo::Capture());
+
+private:
+    std::unique_ptr<SkSL::Expression> fExpression;
+
+    friend class DSLExpression;
+};
+
+} // namespace dsl
+
+} // namespace SkSL
+
+#endif

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

@@ -0,0 +1,116 @@
+/*
+ * 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_FUNCTION
+#define SKSL_DSL_FUNCTION
+
+#include "include/sksl/DSLBlock.h"
+#include "include/sksl/DSLExpression.h"
+#include "include/sksl/DSLType.h"
+#include "include/sksl/DSLVar.h"
+#include "include/sksl/DSLWrapper.h"
+
+namespace SkSL {
+
+class Block;
+class FunctionDeclaration;
+class Variable;
+
+namespace dsl {
+
+class DSLType;
+
+class DSLFunction {
+public:
+    template<class... Parameters>
+    DSLFunction(const DSLType& returnType, skstd::string_view name, Parameters&... parameters)
+        : DSLFunction(DSLModifiers(), returnType, name, parameters...) {}
+
+    template<class... Parameters>
+    DSLFunction(const DSLModifiers& modifiers, const DSLType& returnType, skstd::string_view name,
+                Parameters&... parameters) {
+        SkTArray<DSLParameter*> parameterArray;
+        parameterArray.reserve_back(sizeof...(parameters));
+
+        // in C++17, we could just do:
+        // (parameterArray.push_back(&parameters), ...);
+        int unused[] = {0, (static_cast<void>(parameterArray.push_back(&parameters)), 0)...};
+        static_cast<void>(unused);
+        // We can't have a default parameter and a template parameter pack at the same time, so
+        // unfortunately we can't capture position info from this overload.
+        this->init(modifiers, returnType, name, std::move(parameterArray), PositionInfo());
+    }
+
+    DSLFunction(const DSLType& returnType, skstd::string_view name,
+                SkTArray<DSLParameter*> parameters, PositionInfo pos = PositionInfo::Capture()) {
+        this->init(DSLModifiers(), returnType, name, std::move(parameters), pos);
+    }
+
+    DSLFunction(const DSLModifiers& modifiers, const DSLType& returnType, skstd::string_view name,
+                SkTArray<DSLParameter*> parameters, PositionInfo pos = PositionInfo::Capture()) {
+        this->init(modifiers, returnType, name, std::move(parameters), pos);
+    }
+
+    DSLFunction(const SkSL::FunctionDeclaration* decl)
+        : fDecl(decl) {}
+
+    virtual ~DSLFunction() = default;
+
+    template<class... Stmt>
+    void define(Stmt... stmts) {
+        DSLBlock block = DSLBlock(DSLStatement(std::move(stmts))...);
+        this->define(std::move(block));
+    }
+
+    void define(DSLBlock block, PositionInfo pos = PositionInfo::Capture());
+
+    /**
+     * Invokes the function with the given arguments.
+     */
+    template<class... Args>
+    DSLExpression operator()(Args&&... args) {
+        ExpressionArray argArray;
+        argArray.reserve_back(sizeof...(args));
+        this->collectArgs(argArray, std::forward<Args>(args)...);
+        return this->call(std::move(argArray));
+    }
+
+    /**
+     * Invokes the function with the given arguments.
+     */
+    DSLExpression call(SkTArray<DSLWrapper<DSLExpression>> args,
+            PositionInfo pos = PositionInfo::Capture());
+
+    DSLExpression call(ExpressionArray args, PositionInfo pos = PositionInfo::Capture());
+
+private:
+    void collectArgs(ExpressionArray& args) {}
+
+    template<class... RemainingArgs>
+    void collectArgs(ExpressionArray& args, DSLVar& var, RemainingArgs&&... remaining) {
+        args.push_back(DSLExpression(var).release());
+        collectArgs(args, std::forward<RemainingArgs>(remaining)...);
+    }
+
+    template<class... RemainingArgs>
+    void collectArgs(ExpressionArray& args, DSLExpression expr, RemainingArgs&&... remaining) {
+        args.push_back(expr.release());
+        collectArgs(args, std::forward<RemainingArgs>(remaining)...);
+    }
+
+    void init(DSLModifiers modifiers, const DSLType& returnType, skstd::string_view name,
+              SkTArray<DSLParameter*> params, PositionInfo pos);
+
+    const SkSL::FunctionDeclaration* fDecl = nullptr;
+    SkSL::PositionInfo fPosition;
+};
+
+} // namespace dsl
+
+} // namespace SkSL
+
+#endif

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

@@ -0,0 +1,94 @@
+/*
+ * 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_LAYOUT
+#define SKSL_DSL_LAYOUT
+
+#include "include/sksl/DSLLayout.h"
+
+#include "include/private/SkSLLayout.h"
+#include "include/sksl/SkSLErrorReporter.h"
+
+namespace SkSL {
+
+namespace dsl {
+
+class DSLLayout {
+public:
+    DSLLayout() {}
+
+    DSLLayout& originUpperLeft(PositionInfo pos = PositionInfo::Capture()) {
+        return this->flag(SkSL::Layout::kOriginUpperLeft_Flag, "origin_upper_left", pos);
+    }
+
+    DSLLayout& pushConstant(PositionInfo pos = PositionInfo::Capture()) {
+        return this->flag(SkSL::Layout::kPushConstant_Flag, "push_constant", pos);
+    }
+
+    DSLLayout& blendSupportAllEquations(PositionInfo pos = PositionInfo::Capture()) {
+        return this->flag(SkSL::Layout::kBlendSupportAllEquations_Flag,
+                          "blend_support_all_equations", pos);
+    }
+
+    DSLLayout& color(PositionInfo pos = PositionInfo::Capture()) {
+        return this->flag(SkSL::Layout::kColor_Flag, "color", pos);
+    }
+
+    DSLLayout& location(int location, PositionInfo pos = PositionInfo::Capture()) {
+        return this->intValue(&fSkSLLayout.fLocation, location, SkSL::Layout::kLocation_Flag,
+                              "location", pos);
+    }
+
+    DSLLayout& offset(int offset, PositionInfo pos = PositionInfo::Capture()) {
+        return this->intValue(&fSkSLLayout.fOffset, offset, SkSL::Layout::kOffset_Flag, "offset",
+                              pos);
+    }
+
+    DSLLayout& binding(int binding, PositionInfo pos = PositionInfo::Capture()) {
+        return this->intValue(&fSkSLLayout.fBinding, binding, SkSL::Layout::kBinding_Flag,
+                              "binding", pos);
+    }
+
+    DSLLayout& index(int index, PositionInfo pos = PositionInfo::Capture()) {
+        return this->intValue(&fSkSLLayout.fIndex, index, SkSL::Layout::kIndex_Flag, "index", pos);
+    }
+
+    DSLLayout& set(int set, PositionInfo pos = PositionInfo::Capture()) {
+        return this->intValue(&fSkSLLayout.fSet, set, SkSL::Layout::kSet_Flag, "set", pos);
+    }
+
+    DSLLayout& builtin(int builtin, PositionInfo pos = PositionInfo::Capture()) {
+        return this->intValue(&fSkSLLayout.fBuiltin, builtin, SkSL::Layout::kBuiltin_Flag,
+                              "builtin", pos);
+    }
+
+    DSLLayout& inputAttachmentIndex(int inputAttachmentIndex,
+                                    PositionInfo pos = PositionInfo::Capture()) {
+        return this->intValue(&fSkSLLayout.fInputAttachmentIndex, inputAttachmentIndex,
+                              SkSL::Layout::kInputAttachmentIndex_Flag, "input_attachment_index",
+                              pos);
+    }
+
+private:
+    explicit DSLLayout(SkSL::Layout skslLayout)
+        : fSkSLLayout(skslLayout) {}
+
+    DSLLayout& flag(SkSL::Layout::Flag mask, const char* name, PositionInfo pos);
+
+    DSLLayout& intValue(int* target, int value, SkSL::Layout::Flag flag, const char* name,
+                        PositionInfo pos);
+
+    SkSL::Layout fSkSLLayout;
+
+    friend class DSLModifiers;
+};
+
+} // namespace dsl
+
+} // namespace SkSL
+
+#endif

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

@@ -0,0 +1,64 @@
+/*
+ * 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_MODIFIERS
+#define SKSL_DSL_MODIFIERS
+
+#include "include/core/SkSpan.h"
+#include "include/private/SkSLModifiers.h"
+#include "include/sksl/DSLLayout.h"
+
+namespace SkSL {
+
+namespace dsl {
+
+class DSLField;
+class DSLType;
+
+enum Modifier {
+    kNo_Modifier            = SkSL::Modifiers::kNo_Flag,
+    kConst_Modifier         = SkSL::Modifiers::kConst_Flag,
+    kIn_Modifier            = SkSL::Modifiers::kIn_Flag,
+    kOut_Modifier           = SkSL::Modifiers::kOut_Flag,
+    kInOut_Modifier         = SkSL::Modifiers::kIn_Flag | SkSL::Modifiers::kOut_Flag,
+    kUniform_Modifier       = SkSL::Modifiers::kUniform_Flag,
+    kFlat_Modifier          = SkSL::Modifiers::kFlat_Flag,
+    kNoPerspective_Modifier = SkSL::Modifiers::kNoPerspective_Flag,
+};
+
+class DSLModifiers {
+public:
+    DSLModifiers(int flags = 0)
+        : DSLModifiers(DSLLayout(), flags) {}
+
+    DSLModifiers(DSLLayout layout, int flags = 0)
+        : fModifiers(layout.fSkSLLayout, flags) {}
+
+    int flags() const {
+        return fModifiers.fFlags;
+    }
+
+    DSLLayout layout() const {
+        return DSLLayout(fModifiers.fLayout);
+    }
+
+private:
+    SkSL::Modifiers fModifiers;
+
+    friend DSLType Struct(skstd::string_view name, SkSpan<DSLField> fields, PositionInfo pos);
+    friend class DSLCore;
+    friend class DSLFunction;
+    friend class DSLType;
+    friend class DSLVarBase;
+    friend class DSLWriter;
+};
+
+} // namespace dsl
+
+} // namespace SkSL
+
+#endif

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

@@ -0,0 +1,32 @@
+/*
+ * 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_RUNTIME_EFFECTS
+#define SKSL_DSL_RUNTIME_EFFECTS
+
+#include "include/effects/SkRuntimeEffect.h"
+#include "include/sksl/DSL.h"
+
+namespace SkSL {
+
+class Compiler;
+
+namespace dsl {
+
+#ifndef SKSL_STANDALONE
+
+void StartRuntimeShader(SkSL::Compiler* compiler);
+
+sk_sp<SkRuntimeEffect> EndRuntimeShader(SkRuntimeEffect::Options options = {});
+
+#endif
+
+} // namespace dsl
+
+} // namespace SkSL
+
+#endif