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

package/math/fit.js

@@ -5,69 +5,21 @@ import { FLOAT0, FLOAT05, FLOAT1, FLOAT2 } from "@thi.ng/shader-ast/ast/lit";
 import { add, div, mul, neq, sub } from "@thi.ng/shader-ast/ast/ops";
 import { mix } from "@thi.ng/shader-ast/builtin/math";
 import { clamp01 } from "./clamp.js";
-/**
- * Returns normalized value of `x` WRT to interval [a,b]. Returns 0, if
- * `a` equals `b`.
- *
- * @param x -
- * @param a -
- * @param b -
- */
-export const fitNorm1 = defn(F, "fitNorm1", [F, F, F], (x, a, b) => [
-    ret(ternary(neq(a, b), div(sub(x, a), sub(b, a)), FLOAT0)),
+const fitNorm1 = defn(F, "fitNorm1", [F, F, F], (x, a, b) => [
+  ret(ternary(neq(a, b), div(sub(x, a), sub(b, a)), FLOAT0))
 ]);
-/**
- * Similar to {@link fitNorm1} but also for vector types and without checking if
- * `a == b`. Scales value `x` from closed interval [a,b] to closed [0,1]
- * interval. No clamping performed.
- *
- * @param x
- * @param a
- * @param b
- * @returns
- */
-export const fitNorm = (x, a, b) => div(sub(x, a), sub(b, a));
-/**
- * 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 -
- */
-export const fit = (x, a, b, c, d) => mix(c, d, fitNorm(x, a, b));
-/**
- * Same as {@link fit}, but first clamps `x` to closed [a,b] interval.
- *
- * @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))));
-/**
- * Inline function. Fits value `a` in [0..1] interval to new interval
- * [b..c]. No clamping performed. Same as `mix(b, c, a)`
- *
- * @param a -
- * @param b -
- * @param c -
- */
-export const fit01 = (a, b, c) => mix(b, c, a);
-/**
- * Inline function. Fits value `x` in [-1..+1] interval to [0..1]
- * interval. No clamping performed.
- *
- * @param x -
- */
-export const fit1101 = (x) => add(mul(x, FLOAT05), FLOAT05);
-/**
- * Inline function. Fits value `x` in [0..1] interval to [-1..+1]
- * interval. No clamping performed.
- *
- * @param x -
- */
-export const fit0111 = (x) => sub(mul(x, FLOAT2), FLOAT1);
+const fitNorm = (x, a, b) => div(sub(x, a), sub(b, a));
+const fit = (x, a, b, c, d) => mix(c, d, fitNorm(x, a, b));
+const fitClamped = (x, a, b, c, d) => mix(c, d, clamp01(div(sub(x, a), sub(b, a))));
+const fit01 = (a, b, c) => mix(b, c, a);
+const fit1101 = (x) => add(mul(x, FLOAT05), FLOAT05);
+const fit0111 = (x) => sub(mul(x, FLOAT2), FLOAT1);
+export {
+  fit,
+  fit01,
+  fit0111,
+  fit1101,
+  fitClamped,
+  fitNorm,
+  fitNorm1
+};

package/math/interval.js

@@ -4,30 +4,29 @@ import { defn, ret } from "@thi.ng/shader-ast/ast/function";
 import { FLOAT0, FLOAT1, FLOAT2 } from "@thi.ng/shader-ast/ast/lit";
 import { div, lt, mul, sub } from "@thi.ng/shader-ast/ast/ops";
 import { sym } from "@thi.ng/shader-ast/ast/sym";
-import { abs, ceil, floor, mix, mod, step, } from "@thi.ng/shader-ast/builtin/math";
-/**
- * GLSL 100 trunc() polyfill.
- */
-export const trunc = defn(F, null, [F], (x) => [
-    ret(ternary(lt(x, FLOAT0), ceil(x), floor(x))),
+import {
+  abs,
+  ceil,
+  floor,
+  mix,
+  mod,
+  step
+} from "@thi.ng/shader-ast/builtin/math";
+const trunc = defn(F, null, [F], (x) => [
+  ret(ternary(lt(x, FLOAT0), ceil(x), floor(x)))
 ]);
-/**
- * Returns `x - y * trunc(x / y)`, i.e. essentially the same as JS `%` operator.
- * Result will always have the sign of `x`.
- */
-export const modulo = defn(F, null, [F, F], (x, y) => [
-    ret(sub(x, mul(y, trunc(div(x, y))))),
+const modulo = defn(F, null, [F, F], (x, y) => [
+  ret(sub(x, mul(y, trunc(div(x, y)))))
 ]);
-/**
- * Same as thi.ng/math foldback01(). Folds `x` into the closed [0..1] interval,
- * using infinite internal reflection on either side of the interval.
- *
- * @param x
- */
-export const foldback01 = defn(F, null, [F], (x) => {
-    let y;
-    return [
-        (y = sym(mod(abs(x), FLOAT2))),
-        ret(mix(y, sub(FLOAT2, y), step(FLOAT1, y))),
-    ];
+const foldback01 = defn(F, null, [F], (x) => {
+  let y;
+  return [
+    y = sym(mod(abs(x), FLOAT2)),
+    ret(mix(y, sub(FLOAT2, y), step(FLOAT1, y)))
+  ];
 });
+export {
+  foldback01,
+  modulo,
+  trunc
+};

package/math/magsq.js

@@ -2,6 +2,11 @@ import { F } from "@thi.ng/shader-ast/api/types";
 import { defn, ret } from "@thi.ng/shader-ast/ast/function";
 import { dot } from "@thi.ng/shader-ast/builtin/math";
 const $ = (n) => defn(F, `magSq${n}`, [`vec${n}`], (v) => [ret(dot(v, v))]);
-export const magSq2 = $(2);
-export const magSq3 = $(3);
-export const magSq4 = $(4);
+const magSq2 = $(2);
+const magSq3 = $(3);
+const magSq4 = $(4);
+export {
+  magSq2,
+  magSq3,
+  magSq4
+};

package/math/maxcomp.js

@@ -1,20 +1,10 @@
 import { $w, $x, $y, $z } from "@thi.ng/shader-ast/ast/swizzle";
 import { max } from "@thi.ng/shader-ast/builtin/math";
-/**
- * Inline function. Returns max(v.x, v.y)
- *
- * @param v -
- */
-export const maxComp2 = (v) => max($x(v), $y(v));
-/**
- * Inline function. Returns max(v.x, v.y, v.z)
- *
- * @param v -
- */
-export const maxComp3 = (v) => max(maxComp2(v), $z(v));
-/**
- * Inline function. Returns max(v.x, v.y, v.z, v.w)
- *
- * @param v -
- */
-export const maxComp4 = (v) => max(maxComp3(v), $w(v));
+const maxComp2 = (v) => max($x(v), $y(v));
+const maxComp3 = (v) => max(maxComp2(v), $z(v));
+const maxComp4 = (v) => max(maxComp3(v), $w(v));
+export {
+  maxComp2,
+  maxComp3,
+  maxComp4
+};

package/math/mincomp.js

@@ -1,20 +1,10 @@
 import { $w, $x, $y, $z } from "@thi.ng/shader-ast/ast/swizzle";
 import { min } from "@thi.ng/shader-ast/builtin/math";
-/**
- * Inline function. Returns min(v.x, v.y)
- *
- * @param v -
- */
-export const minComp2 = (v) => min($x(v), $y(v));
-/**
- * Inline function. Returns min(v.x, v.y, v.z)
- *
- * @param v -
- */
-export const minComp3 = (v) => min(minComp2(v), $z(v));
-/**
- * Inline function. Returns min(v.x, v.y, v.z, v.w)
- *
- * @param v -
- */
-export const minComp4 = (v) => min(minComp3(v), $w(v));
+const minComp2 = (v) => min($x(v), $y(v));
+const minComp3 = (v) => min(minComp2(v), $z(v));
+const minComp4 = (v) => min(minComp3(v), $w(v));
+export {
+  minComp2,
+  minComp3,
+  minComp4
+};

package/math/mix-cubic.js

@@ -2,18 +2,40 @@ import { F, V2, V3, V4 } from "@thi.ng/shader-ast/api/types";
 import { defn, ret } from "@thi.ng/shader-ast/ast/function";
 import { add, mul, sub } from "@thi.ng/shader-ast/ast/ops";
 import { sym } from "@thi.ng/shader-ast/ast/sym";
-const $ = (n, type) => defn(type, `mixCubic${n > 1 ? n : ""}`, [type, type, type, type, F], (a, b, c, d, t) => {
+const $ = (n, type) => defn(
+  type,
+  `mixCubic${n > 1 ? n : ""}`,
+  [type, type, type, type, F],
+  (a, b, c, d, t) => {
     let s;
     let s2;
     let t2;
     return [
-        (t2 = sym(mul(t, t))),
-        (s = sym(sub(1, t))),
-        (s2 = sym(mul(s, s))),
-        ret(add(add(add(mul(a, mul(s, s2)), mul(b, mul(3, mul(s2, t)))), mul(c, mul(3, mul(t2, s)))), mul(d, mul(t, t2)))),
+      t2 = sym(mul(t, t)),
+      s = sym(sub(1, t)),
+      s2 = sym(mul(s, s)),
+      ret(
+        add(
+          add(
+            add(
+              mul(a, mul(s, s2)),
+              mul(b, mul(3, mul(s2, t)))
+            ),
+            mul(c, mul(3, mul(t2, s)))
+          ),
+          mul(d, mul(t, t2))
+        )
+      )
     ];
-});
-export const mixCubic = $(1, F);
-export const mixCubic2 = $(2, V2);
-export const mixCubic3 = $(3, V3);
-export const mixCubic4 = $(4, V4);
+  }
+);
+const mixCubic = $(1, F);
+const mixCubic2 = $(2, V2);
+const mixCubic3 = $(3, V3);
+const mixCubic4 = $(4, V4);
+export {
+  mixCubic,
+  mixCubic2,
+  mixCubic3,
+  mixCubic4
+};

package/math/mix-quadratic.js

@@ -2,14 +2,33 @@ import { F, V2, V3, V4 } from "@thi.ng/shader-ast/api/types";
 import { defn, ret } from "@thi.ng/shader-ast/ast/function";
 import { add, mul, sub } from "@thi.ng/shader-ast/ast/ops";
 import { sym } from "@thi.ng/shader-ast/ast/sym";
-const $ = (n, type) => defn(type, `mixQuadratic${n > 1 ? n : ""}`, [type, type, type, F], (a, b, c, t) => {
+const $ = (n, type) => defn(
+  type,
+  `mixQuadratic${n > 1 ? n : ""}`,
+  [type, type, type, F],
+  (a, b, c, t) => {
     let s;
     return [
-        (s = sym(sub(1, t))),
-        ret(add(add(mul(a, mul(s, s)), mul(b, mul(2, mul(s, t)))), mul(c, mul(t, t)))),
+      s = sym(sub(1, t)),
+      ret(
+        add(
+          add(
+            mul(a, mul(s, s)),
+            mul(b, mul(2, mul(s, t)))
+          ),
+          mul(c, mul(t, t))
+        )
+      )
     ];
-});
-export const mixQuadratic = $(1, F);
-export const mixQuadratic2 = $(2, V2);
-export const mixQuadratic3 = $(3, V3);
-export const mixQuadratic4 = $(4, V4);
+  }
+);
+const mixQuadratic = $(1, F);
+const mixQuadratic2 = $(2, V2);
+const mixQuadratic3 = $(3, V3);
+const mixQuadratic4 = $(4, V4);
+export {
+  mixQuadratic,
+  mixQuadratic2,
+  mixQuadratic3,
+  mixQuadratic4
+};

package/math/orthogonal.js

@@ -5,25 +5,19 @@ import { vec2, vec3 } from "@thi.ng/shader-ast/ast/lit";
 import { gt, neg } from "@thi.ng/shader-ast/ast/ops";
 import { $x, $y, $z } from "@thi.ng/shader-ast/ast/swizzle";
 import { abs } from "@thi.ng/shader-ast/builtin/math";
-/**
- * Inline function. Returns counter-clockwise perpendicular vector (assuming
- * Y-up). [-y, x]
- *
- * @param v -
- */
-export const perpendicularCCW = (v) => vec2(neg($y(v)), $x(v));
-/**
- * Inline function. Returns clockwise perpendicular vector (assuming Y-up).
- * [y,-x]
- *
- * @param v -
- */
-export const perpendicularCW = (v) => vec2($y(v), neg($x(v)));
-/**
- * Returns an orthogonal vector to `v`.
- *
- * http://lolengine.net/blog/2013/09/21/picking-orthogonal-vector-combing-coconuts
- */
-export const orthogonal3 = defn(V3, "orthogonal3", [V3], (v) => [
-    ret(ternary(gt(abs($x(v)), abs($z(v))), vec3(neg($y(v)), $x(v), 0), vec3(0, neg($z(v)), $y(v)))),
+const perpendicularCCW = (v) => vec2(neg($y(v)), $x(v));
+const perpendicularCW = (v) => vec2($y(v), neg($x(v)));
+const orthogonal3 = defn(V3, "orthogonal3", [V3], (v) => [
+  ret(
+    ternary(
+      gt(abs($x(v)), abs($z(v))),
+      vec3(neg($y(v)), $x(v), 0),
+      vec3(0, neg($z(v)), $y(v))
+    )
+  )
 ]);
+export {
+  orthogonal3,
+  perpendicularCCW,
+  perpendicularCW
+};

package/math/osc.js

@@ -1,42 +1,31 @@
-import { float, FLOAT0, FLOAT05, FLOAT1, FLOAT2, TAU, } from "@thi.ng/shader-ast/ast/lit";
+import {
+  float,
+  FLOAT0,
+  FLOAT05,
+  FLOAT1,
+  FLOAT2,
+  TAU
+} from "@thi.ng/shader-ast/ast/lit";
 import { madd, mul, sub } from "@thi.ng/shader-ast/ast/ops";
 import { abs, fract, sin, step } from "@thi.ng/shader-ast/builtin/math";
 const defOsc = (fn) => (phase, freq, amp = FLOAT1, dc = FLOAT0) => madd(fn(mul(float(phase), float(freq))), amp, dc);
-/**
- * Sine oscillator (ported from thi.ng/dsp)
- *
- * @param phase - normalized phase
- * @param freq -
- * @param amp -
- * @param dc -
- */
-export const sinOsc = defOsc((phase) => sin(mul(phase, TAU)));
-/**
- * Sawtooth oscillator (ported from thi.ng/dsp)
- *
- * @param phase - normalized phase
- * @param freq -
- * @param amp -
- * @param dc -
- */
-export const sawOsc = defOsc((phase) => sub(FLOAT1, mul(fract(phase), FLOAT2)));
-/**
- * Triangle oscillator (ported from thi.ng/dsp)
- *
- * @param phase - normalized phase
- * @param freq -
- * @param amp -
- * @param dc -
- */
-export const triOsc = defOsc((phase) => sub(abs(madd(fract(phase), 4, float(-2))), FLOAT1));
-/**
- * Rect oscillator w/ customizable duty cycle (default: 0.5) (ported from
- * thi.ng/dsp)
- *
- * @param phase - normalized phase
- * @param freq -
- * @param amp -
- * @param dc -
- * @param duty -
- */
-export const rectOsc = (phase, freq, amp = FLOAT1, dc = FLOAT0, duty = FLOAT05) => madd(madd(step(float(duty), fract(mul(float(phase), float(freq)))), FLOAT2, float(-1)), amp, dc);
+const sinOsc = defOsc((phase) => sin(mul(phase, TAU)));
+const sawOsc = defOsc((phase) => sub(FLOAT1, mul(fract(phase), FLOAT2)));
+const triOsc = defOsc(
+  (phase) => sub(abs(madd(fract(phase), 4, float(-2))), FLOAT1)
+);
+const rectOsc = (phase, freq, amp = FLOAT1, dc = FLOAT0, duty = FLOAT05) => madd(
+  madd(
+    step(float(duty), fract(mul(float(phase), float(freq)))),
+    FLOAT2,
+    float(-1)
+  ),
+  amp,
+  dc
+);
+export {
+  rectOsc,
+  sawOsc,
+  sinOsc,
+  triOsc
+};

package/math/polar.js

@@ -5,26 +5,17 @@ import { div } from "@thi.ng/shader-ast/ast/ops";
 import { $x, $y, $z } from "@thi.ng/shader-ast/ast/swizzle";
 import { sym } from "@thi.ng/shader-ast/ast/sym";
 import { asin, atan, length } from "@thi.ng/shader-ast/builtin/math";
-/**
- * Converts 2D cartesian vector `v` to polar coordinates, i.e. `[r,θ]`
- * (angle in radians). See {@link cartesian2} for reverse operation.
- *
- * @param v -
- */
-export const polar2 = defn(V2, "polar2", [V2], (v) => [
-    ret(vec2(length(v), atan(div($y(v), $x(v))))),
+const polar2 = defn(V2, "polar2", [V2], (v) => [
+  ret(vec2(length(v), atan(div($y(v), $x(v)))))
 ]);
-/**
- * Converts 3D cartesian vector `v` to spherical coordinates, i.e.
- * `[r,θ,ϕ]` (angles in radians). See {@link cartesian3} for reverse
- * operation.
- *
- * @param v -
- */
-export const polar3 = defn(V3, "polar3", [V3], (v) => {
-    let r;
-    return [
-        (r = sym(length(v))),
-        ret(vec3(r, asin(div($z(v), r)), atan(div($y(v), $x(v))))),
-    ];
+const polar3 = defn(V3, "polar3", [V3], (v) => {
+  let r;
+  return [
+    r = sym(length(v)),
+    ret(vec3(r, asin(div($z(v), r)), atan(div($y(v), $x(v)))))
+  ];
 });
+export {
+  polar2,
+  polar3
+};

package/math/sincos.js

@@ -1,14 +1,8 @@
 import { vec2 } from "@thi.ng/shader-ast/ast/lit";
 import { cos, sin } from "@thi.ng/shader-ast/builtin/math";
-/**
- * Inline function. Returns vec2(sin(x), cos(x)).
- *
- * @param x -
- */
-export const sincos = (x) => vec2(sin(x), cos(x));
-/**
- * Inline function. Returns vec2(cos(x), sin(x)).
- *
- * @param x -
- */
-export const cossin = (x) => vec2(cos(x), sin(x));
+const sincos = (x) => vec2(sin(x), cos(x));
+const cossin = (x) => vec2(cos(x), sin(x));
+export {
+  cossin,
+  sincos
+};

package/math/smoother-step.js

@@ -3,28 +3,30 @@ import { defn, ret } from "@thi.ng/shader-ast/ast/function";
 import { add, div, mul, sub } from "@thi.ng/shader-ast/ast/ops";
 import { clamp01 } from "./clamp.js";
 const $ = (n, type) => defn(type, `smootherStep01${n > 1 ? "_" + n : ""}`, [type], (x) => [
-    // @ts-ignore
-    ret(mul(x, mul(x, mul(x, add(mul(x, sub(mul(x, 6), 15)), 10))))),
+  // @ts-ignore
+  ret(mul(x, mul(x, mul(x, add(mul(x, sub(mul(x, 6), 15)), 10)))))
 ]);
-/**
- * Specialized version of {@link smootherStep}, assuming edges are 0/1
- * respectively and `x` is in [0..1]. No clamping performed.
- *
- * @param x
- */
-export const smootherStep01 = $(1, F);
-export const smootherStep01_2 = $(2, V2);
-export const smootherStep01_3 = $(3, V3);
-export const smootherStep01_4 = $(4, V4);
-const $$ = (n, type, fn) => defn(type, `smootherStep${n > 1 ? n : ""}`, [type, type, type], (e0, e1, x) => [ret(fn(clamp01(div(sub(x, e0), sub(e1, e0)))))]);
-/**
- * Similar to GLSL-native `smoothstep()` but using different, higher degree
- * polynomial.
- *
- * @remarks
- * Also see {@link smootherStep01}
- */
-export const smootherStep = $$(1, F, smootherStep01);
-export const smootherStep2 = $$(2, V2, smootherStep01_2);
-export const smootherStep3 = $$(3, V3, smootherStep01_3);
-export const smootherStep4 = $$(4, V4, smootherStep01_4);
+const smootherStep01 = $(1, F);
+const smootherStep01_2 = $(2, V2);
+const smootherStep01_3 = $(3, V3);
+const smootherStep01_4 = $(4, V4);
+const $$ = (n, type, fn) => defn(
+  type,
+  `smootherStep${n > 1 ? n : ""}`,
+  [type, type, type],
+  (e0, e1, x) => [ret(fn(clamp01(div(sub(x, e0), sub(e1, e0)))))]
+);
+const smootherStep = $$(1, F, smootherStep01);
+const smootherStep2 = $$(2, V2, smootherStep01_2);
+const smootherStep3 = $$(3, V3, smootherStep01_3);
+const smootherStep4 = $$(4, V4, smootherStep01_4);
+export {
+  smootherStep,
+  smootherStep01,
+  smootherStep01_2,
+  smootherStep01_3,
+  smootherStep01_4,
+  smootherStep2,
+  smootherStep3,
+  smootherStep4
+};

package/matrix/convert.js

@@ -2,13 +2,24 @@ import { M2, M3, M4 } from "@thi.ng/shader-ast/api/types";
 import { defn, ret } from "@thi.ng/shader-ast/ast/function";
 import { indexMat } from "@thi.ng/shader-ast/ast/indexed";
 import { VEC3_0, mat3, mat4, vec3, vec4 } from "@thi.ng/shader-ast/ast/lit";
-export const m22ToM33 = defn(M3, "m22ToM33", [M2], (m) => {
-    return [
-        ret(mat3(vec3(indexMat(m, 0), 0), vec3(indexMat(m, 1), 0), VEC3_0)),
-    ];
+const m22ToM33 = defn(M3, "m22ToM33", [M2], (m) => {
+  return [
+    ret(mat3(vec3(indexMat(m, 0), 0), vec3(indexMat(m, 1), 0), VEC3_0))
+  ];
 });
-export const m33ToM44 = defn(M4, "m33ToM44", [M3], (m) => {
-    return [
-        ret(mat4(vec4(indexMat(m, 0), 0), vec4(indexMat(m, 1), 0), vec4(indexMat(m, 2), 0), vec4())),
-    ];
+const m33ToM44 = defn(M4, "m33ToM44", [M3], (m) => {
+  return [
+    ret(
+      mat4(
+        vec4(indexMat(m, 0), 0),
+        vec4(indexMat(m, 1), 0),
+        vec4(indexMat(m, 2), 0),
+        vec4()
+      )
+    )
+  ];
 });
+export {
+  m22ToM33,
+  m33ToM44
+};

package/matrix/lookat.js

@@ -4,22 +4,24 @@ import { mat4, vec4 } from "@thi.ng/shader-ast/ast/lit";
 import { neg, sub } from "@thi.ng/shader-ast/ast/ops";
 import { sym } from "@thi.ng/shader-ast/ast/sym";
 import { cross, dot, normalize } from "@thi.ng/shader-ast/builtin/math";
-/**
- * Creates a mat4 view matrix from given `eyePos`, `target` and `up`
- * vector.
- *
- * @param eye - vec3
- * @param target - vec3
- * @param up - vec3
- */
-export const lookat = defn(M4, "lookat", [V3, V3, V3], (eye, target, up) => {
-    let x;
-    let y;
-    let z;
-    return [
-        (z = sym(normalize(sub(eye, target)))),
-        (x = sym(normalize(cross(up, z)))),
-        (y = sym(normalize(cross(z, x)))),
-        ret(mat4(vec4(x, neg(dot(eye, x))), vec4(up, neg(dot(eye, y))), vec4(z, neg(dot(eye, z))), vec4(0, 0, 0, 1))),
-    ];
+const lookat = defn(M4, "lookat", [V3, V3, V3], (eye, target, up) => {
+  let x;
+  let y;
+  let z;
+  return [
+    z = sym(normalize(sub(eye, target))),
+    x = sym(normalize(cross(up, z))),
+    y = sym(normalize(cross(z, x))),
+    ret(
+      mat4(
+        vec4(x, neg(dot(eye, x))),
+        vec4(up, neg(dot(eye, y))),
+        vec4(z, neg(dot(eye, z))),
+        vec4(0, 0, 0, 1)
+      )
+    )
+  ];
 });
+export {
+  lookat
+};

package/matrix/mvp.js

@@ -1,12 +1,6 @@
 import { FLOAT1, vec4 } from "@thi.ng/shader-ast/ast/lit";
 import { mul } from "@thi.ng/shader-ast/ast/ops";
-/**
- * Inline function. Multiplies `pos` with given model, view & projection
- * matrices (in order). `p` is extended to a vec4.
- *
- * @param p -
- * @param model -
- * @param view -
- * @param proj -
- */
-export const transformMVP = (p, model, view, proj) => mul(mul(proj, mul(view, model)), vec4(p, FLOAT1));
+const transformMVP = (p, model, view, proj) => mul(mul(proj, mul(view, model)), vec4(p, FLOAT1));
+export {
+  transformMVP
+};

package/matrix/normal.js

@@ -2,11 +2,7 @@ import { vec4 } from "@thi.ng/shader-ast/ast/lit";
 import { mul } from "@thi.ng/shader-ast/ast/ops";
 import { $xyz } from "@thi.ng/shader-ast/ast/swizzle";
 import { normalize } from "@thi.ng/shader-ast/builtin/math";
-/**
- * Inline function. Multiplies `normal` with given 4x4 normal matrix
- * (e.g. transpose inverse of view * model).
- *
- * @param n -
- * @param normalMat -
- */
-export const surfaceNormal = (n, normalMat) => normalize($xyz(mul(normalMat, vec4(n, 0))));
+const surfaceNormal = (n, normalMat) => normalize($xyz(mul(normalMat, vec4(n, 0))));
+export {
+  surfaceNormal
+};