@thi.ng/shader-ast-stdlib 0.16.9 → 0.16.10

package/sdf/smooth-isec.js

@@ -6,23 +6,20 @@ import { sym } from "@thi.ng/shader-ast/ast/sym";
 import { mix } from "@thi.ng/shader-ast/builtin/math";
 import { clamp01 } from "../math/clamp.js";
 import { fit1101 } from "../math/fit.js";
-/**
- * @param d1 - float
- * @param d2 - float
- * @param k - float
- */
-export const sdfSmoothIntersect = defn(F, "sdOpSmoothIntersect", [F, F, F], (a, b, k) => {
+const sdfSmoothIntersect = defn(
+  F,
+  "sdOpSmoothIntersect",
+  [F, F, F],
+  (a, b, k) => {
     let h;
     return [
-        (h = sym(clamp01(fit1101(div(sub(b, a), k))))),
-        ret(add(mix(b, a, h), mul(mul(k, h), sub(FLOAT1, h)))),
+      h = sym(clamp01(fit1101(div(sub(b, a), k)))),
+      ret(add(mix(b, a, h), mul(mul(k, h), sub(FLOAT1, h))))
     ];
-});
-/**
- * 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 -
- */
-export const sdfSmoothIntersectAll = (k, ...terms) => terms.reduce((acc, x) => sdfSmoothIntersect(acc, x, k));
+  }
+);
+const sdfSmoothIntersectAll = (k, ...terms) => terms.reduce((acc, x) => sdfSmoothIntersect(acc, x, k));
+export {
+  sdfSmoothIntersect,
+  sdfSmoothIntersectAll
+};

package/sdf/smooth-sub.js

@@ -6,23 +6,20 @@ import { sym } from "@thi.ng/shader-ast/ast/sym";
 import { mix } from "@thi.ng/shader-ast/builtin/math";
 import { clamp01 } from "../math/clamp.js";
 import { fit1101 } from "../math/fit.js";
-/**
- * @param d1 - float
- * @param d2 - float
- * @param k - float
- */
-export const sdfSmoothSubtract = defn(F, "sdOpSmoothSubtract", [F, F, F], (a, b, k) => {
+const sdfSmoothSubtract = defn(
+  F,
+  "sdOpSmoothSubtract",
+  [F, F, F],
+  (a, b, k) => {
     let h;
     return [
-        (h = sym(clamp01(fit1101(div(add(b, a), k))))),
-        ret(add(mix(b, neg(a), h), mul(mul(k, h), sub(FLOAT1, h)))),
+      h = sym(clamp01(fit1101(div(add(b, a), k)))),
+      ret(add(mix(b, neg(a), h), mul(mul(k, h), sub(FLOAT1, h))))
     ];
-});
-/**
- * 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 -
- */
-export const sdfSmoothSubtractAll = (k, ...terms) => terms.reduce((acc, x) => sdfSmoothSubtract(acc, x, k));
+  }
+);
+const sdfSmoothSubtractAll = (k, ...terms) => terms.reduce((acc, x) => sdfSmoothSubtract(acc, x, k));
+export {
+  sdfSmoothSubtract,
+  sdfSmoothSubtractAll
+};

package/sdf/smooth-union.js

@@ -6,23 +6,20 @@ import { sym } from "@thi.ng/shader-ast/ast/sym";
 import { mix } from "@thi.ng/shader-ast/builtin/math";
 import { clamp01 } from "../math/clamp.js";
 import { fit1101 } from "../math/fit.js";
-/**
- * @param d1 - float
- * @param d2 - float
- * @param k - float
- */
-export const sdfSmoothUnion = defn(F, "sdOpSmoothUnion", [F, F, F], (a, b, k) => {
+const sdfSmoothUnion = defn(
+  F,
+  "sdOpSmoothUnion",
+  [F, F, F],
+  (a, b, k) => {
     let h;
     return [
-        (h = sym(clamp01(fit1101(div(sub(b, a), k))))),
-        ret(sub(mix(b, a, h), mul(mul(k, h), sub(FLOAT1, h)))),
+      h = sym(clamp01(fit1101(div(sub(b, a), k)))),
+      ret(sub(mix(b, a, h), mul(mul(k, h), sub(FLOAT1, h))))
     ];
-});
-/**
- * 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 -
- */
-export const sdfSmoothUnionAll = (k, ...terms) => terms.reduce((acc, x) => sdfSmoothUnion(acc, x, k));
+  }
+);
+const sdfSmoothUnionAll = (k, ...terms) => terms.reduce((acc, x) => sdfSmoothUnion(acc, x, k));
+export {
+  sdfSmoothUnion,
+  sdfSmoothUnionAll
+};

