@shopify/react-native-skia 0.1.129 → 0.1.130

package/cpp/skia/include/private/gpu/graphite/MtlTypesPriv.h

@@ -0,0 +1,74 @@
+/*
+ * Copyright 2021 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef skgpu_graphite_MtlTypesPriv_DEFINED
+#define skgpu_graphite_MtlTypesPriv_DEFINED
+
+#include "include/gpu/graphite/GraphiteTypes.h"
+#include "include/gpu/graphite/mtl/MtlTypes.h"
+
+///////////////////////////////////////////////////////////////////////////////
+
+#ifdef __APPLE__
+
+#include <TargetConditionals.h>
+
+// We're using the MSL version as shorthand for the Metal SDK version here
+#if defined(SK_BUILD_FOR_MAC)
+#if __MAC_OS_X_VERSION_MAX_ALLOWED >= 110000
+#define GR_METAL_SDK_VERSION 230
+#elif __MAC_OS_X_VERSION_MAX_ALLOWED >= 120000
+#define GR_METAL_SDK_VERSION 240
+#else
+#error Must use at least 11.00 SDK to build Metal backend for MacOS
+#endif
+#else
+#if __IPHONE_OS_VERSION_MAX_ALLOWED >= 140000 || __TV_OS_VERSION_MAX_ALLOWED >= 140000
+#define GR_METAL_SDK_VERSION 230
+#elif __IPHONE_OS_VERSION_MAX_ALLOWED >= 150000 || __TV_OS_VERSION_MAX_ALLOWED >= 150000
+#define GR_METAL_SDK_VERSION 240
+#else
+#error Must use at least 14.00 SDK to build Metal backend for iOS
+#endif
+#endif
+
+#endif  // __APPLE__
+
+namespace skgpu::graphite {
+
+struct MtlTextureSpec {
+    MtlTextureSpec()
+            : fFormat(0)
+            , fUsage(0)
+            , fStorageMode(0)
+            , fFramebufferOnly(false) {}
+    MtlTextureSpec(const MtlTextureInfo& info)
+            : fFormat(info.fFormat)
+            , fUsage(info.fUsage)
+            , fStorageMode(info.fStorageMode)
+            , fFramebufferOnly(info.fFramebufferOnly) {}
+
+    bool operator==(const MtlTextureSpec& that) const {
+        return fFormat == that.fFormat &&
+               fUsage == that.fUsage &&
+               fStorageMode == that.fStorageMode &&
+               fFramebufferOnly == that.fFramebufferOnly;
+    }
+
+    MtlPixelFormat fFormat;
+    MtlTextureUsage fUsage;
+    MtlStorageMode fStorageMode;
+    bool fFramebufferOnly;
+};
+
+MtlTextureInfo MtlTextureSpecToTextureInfo(const MtlTextureSpec& mtlSpec,
+                                           uint32_t sampleCount,
+                                           uint32_t levelCount);
+
+}  // namespace skgpu::graphite
+
+#endif  // skgpu_graphite_MtlTypesPriv_DEFINED

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

@@ -8,7 +8,11 @@
 #ifndef SKSL_DSL
 #define SKSL_DSL
 
+#include "include/sksl/DSLBlock.h"
 #include "include/sksl/DSLCore.h"
+#include "include/sksl/DSLExpression.h"
+#include "include/sksl/DSLFunction.h"
+#include "include/sksl/DSLType.h"
 
 namespace SkSL {
 

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

@@ -9,10 +9,12 @@
 #define SKSL_DSL_BLOCK
 
 #include "include/private/SkSLDefines.h"
-#include "include/sksl/DSLExpression.h"
+#include "include/private/SkTArray.h"
 #include "include/sksl/DSLStatement.h"
+#include "include/sksl/SkSLPosition.h"
 
 #include <memory>
+#include <utility>
 
 namespace SkSL {
 
@@ -37,9 +39,11 @@ public:
 
     DSLBlock(DSLBlock&& other) = default;
 
-    DSLBlock(SkSL::StatementArray statements, std::shared_ptr<SymbolTable> symbols = nullptr);
+    DSLBlock(SkSL::StatementArray statements, std::shared_ptr<SymbolTable> symbols = nullptr,
+            Position pos = {});
 
-    DSLBlock(SkTArray<DSLStatement> statements, std::shared_ptr<SymbolTable> symbols = nullptr);
+    DSLBlock(SkTArray<DSLStatement> statements, std::shared_ptr<SymbolTable> symbols = nullptr,
+            Position pos = {});
 
     ~DSLBlock();
 
@@ -55,6 +59,7 @@ public:
 private:
     SkSL::StatementArray fStatements;
     std::shared_ptr<SkSL::SymbolTable> fSymbols;
+    Position fPosition;
 
     friend class DSLStatement;
     friend class DSLFunction;

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

@@ -9,15 +9,15 @@
 #define SKSL_DSL_CASE
 
 #include "include/private/SkSLDefines.h"
+#include "include/private/SkTArray.h"
 #include "include/sksl/DSLExpression.h"
 #include "include/sksl/DSLStatement.h"
+#include "include/sksl/SkSLPosition.h"
 
-#include <memory>
+#include <utility>
 
 namespace SkSL {
 
-class Statement;
-
 namespace dsl {
 
 class DSLCase {
@@ -37,10 +37,10 @@ public:
     }
 
     DSLCase(DSLExpression value, SkTArray<DSLStatement> statements,
-            PositionInfo info = PositionInfo::Capture());
+            Position pos = {});
 
     DSLCase(DSLExpression value, SkSL::StatementArray statements,
-            PositionInfo info = PositionInfo::Capture());
+            Position pos = {});
 
     DSLCase(DSLCase&&);
 
@@ -53,7 +53,7 @@ public:
 private:
     DSLExpression fValue;
     SkSL::StatementArray fStatements;
-    PositionInfo fPosition;
+    Position fPosition;
 
     friend class DSLCore;
 

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

@@ -8,26 +8,33 @@
 #ifndef SKSL_DSL_CORE
 #define SKSL_DSL_CORE
 
+#include "include/private/SkSLDefines.h"
 #include "include/private/SkSLProgramKind.h"
 #include "include/private/SkTArray.h"
-#include "include/sksl/DSLBlock.h"
 #include "include/sksl/DSLCase.h"
 #include "include/sksl/DSLExpression.h"
-#include "include/sksl/DSLFunction.h"
 #include "include/sksl/DSLStatement.h"
-#include "include/sksl/DSLType.h"
 #include "include/sksl/DSLVar.h"
-#include "include/sksl/DSLWrapper.h"
-#include "include/sksl/SkSLErrorReporter.h"
+
+#include <memory>
+#include <string>
+#include <string_view>
+#include <utility>
 
 namespace SkSL {
 
 class Compiler;
+class ErrorReporter;
+class Position;
+struct ForLoopPositions;
 struct Program;
 struct ProgramSettings;
 
 namespace dsl {
 
+class DSLField;
+class DSLModifiers;
+
 // When users import the DSL namespace via `using namespace SkSL::dsl`, we want the SwizzleComponent
 // Type enum to come into scope as well, so `Swizzle(var, X, Y, ONE)` can work as expected.
 // `namespace SkSL::SwizzleComponent` contains only an `enum Type`; this `using namespace` directive
@@ -52,9 +59,9 @@ void End();
  * Returns all global elements (functions and global variables) as a self-contained Program. The
  * optional source string is retained as the program's source. DSL programs do not normally have
  * sources, but when a DSL program is produced from parsed program text (as in DSLParser), it may be
- * important to retain it so that any skstd::string_views derived from it remain valid.
+ * important to retain it so that any std::string_views derived from it remain valid.
  */
