@thi.ng/shader-ast-stdlib 0.13.13 → 0.13.15

package/noise/simplex2.js

@@ -1,7 +1,8 @@
+import { F, V2 } from "@thi.ng/shader-ast/api/types";
 import { assign } from "@thi.ng/shader-ast/ast/assign";
 import { ternary } from "@thi.ng/shader-ast/ast/controlflow";
 import { defn, ret } from "@thi.ng/shader-ast/ast/function";
-import { float, FLOAT05, FLOAT1, vec2, vec3, VEC3_0, vec4, } from "@thi.ng/shader-ast/ast/lit";
+import { FLOAT05, FLOAT1, VEC3_0, float, vec2, vec3, vec4, } from "@thi.ng/shader-ast/ast/lit";
 import { add, gt, mul, 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";
@@ -14,7 +15,7 @@ import { permute3 } from "./permute.js";
  *
  * https://github.com/ashima/webgl-noise
  */
-export const snoise2 = defn("float", "snoise2", ["vec2"], (v) => {
+export const snoise2 = defn(F, "snoise2", [V2], (v) => {
     let C;
     let i;
     let i1;

package/noise/simplex3.d.ts

@@ -1,3 +1,4 @@
 export declare const snoise3: import("@thi.ng/shader-ast").TaggedFn1<"vec3", "float">;
+export declare const snoiseVec32: import("@thi.ng/shader-ast").TaggedFn1<"vec3", "vec2">;
 export declare const snoiseVec3: import("@thi.ng/shader-ast").TaggedFn1<"vec3", "vec3">;
 //# sourceMappingURL=simplex3.d.ts.map

package/noise/simplex3.js

@@ -1,12 +1,13 @@
+import { F, V2, V3 } from "@thi.ng/shader-ast/api/types";
 import { assign } from "@thi.ng/shader-ast/ast/assign";
 import { defn, ret } from "@thi.ng/shader-ast/ast/function";
-import { float, FLOAT0, FLOAT05, FLOAT1, FLOAT2, vec3, vec4, } from "@thi.ng/shader-ast/ast/lit";
+import { FLOAT0, FLOAT05, FLOAT1, FLOAT2, float, vec2, vec3, vec4, } from "@thi.ng/shader-ast/ast/lit";
 import { add, mul, neg, sub } from "@thi.ng/shader-ast/ast/ops";
 import { $, $w, $x, $xy, $y, $z } from "@thi.ng/shader-ast/ast/swizzle";
 import { sym } from "@thi.ng/shader-ast/ast/sym";
 import { abs, dot, floor, max, min, mod, step, } from "@thi.ng/shader-ast/builtin/math";
 import { permute4 } from "./permute.js";
-export const snoise3 = defn("float", "snoise3", ["vec3"], (v) => {
+export const snoise3 = defn(F, "snoise3", [V3], (v) => {
     let g;
     let j;
     let l;
@@ -72,7 +73,12 @@ export const snoise3 = defn("float", "snoise3", ["vec3"], (v) => {
         ret(mul(42, dot(mul(m, m), vec4(dot(p0, x0), dot(p1, x1), dot(p2, x2), dot(p3, x3))))),
     ];
 });
-export const snoiseVec3 = defn("vec3", "snoiseVec3", ["vec3"], (p) => {
+export const snoiseVec32 = defn(V2, "snoiseVec3", [V3], (p) => {
+    return [
+        ret(vec2(snoise3(p), snoise3(vec3(sub($y(p), 19.1), add($z(p), 33.4), add($x(p), 47.2))))),
+    ];
+});
+export const snoiseVec3 = defn(V3, "snoiseVec3", [V3], (p) => {
     return [
         ret(vec3(snoise3(p), snoise3(vec3(sub($y(p), 19.1), add($z(p), 33.4), add($x(p), 47.2))), snoise3(vec3(add($z(p), 74.2), sub($x(p), 124.5), add($y(p), 99.4))))),
     ];

package/noise/voronoi2.js

@@ -1,7 +1,8 @@
+import { F, V2 } from "@thi.ng/shader-ast/api/types";
 import { assign } from "@thi.ng/shader-ast/ast/assign";
 import { forLoop } from "@thi.ng/shader-ast/ast/controlflow";
 import { defn, ret } from "@thi.ng/shader-ast/ast/function";
-import { float, FLOAT0, int, SQRT2, vec2, vec3, } from "@thi.ng/shader-ast/ast/lit";
+import { FLOAT0, SQRT2, float, int, vec2, vec3, } from "@thi.ng/shader-ast/ast/lit";
 import { add, div, inc, lte, madd, mul, sub } from "@thi.ng/shader-ast/ast/ops";
 import { $xy, $z } from "@thi.ng/shader-ast/ast/swizzle";
 import { sym } from "@thi.ng/shader-ast/ast/sym";
@@ -25,7 +26,7 @@ import { hash32 } from "./hash.js";
  * @param u -
  * @param v -
  */
-export const voronoise2 = defn("float", "voronoise2", ["vec2", "float", "float"], (x, u, v) => {
+export const voronoise2 = defn(F, "voronoise2", [V2, F, F], (x, u, v) => {
     let p;
     let f;
     let coeff;

package/noise/worley2.d.ts

@@ -2,17 +2,22 @@ import type { Func2 } from "@thi.ng/shader-ast";
 export declare const worleyDist: import("@thi.ng/shader-ast").TaggedFn2<"vec3", "vec3", "vec3">;
 export declare const worleyDistManhattan: import("@thi.ng/shader-ast").TaggedFn2<"vec3", "vec3", "vec3">;
 /**
- * Higher order function. Computes 2D Worley noise using provided
- * distance function. The returned function takes 2 args: position and
- * jitter amount, the latter in [0..1] interval. Returns noise
- * components as vec2, with the x component containing the distance from
- * closest simplex center and y the noise value. The vector components
- * can be used individually or combined (e.g. `noise.y - noise.x`)...
+ * Higher order function. Computes 2D Worley noise using provided distance
+ * function. The returned function takes 2 args: position and jitter amount, the
+ * latter in [0..1] interval. Returns noise components as vec2, with the x
+ * component containing the distance from closest simplex center and y the noise
+ * value. The vector components can be used individually or combined (e.g.
+ * `noise.y - noise.x`)...
  *
+ * THe optional `name` arg can be used to customize the name of the generated
+ * function.
+ *
+ * @remarks
  * Based on implementation by Stefan Gustavson:
  * http://webstaff.itn.liu.se/~stegu/GLSL-cellular/GLSL-cellular-notes.pdf
  *
  * @param distFn -
+ * @param name -
  */
-export declare const worley2: (distFn: Func2<"vec3", "vec3", "vec3">) => import("@thi.ng/shader-ast").TaggedFn2<"vec2", "float", "vec2">;
+export declare const worley2: (distFn: Func2<"vec3", "vec3", "vec3">, name?: string) => import("@thi.ng/shader-ast").TaggedFn2<"vec2", "float", "vec2">;
 //# sourceMappingURL=worley2.d.ts.map

package/noise/worley2.js

@@ -1,28 +1,37 @@
+import { F, V2, V3 } from "@thi.ng/shader-ast/api/types";
 import { assign } from "@thi.ng/shader-ast/ast/assign";
 import { ternary } from "@thi.ng/shader-ast/ast/controlflow";
 import { defn, ret } from "@thi.ng/shader-ast/ast/function";
+import { gensym } from "@thi.ng/shader-ast/ast/idgen";
 import { float, vec3 } from "@thi.ng/shader-ast/ast/lit";
 import { add, lt, mul, sub } from "@thi.ng/shader-ast/ast/ops";
 import { $, $x, $xy, $y, $z } from "@thi.ng/shader-ast/ast/swizzle";
 import { sym } from "@thi.ng/shader-ast/ast/sym";
 import { abs, floor, fract, max, min, mod, sqrt, } from "@thi.ng/shader-ast/builtin/math";
 import { permute3 } from "./permute.js";
-export const worleyDist = defn("vec3", "worleyDist", ["vec3", "vec3"], (a, b) => [ret(add(mul(a, a), mul(b, b)))]);
-export const worleyDistManhattan = defn("vec3", "worleyDistManhatten", ["vec3", "vec3"], (a, b) => [ret(add(abs(a), abs(b)))]);
+export const worleyDist = defn(V3, "worleyDist", [V3, V3], (a, b) => [
+    ret(add(mul(a, a), mul(b, b))),
+]);
+export const worleyDistManhattan = defn(V3, "worleyDistManhatten", [V3, V3], (a, b) => [ret(add(abs(a), abs(b)))]);
 /**
- * Higher order function. Computes 2D Worley noise using provided
- * distance function. The returned function takes 2 args: position and
- * jitter amount, the latter in [0..1] interval. Returns noise
- * components as vec2, with the x component containing the distance from
- * closest simplex center and y the noise value. The vector components
- * can be used individually or combined (e.g. `noise.y - noise.x`)...
+ * Higher order function. Computes 2D Worley noise using provided distance
+ * function. The returned function takes 2 args: position and jitter amount, the
+ * latter in [0..1] interval. Returns noise components as vec2, with the x
+ * component containing the distance from closest simplex center and y the noise
+ * value. The vector components can be used individually or combined (e.g.
+ * `noise.y - noise.x`)...
  *
+ * THe optional `name` arg can be used to customize the name of the generated
+ * function.
+ *
+ * @remarks
  * Based on implementation by Stefan Gustavson:
  * http://webstaff.itn.liu.se/~stegu/GLSL-cellular/GLSL-cellular-notes.pdf
  *
  * @param distFn -
+ * @param name -
  */
-export const worley2 = (distFn) => defn("vec2", "worley2", ["vec2", "float"], (P, jitter) => {
+export const worley2 = (distFn, name = gensym("worley2_")) => defn(V2, name, [V2, F], (P, jitter) => {
     const K = float(1 / 7);
     const Ko = float(3 / 7);
     const oI = sym(vec3(-1, 0, 1));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@thi.ng/shader-ast-stdlib",
-  "version": "0.13.13",
+  "version": "0.13.15",
   "description": "Function collection for modular GPGPU / shader programming with @thi.ng/shader-ast",
   "type": "module",
   "module": "./index.js",
@@ -34,15 +34,15 @@
     "test": "testament test"
   },
   "dependencies": {
-    "@thi.ng/api": "^8.8.0",
-    "@thi.ng/shader-ast": "^0.12.50"
+    "@thi.ng/api": "^8.8.1",
+    "@thi.ng/shader-ast": "^0.12.52"
   },
   "devDependencies": {
-    "@microsoft/api-extractor": "^7.34.4",
-    "@thi.ng/testament": "^0.3.15",
-    "rimraf": "^4.4.1",
+    "@microsoft/api-extractor": "^7.34.8",
+    "@thi.ng/testament": "^0.3.16",
+    "rimraf": "^5.0.0",
     "tools": "^0.0.1",
-    "typedoc": "^0.23.28",
+    "typedoc": "^0.24.6",
     "typescript": "^5.0.4"
   },
   "keywords": [
@@ -330,5 +330,5 @@
     ],
     "year": 2019
   },
-  "gitHead": "ca22f02a137c0a4e3a38ef81e82e2bc7e3c43849\n"
+  "gitHead": "20ab11b687a13228f6a8cecdc5f05ba9105122ea\n"
 }

package/raymarch/ao.d.ts

@@ -7,6 +7,7 @@ import type { RaymarchScene } from "../api.js";
  *
  * @param scene -
  * @param numSamples -
+ * @param name -
  */
-export declare const raymarchAO: (scene: RaymarchScene, numSamples?: number) => import("@thi.ng/shader-ast").TaggedFn2<"vec3", "vec3", "float">;
+export declare const raymarchAO: (scene: RaymarchScene, numSamples?: number, name?: string) => import("@thi.ng/shader-ast").TaggedFn2<"vec3", "vec3", "float">;
 //# sourceMappingURL=ao.d.ts.map

package/raymarch/ao.js

@@ -1,7 +1,9 @@
+import { F, V3 } from "@thi.ng/shader-ast/api/types";
 import { assign } from "@thi.ng/shader-ast/ast/assign";
 import { forLoop } from "@thi.ng/shader-ast/ast/controlflow";
 import { defn, ret } from "@thi.ng/shader-ast/ast/function";
-import { float, FLOAT0, FLOAT05, FLOAT1 } from "@thi.ng/shader-ast/ast/lit";
+import { gensym } from "@thi.ng/shader-ast/ast/idgen";
+import { FLOAT0, FLOAT05, FLOAT1, float } from "@thi.ng/shader-ast/ast/lit";
 import { add, inc, lte, mul, sub } from "@thi.ng/shader-ast/ast/ops";
 import { $x } from "@thi.ng/shader-ast/ast/swizzle";
 import { sym } from "@thi.ng/shader-ast/ast/sym";
@@ -14,8 +16,9 @@ import { clamp01 } from "../math/clamp.js";
  *
  * @param scene -
  * @param numSamples -
+ * @param name -
  */
-export const raymarchAO = (scene, numSamples = 5) => defn("float", "raymarchAO", ["vec3", "vec3"], (p, n) => {
+export const raymarchAO = (scene, numSamples = 5, name = gensym("raymarchAO_")) => defn(F, name, [V3, V3], (p, n) => {
     let r;
     let w;
     let d0;

package/raymarch/direction.js

@@ -1,3 +1,4 @@
+import { F, V2, V3 } from "@thi.ng/shader-ast/api/types";
 import { defn, ret } from "@thi.ng/shader-ast/ast/function";
 import { FLOAT2, vec3 } from "@thi.ng/shader-ast/ast/lit";
 import { div, neg, sub } from "@thi.ng/shader-ast/ast/ops";
@@ -9,7 +10,7 @@ import { normalize, radians, tan } from "@thi.ng/shader-ast/builtin/math";
  * @param res - vec2
  * @param fov - float vertical FOV (in degrees)
  */
-export const raymarchDir = defn("vec3", "raymarchDir", ["vec2", "vec2", "float"], (frag, res, fov) => {
+export const raymarchDir = defn(V3, "raymarchDir", [V2, V2, F], (frag, res, fov) => {
     let uv;
     return [
         (uv = sym(sub(frag, div(res, FLOAT2)))),

package/raymarch/normal.js

@@ -1,4 +1,6 @@
+import { F, V3 } from "@thi.ng/shader-ast/api/types";
 import { defn, ret } from "@thi.ng/shader-ast/ast/function";
+import { gensym } from "@thi.ng/shader-ast/ast/idgen";
 import { vec2, vec3 } from "@thi.ng/shader-ast/ast/lit";
 import { add, sub } from "@thi.ng/shader-ast/ast/ops";
 import { $, $x } from "@thi.ng/shader-ast/ast/swizzle";
@@ -13,7 +15,7 @@ import { normalize } from "@thi.ng/shader-ast/builtin/math";
  * @param scene -
  * @param name -
  */
-export const raymarchNormal = (scene, name = "raymarchNormal") => defn("vec3", name, ["vec3", "float"], (p, smooth) => {
+export const raymarchNormal = (scene, name = gensym("raymarchNormal_")) => defn(V3, name, [V3, F], (p, smooth) => {
     let dn;
     const comp = (id) => sub($x(scene(add(p, $(dn, id)))), $x(scene(sub(p, $(dn, id)))));
     return [

package/raymarch/scene.js

@@ -1,7 +1,9 @@
+import { V2, V3 } from "@thi.ng/shader-ast/api/types";
 import { assign } from "@thi.ng/shader-ast/ast/assign";
 import { brk, forLoop, ifThen } from "@thi.ng/shader-ast/ast/controlflow";
 import { defn, ret } from "@thi.ng/shader-ast/ast/function";
-import { float, int, INT0, vec2 } from "@thi.ng/shader-ast/ast/lit";
+import { gensym } from "@thi.ng/shader-ast/ast/idgen";
+import { INT0, float, int, vec2 } from "@thi.ng/shader-ast/ast/lit";
 import { gt, inc, lt, madd } 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";
@@ -25,7 +27,7 @@ import { rayPointAt } from "./point-at.js";
  */
 export const raymarchScene = (scene, _opts) => {
     const opts = {
-        name: "raymarchScene",
+        name: gensym("raymarchScene_"),
         near: 0.1,
         far: 10,
         steps: 100,
@@ -33,12 +35,12 @@ export const raymarchScene = (scene, _opts) => {
         bias: 0.7,
         ..._opts,
     };
-    return defn("vec2", opts.name, ["vec3", "vec3"], (pos, dir) => {
+    return defn(V2, opts.name, [V3, V3], (pos, dir) => {
         let total;
         let res;
         return [
             (total = sym(float(opts.near))),
-            (res = sym("vec2")),
+            (res = sym(V2)),
             forLoop(sym(INT0), (i) => lt(i, int(opts.steps)), inc, () => [
                 assign(res, scene(rayPointAt(pos, dir, total))),
                 ifThen(lt($x(res), float(opts.eps)), [

package/screen/uv.js

@@ -1,10 +1,11 @@
+import { F, V2 } from "@thi.ng/shader-ast/api/types";
 import { assign } from "@thi.ng/shader-ast/ast/assign";
 import { defn, ret } from "@thi.ng/shader-ast/ast/function";
-import { bvec4, vec2, VEC2_1 } from "@thi.ng/shader-ast/ast/lit";
+import { VEC2_1, bvec4, vec2 } from "@thi.ng/shader-ast/ast/lit";
 import { add, div, mul } 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 { greaterThan, lessThan, _any } from "@thi.ng/shader-ast/builtin/bvec";
+import { _any, greaterThan, lessThan } from "@thi.ng/shader-ast/builtin/bvec";
 import { fit0111 } from "../math/fit.js";
 /**
  * Computes UV coord in [0..1] interval from given `fragCoord` and screen `res`.
@@ -21,7 +22,7 @@ export const fragUV = (fragCoord, res) => div($xy(fragCoord), res);
  * @param fragCoord - vec2
  * @param res - vec2
  */
-export const aspectCorrectedUV = defn("vec2", "aspectCorrectedUV", ["vec2", "vec2"], (pos, res) => {
+export const aspectCorrectedUV = defn(V2, "aspectCorrectedUV", [V2, V2], (pos, res) => {
     let uv;
     return [
         (uv = sym(fit0111(div(pos, res)))),
@@ -39,6 +40,6 @@ export const aspectCorrectedUV = defn("vec2", "aspectCorrectedUV", ["vec2", "vec
  * borderMask(vec2(0.2, 0.2), 0.1) // false
  * ```
  */
-export const borderMask = defn("bool", "borderMask", ["vec2", "float"], (uv, width) => [
+export const borderMask = defn("bool", "borderMask", [V2, F], (uv, width) => [
     ret(_any(bvec4(lessThan(uv, vec2(width)), greaterThan(add(uv, width), VEC2_1)))),
 ]);

package/sdf/arc.js

@@ -1,3 +1,4 @@
+import { F, V2 } from "@thi.ng/shader-ast/api/types";
 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";
@@ -16,7 +17,7 @@ import { abs, cos, length, sin } from "@thi.ng/shader-ast/builtin/math";
  * - 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) => {
+export const sdfArc2 = defn(F, "sdfArc", [V2, F, F, F], (p, apert, ra, rb) => {
     let q;
     let sc;
     return [

package/sdf/bezier.js

@@ -1,7 +1,8 @@
+import { F, V2 } from "@thi.ng/shader-ast/api/types";
 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 { FLOAT0, FLOAT1, FLOAT2, float, 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";
@@ -18,7 +19,7 @@ import { cross2 } from "../math/cross2.js";
  * - 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) => {
+export const sdfQuadratic2 = defn(F, "sdfQuadratic2", [V2, V2, V2, V2], (pos, A, B, C) => {
     let a, b, c, d;
     let kk, kx, ky, kz;
     let p, q, p3, q2, h;

package/sdf/box-rounded.js

@@ -1,3 +1,4 @@
+import { F, V2, V4 } from "@thi.ng/shader-ast/api/types";
 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";
@@ -18,7 +19,7 @@ import { maxComp2 } from "../math/maxcomp.js";
  * @param size - vec2
  * @param r - vec4
  */
-export const sdfBoxRounded = defn("float", "sdfBoxRounded", ["vec2", "vec2", "vec4"], (p, size, r) => {
+export const sdfBoxRounded = defn(F, "sdfBoxRounded", [V2, V2, V4], (p, size, r) => {
     let q, t, d;
     return [
         (t = sym(ternary(gt($x(p), FLOAT0), $xy(r), $(r, "zw")))),

package/sdf/box.js

@@ -1,3 +1,4 @@
+import { F, V2, V3 } from "@thi.ng/shader-ast/api/types";
 import { defn, ret } from "@thi.ng/shader-ast/ast/function";
 import { FLOAT0, VEC2_0, VEC3_0 } from "@thi.ng/shader-ast/ast/lit";
 import { add, sub } from "@thi.ng/shader-ast/ast/ops";
@@ -10,7 +11,7 @@ import { maxComp2, maxComp3 } from "../math/maxcomp.js";
  * @param p - vec2
  * @param size - vec2
  */
-export const sdfBox2 = defn("float", "sdfBox2", ["vec2", "vec2"], (p, size) => {
+export const sdfBox2 = defn(F, "sdfBox2", [V2, V2], (p, size) => {
     let d;
     return [
         (d = sym(sub(abs(p), size))),
@@ -23,7 +24,7 @@ export const sdfBox2 = defn("float", "sdfBox2", ["vec2", "vec2"], (p, size) => {
  * @param p - vec3
  * @param size - vec3
  */
-export const sdfBox3 = defn("float", "sdfBox3", ["vec3", "vec3"], (p, size) => {
+export const sdfBox3 = defn(F, "sdfBox3", [V3, V3], (p, size) => {
     let d;
     return [
         (d = sym(sub(abs(p), size))),

package/sdf/cross.js

@@ -1,7 +1,8 @@
+import { F, V2 } from "@thi.ng/shader-ast/api/types";
 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 { FLOAT0, FLOAT05, VEC2_0, vec2 } 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";
@@ -22,7 +23,7 @@ import { maxComp2 } from "../math/maxcomp.js";
  * @param size -
  * @param r -
  */
-export const sdfCross2 = defn("float", "sdfCross2", ["vec2", "vec2", "float"], (p, size, r) => {
+export const sdfCross2 = defn(F, "sdfCross2", [V2, V2, F], (p, size, r) => {
     let a, q, w;
     let k;
     return [
@@ -46,7 +47,7 @@ export const sdfCross2 = defn("float", "sdfCross2", ["vec2", "vec2", "float"], (
  * @param size -
  * @param r -
  */
-export const sdfRoundedX2 = defn("float", "sdfRoundedX", ["vec2", "float", "float"], (p, size, r) => {
+export const sdfRoundedX2 = defn(F, "sdfRoundedX", [V2, F, F], (p, size, r) => {
     let q;
     return [
         (q = sym(abs(p))),

package/sdf/cylinder.js

@@ -1,5 +1,6 @@
+import { F, V3 } from "@thi.ng/shader-ast/api/types";
 import { defn, ret } from "@thi.ng/shader-ast/ast/function";
-import { FLOAT0, vec2, VEC2_0 } from "@thi.ng/shader-ast/ast/lit";
+import { FLOAT0, VEC2_0, vec2 } from "@thi.ng/shader-ast/ast/lit";
 import { add, sub } from "@thi.ng/shader-ast/ast/ops";
 import { $, $y } from "@thi.ng/shader-ast/ast/swizzle";
 import { sym } from "@thi.ng/shader-ast/ast/sym";
@@ -13,7 +14,7 @@ import { maxComp2 } from "../math/maxcomp.js";
  * @param h - float
  * @param r - float
  */
-export const sdfCylinder = defn("float", "sdCylinder", ["vec3", "float", "float"], (p, h, r) => {
+export const sdfCylinder = defn(F, "sdCylinder", [V3, F, F], (p, h, r) => {
     let d;
     return [
         (d = sym(sub(abs(vec2(length($(p, "xz")), $y(p))), vec2(h, r)))),

package/sdf/hex.js

@@ -1,3 +1,4 @@
+import { F, V2 } from "@thi.ng/shader-ast/api/types";
 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";
@@ -12,7 +13,7 @@ import { abs, clamp, dot, length, min, sign, } from "@thi.ng/shader-ast/builtin/
  * Ported from original GLSL impl by Inigo Quilez:
  * - https://iquilezles.org/articles/distfunctions2d/
  */
-export const sdfHexagon2 = defn("float", "sdfHexagon2", ["vec2", "float"], (p, r) => {
+export const sdfHexagon2 = defn(F, "sdfHexagon2", [V2, F], (p, r) => {
     const TAN30 = 0.5773502691896257;
     let k, q;
     return [

package/sdf/line.js

@@ -1,3 +1,4 @@
+import { F, V2, V3 } from "@thi.ng/shader-ast/api/types";
 import { defn, ret } from "@thi.ng/shader-ast/ast/function";
 import { div, mul, sub } from "@thi.ng/shader-ast/ast/ops";
 import { sym } from "@thi.ng/shader-ast/ast/sym";
@@ -10,7 +11,7 @@ import { clamp01 } from "../math/clamp.js";
  * @param a -
  * @param b -
  */
-const $ = (n, type) => defn("float", `sdLine${n}`, [type, type, type], (p, a, b) => {
+const $ = (n, type) => defn(F, `sdLine${n}`, [type, type, type], (p, a, b) => {
     let pa, ba;
     return [
         (pa = sym(sub(p, a))),
@@ -25,7 +26,7 @@ const $ = (n, type) => defn("float", `sdLine${n}`, [type, type, type], (p, a, b)
  * @param a - vec2
  * @param b - vec2
  */
-export const sdfLine2 = $(2, "vec2");
+export const sdfLine2 = $(2, V2);
 /**
  * Returns signed distance from `p` to 3D line segment `a` -> `b`.
  *
@@ -33,4 +34,4 @@ export const sdfLine2 = $(2, "vec2");
  * @param a - vec3
  * @param b - vec3
  */
-export const sdfLine3 = $(3, "vec3");
+export const sdfLine3 = $(3, V3);

package/sdf/mirror.js

@@ -1,3 +1,4 @@
+import { V2 } from "@thi.ng/shader-ast/api/types";
 import { defn, ret } from "@thi.ng/shader-ast/ast/function";
 import { FLOAT05, VEC2_1, VEC2_2 } from "@thi.ng/shader-ast/ast/lit";
 import { add, div, mul, sub } from "@thi.ng/shader-ast/ast/ops";
@@ -10,7 +11,7 @@ import { floor, mod } from "@thi.ng/shader-ast/builtin/math";
  * @param p - point
  * @param size - mirror box size
  */
-export const sdfMirror2 = defn("vec2", "sdfMirror2", ["vec2", "vec2"], (p, size) => {
+export const sdfMirror2 = defn(V2, "sdfMirror2", [V2, V2], (p, size) => {
     let halfSize;
     return [
         (halfSize = sym(mul(size, FLOAT05))),

package/sdf/plane.js

@@ -1,3 +1,4 @@
+import { F, V2, V3 } from "@thi.ng/shader-ast/api/types";
 import { defn, ret } from "@thi.ng/shader-ast/ast/function";
 import { add } from "@thi.ng/shader-ast/ast/ops";
 import { dot } from "@thi.ng/shader-ast/builtin/math";
@@ -8,7 +9,9 @@ import { dot } from "@thi.ng/shader-ast/builtin/math";
  * @param normal - vec2
  * @param w - float
  */
-export const sdfPlane2 = defn("float", "sdPlane2", ["vec2", "vec2", "float"], (p, n, w) => [ret(add(dot(p, n), w))]);
+export const sdfPlane2 = defn(F, "sdPlane2", [V2, V2, F], (p, n, w) => [
+    ret(add(dot(p, n), w)),
+]);
 /**
  * Returns signed distance from `p` to plane defined by `normal` and `w`.
  *
@@ -16,4 +19,6 @@ export const sdfPlane2 = defn("float", "sdPlane2", ["vec2", "vec2", "float"], (p
  * @param normal - vec3
  * @param w - float
  */
-export const sdfPlane3 = defn("float", "sdPlane3", ["vec3", "vec3", "float"], (p, n, w) => [ret(add(dot(p, n), w))]);
+export const sdfPlane3 = defn(F, "sdPlane3", [V3, V3, F], (p, n, w) => [
+    ret(add(dot(p, n), w)),
+]);

package/sdf/polygon.js

@@ -1,12 +1,13 @@
+import { F, V2 } from "@thi.ng/shader-ast/api/types";
 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 { FLOAT1, INT0, bvec3, int } 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 { _any, all } from "@thi.ng/shader-ast/builtin/bvec";
 import { dot, min, sqrt } from "@thi.ng/shader-ast/builtin/math";
 import { clamp01 } from "../math/clamp.js";
 /**
@@ -19,7 +20,7 @@ import { clamp01 } from "../math/clamp.js";
  *
  * @param N
  */
-export const sdfPolygon2 = (N) => defn("float", `sdfPolygon2_${N}`, ["vec2", ["vec2[]", "pts", { num: N }]], (p, pts) => {
+export const sdfPolygon2 = (N) => defn(F, `sdfPolygon2_${N}`, [V2, ["vec2[]", "pts", { num: N }]], (p, pts) => {
     let d, s;
     let b, e, w, t;
     let pi, pj;

package/sdf/polyhedra.js

@@ -1,3 +1,4 @@
+import { F, V3 } from "@thi.ng/shader-ast/api/types";
 import { defn, ret } from "@thi.ng/shader-ast/ast/function";
 import { FLOAT0, PHI, vec3 } from "@thi.ng/shader-ast/ast/lit";
 import { add, reciprocal, sub } from "@thi.ng/shader-ast/ast/ops";
@@ -40,10 +41,10 @@ const GDF = [
  * @param vecs -
  */
 const defGDF = (id, vecs) => [
-    defn("float", id, ["vec3", "float"], (p, r) => [
+    defn(F, id, [V3, F], (p, r) => [
         ret(sub(vecs.reduce((acc, v) => max(acc, abs(dot(p, v))), FLOAT0), r)),
     ]),
-    defn("float", id + "Smooth", ["vec3", "float", "float"], (p, r, e) => [
+    defn(F, id + "Smooth", [V3, F, F], (p, r, e) => [
         ret(sub(pow(vecs.reduce((acc, v) => add(acc, pow(abs(dot(p, v)), e)), FLOAT0), reciprocal(e)), r)),
     ]),
 ];

package/sdf/repeat-polar.js

@@ -1,3 +1,4 @@
+import { F, V2 } from "@thi.ng/shader-ast/api/types";
 import { defn, ret } from "@thi.ng/shader-ast/ast/function";
 import { FLOAT05, TAU } from "@thi.ng/shader-ast/ast/lit";
 import { add, div, mul, sub } from "@thi.ng/shader-ast/ast/ops";
@@ -12,7 +13,7 @@ import { cossin } from "../math/sincos.js";
  * @param p - point
  * @param n - number of polar repetitions
  */
-export const sdfRepeatPolar2 = defn("vec2", "sdfRepeatPolar2", ["vec2", "float"], (p, n) => {
+export const sdfRepeatPolar2 = defn(V2, "sdfRepeatPolar2", [V2, F], (p, n) => {
     let angle;
     let angle2;
     let a;

package/sdf/repeat.js

@@ -1,3 +1,4 @@
+import { V2, V3 } from "@thi.ng/shader-ast/api/types";
 import { defn, ret } from "@thi.ng/shader-ast/ast/function";
 import { FLOAT05 } from "@thi.ng/shader-ast/ast/lit";
 import { mul, sub } from "@thi.ng/shader-ast/ast/ops";
@@ -11,11 +12,11 @@ const $ = (n, type) => defn(type, `sdTxRepeat${n}`, [type, type], (p, c) => [
  * @param p - vec2
  * @param c - vec2
  */
-export const sdfRepeat2 = $(2, "vec2");
+export const sdfRepeat2 = $(2, V2);
 /**
  * 3D domain repetition by wrapping position `p` into period `c`.
  *
  * @param p - vec3
  * @param c - vec3
  */
-export const sdfRepeat3 = $(3, "vec3");
+export const sdfRepeat3 = $(3, V3);

package/sdf/smooth-isec.js

@@ -1,3 +1,4 @@
+import { F } from "@thi.ng/shader-ast/api/types";
 import { defn, ret } from "@thi.ng/shader-ast/ast/function";
 import { FLOAT1 } from "@thi.ng/shader-ast/ast/lit";
 import { add, div, mul, sub } from "@thi.ng/shader-ast/ast/ops";
@@ -10,7 +11,7 @@ import { fit1101 } from "../math/fit.js";
  * @param d2 - float
  * @param k - float
  */
-export const sdfSmoothIntersect = defn("float", "sdOpSmoothIntersect", ["float", "float", "float"], (a, b, k) => {
+export const sdfSmoothIntersect = defn(F, "sdOpSmoothIntersect", [F, F, F], (a, b, k) => {
     let h;
     return [
         (h = sym(clamp01(fit1101(div(sub(b, a), k))))),