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

package/matrix/rotation.js

@@ -8,62 +8,146 @@ import { cos, sin } from "@thi.ng/shader-ast/builtin/math";
 import { perpendicularCCW } from "../math/orthogonal.js";
 import { cossin } from "../math/sincos.js";
 import { m33ToM44 } from "./convert.js";
-export const rotation2 = defn(M2, "rotation2", [F], (theta) => {
-    let cs;
-    return [(cs = sym(cossin(theta))), ret(mat2(cs, perpendicularCCW(cs)))];
+const rotation2 = defn(M2, "rotation2", [F], (theta) => {
+  let cs;
+  return [cs = sym(cossin(theta)), ret(mat2(cs, perpendicularCCW(cs)))];
 });
-export const rotationX3 = defn(M3, "rotationX3", [F], (theta) => {
-    let cs;
-    return [
-        (cs = sym(cossin(theta))),
-        ret(mat3(1, 0, 0, 0, $x(cs), $y(cs), 0, neg($y(cs)), $x(cs))),
-    ];
+const rotationX3 = defn(M3, "rotationX3", [F], (theta) => {
+  let cs;
+  return [
+    cs = sym(cossin(theta)),
+    ret(mat3(1, 0, 0, 0, $x(cs), $y(cs), 0, neg($y(cs)), $x(cs)))
+  ];
 });
-export const rotationY3 = defn(M3, "rotationY3", [F], (theta) => {
-    let cs;
-    return [
-        (cs = sym(cossin(theta))),
-        ret(mat3($x(cs), 0, neg($y(cs)), 0, 1, 0, $y(cs), 0, $x(cs))),
-    ];
+const rotationY3 = defn(M3, "rotationY3", [F], (theta) => {
+  let cs;
+  return [
+    cs = sym(cossin(theta)),
+    ret(mat3($x(cs), 0, neg($y(cs)), 0, 1, 0, $y(cs), 0, $x(cs)))
+  ];
 });
-export const rotationZ3 = defn(M3, "rotationZ3", [F], (theta) => {
-    let cs;
-    return [
-        (cs = sym(cossin(theta))),
-        ret(mat3($x(cs), $y(cs), 0, neg($y(cs)), $x(cs), 0, 0, 0, 1)),
-    ];
+const rotationZ3 = defn(M3, "rotationZ3", [F], (theta) => {
+  let cs;
+  return [
+    cs = sym(cossin(theta)),
+    ret(mat3($x(cs), $y(cs), 0, neg($y(cs)), $x(cs), 0, 0, 0, 1))
+  ];
 });
-export const rotationX4 = defn(M4, "rotationX4", [F], (theta) => {
-    let cs;
-    return [
-        (cs = sym(cossin(theta))),
-        ret(mat4(1, 0, 0, 0, 0, $x(cs), $y(cs), 0, 0, neg($y(cs)), $x(cs), 0, 0, 0, 0, 1)),
-    ];
+const rotationX4 = defn(M4, "rotationX4", [F], (theta) => {
+  let cs;
+  return [
+    cs = sym(cossin(theta)),
+    ret(
+      mat4(
+        1,
+        0,
+        0,
+        0,
+        0,
+        $x(cs),
+        $y(cs),
+        0,
+        0,
+        neg($y(cs)),
+        $x(cs),
+        0,
+        0,
+        0,
+        0,
+        1
+      )
+    )
+  ];
 });
-export const rotationY4 = defn(M4, "rotationY4", [F], (theta) => {
-    let cs;
-    return [
-        (cs = sym(cossin(theta))),
-        ret(mat4($x(cs), 0, neg($y(cs)), 0, 0, 1, 0, 0, $y(cs), 0, $x(cs), 0, 0, 0, 0, 1)),
-    ];
+const rotationY4 = defn(M4, "rotationY4", [F], (theta) => {
+  let cs;
+  return [
+    cs = sym(cossin(theta)),
+    ret(
+      mat4(
+        $x(cs),
+        0,
+        neg($y(cs)),
+        0,
+        0,
+        1,
+        0,
+        0,
+        $y(cs),
+        0,
+        $x(cs),
+        0,
+        0,
+        0,
+        0,
+        1
+      )
+    )
+  ];
 });
-export const rotationZ4 = defn(M4, "rotationZ4", [F], (theta) => {
-    let cs;
-    return [
-        (cs = sym(cossin(theta))),
-        ret(mat4($x(cs), $y(cs), 0, 0, neg($y(cs)), $x(cs), 0, 0, 0, 0, 1, 0, 0, 0, 0, 1)),
-    ];
+const rotationZ4 = defn(M4, "rotationZ4", [F], (theta) => {
+  let cs;
+  return [
+    cs = sym(cossin(theta)),
+    ret(
+      mat4(
+        $x(cs),
+        $y(cs),
+        0,
+        0,
+        neg($y(cs)),
+        $x(cs),
+        0,
+        0,
+        0,
+        0,
+        1,
+        0,
+        0,
+        0,
+        0,
+        1
+      )
+    )
+  ];
 });
-export const rotationAroundAxis3 = defn(M3, "rotationAroundAxis3", [V3, F], (axis, theta) => {
+const rotationAroundAxis3 = defn(
+  M3,
+  "rotationAroundAxis3",
+  [V3, F],
+  (axis, theta) => {
     let s;
     let c;
     let t;
-    const $$ = (a, b, c, d, e, f, g) => add(mul(mul(axis, a), t), mul(vec3(b, c, d), vec3(e, f, g)));
+    const $$ = (a, b, c2, d, e, f, g) => add(mul(mul(axis, a), t), mul(vec3(b, c2, d), vec3(e, f, g)));
     return [
-        (s = sym(sin(theta))),
-        (c = sym(cos(theta))),
-        (t = sym(sub(1, c))),
-        ret(mat3($$($x(axis), 1, $z(axis), neg($y(axis)), c, s, s), $$($y(axis), neg($z(axis)), 1, $x(axis), s, c, s), $$($z(axis), $y(axis), neg($x(axis)), 1, s, s, c))),
+      s = sym(sin(theta)),
+      c = sym(cos(theta)),
+      t = sym(sub(1, c)),
+      ret(
+        mat3(
+          $$($x(axis), 1, $z(axis), neg($y(axis)), c, s, s),
+          $$($y(axis), neg($z(axis)), 1, $x(axis), s, c, s),
+          $$($z(axis), $y(axis), neg($x(axis)), 1, s, s, c)
+        )
+      )
     ];
-});
-export const rotationAroundAxis4 = defn(M4, "rotationAroundAxis4", [V3, F], (axis, theta) => [ret(m33ToM44(rotationAroundAxis3(axis, theta)))]);
+  }
+);
+const rotationAroundAxis4 = defn(
+  M4,
+  "rotationAroundAxis4",
+  [V3, F],
+  (axis, theta) => [ret(m33ToM44(rotationAroundAxis3(axis, theta)))]
+);
+export {
+  rotation2,
+  rotationAroundAxis3,
+  rotationAroundAxis4,
+  rotationX3,
+  rotationX4,
+  rotationY3,
+  rotationY4,
+  rotationZ3,
+  rotationZ4
+};

package/noise/curl3.js

@@ -5,22 +5,34 @@ import { add, div, mul, sub } 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 { snoiseVec3 } from "./simplex3.js";
-export const curlNoise3 = defn(V3, "curlNoise3", [V3, F], (p, e) => {
-    let D;
-    let px0;
-    let px1;
-    let py0;
-    let py1;
-    let pz0;
-    let pz1;
-    return [
-        (D = sym(vec2(e, 0))),
-        (px0 = sym(snoiseVec3(sub(p, $(D, "xyy"))))),
-        (px1 = sym(snoiseVec3(add(p, $(D, "xyy"))))),
-        (py0 = sym(snoiseVec3(sub(p, $(D, "yxy"))))),
-        (py1 = sym(snoiseVec3(add(p, $(D, "yxy"))))),
-        (pz0 = sym(snoiseVec3(sub(p, $(D, "yyx"))))),
-        (pz1 = sym(snoiseVec3(add(p, $(D, "yyx"))))),
-        ret(div(vec3(add(sub(sub($z(py1), $z(py0)), $y(pz1)), $y(pz0)), add(sub(sub($x(pz1), $x(pz0)), $z(px1)), $z(px0)), add(sub(sub($y(px1), $y(px0)), $x(py1)), $x(py0))), mul(2, e))),
-    ];
+const curlNoise3 = defn(V3, "curlNoise3", [V3, F], (p, e) => {
+  let D;
+  let px0;
+  let px1;
+  let py0;
+  let py1;
+  let pz0;
+  let pz1;
+  return [
+    D = sym(vec2(e, 0)),
+    px0 = sym(snoiseVec3(sub(p, $(D, "xyy")))),
+    px1 = sym(snoiseVec3(add(p, $(D, "xyy")))),
+    py0 = sym(snoiseVec3(sub(p, $(D, "yxy")))),
+    py1 = sym(snoiseVec3(add(p, $(D, "yxy")))),
+    pz0 = sym(snoiseVec3(sub(p, $(D, "yyx")))),
+    pz1 = sym(snoiseVec3(add(p, $(D, "yyx")))),
+    ret(
+      div(
+        vec3(
+          add(sub(sub($z(py1), $z(py0)), $y(pz1)), $y(pz0)),
+          add(sub(sub($x(pz1), $x(pz0)), $z(px1)), $z(px0)),
+          add(sub(sub($y(px1), $y(px0)), $x(py1)), $x(py0))
+        ),
+        mul(2, e)
+      )
+    )
+  ];
 });
+export {
+  curlNoise3
+};

package/noise/hash.js

@@ -6,217 +6,146 @@ import { add, mul } 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 { dot, fract, sin } from "@thi.ng/shader-ast/builtin/math";
-/**
- * iq's hash PRNG producing 2D results.
- *
- * @param p -
- */
-export const hash2 = defn(V2, "hash2", [V2], (p) => [
-    ret(fract(mul(sin(mul(p, mat2(127.1, 311.7, 269.5, 183.3))), 43758.5453))),
+const hash2 = defn(V2, "hash2", [V2], (p) => [
+  ret(fract(mul(sin(mul(p, mat2(127.1, 311.7, 269.5, 183.3))), 43758.5453)))
 ]);
-/**
- * iq's hash PRNG producing 3D results.
- *
- * @param p -
- */
-export const hash3 = defn(V3, "hash3", [V2], (p) => [
-    ret(fract(mul(sin(vec3(dot(p, vec2(127.1, 311.7)), dot(p, vec2(269.5, 183.3)), dot(p, vec2(419.2, 371.9)))), 43758.5453))),
+const hash3 = defn(V3, "hash3", [V2], (p) => [
+  ret(
+    fract(
+      mul(
+        sin(
+          vec3(
+            dot(p, vec2(127.1, 311.7)),
+            dot(p, vec2(269.5, 183.3)),
+            dot(p, vec2(419.2, 371.9))
+          )
+        ),
+        43758.5453
+      )
+    )
+  )
 ]);
 const H = vec3(0.1031, 0.103, 0.0973);
 const H4 = vec4(0.1031, 0.103, 0.0973, 0.1099);
-/**
- * 1D hash.
- *
- * Dave Hoskins (https://www.shadertoy.com/view/4djSRW)
- *
- * @param p -
- */
-export const hash11 = defn(F, "hash11", [F], (p) => {
-    let x;
-    return [
-        (x = sym(fract(mul(p, 0.1031)))),
-        assign(x, mul(x, add(x, 19.19))),
-        assign(x, mul(x, add(x, x))),
-        ret(fract(x)),
-    ];
+const hash11 = defn(F, "hash11", [F], (p) => {
+  let x;
+  return [
+    x = sym(fract(mul(p, 0.1031))),
+    assign(x, mul(x, add(x, 19.19))),
+    assign(x, mul(x, add(x, x))),
+    ret(fract(x))
+  ];
 });
-/**
- * 2D -> 1D hash.
- *
- * Dave Hoskins (https://www.shadertoy.com/view/4djSRW)
- *
- * @param p -
- */
-export const hash12 = defn(F, "hash12", [V2], (p) => {
-    let x;
-    return [
-        (x = sym(fract(mul($(p, "xyx"), 0.1031)))),
-        assign(x, add(x, dot(x, add($(x, "yzx"), 19.19)))),
-        ret(fract(mul(add($x(x), $y(x)), $z(x)))),
-    ];
+const hash12 = defn(F, "hash12", [V2], (p) => {
+  let x;
+  return [
+    x = sym(fract(mul($(p, "xyx"), 0.1031))),
+    assign(x, add(x, dot(x, add($(x, "yzx"), 19.19)))),
+    ret(fract(mul(add($x(x), $y(x)), $z(x))))
+  ];
 });
-/**
- * 3D -> 1D hash.
- *
- * Dave Hoskins (https://www.shadertoy.com/view/4djSRW)
- *
- * @param p -
- */
-export const hash13 = defn(F, "hash13", [V3], (p) => {
-    let x;
-    return [
-        (x = sym(fract(mul($(p, "xyx"), 0.1031)))),
-        assign(x, add(x, dot(x, add($(x, "yzx"), 19.19)))),
-        ret(fract(mul(add($x(x), $y(x)), $z(x)))),
-    ];
+const hash13 = defn(F, "hash13", [V3], (p) => {
+  let x;
+  return [
+    x = sym(fract(mul($(p, "xyx"), 0.1031))),
+    assign(x, add(x, dot(x, add($(x, "yzx"), 19.19)))),
+    ret(fract(mul(add($x(x), $y(x)), $z(x))))
+  ];
 });
-/**
- * 1D -> 2D hash.
- *
- * Dave Hoskins (https://www.shadertoy.com/view/4djSRW)
- *
- * @param p -
- */
-export const hash21 = defn(V2, "hash21", [F], (p) => {
-    let x;
-    return [
-        (x = sym(fract(mul(vec3(p), H)))),
-        assign(x, add(x, dot(x, add($(x, "yzx"), 19.19)))),
-        ret(fract(mul(add($(x, "xx"), $(x, "yz")), $(x, "zy")))),
-    ];
+const hash21 = defn(V2, "hash21", [F], (p) => {
+  let x;
+  return [
+    x = sym(fract(mul(vec3(p), H))),
+    assign(x, add(x, dot(x, add($(x, "yzx"), 19.19)))),
+    ret(fract(mul(add($(x, "xx"), $(x, "yz")), $(x, "zy"))))
+  ];
 });
-/**
- * 2D -> 2D hash.
- *
- * Dave Hoskins (https://www.shadertoy.com/view/4djSRW)
- *
- * @param p -
- */
-export const hash22 = defn(V2, "hash22", [V2], (p) => {
-    let x;
-    return [
-        (x = sym(fract(mul($(p, "xyx"), H)))),
-        assign(x, add(x, dot(x, add($(x, "yzx"), 19.19)))),
-        ret(fract(mul(add($(x, "xx"), $(x, "yz")), $(x, "zy")))),
-    ];
+const hash22 = defn(V2, "hash22", [V2], (p) => {
+  let x;
+  return [
+    x = sym(fract(mul($(p, "xyx"), H))),
+    assign(x, add(x, dot(x, add($(x, "yzx"), 19.19)))),
+    ret(fract(mul(add($(x, "xx"), $(x, "yz")), $(x, "zy"))))
+  ];
 });
-/**
- * 3D -> 2D hash.
- *
- * Dave Hoskins (https://www.shadertoy.com/view/4djSRW)
- *
- * @param p -
- */
-export const hash23 = defn(V2, "hash23", [V3], (p) => {
-    let x;
-    return [
-        (x = sym(fract(mul(p, H)))),
-        assign(x, add(x, dot(x, add($(x, "yzx"), 19.19)))),
-        ret(fract(mul(add($(x, "xx"), $(x, "yz")), $(x, "zy")))),
-    ];
+const hash23 = defn(V2, "hash23", [V3], (p) => {
+  let x;
+  return [
+    x = sym(fract(mul(p, H))),
+    assign(x, add(x, dot(x, add($(x, "yzx"), 19.19)))),
+    ret(fract(mul(add($(x, "xx"), $(x, "yz")), $(x, "zy"))))
+  ];
 });
-/**
- * 1D -> 3D hash.
- *
- * Dave Hoskins (https://www.shadertoy.com/view/4djSRW)
- *
- * @param p -
- */
-export const hash31 = defn(V3, "hash31", [F], (p) => {
-    let x;
-    return [
-        (x = sym(fract(mul(p, H)))),
-        assign(x, add(x, dot(x, add($(x, "yzx"), 19.19)))),
-        ret(fract(mul(add($(x, "xxy"), $(x, "yzz")), $(x, "zyx")))),
-    ];
+const hash31 = defn(V3, "hash31", [F], (p) => {
+  let x;
+  return [
+    x = sym(fract(mul(p, H))),
+    assign(x, add(x, dot(x, add($(x, "yzx"), 19.19)))),
+    ret(fract(mul(add($(x, "xxy"), $(x, "yzz")), $(x, "zyx"))))
+  ];
 });
-/**
- * 2D -> 3D hash.
- *
- * Dave Hoskins (https://www.shadertoy.com/view/4djSRW)
- *
- * @param p -
- */
-export const hash32 = defn(V3, "hash32", [V2], (p) => {
-    let x;
-    return [
-        (x = sym(fract(mul($(p, "xyx"), H)))),
-        assign(x, add(x, dot(x, add($(x, "yzx"), 19.19)))),
-        ret(fract(mul(add($(x, "xxy"), $(x, "yzz")), $(x, "zyx")))),
-    ];
+const hash32 = defn(V3, "hash32", [V2], (p) => {
+  let x;
+  return [
+    x = sym(fract(mul($(p, "xyx"), H))),
+    assign(x, add(x, dot(x, add($(x, "yzx"), 19.19)))),
+    ret(fract(mul(add($(x, "xxy"), $(x, "yzz")), $(x, "zyx"))))
+  ];
 });
-/**
- * 3D -> 3D hash.
- *
- * Dave Hoskins (https://www.shadertoy.com/view/4djSRW)
- *
- * @param p -
- */
-export const hash33 = defn(V3, "hash33", [V3], (p) => {
-    let x;
-    return [
-        (x = sym(fract(mul(p, H)))),
-        assign(x, add(x, dot(x, add($(x, "yzx"), 19.19)))),
-        ret(fract(mul(add($(x, "xxy"), $(x, "yzz")), $(x, "zyx")))),
-    ];
+const hash33 = defn(V3, "hash33", [V3], (p) => {
+  let x;
+  return [
+    x = sym(fract(mul(p, H))),
+    assign(x, add(x, dot(x, add($(x, "yzx"), 19.19)))),
+    ret(fract(mul(add($(x, "xxy"), $(x, "yzz")), $(x, "zyx"))))
+  ];
 });
-/**
- * 1D -> 4D hash.
- *
- * Dave Hoskins (https://www.shadertoy.com/view/4djSRW)
- *
- * @param p -
- */
-export const hash41 = defn(V4, "hash41", [F], (p) => {
-    let x;
-    return [
-        (x = sym(fract(mul(p, H4)))),
-        assign(x, add(x, dot(x, add($(x, "wzxy"), 19.19)))),
-        ret(fract(mul(add($(x, "xxyz"), $(x, "yzzw")), $(x, "zywx")))),
-    ];
+const hash41 = defn(V4, "hash41", [F], (p) => {
+  let x;
+  return [
+    x = sym(fract(mul(p, H4))),
+    assign(x, add(x, dot(x, add($(x, "wzxy"), 19.19)))),
+    ret(fract(mul(add($(x, "xxyz"), $(x, "yzzw")), $(x, "zywx"))))
+  ];
 });
-/**
- * 2D -> 4D hash.
- *
- * Dave Hoskins (https://www.shadertoy.com/view/4djSRW)
- *
- * @param p -
- */
-export const hash42 = defn(V4, "hash42", [V2], (p) => {
-    let x;
-    return [
-        (x = sym(fract(mul($(p, "xyxy"), H4)))),
-        assign(x, add(x, dot(x, add($(x, "wzxy"), 19.19)))),
-        ret(fract(mul(add($(x, "xxyz"), $(x, "yzzw")), $(x, "zywx")))),
-    ];
+const hash42 = defn(V4, "hash42", [V2], (p) => {
+  let x;
+  return [
+    x = sym(fract(mul($(p, "xyxy"), H4))),
+    assign(x, add(x, dot(x, add($(x, "wzxy"), 19.19)))),
+    ret(fract(mul(add($(x, "xxyz"), $(x, "yzzw")), $(x, "zywx"))))
+  ];
 });
-/**
- * 3D -> 4D hash.
- *
- * Dave Hoskins (https://www.shadertoy.com/view/4djSRW)
- *
- * @param p -
- */
-export const hash43 = defn(V4, "hash43", [V3], (p) => {
-    let x;
-    return [
-        (x = sym(fract(mul($(p, "xyzx"), H4)))),
-        assign(x, add(x, dot(x, add($(x, "wzxy"), 19.19)))),
-        ret(fract(mul(add($(x, "xxyz"), $(x, "yzzw")), $(x, "zywx")))),
-    ];
+const hash43 = defn(V4, "hash43", [V3], (p) => {
+  let x;
+  return [
+    x = sym(fract(mul($(p, "xyzx"), H4))),
+    assign(x, add(x, dot(x, add($(x, "wzxy"), 19.19)))),
+    ret(fract(mul(add($(x, "xxyz"), $(x, "yzzw")), $(x, "zywx"))))
+  ];
 });
-/**
- * 4D -> 4D hash.
- *
- * Dave Hoskins (https://www.shadertoy.com/view/4djSRW)
- *
- * @param p -
- */
-export const hash44 = defn(V4, "hash44", [V4], (p) => {
-    let x;
-    return [
-        (x = sym(fract(mul(p, H4)))),
-        assign(x, add(x, dot(x, add($(x, "wzxy"), 19.19)))),
-        ret(fract(mul(add($(x, "xxyz"), $(x, "yzzw")), $(x, "zywx")))),
-    ];
+const hash44 = defn(V4, "hash44", [V4], (p) => {
+  let x;
+  return [
+    x = sym(fract(mul(p, H4))),
+    assign(x, add(x, dot(x, add($(x, "wzxy"), 19.19)))),
+    ret(fract(mul(add($(x, "xxyz"), $(x, "yzzw")), $(x, "zywx"))))
+  ];
 });
+export {
+  hash11,
+  hash12,
+  hash13,
+  hash2,
+  hash21,
+  hash22,
+  hash23,
+  hash3,
+  hash31,
+  hash32,
+  hash33,
+  hash41,
+  hash42,
+  hash43,
+  hash44
+};

package/noise/permute.js

@@ -4,9 +4,15 @@ import { FLOAT1, float } from "@thi.ng/shader-ast/ast/lit";
 import { add, mul } from "@thi.ng/shader-ast/ast/ops";
 import { mod } from "@thi.ng/shader-ast/builtin/math";
 const __permute = (type, suffix = "") => defn(type, `permute${suffix}`, [type], (v) => [
-    ret(mod(mul(v, add(mul(v, float(34)), FLOAT1)), float(289))),
+  ret(mod(mul(v, add(mul(v, float(34)), FLOAT1)), float(289)))
 ]);
-export const permute = __permute(F);
-export const permute2 = __permute(V2, "2");
-export const permute3 = __permute(V3, "3");
-export const permute4 = __permute(V4, "4");
+const permute = __permute(F);
+const permute2 = __permute(V2, "2");
+const permute3 = __permute(V3, "3");
+const permute4 = __permute(V4, "4");
+export {
+  permute,
+  permute2,
+  permute3,
+  permute4
+};