@thi.ng/shader-ast-stdlib 0.11.6 → 0.12.0

package/CHANGELOG.md

@@ -1,6 +1,6 @@
 # Change Log
 
-- **Last updated**: 2022-04-07T14:17:30Z
+- **Last updated**: 2022-05-07T11:33:35Z
 - **Generator**: [thi.ng/monopub](https://thi.ng/monopub)
 
 All notable changes to this project will be documented in this file.
@@ -9,6 +9,17 @@ See [Conventional Commits](https://conventionalcommits.org/) for commit guidelin
 **Note:** Unlisted _patch_ versions only involve non-code or otherwise excluded changes
 and/or version bumps of transitive dependencies.
 
+## [0.12.0](https://github.com/thi-ng/umbrella/tree/@thi.ng/shader-ast-stdlib@0.12.0) (2022-05-07)
+
+#### 🚀 Features
+
+- add more 2D SDF prims ([2672e75](https://github.com/thi-ng/umbrella/commit/2672e75))
+- add 2D SDF arc/bezier fns ([07bd445](https://github.com/thi-ng/umbrella/commit/07bd445))
+
+#### ♻️ Refactoring
+
+- update cross2() as non-inline fn ([59d631a](https://github.com/thi-ng/umbrella/commit/59d631a))
+
 ## [0.11.0](https://github.com/thi-ng/umbrella/tree/@thi.ng/shader-ast-stdlib@0.11.0) (2021-11-17)
 
 #### 🚀 Features

package/README.md

@@ -104,7 +104,7 @@ node --experimental-repl-await
 > const shaderAstStdlib = await import("@thi.ng/shader-ast-stdlib");
 ```
 
-Package sizes (gzipped, pre-treeshake): ESM: 11.05 KB
+Package sizes (gzipped, pre-treeshake): ESM: 12.82 KB
 
 ## Dependencies
 
@@ -443,6 +443,7 @@ for reference.
 
 #### Primitives
 
+- `sdfArc2`
 - `sdfBox2`
 - `sdfBox3`
 - `sdfCircle`
@@ -451,6 +452,7 @@ for reference.
 - `sdfLine3`
 - `sdfPlane2`
 - `sdfPlane3`
+- `sdfQuadratic2`
 - `sdfSphere`
 - `sdfTorus`
 - `sdfTriangle2`

package/index.d.ts

@@ -44,13 +44,19 @@ export * from "./raymarch/point-at.js";
 export * from "./raymarch/scene.js";
 export * from "./screen/uv.js";
 export * from "./sdf/annular.js";
+export * from "./sdf/arc.js";
+export * from "./sdf/bezier.js";
 export * from "./sdf/box.js";
+export * from "./sdf/box-rounded.js";
+export * from "./sdf/cross.js";
 export * from "./sdf/cylinder.js";
+export * from "./sdf/hex.js";
 export * from "./sdf/isec.js";
 export * from "./sdf/line.js";
 export * from "./sdf/mirror.js";
 export * from "./sdf/plane.js";
 export * from "./sdf/polyhedra.js";
+export * from "./sdf/polygon.js";
 export * from "./sdf/repeat.js";
 export * from "./sdf/repeat-polar.js";
 export * from "./sdf/round.js";

package/index.js

@@ -44,13 +44,19 @@ export * from "./raymarch/point-at.js";
 export * from "./raymarch/scene.js";
 export * from "./screen/uv.js";
 export * from "./sdf/annular.js";
+export * from "./sdf/arc.js";
+export * from "./sdf/bezier.js";
 export * from "./sdf/box.js";
+export * from "./sdf/box-rounded.js";
+export * from "./sdf/cross.js";
 export * from "./sdf/cylinder.js";
+export * from "./sdf/hex.js";
 export * from "./sdf/isec.js";
 export * from "./sdf/line.js";
 export * from "./sdf/mirror.js";
 export * from "./sdf/plane.js";
 export * from "./sdf/polyhedra.js";
+export * from "./sdf/polygon.js";
 export * from "./sdf/repeat.js";
 export * from "./sdf/repeat-polar.js";
 export * from "./sdf/round.js";

package/math/cross2.d.ts

@@ -1,12 +1,12 @@
-import type { FloatTerm, Vec2Term } from "@thi.ng/shader-ast";
+import type { FloatTerm } from "@thi.ng/shader-ast";
 /**
- * Inline function. Computes 2D "cross product" of given vectors. See
+ * Computes 2D "cross product" of given vectors. Also see
  * {@link crossC2}.
  *
  * @param a -
  * @param b -
  */
-export declare const cross2: (a: Vec2Term, b: Vec2Term) => import("@thi.ng/shader-ast").Op2<"float">;
+export declare const cross2: import("@thi.ng/shader-ast").TaggedFn2<"vec2", "vec2", "float">;
 /**
  * Inline function. Computes 2D cross product of given individual
  * components: ax * by - ay * bx

package/math/cross2.js

@@ -1,13 +1,16 @@
+import { defn, ret } from "@thi.ng/shader-ast/ast/function";
 import { mul, sub } from "@thi.ng/shader-ast/ast/ops";
 import { $x, $y } from "@thi.ng/shader-ast/ast/swizzle";
 /**
- * Inline function. Computes 2D "cross product" of given vectors. See
+ * Computes 2D "cross product" of given vectors. Also see
  * {@link crossC2}.
  *
  * @param a -
  * @param b -
  */
-export const cross2 = (a, b) => crossC2($x(a), $y(a), $x(b), $y(b));
+export const cross2 = defn("float", "cross2", ["vec2", "vec2"], (a, b) => [
+    ret(sub(mul($x(a), $y(b)), mul($y(a), $x(b)))),
+]);
 /**
  * Inline function. Computes 2D cross product of given individual
  * components: ax * by - ay * bx

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@thi.ng/shader-ast-stdlib",
-  "version": "0.11.6",
+  "version": "0.12.0",
   "description": "Function collection for modular GPGPU / shader programming with @thi.ng/shader-ast",
   "type": "module",
   "module": "./index.js",
@@ -34,16 +34,16 @@
     "test": "testament test"
   },
   "dependencies": {
-    "@thi.ng/api": "^8.3.5",
-    "@thi.ng/shader-ast": "^0.12.6"
+    "@thi.ng/api": "^8.3.6",
+    "@thi.ng/shader-ast": "^0.12.7"
   },
   "devDependencies": {
-    "@microsoft/api-extractor": "^7.19.4",
-    "@thi.ng/testament": "^0.2.5",
+    "@microsoft/api-extractor": "^7.23.1",
+    "@thi.ng/testament": "^0.2.6",
     "rimraf": "^3.0.2",
     "tools": "^0.0.1",
-    "typedoc": "^0.22.13",
-    "typescript": "^4.6.2"
+    "typedoc": "^0.22.15",
+    "typescript": "^4.6.4"
   },
   "keywords": [
     "ast",
@@ -236,12 +236,27 @@
     "./sdf/annular": {
       "default": "./sdf/annular.js"
     },
+    "./sdf/arc": {
+      "default": "./sdf/arc.js"
+    },
+    "./sdf/bezier": {
+      "default": "./sdf/bezier.js"
+    },
+    "./sdf/box-rounded": {
+      "default": "./sdf/box-rounded.js"
+    },
     "./sdf/box": {
       "default": "./sdf/box.js"
     },
+    "./sdf/cross": {
+      "default": "./sdf/cross.js"
+    },
     "./sdf/cylinder": {
       "default": "./sdf/cylinder.js"
     },
+    "./sdf/hex": {
+      "default": "./sdf/hex.js"
+    },
     "./sdf/isec": {
       "default": "./sdf/isec.js"
     },
@@ -254,6 +269,9 @@
     "./sdf/plane": {
       "default": "./sdf/plane.js"
     },
+    "./sdf/polygon": {
+      "default": "./sdf/polygon.js"
+    },
     "./sdf/polyhedra": {
       "default": "./sdf/polyhedra.js"
     },
@@ -312,5 +330,5 @@
     ],
     "year": 2019
   },
-  "gitHead": "5ee1feb590dd935593b1dd4e7f38a3ed3ba64765\n"
+  "gitHead": "cf084be5fd5932226054d2dd32bad35481379f5d\n"
 }

package/sdf/arc.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Returns signed distance from `p` to 2D circular arc with `aperture` (in
+ * [0..π] interval), radius `ra` and `thickness`.
+ *
+ * @remarks
+ * Slightly modified version (easier to use aperture control) of original GLSL
+ * impl by Inigo Quilez:
+ *
+ * - https://www.shadertoy.com/view/wl23RK
+ * - https://iquilezles.org/articles/distfunctions2d/
+ */
+export declare const sdfArc2: import("@thi.ng/shader-ast").TaggedFn4<"vec2", "float", "float", "float", "float">;
+//# sourceMappingURL=arc.d.ts.map

package/sdf/arc.js

@@ -0,0 +1,27 @@
+import { ternary } from "@thi.ng/shader-ast/ast/controlflow";
+import { defn, ret } from "@thi.ng/shader-ast/ast/function";
+import { vec2 } from "@thi.ng/shader-ast/ast/lit";
+import { gt, madd, mul, neg, sub } from "@thi.ng/shader-ast/ast/ops";
+import { $x, $y } from "@thi.ng/shader-ast/ast/swizzle";
+import { sym } from "@thi.ng/shader-ast/ast/sym";
+import { abs, cos, length, sin } from "@thi.ng/shader-ast/builtin/math";
+/**
+ * Returns signed distance from `p` to 2D circular arc with `aperture` (in
+ * [0..π] interval), radius `ra` and `thickness`.
+ *
+ * @remarks
+ * Slightly modified version (easier to use aperture control) of original GLSL
+ * impl by Inigo Quilez:
+ *
+ * - https://www.shadertoy.com/view/wl23RK
+ * - https://iquilezles.org/articles/distfunctions2d/
+ */
+export const sdfArc2 = defn("float", "sdfArc", ["vec2", "float", "float", "float"], (p, apert, ra, rb) => {
+    let q;
+    let sc;
+    return [
+        (q = sym(vec2(abs($x(p)), $y(p)))),
+        (sc = sym(vec2(sin(apert), cos(apert)))),
+        ret(sub(ternary(gt(mul($y(sc), $x(q)), mul($x(sc), $y(q))), length(madd(sc, neg(ra), q)), abs(sub(length(q), ra))), rb)),
+    ];
+});

package/sdf/bezier.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Returns signed distance from `p` to 2D quadratic bezier (given by points A,
+ * B, C).
+ *
+ * @remarks
+ * Ported from original GLSL impl by Inigo Quilez:
+ *
+ * - https://www.shadertoy.com/view/MlKcDD
+ * - https://iquilezles.org/articles/distfunctions2d/
+ */
+export declare const sdfQuadratic2: import("@thi.ng/shader-ast").TaggedFn4<"vec2", "vec2", "vec2", "vec2", "float">;
+//# sourceMappingURL=bezier.d.ts.map

package/sdf/bezier.js

@@ -0,0 +1,72 @@
+import { assign } from "@thi.ng/shader-ast/ast/assign";
+import { ifThen } from "@thi.ng/shader-ast/ast/controlflow";
+import { defn, ret } from "@thi.ng/shader-ast/ast/function";
+import { float, FLOAT0, FLOAT1, FLOAT2, vec2, } from "@thi.ng/shader-ast/ast/lit";
+import { add, div, gte, lt, madd, mul, neg, sub, } from "@thi.ng/shader-ast/ast/ops";
+import { $x, $y } from "@thi.ng/shader-ast/ast/swizzle";
+import { sym } from "@thi.ng/shader-ast/ast/sym";
+import { abs, acos, cos, dot, powf, sign, sin, sqrt, } from "@thi.ng/shader-ast/builtin/math";
+import { clamp01 } from "../math/clamp.js";
+import { cross2 } from "../math/cross2.js";
+/**
+ * Returns signed distance from `p` to 2D quadratic bezier (given by points A,
+ * B, C).
+ *
+ * @remarks
+ * Ported from original GLSL impl by Inigo Quilez:
+ *
+ * - https://www.shadertoy.com/view/MlKcDD
+ * - https://iquilezles.org/articles/distfunctions2d/
+ */
+export const sdfQuadratic2 = defn("float", "sdfQuadratic2", ["vec2", "vec2", "vec2", "vec2"], (pos, A, B, C) => {
+    let a, b, c, d;
+    let kk, kx, ky, kz;
+    let p, q, p3, q2, h;
+    let m, n, t, v, z;
+    let res, sgn;
+    let x, y, uv;
+    return [
+        (a = sym(sub(B, A))),
+        (b = sym(add(madd(B, -2, A), C))),
+        (c = sym(mul(a, 2))),
+        (d = sym(sub(A, pos))),
+        (kk = sym(div(FLOAT1, dot(b, b)))),
+        (kx = sym(mul(kk, dot(a, b)))),
+        (ky = sym(mul(kk, div(madd(FLOAT2, dot(a, a), dot(d, b)), 3)))),
+        (kz = sym(mul(kk, dot(d, a)))),
+        (res = sym(FLOAT0)),
+        (sgn = sym(FLOAT0)),
+        (p = sym(sub(ky, mul(kx, kx)))),
+        (q = sym(madd(sub(mul(mul(FLOAT2, kx), kx), mul(3, ky)), kx, kz))),
+        (p3 = sym(mul(mul(p, p), p))),
+        (q2 = sym(mul(q, q))),
+        (h = sym(madd(p3, 4, q2))),
+        ifThen(gte(h, FLOAT0), [
+            assign(h, sqrt(h)),
+            (x = sym(div(sub(vec2(h, neg(h)), q), FLOAT2))),
+            (uv = sym(mul(sign(x), powf(abs(x), float(1 / 3))))),
+            (t = sym(clamp01(sub(add($x(uv), $y(uv)), kx)))),
+            assign(x, madd(madd(b, t, c), t, d)),
+            assign(res, dot(x, x)),
+            assign(sgn, cross2(madd(b, mul(t, FLOAT2), c), x)),
+        ], [
+            (z = sym(sqrt(neg(p)))),
+            (v = sym(div(acos(div(q, mul(mul(p, z), FLOAT2))), float(3)))),
+            (m = sym(cos(v))),
+            (n = sym(mul(sin(v), 1.732050808))),
+            (uv = sym(clamp01(sub(mul(vec2(add(m, m), sub(neg(n), m)), z), kx)))),
+            (x = sym(madd(madd(b, $x(uv), c), $x(uv), d))),
+            (y = sym(madd(madd(b, $y(uv), c), $y(uv), d))),
+            assign(m, dot(x, x)),
+            assign(n, dot(y, y)),
+            ifThen(lt(m, n), [
+                assign(res, m),
+                assign(sgn, cross2(madd(b, mul($x(uv), 2), c), x)),
+            ], [
+                assign(res, n),
+                assign(sgn, cross2(madd(b, mul($y(uv), 2), c), y)),
+            ]),
+        ]),
+        ret(mul(sign(sgn), sqrt(res))),
+    ];
+});

package/sdf/box-rounded.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Returns signed distance from `p` to centered 2D rect of `size` and corner
+ * radii defined by given vec4 `r`.
+ *
+ * @remarks
+ * Ported from original GLSL impl by Inigo Quilez:
+ * - https://iquilezles.org/articles/distfunctions2d/
+ *
+ * @param p - vec2
+ * @param size - vec2
+ * @param r - vec4
+ */
+export declare const sdfBoxRounded: import("@thi.ng/shader-ast").TaggedFn3<"vec2", "vec2", "vec4", "float">;
+//# sourceMappingURL=box-rounded.d.ts.map

package/sdf/box-rounded.js

@@ -0,0 +1,29 @@
+import { ternary } from "@thi.ng/shader-ast/ast/controlflow";
+import { defn, ret } from "@thi.ng/shader-ast/ast/function";
+import { FLOAT0, VEC2_0 } from "@thi.ng/shader-ast/ast/lit";
+import { add, gt, sub } from "@thi.ng/shader-ast/ast/ops";
+import { $, $x, $xy, $y } from "@thi.ng/shader-ast/ast/swizzle";
+import { sym } from "@thi.ng/shader-ast/ast/sym";
+import { abs, length, max, min } from "@thi.ng/shader-ast/builtin/math";
+import { maxComp2 } from "../math/maxcomp.js";
+/**
+ * Returns signed distance from `p` to centered 2D rect of `size` and corner
+ * radii defined by given vec4 `r`.
+ *
+ * @remarks
+ * Ported from original GLSL impl by Inigo Quilez:
+ * - https://iquilezles.org/articles/distfunctions2d/
+ *
+ * @param p - vec2
+ * @param size - vec2
+ * @param r - vec4
+ */
+export const sdfBoxRounded = defn("float", "sdfBoxRounded", ["vec2", "vec2", "vec4"], (p, size, r) => {
+    let q, t, d;
+    return [
+        (t = sym(ternary(gt($x(p), FLOAT0), $xy(r), $(r, "zw")))),
+        (d = sym(ternary(gt($y(p), FLOAT0), $x(t), $y(t)))),
+        (q = sym(add(sub(abs(p), size), d))),
+        ret(sub(add(min(maxComp2(q), FLOAT0), length(max(q, VEC2_0))), d)),
+    ];
+});

package/sdf/cross.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Returns signed distance from `p` to 2D cross/plus of given `size` and corner
+ * radius `r`.
+ *
+ * @remarks
+ * - `size` consist of overall width/size (in x) and thickness (in y component)
+ * - corner radius can also be negative
+ *
+ * Ported from original GLSL impl by Inigo Quilez:
+ * - https://iquilezles.org/articles/distfunctions2d/
+ *
+ * @param p -
+ * @param size -
+ * @param r -
+ */
+export declare const sdfCross2: import("@thi.ng/shader-ast").TaggedFn3<"vec2", "vec2", "float", "float">;
+/**
+ * Returns signed distance from `p` to 2D "X-sign" of given `size` and stroke
+ * weight `r`.
+ *
+ * @remarks
+ * Ported from original GLSL impl by Inigo Quilez:
+ * - https://iquilezles.org/articles/distfunctions2d/
+ *
+ * @param p -
+ * @param size -
+ * @param r -
+ */
+export declare const sdfRoundedX2: import("@thi.ng/shader-ast").TaggedFn3<"vec2", "float", "float", "float">;
+//# sourceMappingURL=cross.d.ts.map

package/sdf/cross.js

@@ -0,0 +1,55 @@
+import { assign } from "@thi.ng/shader-ast/ast/assign";
+import { ifThen, ternary } from "@thi.ng/shader-ast/ast/controlflow";
+import { defn, ret } from "@thi.ng/shader-ast/ast/function";
+import { FLOAT0, FLOAT05, vec2, VEC2_0 } from "@thi.ng/shader-ast/ast/lit";
+import { add, gt, madd, mul, neg, sub } from "@thi.ng/shader-ast/ast/ops";
+import { $, $x, $y } from "@thi.ng/shader-ast/ast/swizzle";
+import { sym } from "@thi.ng/shader-ast/ast/sym";
+import { abs, length, max, min, sign } from "@thi.ng/shader-ast/builtin/math";
+import { maxComp2 } from "../math/maxcomp.js";
+/**
+ * Returns signed distance from `p` to 2D cross/plus of given `size` and corner
+ * radius `r`.
+ *
+ * @remarks
+ * - `size` consist of overall width/size (in x) and thickness (in y component)
+ * - corner radius can also be negative
+ *
+ * Ported from original GLSL impl by Inigo Quilez:
+ * - https://iquilezles.org/articles/distfunctions2d/
+ *
+ * @param p -
+ * @param size -
+ * @param r -
+ */
+export const sdfCross2 = defn("float", "sdfCross2", ["vec2", "vec2", "float"], (p, size, r) => {
+    let a, q, w;
+    let k;
+    return [
+        (a = sym(abs(p))),
+        ifThen(gt($y(a), $x(a)), [assign(a, $(a, "yx"))]),
+        (q = sym(sub(a, size))),
+        (k = sym(maxComp2(q))),
+        (w = sym(ternary(gt(k, FLOAT0), q, vec2(sub($y(size), $x(a)), neg(k))))),
+        ret(madd(sign(k), length(max(w, VEC2_0)), r)),
+    ];
+});
+/**
+ * Returns signed distance from `p` to 2D "X-sign" of given `size` and stroke
+ * weight `r`.
+ *
+ * @remarks
+ * Ported from original GLSL impl by Inigo Quilez:
+ * - https://iquilezles.org/articles/distfunctions2d/
+ *
+ * @param p -
+ * @param size -
+ * @param r -
+ */
+export const sdfRoundedX2 = defn("float", "sdfRoundedX", ["vec2", "float", "float"], (p, size, r) => {
+    let q;
+    return [
+        (q = sym(abs(p))),
+        ret(sub(length(sub(q, mul(min(add($x(q), $y(q)), size), FLOAT05))), r)),
+    ];
+});

package/sdf/hex.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Returns signed distance from `p` to 2D hexagon of given radius `r`.
+ *
+ * @remarks
+ * Ported from original GLSL impl by Inigo Quilez:
+ * - https://iquilezles.org/articles/distfunctions2d/
+ */
+export declare const sdfHexagon2: import("@thi.ng/shader-ast").TaggedFn2<"vec2", "float", "float">;
+//# sourceMappingURL=hex.d.ts.map

package/sdf/hex.js

@@ -0,0 +1,26 @@
+import { assign } from "@thi.ng/shader-ast/ast/assign";
+import { defn, ret } from "@thi.ng/shader-ast/ast/function";
+import { FLOAT0, vec2 } from "@thi.ng/shader-ast/ast/lit";
+import { mul, sub } from "@thi.ng/shader-ast/ast/ops";
+import { $x, $y } from "@thi.ng/shader-ast/ast/swizzle";
+import { sym } from "@thi.ng/shader-ast/ast/sym";
+import { abs, clamp, dot, length, min, sign, } from "@thi.ng/shader-ast/builtin/math";
+/**
+ * Returns signed distance from `p` to 2D hexagon of given radius `r`.
+ *
+ * @remarks
+ * Ported from original GLSL impl by Inigo Quilez:
+ * - https://iquilezles.org/articles/distfunctions2d/
+ */
+export const sdfHexagon2 = defn("float", "sdfHexagon2", ["vec2", "float"], (p, r) => {
+    const TAN30 = 0.5773502691896257;
+    let k, q;
+    return [
+        // sin/cos @ 60deg
+        (k = sym(vec2(-0.8660254037844386, 0.5))),
+        (q = sym(abs(p))),
+        assign(q, sub(q, mul(k, mul(2, min(dot(k, q), FLOAT0))))),
+        assign(q, sub(q, vec2(clamp($x(q), mul(r, -TAN30), mul(r, TAN30)), r))),
+        ret(mul(length(q), sign($y(q)))),
+    ];
+});

package/sdf/polygon.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Higher-order function. Returns specialized function to compute signed
+ * distance for 2D polygons of `N` vertices.
+ *
+ * @remarks
+ * Based on original GLSL impl by Inigo Quilez:
+ * - https://iquilezles.org/articles/distfunctions2d/
+ *
+ * @param N
+ */
+export declare const sdfPolygon2: (N: number) => import("@thi.ng/shader-ast").TaggedFn2<"vec2", "vec2[]", "float">;
+//# sourceMappingURL=polygon.d.ts.map

package/sdf/polygon.js

@@ -0,0 +1,46 @@
+import { assign } from "@thi.ng/shader-ast/ast/assign";
+import { forLoop, ifThen } from "@thi.ng/shader-ast/ast/controlflow";
+import { defn, ret } from "@thi.ng/shader-ast/ast/function";
+import { index } from "@thi.ng/shader-ast/ast/indexed";
+import { bvec3, FLOAT1, int, INT0 } from "@thi.ng/shader-ast/ast/lit";
+import { div, gt, gte, inc, lt, mul, neg, not, or, sub, } from "@thi.ng/shader-ast/ast/ops";
+import { $x, $y } from "@thi.ng/shader-ast/ast/swizzle";
+import { sym } from "@thi.ng/shader-ast/ast/sym";
+import { all, _any } from "@thi.ng/shader-ast/builtin/bvec";
+import { dot, min, sqrt } from "@thi.ng/shader-ast/builtin/math";
+import { clamp01 } from "../math/clamp.js";
+/**
+ * Higher-order function. Returns specialized function to compute signed
+ * distance for 2D polygons of `N` vertices.
+ *
+ * @remarks
+ * Based on original GLSL impl by Inigo Quilez:
+ * - https://iquilezles.org/articles/distfunctions2d/
+ *
+ * @param N
+ */
+export const sdfPolygon2 = (N) => defn("float", `sdfPolygon2_${N}`, ["vec2", ["vec2[]", "pts", { num: N }]], (p, pts) => {
+    let d, s;
+    let b, e, w, t;
+    let pi, pj;
+    let c;
+    let j;
+    return [
+        (t = sym(sub(p, index(pts, 0)))),
+        (d = sym(dot(t, t))),
+        (s = sym(FLOAT1)),
+        (j = sym(int(N - 1))),
+        forLoop(sym(INT0), (i) => lt(i, int(N)), inc, (i) => [
+            (pi = sym(index(pts, i))),
+            (pj = sym(index(pts, j))),
+            (e = sym(sub(pj, pi))),
+            (w = sym(sub(p, pi))),
+            (b = sym(sub(w, mul(e, clamp01(div(dot(w, e), dot(e, e))))))),
+            assign(d, min(d, dot(b, b))),
+            (c = sym(bvec3(gte($y(p), $y(pi)), lt($y(p), $y(pj)), gt(mul($x(e), $y(w)), mul($y(e), $x(w)))))),
+            ifThen(or(all(c), not(_any(c))), [assign(s, neg(s))]),
+            assign(j, i),
+        ]),
+        ret(mul(s, sqrt(d))),
+    ];
+});

package/sdf/union.d.ts

@@ -9,7 +9,8 @@ import type { FloatTerm } from "@thi.ng/shader-ast";
 export declare const sdfUnion: (a: FloatTerm, ...terms: FloatTerm[]) => FloatTerm;
 /**
  * SDF shape union for vec2 terms, i.e. the common form where the X coord
- * defines distance and Y an object or material ID.
+ * defines distance and Y an object or material ID. Returns `a` or `b`,
+ * depending whose x-coord (dist) is smaller.
  *
  * @param a -
  * @param b -

package/sdf/union.js

@@ -13,7 +13,8 @@ import { min } from "@thi.ng/shader-ast/builtin/math";
 export const sdfUnion = (a, ...terms) => terms.reduce((a, b) => min(a, b), a);
 /**
  * SDF shape union for vec2 terms, i.e. the common form where the X coord
- * defines distance and Y an object or material ID.
+ * defines distance and Y an object or material ID. Returns `a` or `b`,
+ * depending whose x-coord (dist) is smaller.
  *
  * @param a -
  * @param b -