@woosh/meep-engine 3.16.0 → 3.17.0

package/src/shade/renderer/particles/graph/groups/particle_groups_psrdnoise.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Simplex noise whose gradients turn with `alpha`, with its exact derivative, and no period.
+ *
+ * `psrdnoise3` with the wrap deleted, which is what the missing `if` costs — see the note at the top
+ * of this file. It still repeats every 289 cells, because that is the hash's modulus rather than a
+ * choice; "non-periodic" here means only that it does not tile to a period you name.
+ *
+ * @type {import("../ParticleNodeGroup.js").ParticleNodeGroup}
+ */
+export const PARTICLE_GROUP_SRDNOISE_3: import("../ParticleNodeGroup.js").ParticleNodeGroup;
+/**
+ * The same field, tiling to a period you give it.
+ *
+ * Any whole period up to 289 works on each axis independently; an axis at or below zero does not
+ * wrap, and all three at zero is {@link PARTICLE_GROUP_SRDNOISE_3} computed the long way — use that
+ * node instead, it is the cheaper one. 289 is a hard ceiling, being the hash's modulus: a longer
+ * period does not tile, it repeats inside itself.
+ *
+ * @type {import("../ParticleNodeGroup.js").ParticleNodeGroup}
+ */
+export const PARTICLE_GROUP_PSRDNOISE_3: import("../ParticleNodeGroup.js").ParticleNodeGroup;
+//# sourceMappingURL=particle_groups_psrdnoise.d.ts.map

package/src/shade/renderer/particles/graph/groups/particle_groups_psrdnoise.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"particle_groups_psrdnoise.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/particles/graph/groups/particle_groups_psrdnoise.js"],"names":[],"mappings":"AAwbA;;;;;;;;GAQG;AACH,wCAFU,OAAO,yBAAyB,EAAE,iBAAiB,CA4BxD;AAEL;;;;;;;;;GASG;AACH,yCAFU,OAAO,yBAAyB,EAAE,iBAAiB,CA+BxD"}

package/src/shade/renderer/particles/graph/groups/particle_groups_psrdnoise.js