-std::unique_ptr<SkSL::Program> ReleaseProgram(std::unique_ptr<SkSL::String> source = nullptr);
+std::unique_ptr<SkSL::Program> ReleaseProgram(std::unique_ptr<std::string> source = nullptr);
 
 /**
  * Returns the ErrorReporter which will be notified of any errors that occur during DSL calls. The
@@ -76,42 +83,42 @@ DSLExpression sk_Position();
 /**
  * #extension <name> : enable
  */
-void AddExtension(skstd::string_view name, PositionInfo pos = PositionInfo::Capture());
+void AddExtension(std::string_view name, Position pos = {});
 
 /**
  * break;
  */
-DSLStatement Break(PositionInfo pos = PositionInfo::Capture());
+DSLStatement Break(Position pos = {});
 
 /**
  * continue;
  */
-DSLStatement Continue(PositionInfo pos = PositionInfo::Capture());
+DSLStatement Continue(Position pos = {});
 
 /**
  * Adds a modifiers declaration to the current program.
  */
-void Declare(const DSLModifiers& modifiers, PositionInfo pos = PositionInfo::Capture());
+void Declare(const DSLModifiers& modifiers, Position pos = {});
 
 /**
  * Creates a local variable declaration statement.
  */
-DSLStatement Declare(DSLVar& var, PositionInfo pos = PositionInfo::Capture());
+DSLStatement Declare(DSLVar& var, Position pos = {});
 
 /**
  * Creates a local variable declaration statement containing multiple variables.
  */
