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

package/sdf/cross.js

@@ -8,49 +8,28 @@ 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(F, "sdfCross2", [V2, V2, F], (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)),
-    ];
+const sdfCross2 = defn(F, "sdfCross2", [V2, V2, F], (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(F, "sdfRoundedX", [V2, F, F], (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)),
-    ];
+const sdfRoundedX2 = defn(F, "sdfRoundedX", [V2, F, F], (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))
+  ];
 });
+export {
+  sdfCross2,
+  sdfRoundedX2
+};

package/sdf/cylinder.js

@@ -6,18 +6,13 @@ import { $, $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 cylinder centered around Y-axis
- * with height `h` and radius `r`.
- *
- * @param p - vec3
- * @param h - float
- * @param r - float
- */
-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)))),
-        ret(add(min(maxComp2(d), FLOAT0), length(max(d, VEC2_0)))),
-    ];
+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))),
+    ret(add(min(maxComp2(d), FLOAT0), length(max(d, VEC2_0))))
+  ];
 });
+export {
+  sdfCylinder
+};

package/sdf/hex.js

@@ -5,23 +5,26 @@ 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(F, "sdfHexagon2", [V2, F], (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)))),
-    ];
+import {
+  abs,
+  clamp,
+  dot,
+  length,
+  min,
+  sign
+} from "@thi.ng/shader-ast/builtin/math";
+const sdfHexagon2 = defn(F, "sdfHexagon2", [V2, F], (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))))
+  ];
 });
+export {
+  sdfHexagon2
+};

package/sdf/isec.js

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

package/sdf/line.js

@@ -4,34 +4,19 @@ import { div, mul, sub } from "@thi.ng/shader-ast/ast/ops";
 import { sym } from "@thi.ng/shader-ast/ast/sym";
 import { dot, length } from "@thi.ng/shader-ast/builtin/math";
 import { clamp01 } from "../math/clamp.js";
-/**
- * Shared impl for sdLine2/3
- *
- * @param p -
- * @param a -
- * @param b -
- */
 const $ = (n, type) => defn(F, `sdLine${n}`, [type, type, type], (p, a, b) => {
-    let pa, ba;
-    return [
-        (pa = sym(sub(p, a))),
-        (ba = sym(sub(b, a))),
-        ret(length(sub(pa, mul(ba, clamp01(div(dot(pa, ba), dot(ba, ba))))))),
-    ];
+  let pa, ba;
+  return [
+    pa = sym(sub(p, a)),
+    ba = sym(sub(b, a)),
+    ret(
+      length(sub(pa, mul(ba, clamp01(div(dot(pa, ba), dot(ba, ba))))))
+    )
+  ];
 });
-/**
- * Returns signed distance from `p` to 2D line segment `a` -> `b`.
- *
- * @param p - vec2
- * @param a - vec2
- * @param b - vec2
- */
-export const sdfLine2 = $(2, V2);
-/**
- * Returns signed distance from `p` to 3D line segment `a` -> `b`.
- *
- * @param p - vec3
- * @param a - vec3
- * @param b - vec3
- */
-export const sdfLine3 = $(3, V3);
+const sdfLine2 = $(2, V2);
+const sdfLine3 = $(3, V3);
+export {
+  sdfLine2,
+  sdfLine3
+};

package/sdf/mirror.js

@@ -4,17 +4,21 @@ 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";
 import { sym } from "@thi.ng/shader-ast/ast/sym";
 import { floor, mod } from "@thi.ng/shader-ast/builtin/math";
