@woosh/meep-engine 3.16.0 → 3.17.0

package/src/shade/renderer/shader/chunk/noise/psrdnoise/chunk_psrdnoise2_kernel.js

@@ -0,0 +1,80 @@
+import { CodeChunk } from "../../../compiler/CodeChunk.js";
+import { chunk_psrdnoise2_hash } from "./chunk_psrdnoise2_hash.js";
+
+/**
+ * Everything a 2-D psrdnoise sample does once its simplex is known: hash the three corners, turn
+ * each hash into a rotating unit gradient, and sum the radially-weighted ramps into a noise value
+ * and its exact first derivative.
+ *
+ * This is the whole cost of the function. It is factored out because it is identical for the
+ * periodic {@link chunk_psrdnoise2} and the non-periodic {@link chunk_srdnoise2} — the two differ
+ * only in how they arrive at `iu`/`iv`, and sharing this keeps that difference down to the wrap
+ * itself.
+ *
+ * **Rotating gradients.** Each corner's gradient is a *unit vector at an angle*, not a table entry:
+ * `psi` is the hashed angle and `alpha` turns every gradient in the field by the same amount. The
+ * result is a swirl rather than a crossfade, which is what "flow noise" is — animate `alpha` and the
+ * pattern rotates in place instead of dissolving. The rotation is a single add, so unlike the 3-D
+ * version there is nothing to gain from `alpha == 0`.
+ *
+ * **Why the derivative is free.** `w⁴·(g·x)` is a product of two things whose derivatives are
+ * already computed, so the product rule costs a handful of multiply-adds and no transcendentals.
+ * Curl noise, normal mapping and erosion all need the gradient, and a finite difference would cost
+ * three more evaluations and be wrong at the cell boundaries.
+ *
+ * Returns `vec3(noise, gradient.x, gradient.y)` — the noise value in `.x`, so a caller that wants
+ * only the value writes `.x` and lets the compiler drop the derivative tail.
+ *
+ * psrdnoise (c) 2021 Stefan Gustavson and Ian McEwan. Published under the MIT license.
+ * @see https://github.com/stegu/psrdnoise/
+ * @type {CodeChunk}
+ */
+export const chunk_psrdnoise2_kernel = CodeChunk.from(
+    //language=WGSL
+    `
+fn psrdnoise2_kernel(
+    iu: vec3<f32>,
+    iv: vec3<f32>,
+    x0: vec2<f32>,
+    x1: vec2<f32>,
+    x2: vec2<f32>,
+    alpha: f32
+) -> vec3<f32> {
+    // a pseudo-random angle per corner, every one of them turned by alpha. 0.07482 rad per hash
+    // step is deliberately not 2*pi/289: the 289 hash values wind about three and a half times
+    // around the circle rather than once, so two corners whose hashes landed near each other do
+    // not get gradients pointing the same way. Upstream states the constant without deriving it
+    let psi = psrdnoise2_hash(iu, iv) * 0.07482 + alpha;
+
+    let gx = cos(psi);
+    let gy = sin(psi);
+
+    let g0 = vec2<f32>(gx.x, gy.x);
+    let g1 = vec2<f32>(gx.y, gy.y);
+    let g2 = vec2<f32>(gx.z, gy.z);
+
+    // radial decay with distance from each corner. 0.8 is the squared radius of each corner's
+    // support: far enough that the three of them cover the cell between them, near enough that no
+    // corner outside the simplex ever reaches into it and would have had to be summed as well
+    let w = max(0.8 - vec3<f32>(dot(x0, x0), dot(x1, x1), dot(x2, x2)), vec3<f32>(0.0));
+    let w2 = w * w;
+    let w4 = w2 * w2;
+
+    // the linear ramp from each corner
+    let gdotx = vec3<f32>(dot(g0, x0), dot(g1, x1), dot(g2, x2));
+
+    let n = dot(w4, gdotx);
+
+    // d/dx of w^4 * (g . x), by the product rule. d(w^4) = 4*w^3 * d(w), and d(w) = -2*x
+    let dw = -8.0 * (w2 * w) * gdotx;
+    let dn0 = w4.x * g0 + dw.x * x0;
+    let dn1 = w4.y * g1 + dw.y * x1;
+    let dn2 = w4.z * g2 + dw.z * x2;
+
+    // 10.9 scales the sum to fill [-1, 1]; the same factor applies to the derivative
+    return vec3<f32>(n, dn0 + dn1 + dn2) * 10.9;
+}
+    `, [
+        chunk_psrdnoise2_hash,
+    ]
+);