-DSLStatement Declare(SkTArray<DSLVar>& vars, PositionInfo pos = PositionInfo::Capture());
+DSLStatement Declare(SkTArray<DSLVar>& vars, Position pos = {});
 
 /**
  * Declares a global variable.
  */
-void Declare(DSLGlobalVar& var, PositionInfo pos = PositionInfo::Capture());
+void Declare(DSLGlobalVar& var, Position pos = {});
 
 /**
  * Declares a set of global variables.
  */
-void Declare(SkTArray<DSLGlobalVar>& vars, PositionInfo pos = PositionInfo::Capture());
+void Declare(SkTArray<DSLGlobalVar>& vars, Position pos = {});
 
 /**
  * default: statements
@@ -124,50 +131,50 @@ DSLCase Default(Statements... statements) {
 /**
  * discard;
  */
-DSLStatement Discard(PositionInfo pos = PositionInfo::Capture());
+DSLStatement Discard(Position pos = {});
 
 /**
  * do stmt; while (test);
  */
-DSLStatement Do(DSLStatement stmt, DSLExpression test, PositionInfo pos = PositionInfo::Capture());
+DSLStatement Do(DSLStatement stmt, DSLExpression test, Position pos = {});
 
 /**
  * for (initializer; test; next) stmt;
  */
 DSLStatement For(DSLStatement initializer, DSLExpression test, DSLExpression next,
-                 DSLStatement stmt, PositionInfo pos = PositionInfo::Capture());
+                 DSLStatement stmt, Position pos = {}, ForLoopPositions positions = {});
 
 /**
  * if (test) ifTrue; [else ifFalse;]
  */
 DSLStatement If(DSLExpression test, DSLStatement ifTrue, DSLStatement ifFalse = DSLStatement(),
-                PositionInfo pos = PositionInfo::Capture());
+                Position pos = {});
 