package/sdf/sphere.js

@@ -2,21 +2,13 @@ import { F, V2, V3 } from "@thi.ng/shader-ast/api/types";
 import { defn, ret } from "@thi.ng/shader-ast/ast/function";
 import { sub } from "@thi.ng/shader-ast/ast/ops";
 import { length } from "@thi.ng/shader-ast/builtin/math";
-/**
- * Returns signed distance from `p` to centered circle of radius `r`.
- *
- * @param p - vec2
- * @param r - float
- */
-export const sdfCircle = defn(F, "sdCircle", [V2, F], (p, r) => [
-    ret(sub(length(p), r)),
+const sdfCircle = defn(F, "sdCircle", [V2, F], (p, r) => [
+  ret(sub(length(p), r))
 ]);
-/**
- * Returns signed distance from `p` to centered sphere of radius `r`.
- *
- * @param p - vec3
- * @param r - float
- */
-export const sdfSphere = defn(F, "sdSphere", [V3, F], (p, r) => [
-    ret(sub(length(p), r)),
+const sdfSphere = defn(F, "sdSphere", [V3, F], (p, r) => [
+  ret(sub(length(p), r))
 ]);
+export {
+  sdfCircle,
+  sdfSphere
+};

package/sdf/sub.js

@@ -1,10 +1,6 @@
 import { neg } from "@thi.ng/shader-ast/ast/ops";
 import { max } from "@thi.ng/shader-ast/builtin/math";
-/**
- * Inline function. Variadic SDF shape subtraction (a - b) for any number of
- * terms (at least 1 required).
- *
- * @param a -
- * @param terms -
- */
-export const sdfSubtract = (a, ...terms) => terms.reduce((a, b) => max(a, neg(b)), a);
+const sdfSubtract = (a, ...terms) => terms.reduce((a2, b) => max(a2, neg(b)), a);
+export {
+  sdfSubtract
+};

package/sdf/torus.js

@@ -4,14 +4,9 @@ import { vec2 } from "@thi.ng/shader-ast/ast/lit";
 import { sub } from "@thi.ng/shader-ast/ast/ops";
 import { $, $y } from "@thi.ng/shader-ast/ast/swizzle";
 import { length } from "@thi.ng/shader-ast/builtin/math";
-/**
- * Returns signed distance from `p` to torus centered around Y-axis with
- * radii `r1`, `r2`.
- *
- * @param p - vec3
- * @param r1 - float
- * @param r2 - float
- */
-export const sdfTorus = defn(F, "sdTorus", [V3, F, F], (p, r1, r2) => [
-    ret(sub(length(vec2(sub(length($(p, "xz")), r2), $y(p))), r1)),
+const sdfTorus = defn(F, "sdTorus", [V3, F, F], (p, r1, r2) => [
+  ret(sub(length(vec2(sub(length($(p, "xz")), r2), $y(p))), r1))
 ]);
+export {
+  sdfTorus
+};

package/sdf/tri.js

@@ -7,13 +7,11 @@ import { sym } from "@thi.ng/shader-ast/ast/sym";
 import { dot, min, sign, sqrt } from "@thi.ng/shader-ast/builtin/math";
 import { clamp01 } from "../math/clamp.js";
 import { cross2 } from "../math/cross2.js";
-/**
- * @param p - vec2
- * @param a - vec2
- * @param b - vec2
- * @param c - vec2
- */
-export const sdfTriangle2 = defn(F, "sdTriangle", [V2, V2, V2, V2], (p, a, b, c) => {
+const sdfTriangle2 = defn(
+  F,
+  "sdTriangle",
+  [V2, V2, V2, V2],
+  (p, a, b, c) => {
     let e0, e1, e2;
     let v0, v1, v2;
     let pq0, pq1, pq2;
@@ -21,17 +19,29 @@ export const sdfTriangle2 = defn(F, "sdTriangle", [V2, V2, V2, V2], (p, a, b, c)
     let d;
     const $pq = (v, e) => sub(v, mul(e, clamp01(div(dot(v, e), dot(e, e)))));
     return [
-        (e0 = sym(sub(b, a))),
-        (e1 = sym(sub(c, b))),
-        (e2 = sym(sub(a, c))),
-        (v0 = sym(sub(p, a))),
-        (v1 = sym(sub(p, b))),
-        (v2 = sym(sub(p, c))),
-        (pq0 = sym($pq(v0, e0))),
-        (pq1 = sym($pq(v1, e1))),
-        (pq2 = sym($pq(v2, e2))),
-        (s = sym(sign(cross2(e0, e2)))),
-        (d = sym(min(min(vec2(dot(pq0, pq0), mul(s, cross2(v0, e0))), vec2(dot(pq1, pq1), mul(s, cross2(v1, e1)))), vec2(dot(pq2, pq2), mul(s, cross2(v2, e2)))))),
-        ret(mul(neg(sqrt($x(d))), sign($y(d)))),
+      e0 = sym(sub(b, a)),
+      e1 = sym(sub(c, b)),
+      e2 = sym(sub(a, c)),
+      v0 = sym(sub(p, a)),
+      v1 = sym(sub(p, b)),
+      v2 = sym(sub(p, c)),
+      pq0 = sym($pq(v0, e0)),
+      pq1 = sym($pq(v1, e1)),
+      pq2 = sym($pq(v2, e2)),
+      s = sym(sign(cross2(e0, e2))),
+      d = sym(
+        min(
+          min(
+            vec2(dot(pq0, pq0), mul(s, cross2(v0, e0))),
+            vec2(dot(pq1, pq1), mul(s, cross2(v1, e1)))
+          ),
+          vec2(dot(pq2, pq2), mul(s, cross2(v2, e2)))
+        )
+      ),
+      ret(mul(neg(sqrt($x(d))), sign($y(d))))
     ];
-});
+  }
+);
+export {
+  sdfTriangle2
+};

package/sdf/union.js

@@ -4,22 +4,11 @@ import { defn, ret } from "@thi.ng/shader-ast/ast/function";
 import { lt } from "@thi.ng/shader-ast/ast/ops";
 import { $x } from "@thi.ng/shader-ast/ast/swizzle";
 import { min } from "@thi.ng/shader-ast/builtin/math";
-/**
- * Inline function. Variadic SDF shape union (a || b) for any number of terms
- * (at least 1 required).
- *
- * @param a -
- * @param terms -
- */
-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. Returns `a` or `b`,
- * depending whose x-coord (dist) is smaller.
- *
- * @param a -
- * @param b -
- */
-export const sdfUnion2 = defn(V2, "sdfUnion2", [V2, V2], (a, b) => [
-    ret(ternary(lt($x(a), $x(b)), a, b)),
+const sdfUnion = (a, ...terms) => terms.reduce((a2, b) => min(a2, b), a);
+const sdfUnion2 = defn(V2, "sdfUnion2", [V2, V2], (a, b) => [
+  ret(ternary(lt($x(a), $x(b)), a, b))
 ]);
+export {
+  sdfUnion,
+  sdfUnion2
+};

package/tex/blur.js

@@ -5,52 +5,35 @@ import { vec2 } from "@thi.ng/shader-ast/ast/lit";
 import { add, div, mul, sub } from "@thi.ng/shader-ast/ast/ops";
 import { sym } from "@thi.ng/shader-ast/ast/sym";
 import { texture } from "@thi.ng/shader-ast/builtin/texture";
-/**
- * Inline function. Computes single blur step for given +/- offset &
- * weight.
- *
- * @param col -
- * @param tex -
- * @param uv -
- * @param off -
- * @param k -
- */
-const singlePass = (col, tex, uv, off, k) => assign(col, add(col, mul(add(texture(tex, add(uv, off)), texture(tex, sub(uv, off))), k)));
-/**
- * 5x5 gaussian blur texture lookup, optimized, but based on:
- *
- * - http://rastergrid.com/blog/2010/09/efficient-gaussian-blur-with-linear-sampling/
- * - https://github.com/Jam3/glsl-fast-gaussian-blur
- *
- * @param tex - sampler2D
- * @param res - resolution
- * @param uv -
- * @param dir - blur pass direction (`vec2(1,0)` or `vec2(0,1)`)
- */
-export const blur5 = defn(V4, "blur5", ["sampler2D", V2, V2, V2], (tex, res, uv, dir) => {
+const singlePass = (col, tex, uv, off, k) => assign(
+  col,
+  add(
+    col,
+    mul(add(texture(tex, add(uv, off)), texture(tex, sub(uv, off))), k)
+  )
+);
+const blur5 = defn(
+  V4,
+  "blur5",
+  ["sampler2D", V2, V2, V2],
+  (tex, res, uv, dir) => {
     let col;
     let off;
     const k1 = 0.29411764705882354;
     const k2 = 0.35294117647058826;
     return [
-        (off = sym(div(mul(vec2(1 + 1 / 3), dir), res))),
-        (col = sym(mul(texture(tex, uv), k1))),
-        singlePass(col, tex, uv, off, k2),
-        ret(col),
+      off = sym(div(mul(vec2(1 + 1 / 3), dir), res)),
+      col = sym(mul(texture(tex, uv), k1)),
+      singlePass(col, tex, uv, off, k2),
+      ret(col)
     ];
-});
-/**
- * 9x9 gaussian blur texture lookup, optimized, but based on:
- *
- * - http://rastergrid.com/blog/2010/09/efficient-gaussian-blur-with-linear-sampling/
- * - https://github.com/Jam3/glsl-fast-gaussian-blur
- *
- * @param tex - sampler2D
- * @param res - resolution
- * @param uv -
- * @param dir - blur pass direction (`vec2(1,0)` or `vec2(0,1)`)
- */
-export const blur9 = defn(V4, "blur9", ["sampler2D", V2, V2, V2], (tex, res, uv, dir) => {
+  }
+);
+const blur9 = defn(
+  V4,
+  "blur9",
+  ["sampler2D", V2, V2, V2],
+  (tex, res, uv, dir) => {
     let col;
     let off;
     let off2;
@@ -58,27 +41,21 @@ export const blur9 = defn(V4, "blur9", ["sampler2D", V2, V2, V2], (tex, res, uv,
     const k1 = 0.3162162162;
     const k2 = 0.0702702703;
     return [
-        (delta = sym(div(dir, res))),
-        (off = sym(mul(delta, 1.3846153846))),
-        (off2 = sym(mul(delta, 3.2307692308))),
-        (col = sym(mul(texture(tex, uv), 0.227027027))),
-        singlePass(col, tex, uv, off, k1),
-        singlePass(col, tex, uv, off2, k2),
-        ret(col),
+      delta = sym(div(dir, res)),
+      off = sym(mul(delta, 1.3846153846)),
+      off2 = sym(mul(delta, 3.2307692308)),
+      col = sym(mul(texture(tex, uv), 0.227027027)),
+      singlePass(col, tex, uv, off, k1),
+      singlePass(col, tex, uv, off2, k2),
+      ret(col)
     ];
-});
-/**
- * 13x13 gaussian blur texture lookup, optimized, but based on:
- *
- * - http://rastergrid.com/blog/2010/09/efficient-gaussian-blur-with-linear-sampling/
- * - https://github.com/Jam3/glsl-fast-gaussian-blur
- *
- * @param tex - sampler2D
- * @param res - resolution
- * @param uv -
- * @param dir - blur pass direction (`vec2(1,0)` or `vec2(0,1)`)
- */
-export const blur13 = defn(V4, "blur13", ["sampler2D", V2, V2, V2], (tex, res, uv, dir) => {
+  }
+);
+const blur13 = defn(
+  V4,
+  "blur13",
+  ["sampler2D", V2, V2, V2],
+  (tex, res, uv, dir) => {
     let col;
     let off;
     let off2;
@@ -88,14 +65,20 @@ export const blur13 = defn(V4, "blur13", ["sampler2D", V2, V2, V2], (tex, res, u
     const k2 = 0.09447039785044732;
     const k3 = 0.010381362401148057;
     return [
-        (delta = sym(div(dir, res))),
-        (off = sym(mul(delta, 1.411764705882353))),
-        (off2 = sym(mul(delta, 3.2941176470588234))),
-        (off3 = sym(mul(delta, 5.176470588235294))),
-        (col = sym(mul(texture(tex, uv), 0.1964825501511404))),
-        singlePass(col, tex, uv, off, k1),
-        singlePass(col, tex, uv, off2, k2),
-        singlePass(col, tex, uv, off3, k3),
-        ret(col),
+      delta = sym(div(dir, res)),
+      off = sym(mul(delta, 1.411764705882353)),
+      off2 = sym(mul(delta, 3.2941176470588234)),
+      off3 = sym(mul(delta, 5.176470588235294)),
+      col = sym(mul(texture(tex, uv), 0.1964825501511404)),
+      singlePass(col, tex, uv, off, k1),
+      singlePass(col, tex, uv, off2, k2),
+      singlePass(col, tex, uv, off3, k3),
+      ret(col)
     ];
-});
+  }
+);
+export {
+  blur13,
+  blur5,
+  blur9
+};

package/tex/index-coord.js

@@ -1,19 +1,9 @@
 import { uvec2 } from "@thi.ng/shader-ast/ast/lit";
 import { div, madd, modi } from "@thi.ng/shader-ast/ast/ops";
 import { $x, $y } from "@thi.ng/shader-ast/ast/swizzle";
-/**
- * Inline function. Similar to {@link indexToUV}, but returns uvec2 in pixel
- * coords. Not compatible with WebGL1.
- *
- * @param i -
- * @param width -
- */
-export const indexToCoord = (i, width) => uvec2(modi(i, width), div(i, width));
-/**
- * Inline function. Reverse op to {@link indexToCoord}.  Not compatible with
- * WebGL1.
- *
- * @param coord -
- * @param width -
- */
-export const coordToIndex = (coord, width) => madd($y(coord), width, $x(coord));
+const indexToCoord = (i, width) => uvec2(modi(i, width), div(i, width));
+const coordToIndex = (coord, width) => madd($y(coord), width, $x(coord));
+export {
+  coordToIndex,
+  indexToCoord
+};

package/tex/index-uv.js

@@ -3,23 +3,33 @@ import { defn, ret } from "@thi.ng/shader-ast/ast/function";
 import { float, int, vec2 } from "@thi.ng/shader-ast/ast/lit";
 import { add, div, modi, mul } from "@thi.ng/shader-ast/ast/ops";
 import { $x, $y } from "@thi.ng/shader-ast/ast/swizzle";
-/**
- * Converts linearized 2D index `i` into a vec2 UV coord, based on given
- * texture `size` (in pixels).
- *
- * @param i -
- * @param size -
- */
-export const indexToUV = defn(V2, "indexToUV", [[I, "i", { prec: "highp" }], ["ivec2"]], (i, size) => [
-    ret(vec2(div(float(modi(i, $x(size))), float($x(size))), div(float(div(i, $x(size))), float($y(size))))),
-]);
-/**
- * Inverse operation of {@link indexToUV}. Converts vec2 UV coord into
- * linearized 2D index, based on given texture `width` (in pixels).
- *
- * @param i -
- * @param width -
- */
-export const uvToIndex = defn(I, "uvToIndex", [V2, [I, "width", { prec: "highp" }]], (uv, width) => [
-    ret(add(int(mul($x(uv), float(width))), int(mul($y(uv), float(mul(width, width)))))),
-]);
+const indexToUV = defn(
+  V2,
+  "indexToUV",
+  [[I, "i", { prec: "highp" }], ["ivec2"]],
+  (i, size) => [
+    ret(
+      vec2(
+        div(float(modi(i, $x(size))), float($x(size))),
+        div(float(div(i, $x(size))), float($y(size)))
+      )
+    )
+  ]
+);
+const uvToIndex = defn(
+  I,
+  "uvToIndex",
+  [V2, [I, "width", { prec: "highp" }]],
+  (uv, width) => [
+    ret(
+      add(
+        int(mul($x(uv), float(width))),
+        int(mul($y(uv), float(mul(width, width))))
+      )
+    )
+  ]
+);
+export {
+  indexToUV,
+  uvToIndex
+};

package/tex/read-index.js

@@ -1,35 +1,13 @@
 import { $x, $xy, $xyz } from "@thi.ng/shader-ast/ast/swizzle";
 import { texture } from "@thi.ng/shader-ast/builtin/texture";
 import { indexToUV } from "./index-uv.js";
-/**
- * Inline function. Returns x component at index `i` in `tex`.
- *
- * @param tex -
- * @param i -
- * @param size -
- */
-export const readIndex1 = (tex, i, size) => $x(readIndex4(tex, i, size));
-/**
- * Inline function. Returns vec2 (x,y components) at index `i` in `tex`.
- *
- * @param tex -
- * @param i -
- * @param size -
- */
-export const readIndex2 = (tex, i, size) => $xy(readIndex4(tex, i, size));
-/**
- * Inline function. Returns vec3 (x,y,z components) at index `i` in `tex`.
- *
- * @param tex -
- * @param i -
- * @param size -
- */
-export const readIndex3 = (tex, i, size) => $xyz(readIndex4(tex, i, size));
-/**
- * Inline function. Returns vec4 at index `i` in `tex`.
- *
- * @param tex -
- * @param i -
- * @param size -
- */
-export const readIndex4 = (tex, i, size) => texture(tex, indexToUV(i, size));
+const readIndex1 = (tex, i, size) => $x(readIndex4(tex, i, size));
+const readIndex2 = (tex, i, size) => $xy(readIndex4(tex, i, size));
+const readIndex3 = (tex, i, size) => $xyz(readIndex4(tex, i, size));
+const readIndex4 = (tex, i, size) => texture(tex, indexToUV(i, size));
+export {
+  readIndex1,
+  readIndex2,
+  readIndex3,
+  readIndex4
+};