package/src/shade/renderer/shader/chunk/noise/psrdnoise/chunk_psrdnoise3.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Periodic (tiling) 3-D simplex noise with rotating gradients and an analytic derivative.
+ *
+ * Returns `vec4(noise, gradient.xyz)`: the noise value is in `.x`, in `[-1, 1]`, and `.yzw` is its
+ * exact gradient. Ask for only `.x` and the compiler drops the derivative.
+ *
+ * **What tiles.** The lattice is axis-aligned in texture space, which ordinary 3-D simplex noise's
+ * skewed grid is not, and that is what lets a rectangular period be imposed on it at all. Any
+ * integer period up to 289 works on each axis independently; zero or negative skips the wrap for
+ * that axis, and `vec3(0.0)` on all three takes a shortcut worth 10-15% by upstream's measurement of
+ * the GLSL. A caller that always passes zero should call {@link chunk_srdnoise3} instead and not pay
+ * for the branch. 289 is the hash's modulus, so it is a hard ceiling — a longer period does not
+ * tile, it repeats inside itself.
+ *
+ * **What `alpha` does.** It turns every gradient by that many radians about a per-corner
+ * pseudo-random axis. Animating it swirls the field in place rather than crossfading it, and with
+ * the gradient it gives curl noise; `alpha == 0` takes a cheaper path when the whole warp agrees on
+ * it. See {@link chunk_psrdnoise3_kernel}.
+ *
+ * psrdnoise (c) 2021 Stefan Gustavson and Ian McEwan. Published under the MIT license.
+ * @see https://github.com/stegu/psrdnoise/
+ * @type {CodeChunk}
+ */
+export const chunk_psrdnoise3: CodeChunk;
+import { CodeChunk } from "../../../compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_psrdnoise3.d.ts.map

package/src/shade/renderer/shader/chunk/noise/psrdnoise/chunk_psrdnoise3.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_psrdnoise3.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/noise/psrdnoise/chunk_psrdnoise3.js"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,+BAFU,SAAS,CAiFjB;0BA5GwB,gCAAgC"}

package/src/shade/renderer/shader/chunk/noise/psrdnoise/chunk_psrdnoise3.js