-DSLGlobalVar InterfaceBlock(const DSLModifiers& modifiers,  skstd::string_view typeName,
-                            SkTArray<DSLField> fields, skstd::string_view varName = "",
-                            int arraySize = 0, PositionInfo pos = PositionInfo::Capture());
+DSLGlobalVar InterfaceBlock(const DSLModifiers& modifiers,  std::string_view typeName,
+                            SkTArray<DSLField> fields, std::string_view varName = "",
+                            int arraySize = 0, Position pos = {});
 
 /**
  * return [value];
  */
 DSLStatement Return(DSLExpression value = DSLExpression(),
-                    PositionInfo pos = PositionInfo::Capture());
+                    Position pos = {});
 
 /**
  * test ? ifTrue : ifFalse
  */
 DSLExpression Select(DSLExpression test, DSLExpression ifTrue, DSLExpression ifFalse,
-                     PositionInfo info = PositionInfo::Capture());
+                     Position  = {});
 
 DSLStatement StaticIf(DSLExpression test, DSLStatement ifTrue,
                       DSLStatement ifFalse = DSLStatement(),
-                      PositionInfo pos = PositionInfo::Capture());
+                      Position pos = {});
 
 // Internal use only
 DSLPossibleStatement PossibleStaticSwitch(DSLExpression value, SkTArray<DSLCase> cases);
 
 DSLStatement StaticSwitch(DSLExpression value, SkTArray<DSLCase> cases,
-                          PositionInfo info = PositionInfo::Capture());
+                          Position pos = {});
 
 /**
  * @switch (value) { cases }
@@ -184,7 +191,7 @@ DSLPossibleStatement StaticSwitch(DSLExpression value, Cases... cases) {
 DSLPossibleStatement PossibleSwitch(DSLExpression value, SkTArray<DSLCase> cases);
 
 DSLStatement Switch(DSLExpression value, SkTArray<DSLCase> cases,
-                    PositionInfo info = PositionInfo::Capture());
+                    Position pos = {});
 
 /**
  * switch (value) { cases }
@@ -201,187 +208,191 @@ DSLPossibleStatement Switch(DSLExpression value, Cases... cases) {
  * while (test) stmt;
  */
 DSLStatement While(DSLExpression test, DSLStatement stmt,
-                   PositionInfo info = PositionInfo::Capture());
+                   Position pos = {});
 
 /**
  * expression.xyz1
  */
 DSLExpression Swizzle(DSLExpression base,
                       SkSL::SwizzleComponent::Type a,
-                      PositionInfo pos = PositionInfo::Capture());
+                      Position pos = {},
+                      Position maskPos = {});
 
 DSLExpression Swizzle(DSLExpression base,
                       SkSL::SwizzleComponent::Type a,
                       SkSL::SwizzleComponent::Type b,
-                      PositionInfo pos = PositionInfo::Capture());
+                      Position pos = {},
+                      Position maskPos = {});
 
 DSLExpression Swizzle(DSLExpression base,
                       SkSL::SwizzleComponent::Type a,
                       SkSL::SwizzleComponent::Type b,
                       SkSL::SwizzleComponent::Type c,
-                      PositionInfo pos = PositionInfo::Capture());
+                      Position pos = {},
+                      Position maskPos = {});
 
 DSLExpression Swizzle(DSLExpression base,
                       SkSL::SwizzleComponent::Type a,
                       SkSL::SwizzleComponent::Type b,
                       SkSL::SwizzleComponent::Type c,
                       SkSL::SwizzleComponent::Type d,
-                      PositionInfo pos = PositionInfo::Capture());
+                      Position pos = {},
+                      Position maskPos = {});
 
 /**
  * Returns the absolute value of x. If x is a vector, operates componentwise.
  */
-DSLExpression Abs(DSLExpression x, PositionInfo pos = PositionInfo::Capture());
+DSLExpression Abs(DSLExpression x, Position pos = {});
 
 /**
  * Returns true if all of the components of boolean vector x are true.
  */
-DSLExpression All(DSLExpression x, PositionInfo pos = PositionInfo::Capture());
+DSLExpression All(DSLExpression x, Position pos = {});
 
 /**
  * Returns true if any of the components of boolean vector x are true.
  */
-DSLExpression Any(DSLExpression x, PositionInfo pos = PositionInfo::Capture());
+DSLExpression Any(DSLExpression x, Position pos = {});
 
 /**
  * Returns the arctangent of y over x. Operates componentwise on vectors.
  */
-DSLExpression Atan(DSLExpression y_over_x, PositionInfo pos = PositionInfo::Capture());
-DSLExpression Atan(DSLExpression y, DSLExpression x, PositionInfo pos = PositionInfo::Capture());
+DSLExpression Atan(DSLExpression y_over_x, Position pos = {});
+DSLExpression Atan(DSLExpression y, DSLExpression x, Position pos = {});
 
 /**
  * Returns x rounded towards positive infinity. If x is a vector, operates componentwise.
  */