@@ -0,0 +1,517 @@
+import { ParticleGroupBuilder } from "../ParticleGroupBuilder.js";
+import { PARTICLE_TYPE_F32, PARTICLE_TYPE_VEC3 } from "../ParticleValueType.js";
+
+/**
+ * psrdnoise: simplex noise with rotating gradients, an exact derivative, and an optional period.
+ *
+ * The engine already has this as a shader chunk — see
+ * {@link ../../../shader/chunk/noise/psrdnoise/chunk_psrdnoise3.js} — and this is the same function
+ * for the particle VM, transcribed from the same source. Three things separate it from the
+ * {@link ./particle_groups_noise.js simplex noise} already here, and each of them is a reason to
+ * spend the instructions:
+ *
+ * - **The gradient comes out with the value.** `w³·(g·x)` differentiates by the product rule into
+ *   things already computed, so the derivative is a handful of multiply-adds rather than three more
+ *   evaluations. A curl built on this needs *two* samples where {@link ./particle_groups_noise.js
+ *   curl3} needs twelve, which is the difference between a curl an UPDATE graph can afford and one
+ *   it cannot.
+ * - **The gradients are a spiral, not a table.** Classic simplex noise picks each corner's gradient
+ *   out of a small fixed set, and the set's directions show up in the field as faint preferred axes.
+ *   Here the hash is read as a point on a Fibonacci spiral over the unit sphere: 289 directions, no
+ *   axis favoured.
+ * - **`alpha` turns the gradients.** Animate it and the field swirls in place instead of sliding
+ *   past — flow noise, which is a different thing from noise sampled at a moving point.
+ *
+ * psrdnoise (c) 2021 Stefan Gustavson and Ian McEwan. Published under the MIT license.
+ * @see https://github.com/stegu/psrdnoise/
+ *
+ * ## What the VM's lack of control flow costs, and what it does not
+ *
+ * The shader has two branches and neither survives here, but only one of them was worth anything.
+ *
+ * `alpha == 0` takes a shortcut in the shader that skips the rotation. The general path *is* that
+ * shortcut when `alpha` is zero — `cos(0)` is 1 and `sin(0)` is 0, so the gradient comes out the
+ * spiral point unchanged — so it is written once, always, and is exactly right either way. The
+ * shortcut only ever bought speed, and only when a whole warp agreed on it; here there are no warps
+ * and no branches for them to agree about.
+ *
+ * The per-axis wrap, `if (period.x > 0.0)`, becomes arithmetic. Multiplying by `1/period` — with the
+ * reciprocal set to **zero** where no period was asked for — makes the wrap `v - floor(v·0)·p`,
+ * which is `v`. So it always runs, does nothing when it is not wanted, and has no divide by zero to
+ * guard: the reciprocal is built once, up front, out of a comparison against zero.
+ *
+ * The outer `if (any(period > 0.0))`, which skips the whole wrap, has no branchless equivalent worth
+ * having. It becomes a *second node*: {@link PARTICLE_GROUP_SRDNOISE_3} is this function with the
+ * wrap deleted, exactly as `chunk_srdnoise3` is. That is the adaptation the missing control flow
+ * actually forces, and it is the one upstream made for the same reason.
+ *
+ * ## Why it is written transposed, and where it stops being
+ *
+ * The four corners' lattice coordinates are carried as three `vec4`s — all four x coordinates, then
+ * all four y, then all four z — rather than as four `vec3`s. That is the layout the hash wants (one
+ * permutation of four corners at once, not four of one), and the layout the wrap wants too: skewing,
+ * unskewing and wrapping are all element-wise in it, so each is three `vec4` instructions instead of
+ * four `vec3` ones plus the shuffling between.
+ *
+ * The corner *offsets* are the other way round, one corner at a time, because that half is a sum
+ * over corners and holding four of everything through it is what would put this over the register
+ * file. Same reasoning as the note on the subject in {@link ./particle_groups_noise.js}.
+ *
+ * The periodic node needs one more turn of that screw, and it is not about *when* things are built —
+ * the compiler emits a value where it is first read, not where it was written down — but about
+ * whether they are built **twice**. Skewing is element-wise in the transposed layout, so each of the
+ * three wrapped lattice axes wants two of the three wrapped texture axes, and computing the three
+ * texture axes once and sharing them keeps twelve registers alive across the whole wrap. Computing
+ * each one where it is used, six times for three distinct values, keeps two alive instead of three
+ * and gives every one of them a live range a few instructions long. That trade — a third again as
+ * much arithmetic for eight slots — is the difference between a node that compiles and a node that
+ * reports it has run out of registers, which is the only exchange rate that matters at 48 slots.
+ */
+
+/**
+ * The permutation polynomial's modulus: 17², and the period every psrdnoise field has whether or not
+ * one was asked for.
+ * @type {number}
+ */
+const PERMUTE_MODULUS = 289;
+
+/**
+ * How much a corner's ramp is scaled to fill `[-1, 1]`. Upstream's number, and it applies to the
+ * derivative as well as to the value.
+ * @type {number}
+ */
+const NOISE_SCALE = 39.5;
+
+/**
+ * The squared radius of a corner's support: far enough that the four corners cover the cell between
+ * them, near enough that no corner outside it ever reaches in.
+ * @type {number}
+ */
+const CORNER_SUPPORT = 0.5;
+
+/**
+ * `x mod 289`, without a modulo opcode: `x - floor(x / 289) * 289`.
+ *
+ * Divided rather than multiplied by a reciprocal, unlike the `mod289` in
+ * {@link ./particle_groups_noise.js}. It costs the same — one instruction, and 289 is then the same
+ * interned word both times — and a divide is correctly rounded where `x * fround(1/289)` rounds
+ * twice. The result decides which gradient a corner is handed, so the cheaper spelling would be
+ * paying in the one currency this function cannot spend.
+ *
+ * @param {ParticleGroupBuilder} g
+ * @param {*} x
+ * @returns {*}
+ */
+function mod289(g, x) {
+    return g.sub(x, g.mul(g.floor(g.div(x, g.f(PERMUTE_MODULUS))), g.f(PERMUTE_MODULUS)));
+}
+
+/**
+ * The permutation: `(34x + 10)x mod 289`, over four corners at once.
+ *
+ * A bijection on `[0, 289)` rather than merely a hash — no two lattice coordinates collide, so no
+ * two corners of a cell are handed the same gradient. Its input is reduced first, which is what
+ * keeps `(34x + 10)x` inside the range an `f32` holds exactly.
+ *
+ * @param {ParticleGroupBuilder} g
+ * @param {*} x
+ * @returns {*}
+ */
+function permute(g, x) {
+    const reduced = mod289(g, x);
+
+    return mod289(g, g.mul(g.mad(reduced, g.f(34), g.f(10)), reduced));
+}
+
+/**
+ * Texture space to psrdnoise's simplex space: `(y + z, z + x, x + y)`.
+ *
+ * The lattice this generates is axis-aligned with the space being sampled rather than skewed away
+ * from it, which is the whole reason a rectangular period can be imposed on this noise at all.
+ *
+ * @param {ParticleGroupBuilder} g
+ * @param {*} v a `vec3`
+ * @returns {*} a `vec3`
+ */
+function skew(g, v) {
+    return g.vec3(
+        g.add(g.y(v), g.z(v)),
+        g.add(g.z(v), g.x(v)),
+        g.add(g.x(v), g.y(v))
+    );
+}
+
+/**
+ * Simplex space back to texture space: `0.5 * (y + z - x, z + x - y, x + y - z)`, the inverse of
+ * {@link skew}. Its inputs here are always integers and the factor is a power of two, so it is
+ * exact.
+ *
+ * @param {ParticleGroupBuilder} g
+ * @param {*} i a `vec3`
+ * @returns {*} a `vec3`
+ */
+function unskew(g, i) {
+    const half = axis => g.mul(axis, g.f(0.5));
+
+    return g.vec3(
+        half(g.sub(g.add(g.y(i), g.z(i)), g.x(i))),
+        half(g.sub(g.add(g.z(i), g.x(i)), g.y(i))),
+        half(g.sub(g.add(g.x(i), g.y(i)), g.z(i)))
+    );
+}
+
+/**
+ * Where the sample point is, in terms of the simplex it falls in.
+ *
+ * `i0` is the base corner of the skewed cell, and `o1` and `o2` are the two steps from it to the
+ * second and third corners — the point's coordinates inside the cell, rank-ordered, since the
+ * descending order of the fractional parts is the order the tetrahedron's corners are walked in. The
+ * fourth corner is always `i0 + 1`.
+ *
+ * The same three steps are then carried in texture space as well, unskewed. `base` is where the
+ * cell's own corner sits, `step1` and `step2` are how far the second and third are from it, and the
+ * fourth is half a unit along every axis whatever the cell is. Both halves are wanted: the lattice
+ * coordinates are what gets hashed, and the texture-space ones are what the corner offsets and the
+ * wrap are measured in. Carrying them as a base and two steps rather than as four positions is what
+ * keeps this to nine registers instead of twelve.
+ *
+ * @param {ParticleGroupBuilder} g
+ * @param {*} x the sample point, a `vec3`
+ * @returns {{i0: *, o1: *, o2: *, base: *, step1: *, step2: *, offset: function(number):*}}
+ */
+function simplex_of(g, x) {
+    const uvw = skew(g, x);
+
+    const i0 = g.floor(uvw);
+    const f0 = g.sub(uvw, i0);
+
+    const gt_ = g.step(g.swz(f0, "xyx"), g.swz(f0, "yzz"));
+    const lt_ = g.sub(g.f(1), gt_);
+
+    const gt = g.vec3(g.z(lt_), g.x(gt_), g.y(gt_));
+    const lt = g.vec3(g.x(lt_), g.y(lt_), g.z(gt_));
+
+    const o1 = g.min(gt, lt);
+    const o2 = g.max(gt, lt);
+
+    const base = unskew(g, i0);
+    const step1 = unskew(g, o1);
+    const step2 = unskew(g, o2);
+
+    // The vector from the cell's own corner to the point, which every corner offset is that minus
+    // the corner's own step. Taken here so that `x` and `base` both die before the hash begins.
+    const from_base = g.sub(x, base);
+
+    return {
+        i0,
+        o1,
+        o2,
+        base,
+        step1,
+        step2,
+
+        /**
+         * The vector from one corner to the sample point.
+         *
+         * Four separate values, each read once, so only one is ever live: what is shared between
+         * them — `from_base` — is three registers rather than twelve.
+         *
+         * @param {number} corner 0 to 3
+         * @returns {*} a `vec3`
+         */
+        offset: corner => [
+            () => from_base,
+            () => g.sub(from_base, step1),
+            () => g.sub(from_base, step2),
+            () => g.sub(from_base, g.f(0.5)),
+        ][corner](),
+    };
+}
+
+/**
+ * One axis of the four corners' lattice coordinates, as a `vec4`: `i0`, `i0 + o1`, `i0 + o2` and
+ * `i0 + 1`, all in one lane of the cell.
+ *
+ * @param {ParticleGroupBuilder} g
+ * @param {{i0: *, o1: *, o2: *}} simplex
+ * @param {string} axis `"x"`, `"y"` or `"z"`
+ * @returns {*} a `vec4`
+ */
+function lattice_axis(g, simplex, axis) {
+    const steps = g.vec4(g.f(0), g.swz(simplex.o1, axis), g.swz(simplex.o2, axis), g.f(1));
+
+    return g.add(g.swz(simplex.i0, axis), steps);
+}
+
+/**
+ * One axis of the four corners' positions in *texture* space, as a `vec4`, wrapped to that axis's
+ * period.
+ *
+ * The wrap has to happen here rather than in simplex space, because it is here that the period is a
+ * rectangle. `reciprocal` is `1/period` where a period was asked for and zero where it was not,
+ * which is what makes one expression cover both: `v - floor(v·0)·p` is `v`.
+ *
+ * @param {ParticleGroupBuilder} g
+ * @param {{base: *, step1: *, step2: *}} simplex
+ * @param {*} period a `vec3`
+ * @param {*} reciprocal a `vec3`
+ * @param {string} axis
+ * @returns {*} a `vec4`
+ */
+function wrapped_texture_axis(g, simplex, period, reciprocal, axis) {
+    const corners = g.vec4(
+        g.f(0),
+        g.swz(simplex.step1, axis),
+        g.swz(simplex.step2, axis),
+        // the fourth corner is `i0 + 1` in simplex space, which unskews to half a unit along every
+        // axis — a constant, whatever cell this is
+        g.f(0.5)
+    );
+
+    const v = g.add(g.swz(simplex.base, axis), corners);
+
+    return g.sub(v, g.mul(g.floor(g.mul(v, g.swz(reciprocal, axis))), g.swz(period, axis)));
+}
+
+/**
+ * One axis of the four corners' lattice coordinates after the wrap: the wrapped texture-space
+ * corners, skewed back.
+ *
+ * Skewing is element-wise in this layout — the x of `skew(v)` is `v.y + v.z` — so one axis of the
+ * answer wants two axes of the input, and this builds both of them rather than being handed all
+ * three. Two axes alive instead of three is four registers, and the third would have to stay alive
+ * across a permutation to be worth keeping. The `+ 0.5` under the floor is a round-to-nearest: the
+ * wrap leaves a corner a hair off the integer it should be, and truncating would drop it into the
+ * neighbouring cell.
+ *
+ * Only the hash inputs move. The offsets the kernel sums are measured from the *unwrapped* corners,
+ * which is what keeps the field continuous across the seam.
+ *
+ * @param {ParticleGroupBuilder} g
+ * @param {{base: *, step1: *, step2: *}} simplex
+ * @param {*} period
+ * @param {*} reciprocal
+ * @param {string} axis
+ * @returns {*} a `vec4`
+ */
+function wrapped_lattice_axis(g, simplex, period, reciprocal, axis) {
+    const [first, second] = { x: ["y", "z"], y: ["z", "x"], z: ["x", "y"] }[axis];
+
+    const sum = g.add(
+        wrapped_texture_axis(g, simplex, period, reciprocal, first),
+        wrapped_texture_axis(g, simplex, period, reciprocal, second)
+    );
+
+    return g.floor(g.add(sum, g.f(0.5)));
+}
+
+/**
+ * `1/period` per axis, and zero on an axis with no period — see {@link wrapped_texture_axis}.
+ *
+ * `max(period, 1)` only keeps the divide honest on the axes whose answer is about to be multiplied
+ * by zero anyway; the comparison is what decides.
+ *
+ * @param {ParticleGroupBuilder} g
+ * @param {*} period a `vec3`
+ * @returns {*} a `vec3`
+ */
+function period_reciprocal(g, period) {
+    return g.div(g.op("compare", [period, g.f(0)], { op: "gt" }), g.max(period, g.f(1)));
+}
+
+/**
+ * One corner's gradient, read off its hash.
+ *
+ * The hash is a position on a Fibonacci spiral over the unit sphere — `theta` around it, `sz` up —
+ * and `alpha` then turns that point by that many radians about a pseudo-random axis orthogonal to
+ * it, which `psi` picks out. `p` is the spiral point and `q` the orthogonal direction, so the two
+ * span the plane of the rotation and the answer is `cos(alpha)·p + sin(alpha)·q`.
+ *
+ * At `alpha == 0` that is `p` exactly, which is why there is no branch — see the note at the top of
+ * this file.
+ *
+ * @param {ParticleGroupBuilder} g
+ * @param {*} hash one corner's hashed index, a scalar in `[0, 289)`
+ * @param {{sin: *, cos: *}} rotation `alpha`'s sine and cosine, taken once for all four corners
+ * @returns {*} a `vec3` unit gradient
+ */
+function corner_gradient(g, hash, rotation) {
+    // 2*pi / the golden ratio: the spiral's turn per step
+    const theta = g.mul(hash, g.f(3.883222077));
+    // the point's height on the sphere, 1 - (hash + 0.5) * 2/289
+    const sz = g.mad(hash, g.f(-0.006920415), g.f(0.996539792));
+    // 10*pi/289 — a rotation phase chosen not to correlate with theta
+    const psi = g.mul(hash, g.f(0.108705628));
+
+    const ct = g.cos(theta);
+    const st = g.sin(theta);
+
+    // the spiral point's radius off the axis
+    const radius = g.sqrt(g.sub(g.f(1), g.mul(sz, sz)));
+
+    const sp = g.sin(psi);
+    const cp = g.cos(psi);
+
+    const px = g.mul(ct, radius);
+    const py = g.mul(st, radius);
+    const pz = sz;
+
+    const ctp = g.sub(g.mul(st, sp), g.mul(ct, cp));
+
+    const qx = g.mix(g.mul(ctp, st), sp, sz);
+    const qy = g.mix(g.neg(g.mul(ctp, ct)), cp, sz);
+    const qz = g.neg(g.add(g.mul(py, cp), g.mul(px, sp)));
+
+    return g.vec3(
+        g.mad(rotation.cos, px, g.mul(rotation.sin, qx)),
+        g.mad(rotation.cos, py, g.mul(rotation.sin, qy)),
+        g.mad(rotation.cos, pz, g.mul(rotation.sin, qz))
+    );
+}
+
+/**
+ * The sum over corners: the noise value and its exact first derivative.
+ *
+ * Each corner contributes `w³·(g·x)`, where `w` is a radial falloff that reaches zero at the edge of
+ * that corner's support. The derivative is that product differentiated — `d(w³) = 3w²·dw` and
+ * `dw = -2x` — which is why it costs multiply-adds and no transcendentals at all: everything in it
+ * was computed for the value.
+ *
+ * `axis_of` is asked for z, then y, then x, and one at a time: the hash folds one axis in between
+ * each permutation, so an axis built up front would sit in registers waiting through work that does
+ * not need it. See the note about the transposed layout at the top of this file.
+ *
+ * @param {ParticleGroupBuilder} g
+ * @param {function(string):*} axis_of one axis of the four corners' lattice coordinates, as a `vec4`
+ * @param {function(number):*} offset_of the vector from corner `k` to the sample point
+ * @param {*} alpha
+ * @returns {{value: *, gradient: *}}
+ */
+function psrdnoise_kernel(g, axis_of, offset_of, alpha) {
+    // One value per corner. Folding one axis in between each permutation is what makes three
+    // coordinates a single hash rather than three independent ones.
+    let hash = permute(g, axis_of("z"));
+
+    hash = permute(g, g.add(hash, axis_of("y")));
+    hash = permute(g, g.add(hash, axis_of("x")));
+
+    // `alpha` is the same for every corner, so its sine and cosine are taken once.
+    const rotation = { sin: g.sin(alpha), cos: g.cos(alpha) };
+
+    let value = null;
+    let gradient = null;
+
+    ["x", "y", "z", "w"].forEach((lane, corner) => {
+        const direction = corner_gradient(g, g.swz(hash, lane), rotation);
+
+        const offset = offset_of(corner);
+
+        const w = g.max(g.sub(g.f(CORNER_SUPPORT), g.dot(offset, offset)), g.f(0));
+        const w2 = g.mul(w, w);
+        const w3 = g.mul(w2, w);
+
+        const ramp = g.dot(direction, offset);
+
+        const contribution = g.mul(w3, ramp);
+
+        const slope = g.add(
+            g.scale(direction, w3),
+            g.scale(offset, g.mul(g.mul(g.f(-6), w2), ramp))
+        );
+
+        value = value === null ? contribution : g.add(value, contribution);
+        gradient = gradient === null ? slope : g.add(gradient, slope);
+    });
+
+    return {
+        value: g.mul(value, g.f(NOISE_SCALE)),
+        gradient: g.scale(gradient, g.f(NOISE_SCALE)),
+    };
+}
+
+/**
+ * What both nodes produce.
+ * @type {Array<{name: string, type: import("../ParticleValueType.js").ParticleValueType}>}
+ */
+const NOISE_OUTPUTS = [
+    { name: "out", type: PARTICLE_TYPE_F32 },
+    { name: "gradient", type: PARTICLE_TYPE_VEC3 },
+];
+
+/**
+ * Simplex noise whose gradients turn with `alpha`, with its exact derivative, and no period.
+ *
+ * `psrdnoise3` with the wrap deleted, which is what the missing `if` costs — see the note at the top
+ * of this file. It still repeats every 289 cells, because that is the hash's modulus rather than a
+ * choice; "non-periodic" here means only that it does not tile to a period you name.
+ *
+ * @type {import("../ParticleNodeGroup.js").ParticleNodeGroup}
+ */
+export const PARTICLE_GROUP_SRDNOISE_3 = (() => {
+    const g = new ParticleGroupBuilder({
+        name: "srdnoise3",
+        label: "Flow Noise 3D",
+        icon: "M4 13c3-6 6 4 9-2s5-4 7-6 M4 20c3-6 6 4 9-2s5-4 7-6",
+        help: "noise whose gradients turn with alpha, plus its exact derivative — read both and it is most of the register file",
+        inputs: [
+            { name: "p", type: PARTICLE_TYPE_VEC3 },
+            { name: "alpha", type: PARTICLE_TYPE_F32 },
+        ],
+        outputs: NOISE_OUTPUTS,
+    });
+
+    const simplex = simplex_of(g, g.in.p);
+
+    const noise = psrdnoise_kernel(
+        g,
+        axis => lattice_axis(g, simplex, axis),
+        corner => simplex.offset(corner),
+        g.in.alpha
+    );
+
+    g.out("out", noise.value);
+    g.out("gradient", noise.gradient);
+
+    return g.build();
+})();
+
+/**
+ * The same field, tiling to a period you give it.
+ *
+ * Any whole period up to 289 works on each axis independently; an axis at or below zero does not
+ * wrap, and all three at zero is {@link PARTICLE_GROUP_SRDNOISE_3} computed the long way — use that
+ * node instead, it is the cheaper one. 289 is a hard ceiling, being the hash's modulus: a longer
+ * period does not tile, it repeats inside itself.
+ *
+ * @type {import("../ParticleNodeGroup.js").ParticleNodeGroup}
+ */
+export const PARTICLE_GROUP_PSRDNOISE_3 = (() => {
+    const g = new ParticleGroupBuilder({
+        name: "psrdnoise3",
+        label: "Tiling Flow Noise 3D",
+        icon: "M3 4h18v16H3z M6 11c2-4 4 3 6-1s3-3 6-4",
+        help: "flow noise that tiles to a whole period, per axis — expensive, and the wrap is not free",
+        inputs: [
+            { name: "p", type: PARTICLE_TYPE_VEC3 },
+            { name: "period", type: PARTICLE_TYPE_VEC3 },
+            { name: "alpha", type: PARTICLE_TYPE_F32 },
+        ],
+        outputs: NOISE_OUTPUTS,
+    });
+
+    const simplex = simplex_of(g, g.in.p);
+
+    const reciprocal = period_reciprocal(g, g.in.period);
+
+    const noise = psrdnoise_kernel(
+        g,
+        axis => wrapped_lattice_axis(g, simplex, g.in.period, reciprocal, axis),
+        corner => simplex.offset(corner),
+        g.in.alpha
+    );
+
+    g.out("out", noise.value);
+    g.out("gradient", noise.gradient);
+
+    return g.build();
+})();

package/src/shade/renderer/particles/graph/groups/simplex_reference.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"simplex_reference.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/particles/graph/groups/simplex_reference.js"],"names":[],"mappings":"AA+EA;;;;;GAKG;AACH,0CAHW,MAAM,EAAE,GACN,MAAM,CA2ElB"}
+{"version":3,"file":"simplex_reference.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/particles/graph/groups/simplex_reference.js"],"names":[],"mappings":"AAyGA;;;;;GAKG;AACH,0CAHW,MAAM,EAAE,GACN,MAAM,CA2ElB"}