@@ -0,0 +1,109 @@
+import { CodeChunk } from "../../../compiler/CodeChunk.js";
+import { chunk_mod_v4f } from "../../math/chunk_mod_v4f.js";
+import { chunk_psrdnoise3_kernel } from "./chunk_psrdnoise3_kernel.js";
+import { chunk_psrdnoise3_skew } from "./chunk_psrdnoise3_skew.js";
+import { chunk_psrdnoise3_unskew } from "./chunk_psrdnoise3_unskew.js";
+
+/**
+ * Periodic (tiling) 3-D simplex noise with rotating gradients and an analytic derivative.
+ *
+ * Returns `vec4(noise, gradient.xyz)`: the noise value is in `.x`, in `[-1, 1]`, and `.yzw` is its
+ * exact gradient. Ask for only `.x` and the compiler drops the derivative.
+ *
+ * **What tiles.** The lattice is axis-aligned in texture space, which ordinary 3-D simplex noise's
+ * skewed grid is not, and that is what lets a rectangular period be imposed on it at all. Any
+ * integer period up to 289 works on each axis independently; zero or negative skips the wrap for
+ * that axis, and `vec3(0.0)` on all three takes a shortcut worth 10-15% by upstream's measurement of
+ * the GLSL. A caller that always passes zero should call {@link chunk_srdnoise3} instead and not pay
+ * for the branch. 289 is the hash's modulus, so it is a hard ceiling — a longer period does not
+ * tile, it repeats inside itself.
+ *
+ * **What `alpha` does.** It turns every gradient by that many radians about a per-corner
+ * pseudo-random axis. Animating it swirls the field in place rather than crossfading it, and with
+ * the gradient it gives curl noise; `alpha == 0` takes a cheaper path when the whole warp agrees on
+ * it. See {@link chunk_psrdnoise3_kernel}.
+ *
+ * psrdnoise (c) 2021 Stefan Gustavson and Ian McEwan. Published under the MIT license.
+ * @see https://github.com/stegu/psrdnoise/
+ * @type {CodeChunk}
+ */
+export const chunk_psrdnoise3 = CodeChunk.from(
+    //language=WGSL
+    `
+fn psrdnoise3(
+    x: vec3<f32>,
+    period: vec3<f32>,
+    alpha: f32
+) -> vec4<f32> {
+    let uvw = psrdnoise3_skew(x);
+
+    // which simplex we are in. i0 is the base corner of the skewed cube; o1 and o2 step to the
+    // second and third corners, found by rank-ordering u, v, w — the descending order of the
+    // fractional coordinates is exactly the order the tetrahedron's corners are traversed in
+    let i0 = floor(uvw);
+    let f0 = uvw - i0;
+
+    let gt_ = step(f0.xyx, f0.yzz);
+    let lt_ = 1.0 - gt_;
+    let gt = vec3<f32>(lt_.z, gt_.xy);
+    let lt = vec3<f32>(lt_.xy, gt_.z);
+    let o1 = min(gt, lt);
+    let o2 = max(gt, lt);
+
+    let i1 = i0 + o1;
+    let i2 = i0 + o2;
+    let i3 = i0 + vec3<f32>(1.0);
+
+    // the four corners back in texture space
+    let v0 = psrdnoise3_unskew(i0);
+    let v1 = psrdnoise3_unskew(i1);
+    let v2 = psrdnoise3_unskew(i2);
+    let v3 = psrdnoise3_unskew(i3);
+
+    var ix = vec4<f32>(i0.x, i1.x, i2.x, i3.x);
+    var iy = vec4<f32>(i0.y, i1.y, i2.y, i3.y);
+    var iz = vec4<f32>(i0.z, i1.z, i2.z, i3.z);
+
+    if (any(period > vec3<f32>(0.0))) {
+        // the wrap has to happen in texture space, where the period is rectangular, and the corners
+        // then go back to simplex space to be hashed. Only the hash inputs move; the offsets below
+        // stay measured from the unwrapped corners, which is what keeps the field continuous
+        // across the seam
+        var vx = vec4<f32>(v0.x, v1.x, v2.x, v3.x);
+        var vy = vec4<f32>(v0.y, v1.y, v2.y, v3.y);
+        var vz = vec4<f32>(v0.z, v1.z, v2.z, v3.z);
+
+        if (period.x > 0.0) {
+            vx = mod_v4f(vx, period.x);
+        }
+
+        if (period.y > 0.0) {
+            vy = mod_v4f(vy, period.y);
+        }
+
+        if (period.z > 0.0) {
+            vz = mod_v4f(vz, period.z);
+        }
+
+        // the skew takes each wrapped corner back to simplex space, where it is an integer lattice
+        // point — but the wrap leaves it a hair off one, so the +0.5 under the floor rounds to
+        // nearest rather than truncating into the neighbouring cell
+        let j0 = floor(psrdnoise3_skew(vec3<f32>(vx.x, vy.x, vz.x)) + 0.5);
+        let j1 = floor(psrdnoise3_skew(vec3<f32>(vx.y, vy.y, vz.y)) + 0.5);
+        let j2 = floor(psrdnoise3_skew(vec3<f32>(vx.z, vy.z, vz.z)) + 0.5);
+        let j3 = floor(psrdnoise3_skew(vec3<f32>(vx.w, vy.w, vz.w)) + 0.5);
+
+        ix = vec4<f32>(j0.x, j1.x, j2.x, j3.x);
+        iy = vec4<f32>(j0.y, j1.y, j2.y, j3.y);
+        iz = vec4<f32>(j0.z, j1.z, j2.z, j3.z);
+    }
+
+    return psrdnoise3_kernel(ix, iy, iz, x - v0, x - v1, x - v2, x - v3, alpha);
+}
+    `, [
+        chunk_mod_v4f,
+        chunk_psrdnoise3_kernel,
+        chunk_psrdnoise3_skew,
+        chunk_psrdnoise3_unskew,
+    ]
+);