-DSLExpression Ceil(DSLExpression x, PositionInfo pos = PositionInfo::Capture());
+DSLExpression Ceil(DSLExpression x, Position pos = {});
 
 /**
  * Returns x clamped to between min and max. If x is a vector, operates componentwise.
  */
 DSLExpression Clamp(DSLExpression x, DSLExpression min, DSLExpression max,
-                    PositionInfo pos = PositionInfo::Capture());
+                    Position pos = {});
 
 /**
  * Returns the cosine of x. If x is a vector, operates componentwise.
  */
-DSLExpression Cos(DSLExpression x, PositionInfo pos = PositionInfo::Capture());
+DSLExpression Cos(DSLExpression x, Position pos = {});
 
 /**
  * Returns the cross product of x and y.
  */
-DSLExpression Cross(DSLExpression x, DSLExpression y, PositionInfo pos = PositionInfo::Capture());
+DSLExpression Cross(DSLExpression x, DSLExpression y, Position pos = {});
 
 /**
  * Returns x converted from radians to degrees. If x is a vector, operates componentwise.
  */
-DSLExpression Degrees(DSLExpression x, PositionInfo pos = PositionInfo::Capture());
+DSLExpression Degrees(DSLExpression x, Position pos = {});
 
 /**
  * Returns the distance between x and y.
  */
 DSLExpression Distance(DSLExpression x, DSLExpression y,
-                       PositionInfo pos = PositionInfo::Capture());
+                       Position pos = {});
 
 /**
  * Returns the dot product of x and y.
  */
-DSLExpression Dot(DSLExpression x, DSLExpression y, PositionInfo pos = PositionInfo::Capture());
+DSLExpression Dot(DSLExpression x, DSLExpression y, Position pos = {});
 
 /**
  * Returns a boolean vector indicating whether components of x are equal to the corresponding
  * components of y.
  */
-DSLExpression Equal(DSLExpression x, DSLExpression y, PositionInfo pos = PositionInfo::Capture());
+DSLExpression Equal(DSLExpression x, DSLExpression y, Position pos = {});
 
 /**
  * Returns e^x. If x is a vector, operates componentwise.
  */
-DSLExpression Exp(DSLExpression x, PositionInfo pos = PositionInfo::Capture());
+DSLExpression Exp(DSLExpression x, Position pos = {});
 
 /**
  * Returns 2^x. If x is a vector, operates componentwise.
  */
-DSLExpression Exp2(DSLExpression x, PositionInfo pos = PositionInfo::Capture());
+DSLExpression Exp2(DSLExpression x, Position pos = {});
 
 /**
  * If dot(i, nref) >= 0, returns n, otherwise returns -n.
  */
 DSLExpression Faceforward(DSLExpression n, DSLExpression i, DSLExpression nref,
-                          PositionInfo pos = PositionInfo::Capture());
+                          Position pos = {});
 
 /**
  * Returns x rounded towards negative infinity. If x is a vector, operates componentwise.
  */
-DSLExpression Floor(DSLExpression x, PositionInfo pos = PositionInfo::Capture());
+DSLExpression Floor(DSLExpression x, Position pos = {});
 
 /**
  * Returns the fractional part of x. If x is a vector, operates componentwise.
  */
-DSLExpression Fract(DSLExpression x, PositionInfo pos = PositionInfo::Capture());
+DSLExpression Fract(DSLExpression x, Position pos = {});
 
 /**
  * Returns a boolean vector indicating whether components of x are greater than the corresponding
  * components of y.
  */
 DSLExpression GreaterThan(DSLExpression x, DSLExpression y,
-                          PositionInfo pos = PositionInfo::Capture());
+                          Position pos = {});
 
 /**
  * Returns a boolean vector indicating whether components of x are greater than or equal to the
  * corresponding components of y.
  */
 DSLExpression GreaterThanEqual(DSLExpression x, DSLExpression y,
-                               PositionInfo pos = PositionInfo::Capture());
+                               Position pos = {});
 
 /**
  * Returns the 1/sqrt(x). If x is a vector, operates componentwise.
  */