-/**
- * @remarks
- * Based on HG_SDF (Mercury Demogroup). Does not compute cell index.
- *
- * @param p - point
- * @param size - mirror box size
- */
-export const sdfMirror2 = defn(V2, "sdfMirror2", [V2, V2], (p, size) => {
-    let halfSize;
-    return [
-        (halfSize = sym(mul(size, FLOAT05))),
-        ret(mul(sub(mod(add(p, halfSize), size), halfSize), sub(mul(mod(floor(div(add(p, halfSize), size)), VEC2_2), 2), VEC2_1))),
-    ];
+const sdfMirror2 = defn(V2, "sdfMirror2", [V2, V2], (p, size) => {
+  let halfSize;
+  return [
+    halfSize = sym(mul(size, FLOAT05)),
+    ret(
+      mul(
+        sub(mod(add(p, halfSize), size), halfSize),
+        sub(
+          mul(mod(floor(div(add(p, halfSize), size)), VEC2_2), 2),
+          VEC2_1
+        )
+      )
+    )
+  ];
 });
+export {
+  sdfMirror2
+};

package/sdf/plane.js

@@ -2,23 +2,13 @@ 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";
-/**
- * Returns signed distance from `p` to plane defined by `normal` and `w`.
- *
- * @param p - vec2
- * @param normal - vec2
- * @param w - float
- */
-export const sdfPlane2 = defn(F, "sdPlane2", [V2, V2, F], (p, n, w) => [
-    ret(add(dot(p, n), w)),
+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`.
- *
- * @param p - vec3
- * @param normal - vec3
- * @param w - float
- */
-export const sdfPlane3 = defn(F, "sdPlane3", [V3, V3, F], (p, n, w) => [
-    ret(add(dot(p, n), w)),
+const sdfPlane3 = defn(F, "sdPlane3", [V3, V3, F], (p, n, w) => [
+  ret(add(dot(p, n), w))
 ]);
+export {
+  sdfPlane2,
+  sdfPlane3
+};

package/sdf/polygon.js

@@ -4,44 +4,66 @@ 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 { 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 {
+  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 { _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";
-/**
- * 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(F, `sdfPolygon2_${N}`, [V2, ["vec2[]", "pts", { num: N }]], (p, pts) => {
+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;
     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))),
+      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)))
     ];
-});
+  }
+);
+export {
+  sdfPolygon2
+};

package/sdf/polyhedra.js

@@ -3,53 +3,88 @@ 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";
 import { abs, dot, max, pow } from "@thi.ng/shader-ast/builtin/math";
-// could use @thi.ng/vectors, but avoiding dependency
 const normalize = ([x, y, z]) => {
-    const m = 1 / Math.hypot(x, y, z);
-    return [x * m, y * m, z * m];
+  const m = 1 / Math.hypot(x, y, z);
+  return [x * m, y * m, z * m];
 };
 const phi = PHI.val;
 const GDF = [
-    [1, 0, 0],
-    [0, 1, 0],
-    [0, 0, 1],
-    [1, 1, 1],
-    [-1, 1, 1],
-    [1, -1, 1],
-    [1, 1, -1],
-    [0, 1, phi + 1],
-    [0, -1, phi + 1],
-    [phi + 1, 0, 1],
-    [-phi - 1, 0, 1],
-    [1, phi + 1, 0],
-    [-1, phi + 1, 0],
-    [0, phi, 1],
-    [0, -phi, 1],
-    [1, 0, phi],
-    [-1, 0, phi],
-    [phi, 1, 0],
-    [-phi, 1, 0],
+  [1, 0, 0],
+  [0, 1, 0],
+  [0, 0, 1],
+  [1, 1, 1],
+  [-1, 1, 1],
+  [1, -1, 1],
+  [1, 1, -1],
+  [0, 1, phi + 1],
+  [0, -1, phi + 1],
+  [phi + 1, 0, 1],
+  [-phi - 1, 0, 1],
+  [1, phi + 1, 0],
+  [-1, phi + 1, 0],
+  [0, phi, 1],
+  [0, -phi, 1],
+  [1, 0, phi],
+  [-1, 0, phi],
+  [phi, 1, 0],
+  [-phi, 1, 0]
 ].map((v) => vec3(...normalize(v)));
-/**
- * @remarks
- * Based on: "Generalized Distance Functions" (E. Akleman, J. Chen)
- * http://people.tamu.edu/~ergun/research/implicitmodeling/papers/sm99.pdf
- *
- * Also based on: HG_SDF (Mercury Demogroup)
- *
- * @param id -
- * @param vecs -
- */
 const defGDF = (id, vecs) => [
-    defn(F, id, [V3, F], (p, r) => [
-        ret(sub(vecs.reduce((acc, v) => max(acc, abs(dot(p, v))), FLOAT0), r)),
-    ]),
-    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)),
-    ]),
+  defn(F, id, [V3, F], (p, r) => [
+    ret(
+      sub(
+        vecs.reduce(
+          (acc, v) => max(acc, abs(dot(p, v))),
+          FLOAT0
+        ),
+        r
+      )
+    )
+  ]),
+  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
+      )
+    )
+  ])
 ];
-export const [sdfOctahedron, sdfOctahedronSmooth] = defGDF("sdfOctahedron", GDF.slice(3, 7));
-export const [sdfDodecahedron, sdfDodecahedronSmooth] = defGDF("sdfDodecahedron", GDF.slice(13));
-export const [sdfIcosahedron, sdfIcosahedronSmooth] = defGDF("sdfIcosahedron", GDF.slice(3, 13));
-export const [sdfTruncatedOctahedron, sdfTruncatedOctahedronSmooth] = defGDF("sdfTruncatedOctahedron", GDF.slice(0, 7));
-export const [sdfTruncatedIcosahedron, sdfTruncatedIcosahedronSmooth] = defGDF("sdfTruncatedIcosahedron", GDF.slice(3));
+const [sdfOctahedron, sdfOctahedronSmooth] = defGDF(
+  "sdfOctahedron",
+  GDF.slice(3, 7)
+);
+const [sdfDodecahedron, sdfDodecahedronSmooth] = defGDF(
+  "sdfDodecahedron",
+  GDF.slice(13)
+);
+const [sdfIcosahedron, sdfIcosahedronSmooth] = defGDF(
+  "sdfIcosahedron",
+  GDF.slice(3, 13)
+);
+const [sdfTruncatedOctahedron, sdfTruncatedOctahedronSmooth] = defGDF(
+  "sdfTruncatedOctahedron",
+  GDF.slice(0, 7)
+);
+const [sdfTruncatedIcosahedron, sdfTruncatedIcosahedronSmooth] = defGDF(
+  "sdfTruncatedIcosahedron",
+  GDF.slice(3)
+);
+export {
+  sdfDodecahedron,
+  sdfDodecahedronSmooth,
+  sdfIcosahedron,
+  sdfIcosahedronSmooth,
+  sdfOctahedron,
+  sdfOctahedronSmooth,
+  sdfTruncatedIcosahedron,
+  sdfTruncatedIcosahedronSmooth,
+  sdfTruncatedOctahedron,
+  sdfTruncatedOctahedronSmooth
+};

package/sdf/polyline.js

@@ -8,13 +8,36 @@ import { add, inc, lt } from "@thi.ng/shader-ast/ast/ops";
 import { sym } from "@thi.ng/shader-ast/ast/sym";
 import { min } from "@thi.ng/shader-ast/builtin/math";
 import { sdfLine2 } from "./line.js";
-export const sdfPolyline2 = (N) => defn(F, `sdfPolyline2_${N}`, [V2, ["vec2[]", "pts", { num: N }]], (p, pts) => {
+const sdfPolyline2 = (N) => defn(
+  F,
+  `sdfPolyline2_${N}`,
+  [V2, ["vec2[]", "pts", { num: N }]],
+  (p, pts) => {
     let minD;
     return [
-        (minD = sym(float(1e6))),
-        forLoop(sym(INT0), (i) => lt(i, int(N - 1)), inc, (i) => [
-            assign(minD, min(minD, sdfLine2(p, index(pts, i), index(pts, add(i, 1))))),
-        ]),
-        ret(minD),
+      minD = sym(float(1e6)),
+      forLoop(
+        sym(INT0),
+        (i) => lt(i, int(N - 1)),
+        inc,
+        (i) => [
+          assign(
+            minD,
+            min(
+              minD,
+              sdfLine2(
+                p,
+                index(pts, i),
+                index(pts, add(i, 1))
+              )
+            )
+          )
+        ]
+      ),
+      ret(minD)
     ];
-});
+  }
+);
+export {
+  sdfPolyline2
+};

package/sdf/repeat-polar.js

@@ -6,21 +6,17 @@ import { $x, $y } from "@thi.ng/shader-ast/ast/swizzle";
 import { sym } from "@thi.ng/shader-ast/ast/sym";
 import { atan, length, mod } from "@thi.ng/shader-ast/builtin/math";
 import { cossin } from "../math/sincos.js";
-/**
- * @remarks
- * Based on HG_SDF (Mercury Demogroup). Does not compute cell index.
- *
- * @param p - point
- * @param n - number of polar repetitions
- */
-export const sdfRepeatPolar2 = defn(V2, "sdfRepeatPolar2", [V2, F], (p, n) => {
-    let angle;
-    let angle2;
-    let a;
-    return [
-        (angle = sym(div(TAU, n))),
-        (angle2 = sym(mul(angle, FLOAT05))),
-        (a = sym(sub(mod(add(angle2, atan($y(p), $x(p))), angle), angle2))),
-        ret(mul(cossin(a), length(p))),
-    ];
+const sdfRepeatPolar2 = defn(V2, "sdfRepeatPolar2", [V2, F], (p, n) => {
+  let angle;
+  let angle2;
+  let a;
+  return [
+    angle = sym(div(TAU, n)),
+    angle2 = sym(mul(angle, FLOAT05)),
+    a = sym(sub(mod(add(angle2, atan($y(p), $x(p))), angle), angle2)),
+    ret(mul(cossin(a), length(p)))
+  ];
 });
+export {
+  sdfRepeatPolar2
+};

package/sdf/repeat.js

@@ -4,19 +4,11 @@ import { FLOAT05 } from "@thi.ng/shader-ast/ast/lit";
 import { mul, sub } from "@thi.ng/shader-ast/ast/ops";
 import { mod } from "@thi.ng/shader-ast/builtin/math";
 const $ = (n, type) => defn(type, `sdTxRepeat${n}`, [type, type], (p, c) => [
-    ret(sub(mod(p, c), mul(c, FLOAT05))),
+  ret(sub(mod(p, c), mul(c, FLOAT05)))
 ]);
-/**
- * 2D domain repetition by wrapping position `p` into period `c`.
- *
- * @param p - vec2
- * @param c - 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, V3);
+const sdfRepeat2 = $(2, V2);
+const sdfRepeat3 = $(3, V3);
+export {
+  sdfRepeat2,
+  sdfRepeat3
+};

package/sdf/round.js

@@ -1,11 +1,5 @@
 import { sub } from "@thi.ng/shader-ast/ast/ops";
-/**
- * Inline function. Essentially an isoline offset to create:
- *
- * - `r > 0`: rounded/thicker shapes
- * - `r < 0`: sharper/thinner shapes
- *
- * @param d -
- * @param r -
- */
-export const sdfRound = (d, r) => sub(d, r);
+const sdfRound = (d, r) => sub(d, r);
+export {
+  sdfRound
+};