package/src/shade/renderer/shader/chunk/noise/psrdnoise/chunk_psrdnoise3_kernel.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Everything a 3-D psrdnoise sample does once its simplex is known: hash the four corners, turn each
+ * hash into a rotating unit gradient, and sum the radially-weighted ramps into a noise value and its
+ * exact first derivative.
+ *
+ * This is the whole cost of the function. It is factored out because it is identical for the
+ * periodic {@link chunk_psrdnoise3} and the non-periodic {@link chunk_srdnoise3}, which differ only
+ * in how they arrive at the lattice coordinates.
+ *
+ * **Gradients from a spiral, not a table.** Classic 3-D simplex noise picks each corner's gradient
+ * from a small fixed table, and the table's directions show up in the field as faint preferred axes.
+ * Here `hash` is read as a position on a Fibonacci spiral over the unit sphere — `theta` around,
+ * `sz` up — which spreads 289 directions near-uniformly with no axis to favour.
+ *
+ * **Rotating gradients.** `alpha` turns every gradient by that many radians about a per-corner
+ * pseudo-random axis. Animating it swirls the field in place instead of crossfading it, which is
+ * what "flow noise" is, and with the analytic derivative below it is what curl noise needs. The
+ * rotation is a genuine 3-D rotation and costs two more transcendental pairs, so `alpha == 0` takes
+ * the shortcut branch and uses the spiral point directly — worth 15-20% by upstream's measurement of
+ * the GLSL when the whole warp agrees on `alpha == 0`, and nothing when it does not.
+ *
+ * **Why the derivative is free.** `w³·(g·x)` is a product of two things already computed, so the
+ * product rule costs a handful of multiply-adds and no transcendentals. A finite difference would
+ * cost three more evaluations and be wrong at the cell boundaries.
+ *
+ * The lattice coordinates arrive transposed — `ix` holds the x coordinate of all four corners, and
+ * so on — which is the layout the hash wants and the one the caller already has.
+ *
+ * Returns `vec4(noise, gradient.xyz)`: the noise value in `.x`, so a caller that wants only the
+ * value writes `.x` and lets the compiler drop the derivative tail.
+ *
+ * psrdnoise (c) 2021 Stefan Gustavson and Ian McEwan. Published under the MIT license.
+ * @see https://github.com/stegu/psrdnoise/
+ * @type {CodeChunk}
+ */
+export const chunk_psrdnoise3_kernel: CodeChunk;
+import { CodeChunk } from "../../../compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_psrdnoise3_kernel.d.ts.map

package/src/shade/renderer/shader/chunk/noise/psrdnoise/chunk_psrdnoise3_kernel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_psrdnoise3_kernel.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/noise/psrdnoise/chunk_psrdnoise3_kernel.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,sCAFU,SAAS,CA4FjB;0BAhIwB,gCAAgC"}

package/src/shade/renderer/shader/chunk/noise/psrdnoise/chunk_psrdnoise3_kernel.js