-DSLExpression Inversesqrt(DSLExpression x, PositionInfo pos = PositionInfo::Capture());
+DSLExpression Inversesqrt(DSLExpression x, Position pos = {});
 
 /**
  * Returns the inverse of the matrix x.
  */
-DSLExpression Inverse(DSLExpression x, PositionInfo pos = PositionInfo::Capture());
+DSLExpression Inverse(DSLExpression x, Position pos = {});
 
 /**
  * Returns the length of the vector x.
  */
-DSLExpression Length(DSLExpression x, PositionInfo pos = PositionInfo::Capture());
+DSLExpression Length(DSLExpression x, Position pos = {});
 
 /**
  * Returns a boolean vector indicating whether components of x are less than the corresponding
  * components of y.
  */
 DSLExpression LessThan(DSLExpression x, DSLExpression y,
-                       PositionInfo pos = PositionInfo::Capture());
+                       Position pos = {});
 
 /**
  * Returns a boolean vector indicating whether components of x are less than or equal to the
  * corresponding components of y.
  */
 DSLExpression LessThanEqual(DSLExpression x, DSLExpression y,
-                            PositionInfo pos = PositionInfo::Capture());
+                            Position pos = {});
 
 /**
  * Returns the log base e of x. If x is a vector, operates componentwise.
  */
-DSLExpression Log(DSLExpression x, PositionInfo pos = PositionInfo::Capture());
+DSLExpression Log(DSLExpression x, Position pos = {});
 
 /**
  * Returns the log base 2 of x. If x is a vector, operates componentwise.
  */
-DSLExpression Log2(DSLExpression x, PositionInfo pos = PositionInfo::Capture());
+DSLExpression Log2(DSLExpression x, Position pos = {});
 
 /**
  * Returns the larger (closer to positive infinity) of x and y. If x is a vector, operates
  * componentwise. y may be either a vector of the same dimensions as x, or a scalar.
  */
-DSLExpression Max(DSLExpression x, DSLExpression y, PositionInfo pos = PositionInfo::Capture());
+DSLExpression Max(DSLExpression x, DSLExpression y, Position pos = {});
 
 /**
  * Returns the smaller (closer to negative infinity) of x and y. If x is a vector, operates
  * componentwise. y may be either a vector of the same dimensions as x, or a scalar.
  */
-DSLExpression Min(DSLExpression x, DSLExpression y, PositionInfo pos = PositionInfo::Capture());
+DSLExpression Min(DSLExpression x, DSLExpression y, Position pos = {});
 
 /**
  * Returns a linear intepolation between x and y at position a, where a=0 results in x and a=1
@@ -389,68 +400,68 @@ DSLExpression Min(DSLExpression x, DSLExpression y, PositionInfo pos = PositionI
  * same dimensions as x and y, or a scalar.
  */
 DSLExpression Mix(DSLExpression x, DSLExpression y, DSLExpression a,
-                  PositionInfo pos = PositionInfo::Capture());
+                  Position pos = {});
 
 /**
  * Returns x modulo y. If x is a vector, operates componentwise. y may be either a vector of the
  * same dimensions as x, or a scalar.
  */
-DSLExpression Mod(DSLExpression x, DSLExpression y, PositionInfo pos = PositionInfo::Capture());
+DSLExpression Mod(DSLExpression x, DSLExpression y, Position pos = {});
 
 /**
  * Returns the vector x normalized to a length of 1.
  */
-DSLExpression Normalize(DSLExpression x, PositionInfo pos = PositionInfo::Capture());
+DSLExpression Normalize(DSLExpression x, Position pos = {});
 
 /**
  * Returns a boolean vector indicating whether components of x are not equal to the corresponding
  * components of y.
  */
 DSLExpression NotEqual(DSLExpression x, DSLExpression y,
-                       PositionInfo pos = PositionInfo::Capture());
+                       Position pos = {});
 
 /**
  * Returns x raised to the power y. If x is a vector, operates componentwise. y may be either a
  * vector of the same dimensions as x, or a scalar.
  */
