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

package/CHANGELOG.md

@@ -1,6 +1,6 @@
 # Change Log
 
-- **Last updated**: 2021-12-13T10:26:00Z
+- **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`
@@ -503,4 +505,4 @@ If this project contributes to an academic publication, please cite it as:
 
 ## License
 
-© 2019 - 2021 Karsten Schmidt // Apache Software License 2.0
+© 2019 - 2022 Karsten Schmidt // Apache Software License 2.0

package/color/aces-film.d.ts

@@ -4,7 +4,7 @@
  * Reference:
  * https://knarkowicz.wordpress.com/2016/01/06/aces-filmic-tone-mapping-curve/
  *
- * @param col
+ * @param col -
  */
 export declare const ACESFilm: import("@thi.ng/shader-ast").TaggedFn1<"vec3", "vec3">;
 //# sourceMappingURL=aces-film.d.ts.map

package/color/aces-film.js

@@ -7,7 +7,7 @@ import { clamp01 } from "../math/clamp.js";
  * Reference:
  * https://knarkowicz.wordpress.com/2016/01/06/aces-filmic-tone-mapping-curve/
  *
- * @param col
+ * @param col -
  */
 export const ACESFilm = defn("vec3", "ACESFilm", ["vec3"], (col) => [
     ret(clamp01(div(mul(col, add(mul(col, 2.51), 0.03)), add(mul(col, add(mul(col, 2.43), 0.59)), 0.14)))),

package/color/levels.d.ts

@@ -12,7 +12,7 @@ export declare const midLevelGamma: import("@thi.ng/shader-ast").TaggedFn1<"floa
  * potentially varying settings per channel). To be used with
  * {@link levelAdjustGammaRGB}.
  *
- * @param mid
+ * @param mid -
  */
 export declare const midLevelGammaRGB: (mid: Vec3Term) => import("@thi.ng/shader-ast").Lit<"vec3">;
 /**
@@ -53,10 +53,10 @@ export declare const levelAdjustMid: (x: FloatTerm, mid: FloatTerm, input: Vec2T
  * @remarks
  * Also see {@link levelAdjustGammaRGB}, {@link midLevelGammaRGB}.
  *
- * @param x
- * @param mid
- * @param input
- * @param output
+ * @param x -
+ * @param mid -
+ * @param input -
+ * @param output -
  */
 export declare const levelAdjustMidRGB: (x: Vec3Term, mid: Vec3Term, input: Mat3Term, output: Mat3Term) => import("@thi.ng/shader-ast").FnCall<"vec3">;
 //# sourceMappingURL=levels.d.ts.map

package/color/levels.js

@@ -21,7 +21,7 @@ export const midLevelGamma = defn("float", "midLevelGamma", ["float"], (mid) =>
  * potentially varying settings per channel). To be used with
  * {@link levelAdjustGammaRGB}.
  *
- * @param mid
+ * @param mid -
  */
 export const midLevelGammaRGB = (mid) => vec3(midLevelGamma($x(mid)), midLevelGamma($y(mid)), midLevelGamma($z(mid)));
 /**
@@ -66,9 +66,9 @@ export const levelAdjustMid = (x, mid, input, output) => levelAdjustGamma(x, mid
  * @remarks
  * Also see {@link levelAdjustGammaRGB}, {@link midLevelGammaRGB}.
  *
- * @param x
- * @param mid
- * @param input
- * @param output
+ * @param x -
+ * @param mid -
+ * @param input -
+ * @param output -
  */
 export const levelAdjustMidRGB = (x, mid, input, output) => levelAdjustGammaRGB(x, midLevelGammaRGB(mid), input, output);

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/math/fit.d.ts

@@ -12,21 +12,21 @@ export declare const fitNorm1: import("@thi.ng/shader-ast").TaggedFn3<"float", "
  * Fits value `x` from closed interval [a,b] to closed interval [c,d]. No
  * clamping performed.
  *
- * @param x
- * @param a
- * @param b
- * @param c
- * @param d
+ * @param x -
+ * @param a -
+ * @param b -
+ * @param c -
+ * @param d -
  */
 export declare const fit: <T extends PrimTerm>(x: T, a: T, b: T, c: T, d: T) => Term<TermType<T>>;
 /**
  * Same as {@link fit}, but first clamps `x` to closed [a,b] interval.
  *
- * @param x
- * @param a
- * @param b
- * @param c
- * @param d
+ * @param x -
+ * @param a -
+ * @param b -
+ * @param c -
+ * @param d -
  */
 export declare const fitClamped: <T extends PrimTerm>(x: T, a: T, b: T, c: T, d: T) => Term<TermType<T>>;
 /**

package/math/fit.js

@@ -17,21 +17,21 @@ export const fitNorm1 = defn("float", "fitNorm1", ["float", "float", "float"], (
  * Fits value `x` from closed interval [a,b] to closed interval [c,d]. No
  * clamping performed.
  *
- * @param x
- * @param a
- * @param b
- * @param c
- * @param d
+ * @param x -
+ * @param a -
+ * @param b -
+ * @param c -
+ * @param d -
  */
 export const fit = (x, a, b, c, d) => mix(c, d, div(sub(x, a), sub(b, a)));
 /**
  * Same as {@link fit}, but first clamps `x` to closed [a,b] interval.
  *
- * @param x
- * @param a
- * @param b
- * @param c
- * @param d
+ * @param x -
+ * @param a -
+ * @param b -
+ * @param c -
+ * @param d -
  */
 export const fitClamped = (x, a, b, c, d) => mix(c, d, clamp01(div(sub(x, a), sub(b, a))));
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@thi.ng/shader-ast-stdlib",
-  "version": "0.11.4",
+  "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.3",
-    "@thi.ng/shader-ast": "^0.12.4"
+    "@thi.ng/api": "^8.3.6",
+    "@thi.ng/shader-ast": "^0.12.7"
   },
   "devDependencies": {
-    "@microsoft/api-extractor": "^7.19.2",
-    "@thi.ng/testament": "^0.2.3",
+    "@microsoft/api-extractor": "^7.23.1",
+    "@thi.ng/testament": "^0.2.6",
     "rimraf": "^3.0.2",
     "tools": "^0.0.1",
-    "typedoc": "^0.22.10",
-    "typescript": "^4.5.3"
+    "typedoc": "^0.22.15",
+    "typescript": "^4.6.4"
   },
   "keywords": [
     "ast",
@@ -93,214 +93,232 @@
   ],
   "exports": {
     ".": {
-      "import": "./index.js"
+      "default": "./index.js"
     },
     "./api": {
-      "import": "./api.js"
+      "default": "./api.js"
     },
     "./color/aces-film": {
-      "import": "./color/aces-film.js"
+      "default": "./color/aces-film.js"
     },
     "./color/levels": {
-      "import": "./color/levels.js"
+      "default": "./color/levels.js"
     },
     "./color/linear-srgb": {
-      "import": "./color/linear-srgb.js"
+      "default": "./color/linear-srgb.js"
     },
     "./color/luminance": {
-      "import": "./color/luminance.js"
+      "default": "./color/luminance.js"
     },
     "./color/porter-duff": {
-      "import": "./color/porter-duff.js"
+      "default": "./color/porter-duff.js"
     },
     "./color/rgbe": {
-      "import": "./color/rgbe.js"
+      "default": "./color/rgbe.js"
     },
     "./fog/exp": {
-      "import": "./fog/exp.js"
+      "default": "./fog/exp.js"
     },
     "./fog/exp2": {
-      "import": "./fog/exp2.js"
+      "default": "./fog/exp2.js"
     },
     "./fog/linear": {
-      "import": "./fog/linear.js"
+      "default": "./fog/linear.js"
     },
     "./light/lambert": {
-      "import": "./light/lambert.js"
+      "default": "./light/lambert.js"
     },
     "./light/trilight": {
-      "import": "./light/trilight.js"
+      "default": "./light/trilight.js"
     },
     "./math/additive": {
-      "import": "./math/additive.js"
+      "default": "./math/additive.js"
     },
     "./math/cartesian": {
-      "import": "./math/cartesian.js"
+      "default": "./math/cartesian.js"
     },
     "./math/clamp": {
-      "import": "./math/clamp.js"
+      "default": "./math/clamp.js"
     },
     "./math/cross2": {
-      "import": "./math/cross2.js"
+      "default": "./math/cross2.js"
     },
     "./math/dist-chebyshev": {
-      "import": "./math/dist-chebyshev.js"
+      "default": "./math/dist-chebyshev.js"
     },
     "./math/dist-manhattan": {
-      "import": "./math/dist-manhattan.js"
+      "default": "./math/dist-manhattan.js"
     },
     "./math/fit": {
-      "import": "./math/fit.js"
+      "default": "./math/fit.js"
     },
     "./math/magsq": {
-      "import": "./math/magsq.js"
+      "default": "./math/magsq.js"
     },
     "./math/maxcomp": {
-      "import": "./math/maxcomp.js"
+      "default": "./math/maxcomp.js"
     },
     "./math/mincomp": {
-      "import": "./math/mincomp.js"
+      "default": "./math/mincomp.js"
     },
     "./math/mix-cubic": {
-      "import": "./math/mix-cubic.js"
+      "default": "./math/mix-cubic.js"
     },
     "./math/mix-quadratic": {
-      "import": "./math/mix-quadratic.js"
+      "default": "./math/mix-quadratic.js"
     },
     "./math/orthogonal": {
-      "import": "./math/orthogonal.js"
+      "default": "./math/orthogonal.js"
     },
     "./math/osc": {
-      "import": "./math/osc.js"
+      "default": "./math/osc.js"
     },
     "./math/polar": {
-      "import": "./math/polar.js"
+      "default": "./math/polar.js"
     },
     "./math/sincos": {
-      "import": "./math/sincos.js"
+      "default": "./math/sincos.js"
     },
     "./matrix/convert": {
-      "import": "./matrix/convert.js"
+      "default": "./matrix/convert.js"
     },
     "./matrix/lookat": {
-      "import": "./matrix/lookat.js"
+      "default": "./matrix/lookat.js"
     },
     "./matrix/mvp": {
-      "import": "./matrix/mvp.js"
+      "default": "./matrix/mvp.js"
     },
     "./matrix/normal": {
-      "import": "./matrix/normal.js"
+      "default": "./matrix/normal.js"
     },
     "./matrix/rotation": {
-      "import": "./matrix/rotation.js"
+      "default": "./matrix/rotation.js"
     },
     "./noise/curl3": {
-      "import": "./noise/curl3.js"
+      "default": "./noise/curl3.js"
     },
     "./noise/hash": {
-      "import": "./noise/hash.js"
+      "default": "./noise/hash.js"
     },
     "./noise/permute": {
-      "import": "./noise/permute.js"
+      "default": "./noise/permute.js"
     },
     "./noise/simplex2": {
-      "import": "./noise/simplex2.js"
+      "default": "./noise/simplex2.js"
     },
     "./noise/simplex3": {
-      "import": "./noise/simplex3.js"
+      "default": "./noise/simplex3.js"
     },
     "./noise/voronoi2": {
-      "import": "./noise/voronoi2.js"
+      "default": "./noise/voronoi2.js"
     },
     "./noise/worley2": {
-      "import": "./noise/worley2.js"
+      "default": "./noise/worley2.js"
     },
     "./raymarch/ao": {
-      "import": "./raymarch/ao.js"
+      "default": "./raymarch/ao.js"
     },
     "./raymarch/direction": {
-      "import": "./raymarch/direction.js"
+      "default": "./raymarch/direction.js"
     },
     "./raymarch/normal": {
-      "import": "./raymarch/normal.js"
+      "default": "./raymarch/normal.js"
     },
     "./raymarch/point-at": {
-      "import": "./raymarch/point-at.js"
+      "default": "./raymarch/point-at.js"
     },
     "./raymarch/scene": {
-      "import": "./raymarch/scene.js"
+      "default": "./raymarch/scene.js"
     },
     "./screen/uv": {
-      "import": "./screen/uv.js"
+      "default": "./screen/uv.js"
     },
     "./sdf/annular": {
-      "import": "./sdf/annular.js"
+      "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": {
-      "import": "./sdf/box.js"
+      "default": "./sdf/box.js"
+    },
+    "./sdf/cross": {
+      "default": "./sdf/cross.js"
     },
     "./sdf/cylinder": {
-      "import": "./sdf/cylinder.js"
+      "default": "./sdf/cylinder.js"
+    },
+    "./sdf/hex": {
+      "default": "./sdf/hex.js"
     },
     "./sdf/isec": {
-      "import": "./sdf/isec.js"
+      "default": "./sdf/isec.js"
     },
     "./sdf/line": {
-      "import": "./sdf/line.js"
+      "default": "./sdf/line.js"
     },
     "./sdf/mirror": {
-      "import": "./sdf/mirror.js"
+      "default": "./sdf/mirror.js"
     },
     "./sdf/plane": {
-      "import": "./sdf/plane.js"
+      "default": "./sdf/plane.js"
+    },
+    "./sdf/polygon": {
+      "default": "./sdf/polygon.js"
     },
     "./sdf/polyhedra": {
-      "import": "./sdf/polyhedra.js"
+      "default": "./sdf/polyhedra.js"
     },
     "./sdf/repeat-polar": {
-      "import": "./sdf/repeat-polar.js"
+      "default": "./sdf/repeat-polar.js"
     },
     "./sdf/repeat": {
-      "import": "./sdf/repeat.js"
+      "default": "./sdf/repeat.js"
     },
     "./sdf/round": {
-      "import": "./sdf/round.js"
+      "default": "./sdf/round.js"
     },
     "./sdf/smooth-isec": {
-      "import": "./sdf/smooth-isec.js"
+      "default": "./sdf/smooth-isec.js"
     },
     "./sdf/smooth-sub": {
-      "import": "./sdf/smooth-sub.js"
+      "default": "./sdf/smooth-sub.js"
     },
     "./sdf/smooth-union": {
-      "import": "./sdf/smooth-union.js"
+      "default": "./sdf/smooth-union.js"
     },
     "./sdf/sphere": {
-      "import": "./sdf/sphere.js"
+      "default": "./sdf/sphere.js"
     },
     "./sdf/sub": {
-      "import": "./sdf/sub.js"
+      "default": "./sdf/sub.js"
     },
     "./sdf/torus": {
-      "import": "./sdf/torus.js"
+      "default": "./sdf/torus.js"
     },
     "./sdf/tri": {
-      "import": "./sdf/tri.js"
+      "default": "./sdf/tri.js"
     },
     "./sdf/union": {
-      "import": "./sdf/union.js"
+      "default": "./sdf/union.js"
     },
     "./tex/blur": {
-      "import": "./tex/blur.js"
+      "default": "./tex/blur.js"
     },
     "./tex/index-coord": {
-      "import": "./tex/index-coord.js"
+      "default": "./tex/index-coord.js"
     },
     "./tex/index-uv": {
-      "import": "./tex/index-uv.js"
+      "default": "./tex/index-uv.js"
     },
     "./tex/read-index": {
-      "import": "./tex/read-index.js"
+      "default": "./tex/read-index.js"
     }
   },
   "thi.ng": {
@@ -312,5 +330,5 @@
     ],
     "year": 2019
   },
-  "gitHead": "1ba92c6b9509e74e509b4c0b875fc380a97bbbc1\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/polyhedra.js

@@ -36,8 +36,8 @@ const GDF = [
  *
  * Also based on: HG_SDF (Mercury Demogroup)
  *
- * @param id
- * @param vecs
+ * @param id -
+ * @param vecs -
  */
 const defGDF = (id, vecs) => [
     defn("float", id, ["vec3", "float"], (p, r) => [

package/sdf/smooth-isec.d.ts

@@ -9,8 +9,8 @@ export declare const sdfSmoothIntersect: import("@thi.ng/shader-ast").TaggedFn3<
  * Variadic compiletime macro for {@link sdfSmoothIntersect}. Takes smooth factor
  * `k`, followed by any number (at least 1 required) of SDF terms.
  *
- * @param k
- * @param terms
+ * @param k -
+ * @param terms -
  */
 export declare const sdfSmoothIntersectAll: (k: FloatTerm, ...terms: FloatTerm[]) => FloatTerm;
 //# sourceMappingURL=smooth-isec.d.ts.map

package/sdf/smooth-isec.js

@@ -21,7 +21,7 @@ export const sdfSmoothIntersect = defn("float", "sdOpSmoothIntersect", ["float",
  * Variadic compiletime macro for {@link sdfSmoothIntersect}. Takes smooth factor
  * `k`, followed by any number (at least 1 required) of SDF terms.
  *
- * @param k
- * @param terms
+ * @param k -
+ * @param terms -
  */
 export const sdfSmoothIntersectAll = (k, ...terms) => terms.reduce((acc, x) => sdfSmoothIntersect(acc, x, k));

package/sdf/smooth-sub.d.ts

@@ -9,8 +9,8 @@ export declare const sdfSmoothSubtract: import("@thi.ng/shader-ast").TaggedFn3<"
  * Variadic compiletime macro for {@link sdfSmoothSubtract}. Takes smooth factor
  * `k`, followed by any number (at least 1 required) of SDF terms.
  *
- * @param k
- * @param terms
+ * @param k -
+ * @param terms -
  */
 export declare const sdfSmoothSubtractAll: (k: FloatTerm, ...terms: FloatTerm[]) => FloatTerm;
 //# sourceMappingURL=smooth-sub.d.ts.map

package/sdf/smooth-sub.js

@@ -21,7 +21,7 @@ export const sdfSmoothSubtract = defn("float", "sdOpSmoothSubtract", ["float", "
  * Variadic compiletime macro for {@link sdfSmoothSubtract}. Takes smooth factor
  * `k`, followed by any number (at least 1 required) of SDF terms.
  *
- * @param k
- * @param terms
+ * @param k -
+ * @param terms -
  */
 export const sdfSmoothSubtractAll = (k, ...terms) => terms.reduce((acc, x) => sdfSmoothSubtract(acc, x, k));

package/sdf/smooth-union.d.ts

@@ -9,8 +9,8 @@ export declare const sdfSmoothUnion: import("@thi.ng/shader-ast").TaggedFn3<"flo
  * Variadic compiletime macro for {@link sdfSmoothUnion}. Takes smooth factor
  * `k`, followed by any number (at least 1 required) of SDF terms.
  *
- * @param k
- * @param terms
+ * @param k -
+ * @param terms -
  */
 export declare const sdfSmoothUnionAll: (k: FloatTerm, ...terms: FloatTerm[]) => FloatTerm;
 //# sourceMappingURL=smooth-union.d.ts.map

package/sdf/smooth-union.js

@@ -21,7 +21,7 @@ export const sdfSmoothUnion = defn("float", "sdOpSmoothUnion", ["float", "float"
  * Variadic compiletime macro for {@link sdfSmoothUnion}. Takes smooth factor
  * `k`, followed by any number (at least 1 required) of SDF terms.
  *
- * @param k
- * @param terms
+ * @param k -
+ * @param terms -
  */
 export const sdfSmoothUnionAll = (k, ...terms) => terms.reduce((acc, x) => sdfSmoothUnion(acc, x, k));

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 -