@@ -0,0 +1,129 @@
+import { CodeChunk } from "../../../compiler/CodeChunk.js";
+import { chunk_psrdnoise3_permute } from "./chunk_psrdnoise3_permute.js";
+
+/**
+ * Everything a 3-D psrdnoise sample does once its simplex is known: hash the four corners, turn each
+ * hash into a rotating unit gradient, and sum the radially-weighted ramps into a noise value and its
+ * exact first derivative.
+ *
+ * This is the whole cost of the function. It is factored out because it is identical for the
+ * periodic {@link chunk_psrdnoise3} and the non-periodic {@link chunk_srdnoise3}, which differ only
+ * in how they arrive at the lattice coordinates.
+ *
+ * **Gradients from a spiral, not a table.** Classic 3-D simplex noise picks each corner's gradient
+ * from a small fixed table, and the table's directions show up in the field as faint preferred axes.
+ * Here `hash` is read as a position on a Fibonacci spiral over the unit sphere — `theta` around,
+ * `sz` up — which spreads 289 directions near-uniformly with no axis to favour.
+ *
+ * **Rotating gradients.** `alpha` turns every gradient by that many radians about a per-corner
+ * pseudo-random axis. Animating it swirls the field in place instead of crossfading it, which is
+ * what "flow noise" is, and with the analytic derivative below it is what curl noise needs. The
+ * rotation is a genuine 3-D rotation and costs two more transcendental pairs, so `alpha == 0` takes
+ * the shortcut branch and uses the spiral point directly — worth 15-20% by upstream's measurement of
+ * the GLSL when the whole warp agrees on `alpha == 0`, and nothing when it does not.
+ *
+ * **Why the derivative is free.** `w³·(g·x)` is a product of two things already computed, so the
+ * product rule costs a handful of multiply-adds and no transcendentals. A finite difference would
+ * cost three more evaluations and be wrong at the cell boundaries.
+ *
+ * The lattice coordinates arrive transposed — `ix` holds the x coordinate of all four corners, and
+ * so on — which is the layout the hash wants and the one the caller already has.
+ *
+ * Returns `vec4(noise, gradient.xyz)`: the noise value in `.x`, so a caller that wants only the
+ * value writes `.x` and lets the compiler drop the derivative tail.
+ *
+ * psrdnoise (c) 2021 Stefan Gustavson and Ian McEwan. Published under the MIT license.
+ * @see https://github.com/stegu/psrdnoise/
+ * @type {CodeChunk}
+ */
+export const chunk_psrdnoise3_kernel = CodeChunk.from(
+    //language=WGSL
+    `
+fn psrdnoise3_kernel(
+    ix: vec4<f32>,
+    iy: vec4<f32>,
+    iz: vec4<f32>,
+    x0: vec3<f32>,
+    x1: vec3<f32>,
+    x2: vec3<f32>,
+    x3: vec3<f32>,
+    alpha: f32
+) -> vec4<f32> {
+    // one pseudo-random value per corner. Folding one axis in between each permutation is what
+    // makes the three coordinates a single hash rather than three independent ones
+    let hash = psrdnoise3_permute(psrdnoise3_permute(psrdnoise3_permute(iz) + iy) + ix);
+
+    // read the hash as a point on a Fibonacci spiral over the unit sphere
+    let theta = hash * 3.883222077;             // 2*pi / golden ratio, the spiral's turn per step
+    let sz = hash * -0.006920415 + 0.996539792; // height, 1 - (hash + 0.5) * 2/289
+    let psi = hash * 0.108705628;               // 10*pi/289, a rotation phase chosen not to
+                                                // correlate with theta
+
+    let ct = cos(theta);
+    let st = sin(theta);
+    let sz_prime = sqrt(1.0 - sz * sz);         // the spiral point's radius off the axis
+
+    var gx: vec4<f32>;
+    var gy: vec4<f32>;
+    var gz: vec4<f32>;
+
+    if (alpha != 0.0) {
+        // rotate the spiral point s by alpha about a pseudo-random axis orthogonal to it. p is s
+        // itself and q is the orthogonal direction that psi picks out, so (p, q) spans the plane
+        // of rotation and the gradient is just cos(alpha)*p + sin(alpha)*q
+        let sp = sin(psi);
+        let cp = cos(psi);
+
+        let px = ct * sz_prime;
+        let py = st * sz_prime;
+        let pz = sz;
+
+        let ctp = st * sp - ct * cp;
+        let qx = mix(ctp * st, sp, sz);
+        let qy = mix(-ctp * ct, cp, sz);
+        let qz = -(py * cp + px * sp);
+
+        let sa = sin(alpha);
+        let ca = cos(alpha);
+
+        gx = ca * px + sa * qx;
+        gy = ca * py + sa * qy;
+        gz = ca * pz + sa * qz;
+    } else {
+        // no rotation asked for, so the spiral point is the gradient
+        gx = ct * sz_prime;
+        gy = st * sz_prime;
+        gz = sz;
+    }
+
+    let g0 = vec3<f32>(gx.x, gy.x, gz.x);
+    let g1 = vec3<f32>(gx.y, gy.y, gz.y);
+    let g2 = vec3<f32>(gx.z, gy.z, gz.z);
+    let g3 = vec3<f32>(gx.w, gy.w, gz.w);
+
+    // radial decay with distance from each corner. 0.5 is the squared radius of each corner's
+    // support: far enough that the four of them cover the cell between them, near enough that no
+    // corner outside the simplex ever reaches into it
+    let w = max(0.5 - vec4<f32>(dot(x0, x0), dot(x1, x1), dot(x2, x2), dot(x3, x3)), vec4<f32>(0.0));
+    let w2 = w * w;
+    let w3 = w2 * w;
+
+    // the linear ramp from each corner
+    let gdotx = vec4<f32>(dot(g0, x0), dot(g1, x1), dot(g2, x2), dot(g3, x3));
+
+    let n = dot(w3, gdotx);
+
+    // d/dx of w^3 * (g . x), by the product rule. d(w^3) = 3*w^2 * d(w), and d(w) = -2*x
+    let dw = -6.0 * w2 * gdotx;
+    let dn0 = w3.x * g0 + dw.x * x0;
+    let dn1 = w3.y * g1 + dw.y * x1;
+    let dn2 = w3.z * g2 + dw.z * x2;
+    let dn3 = w3.w * g3 + dw.w * x3;
+
+    // 39.5 scales the sum to fill [-1, 1]; the same factor applies to the derivative
+    return vec4<f32>(n, dn0 + dn1 + dn2 + dn3) * 39.5;
+}
+    `, [
+        chunk_psrdnoise3_permute,
+    ]
+);

package/src/shade/renderer/shader/chunk/noise/psrdnoise/chunk_psrdnoise3_permute.d.ts