-DSLExpression Pow(DSLExpression x, DSLExpression y, PositionInfo pos = PositionInfo::Capture());
+DSLExpression Pow(DSLExpression x, DSLExpression y, Position pos = {});
 
 /**
  * Returns x converted from degrees to radians. If x is a vector, operates componentwise.
  */
-DSLExpression Radians(DSLExpression x, PositionInfo pos = PositionInfo::Capture());
+DSLExpression Radians(DSLExpression x, Position pos = {});
 
 /**
  * Returns i reflected from a surface with normal n.
  */
-DSLExpression Reflect(DSLExpression i, DSLExpression n, PositionInfo pos = PositionInfo::Capture());
+DSLExpression Reflect(DSLExpression i, DSLExpression n, Position pos = {});
 
 /**
  * Returns i refracted across a surface with normal n and ratio of indices of refraction eta.
  */
 DSLExpression Refract(DSLExpression i, DSLExpression n, DSLExpression eta,
-                      PositionInfo pos = PositionInfo::Capture());
+                      Position pos = {});
 
 /**
  * Returns x, rounded to the nearest integer. If x is a vector, operates componentwise.
  */
-DSLExpression Round(DSLExpression x, PositionInfo pos = PositionInfo::Capture());
+DSLExpression Round(DSLExpression x, Position pos = {});
 
 /**
  * Returns x clamped to the range [0, 1]. If x is a vector, operates componentwise.
  */
-DSLExpression Saturate(DSLExpression x, PositionInfo pos = PositionInfo::Capture());
+DSLExpression Saturate(DSLExpression x, Position pos = {});
 
 /**
  * Returns -1, 0, or 1 depending on whether x is negative, zero, or positive, respectively. If x is
  * a vector, operates componentwise.
  */
-DSLExpression Sign(DSLExpression x, PositionInfo pos = PositionInfo::Capture());
+DSLExpression Sign(DSLExpression x, Position pos = {});
 
 /**
  * Returns the sine of x. If x is a vector, operates componentwise.
  */
-DSLExpression Sin(DSLExpression x, PositionInfo pos = PositionInfo::Capture());
+DSLExpression Sin(DSLExpression x, Position pos = {});
 
 /**
  * Returns a smooth interpolation between 0 (at x=edge1) and 1 (at x=edge2). If x is a vector,
@@ -458,28 +469,28 @@ DSLExpression Sin(DSLExpression x, PositionInfo pos = PositionInfo::Capture());
  * scalars.
  */
 DSLExpression Smoothstep(DSLExpression edge1, DSLExpression edge2, DSLExpression x,
-                         PositionInfo pos = PositionInfo::Capture());
+                         Position pos = {});
 
 /**
  * Returns the square root of x. If x is a vector, operates componentwise.
  */
-DSLExpression Sqrt(DSLExpression x, PositionInfo pos = PositionInfo::Capture());
+DSLExpression Sqrt(DSLExpression x, Position pos = {});
 
 /**
  * Returns 0 if x < edge or 1 if x >= edge. If x is a vector, operates componentwise. edge may be
  * either a vector of the same dimensions as x, or a scalar.
  */
-DSLExpression Step(DSLExpression edge, DSLExpression x, PositionInfo pos = PositionInfo::Capture());
+DSLExpression Step(DSLExpression edge, DSLExpression x, Position pos = {});
 
 /**
  * Returns the tangent of x. If x is a vector, operates componentwise.
  */
-DSLExpression Tan(DSLExpression x, PositionInfo pos = PositionInfo::Capture());
+DSLExpression Tan(DSLExpression x, Position pos = {});
 
 /**
  * Returns x converted from premultipled to unpremultiplied alpha.
  */
-DSLExpression Unpremul(DSLExpression x, PositionInfo pos = PositionInfo::Capture());
+DSLExpression Unpremul(DSLExpression x, Position pos = {});
 
 } // namespace dsl