@@ -0,0 +1,21 @@
+/**
+ * The permutation polynomial behind the 3-D psrdnoise hash, applied to four lattice coordinates at
+ * once.
+ *
+ * `x ↦ (34x + 10)x mod 289` is a bijection on `[0, 289)`, which is what makes it a *permutation*
+ * and not merely a hash: no two lattice coordinates collide, so no two corners of a cell can be
+ * handed the same gradient. Nesting it three times, folding in one axis between each, extends that
+ * to three dimensions — see {@link chunk_psrdnoise3_kernel} for the nesting.
+ *
+ * 289 is 17², and the modulus is what bounds the period of the noise field: coordinates congruent
+ * modulo 289 hash the same, so the field repeats every 289 cells whether or not a period was asked
+ * for. The coefficients are sized to keep `(34x + 10)x` inside the range an `f32` represents
+ * exactly, which is why the modulus cannot simply be made larger.
+ *
+ * psrdnoise (c) 2021 Stefan Gustavson and Ian McEwan. Published under the MIT license.
+ * @see https://github.com/stegu/psrdnoise/
+ * @type {CodeChunk}
+ */
+export const chunk_psrdnoise3_permute: CodeChunk;
+import { CodeChunk } from "../../../compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_psrdnoise3_permute.d.ts.map

package/src/shade/renderer/shader/chunk/noise/psrdnoise/chunk_psrdnoise3_permute.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_psrdnoise3_permute.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/noise/psrdnoise/chunk_psrdnoise3_permute.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;GAiBG;AACH,uCAFU,SAAS,CAejB;0BAlCwB,gCAAgC"}

package/src/shade/renderer/shader/chunk/noise/psrdnoise/chunk_psrdnoise3_permute.js

@@ -0,0 +1,35 @@
+import { CodeChunk } from "../../../compiler/CodeChunk.js";
+import { chunk_mod_v4f } from "../../math/chunk_mod_v4f.js";
+
+/**
+ * The permutation polynomial behind the 3-D psrdnoise hash, applied to four lattice coordinates at
+ * once.
+ *
+ * `x ↦ (34x + 10)x mod 289` is a bijection on `[0, 289)`, which is what makes it a *permutation*
+ * and not merely a hash: no two lattice coordinates collide, so no two corners of a cell can be
+ * handed the same gradient. Nesting it three times, folding in one axis between each, extends that
+ * to three dimensions — see {@link chunk_psrdnoise3_kernel} for the nesting.
+ *
+ * 289 is 17², and the modulus is what bounds the period of the noise field: coordinates congruent
+ * modulo 289 hash the same, so the field repeats every 289 cells whether or not a period was asked
+ * for. The coefficients are sized to keep `(34x + 10)x` inside the range an `f32` represents
+ * exactly, which is why the modulus cannot simply be made larger.
+ *
+ * psrdnoise (c) 2021 Stefan Gustavson and Ian McEwan. Published under the MIT license.
+ * @see https://github.com/stegu/psrdnoise/
+ * @type {CodeChunk}
+ */
+export const chunk_psrdnoise3_permute = CodeChunk.from(
+    //language=WGSL
+    `
+fn psrdnoise3_permute(
+    x: vec4<f32>
+) -> vec4<f32> {
+    let xm = mod_v4f(x, 289.0);
+
+    return mod_v4f((xm * 34.0 + 10.0) * xm, 289.0);
+}
+    `, [
+        chunk_mod_v4f,
+    ]
+);

package/src/shade/renderer/shader/chunk/noise/psrdnoise/chunk_psrdnoise3_skew.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Texture space to 3-D psrdnoise simplex space.
+ *
+ * The transform `M = [[0,1,1],[1,0,1],[1,1,0]]`, written out. `det(M) = 2`, so the lattice it
+ * generates carries two points per unit cube of texture space — the body-centred cubic lattice that
+ * every tetrahedral simplex noise uses, but here *axis-aligned* with the space being sampled rather
+ * than skewed away from it. That alignment is the whole reason this noise can be given a rectangular
+ * period at all: a wrap applied to the texture-space corners maps back onto the lattice cleanly,
+ * which it does not when the lattice sits at an angle to the axes the period is expressed in.
+ *
+ * {@link chunk_psrdnoise3_unskew} is the inverse.
+ *
+ * psrdnoise (c) 2021 Stefan Gustavson and Ian McEwan. Published under the MIT license.
+ * @see https://github.com/stegu/psrdnoise/
+ * @type {CodeChunk}
+ */
+export const chunk_psrdnoise3_skew: CodeChunk;
+import { CodeChunk } from "../../../compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_psrdnoise3_skew.d.ts.map

package/src/shade/renderer/shader/chunk/noise/psrdnoise/chunk_psrdnoise3_skew.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_psrdnoise3_skew.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/noise/psrdnoise/chunk_psrdnoise3_skew.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;GAeG;AACH,oCAFU,SAAS,CAWjB;0BA3BwB,gCAAgC"}

package/src/shade/renderer/shader/chunk/noise/psrdnoise/chunk_psrdnoise3_skew.js

@@ -0,0 +1,28 @@
+import { CodeChunk } from "../../../compiler/CodeChunk.js";
+
+/**
+ * Texture space to 3-D psrdnoise simplex space.
+ *
+ * The transform `M = [[0,1,1],[1,0,1],[1,1,0]]`, written out. `det(M) = 2`, so the lattice it
+ * generates carries two points per unit cube of texture space — the body-centred cubic lattice that
+ * every tetrahedral simplex noise uses, but here *axis-aligned* with the space being sampled rather
+ * than skewed away from it. That alignment is the whole reason this noise can be given a rectangular
+ * period at all: a wrap applied to the texture-space corners maps back onto the lattice cleanly,
+ * which it does not when the lattice sits at an angle to the axes the period is expressed in.
+ *
+ * {@link chunk_psrdnoise3_unskew} is the inverse.
+ *
+ * psrdnoise (c) 2021 Stefan Gustavson and Ian McEwan. Published under the MIT license.
+ * @see https://github.com/stegu/psrdnoise/
+ * @type {CodeChunk}
+ */
+export const chunk_psrdnoise3_skew = CodeChunk.from(
+    //language=WGSL
+    `
+fn psrdnoise3_skew(
+    x: vec3<f32>
+) -> vec3<f32> {
+    return vec3<f32>(x.y + x.z, x.z + x.x, x.x + x.y);
+}
+    `
+);

package/src/shade/renderer/shader/chunk/noise/psrdnoise/chunk_psrdnoise3_unskew.d.ts

@@ -0,0 +1,13 @@
+/**
+ * 3-D psrdnoise simplex space back to texture space — the inverse of {@link chunk_psrdnoise3_skew}.
+ *
+ * `M⁻¹ = [[-0.5,0.5,0.5],[0.5,-0.5,0.5],[0.5,0.5,-0.5]]`, written out. Its inputs are always
+ * integer lattice coordinates and the factor is a power of two, so every operation here is exact.
+ *
+ * psrdnoise (c) 2021 Stefan Gustavson and Ian McEwan. Published under the MIT license.
+ * @see https://github.com/stegu/psrdnoise/
+ * @type {CodeChunk}
+ */
+export const chunk_psrdnoise3_unskew: CodeChunk;
+import { CodeChunk } from "../../../compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_psrdnoise3_unskew.d.ts.map

package/src/shade/renderer/shader/chunk/noise/psrdnoise/chunk_psrdnoise3_unskew.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_psrdnoise3_unskew.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/noise/psrdnoise/chunk_psrdnoise3_unskew.js"],"names":[],"mappings":"AAEA;;;;;;;;;GASG;AACH,sCAFU,SAAS,CAWjB;0BArBwB,gCAAgC"}

package/src/shade/renderer/shader/chunk/noise/psrdnoise/chunk_psrdnoise3_unskew.js

@@ -0,0 +1,22 @@
+import { CodeChunk } from "../../../compiler/CodeChunk.js";
+
+/**
+ * 3-D psrdnoise simplex space back to texture space — the inverse of {@link chunk_psrdnoise3_skew}.
+ *
+ * `M⁻¹ = [[-0.5,0.5,0.5],[0.5,-0.5,0.5],[0.5,0.5,-0.5]]`, written out. Its inputs are always
+ * integer lattice coordinates and the factor is a power of two, so every operation here is exact.
+ *
+ * psrdnoise (c) 2021 Stefan Gustavson and Ian McEwan. Published under the MIT license.
+ * @see https://github.com/stegu/psrdnoise/
+ * @type {CodeChunk}
+ */
+export const chunk_psrdnoise3_unskew = CodeChunk.from(
+    //language=WGSL
+    `
+fn psrdnoise3_unskew(
+    i: vec3<f32>
+) -> vec3<f32> {
+    return 0.5 * vec3<f32>(i.y + i.z - i.x, i.z + i.x - i.y, i.x + i.y - i.z);
+}
+    `
+);

package/src/shade/renderer/shader/chunk/noise/psrdnoise/chunk_srdnoise2.d.ts

@@ -0,0 +1,22 @@
+/**
+ * 2-D simplex noise with rotating gradients and an analytic derivative — `psrdnoise` without the
+ * `p`, for fields that never need to tile.
+ *
+ * Returns `vec3(noise, gradient.x, gradient.y)`: the noise value is in `.x`, in `[-1, 1]`, and
+ * `.yz` is its exact gradient. Ask for only `.x` and the compiler drops the derivative.
+ *
+ * `alpha` turns every gradient in the field by that many radians. Animating it swirls the pattern
+ * in place — see {@link chunk_psrdnoise2_kernel} for what that buys and why it is nearly free.
+ *
+ * This is {@link chunk_psrdnoise2} with the wrap deleted, not a call into it with a zero period: it
+ * exists so a caller whose period is a runtime value it never sets does not pay for the branch and
+ * the modulo. It still repeats every 289 cells — that is the hash's modulus, not a choice — so it
+ * is "non-periodic" only in the sense that it does not tile to a period you name.
+ *
+ * psrdnoise (c) 2021 Stefan Gustavson and Ian McEwan. Published under the MIT license.
+ * @see https://github.com/stegu/psrdnoise/
+ * @type {CodeChunk}
+ */
+export const chunk_srdnoise2: CodeChunk;
+import { CodeChunk } from "../../../compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_srdnoise2.d.ts.map

package/src/shade/renderer/shader/chunk/noise/psrdnoise/chunk_srdnoise2.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_srdnoise2.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/noise/psrdnoise/chunk_srdnoise2.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;GAkBG;AACH,8BAFU,SAAS,CAsCjB;0BA1DwB,gCAAgC"}

package/src/shade/renderer/shader/chunk/noise/psrdnoise/chunk_srdnoise2.js

@@ -0,0 +1,59 @@
+import { CodeChunk } from "../../../compiler/CodeChunk.js";
+import { chunk_psrdnoise2_kernel } from "./chunk_psrdnoise2_kernel.js";
+
+/**
+ * 2-D simplex noise with rotating gradients and an analytic derivative — `psrdnoise` without the
+ * `p`, for fields that never need to tile.
+ *
+ * Returns `vec3(noise, gradient.x, gradient.y)`: the noise value is in `.x`, in `[-1, 1]`, and
+ * `.yz` is its exact gradient. Ask for only `.x` and the compiler drops the derivative.
+ *
+ * `alpha` turns every gradient in the field by that many radians. Animating it swirls the pattern
+ * in place — see {@link chunk_psrdnoise2_kernel} for what that buys and why it is nearly free.
+ *
+ * This is {@link chunk_psrdnoise2} with the wrap deleted, not a call into it with a zero period: it
+ * exists so a caller whose period is a runtime value it never sets does not pay for the branch and
+ * the modulo. It still repeats every 289 cells — that is the hash's modulus, not a choice — so it
+ * is "non-periodic" only in the sense that it does not tile to a period you name.
+ *
+ * psrdnoise (c) 2021 Stefan Gustavson and Ian McEwan. Published under the MIT license.
+ * @see https://github.com/stegu/psrdnoise/
+ * @type {CodeChunk}
+ */
+export const chunk_srdnoise2 = CodeChunk.from(
+    //language=WGSL
+    `
+fn srdnoise2(
+    x: vec2<f32>,
+    alpha: f32
+) -> vec3<f32> {
+    // into simplex space — an axis-aligned hexagonal grid, stretched in y so it can tile
+    let uv = vec2<f32>(x.x + x.y * 0.5, x.y);
+
+    // which simplex we are in. i0 is the base corner, o1 the offset to the second: the cell is a
+    // rhombus split along its diagonal, and which half we are in decides which corner joins
+    let i0 = floor(uv);
+    let f0 = uv - i0;
+    let o1 = select(vec2<f32>(0.0, 1.0), vec2<f32>(1.0, 0.0), f0.x > f0.y);
+
+    let i1 = i0 + o1;
+    let i2 = i0 + vec2<f32>(1.0);
+
+    // the three corners back in texture space
+    let v0 = vec2<f32>(i0.x - i0.y * 0.5, i0.y);
+    let v1 = vec2<f32>(v0.x + o1.x - o1.y * 0.5, v0.y + o1.y);
+    let v2 = vec2<f32>(v0.x + 0.5, v0.y + 1.0);
+
+    return psrdnoise2_kernel(
+        vec3<f32>(i0.x, i1.x, i2.x),
+        vec3<f32>(i0.y, i1.y, i2.y),
+        x - v0,
+        x - v1,
+        x - v2,
+        alpha
+    );
+}
+    `, [
+        chunk_psrdnoise2_kernel,
+    ]
+);