sparcoon 0.9.1 → 0.9.3

package/dist/instancedParticle/FXTransformFeedbackParticle.js

@@ -0,0 +1,169 @@
+import { GLBufferAttribute, InstancedBufferGeometry, Mesh } from "three";
+/**
+ * @internal A `GLBufferAttribute` additionally declared instanced (divisor 1, one value per drawn
+ * particle instead of per vertex). Confirmed by reading `WebGLBindingStates.js:432-444`: the
+ * per-instance vertex-attribute divisor is driven by `isInstancedBufferAttribute`/
+ * `meshPerAttribute` on the attribute object itself - a plain `GLBufferAttribute` never sets
+ * either, so without this every particle's state would be read as per-VERTEX (one value shared
+ * by the whole base primitive) instead of per-INSTANCE.
+ */
+class FXGLInstancedBufferAttribute extends GLBufferAttribute {
+    constructor() {
+        super(...arguments);
+        this.isInstancedBufferAttribute = true;
+        this.meshPerAttribute = 1;
+    }
+}
+/**
+ * `InstancedBufferGeometry.setAttribute` is typed only for `BufferAttribute`/
+ * `InterleavedBufferAttribute` - its `Attributes` generic defaults to `NormalBufferAttributes`,
+ * and `InstancedBufferGeometry` itself is declared non-generic, so the wider
+ * `NormalOrGLBufferAttributes` union (which DOES include `GLBufferAttribute`) is unreachable
+ * through it at the type level, even though `GLBufferAttribute` is a real, three.js-documented
+ * attribute type for exactly this GPGPU use case. Narrow, isolated escape hatch - matches the
+ * existing three.js-typing-gap precedent in `FXInstancedParticle.invalidateInstanceCap`.
+ */
+function setInstancedGLAttribute(geometry, name, attribute) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    geometry.setAttribute(name, attribute);
+}
+/**
+ * @internal GPU-resident sibling of `FXInstancedParticle`: same instanced-mesh shape (one base
+ * primitive drawn `capacity` times, one property buffer per declared varying), but every property
+ * buffer is a **ping-pong pair** of raw `WebGLBuffer`s the transform-feedback simulation holder
+ * writes directly - never a `Float32Array`-backed `InstancedBufferAttribute` three.js uploads
+ * itself (`FXInstancedParticle`'s own mechanism, untouched). Capacity is fixed at construction, no
+ * growth: this class is never resized, unlike `FXInstancedParticle.ensureCapacity` (a deferred
+ * future extension, not required for correctness today). Every
+ * particle slot is always drawn (`instanceCount` is always `capacity`) - the CPU never knows the
+ * true live count for a GPU-driven emitter, so dead slots are hidden by the render shader's own
+ * age/lifetime test, not by shrinking the draw range.
+ */
+export class FXTransformFeedbackParticle extends Mesh {
+    constructor(gl, varyings, capacity, material, baseGeometry) {
+        const instancedGeometry = new InstancedBufferGeometry();
+        // Copy the base geometry's position/uv/normal + index onto the instanced geometry, same as
+        // FXInstancedParticle - these stay real, CPU-readable BufferAttributes (the base primitive's
+        // own shape, not per-particle state), borrowed by reference, never disposed here.
+        const baseIndex = baseGeometry.getIndex();
+        if (baseIndex !== null) {
+            instancedGeometry.setIndex(baseIndex);
+        }
+        instancedGeometry.setAttribute("position", baseGeometry.getAttribute("position"));
+        instancedGeometry.setAttribute("uv", baseGeometry.getAttribute("uv"));
+        instancedGeometry.setAttribute("normal", baseGeometry.getAttribute("normal"));
+        super(instancedGeometry, material);
+        this.propertyBuffers = {};
+        // Per-buffer-name ping-pong pair; `currentIndex[name]` (0 or 1) is which half is the currently
+        // valid, renderable side - the other half is what the transform-feedback pass writes into this
+        // tick. Never read and written by name in the same pass (see `readBuffer`/`writeBuffer`).
+        this.rawBufferPairs = {};
+        this.currentIndex = {};
+        this.strides = {};
+        this.frustumCulled = false;
+        this.gl = gl;
+        this.instancedGeometry = instancedGeometry;
+        this.capacity = capacity;
+        this.instancedGeometry.instanceCount = capacity;
+        for (const name in varyings) {
+            const { bufferSize } = varyings[name];
+            this.strides[name] = bufferSize;
+            const bufferA = this.createSizedBuffer(bufferSize, capacity);
+            const bufferB = this.createSizedBuffer(bufferSize, capacity);
+            this.rawBufferPairs[name] = [bufferA, bufferB];
+            this.currentIndex[name] = 0;
+            const attribute = new FXGLInstancedBufferAttribute(bufferA, gl.FLOAT, bufferSize, 4, capacity);
+            setInstancedGLAttribute(this.instancedGeometry, `a_${name}`, attribute);
+            this.propertyBuffers[name] = attribute;
+        }
+    }
+    /** The buffer transform feedback should bind as its `in` (read) source this tick - last tick's
+     *  result, or uninitialized garbage on the very first tick (safe: the assembled program's spawn
+     *  branch always zero-defaults every buffer before the graph's own writes, so a freshly claimed
+     *  slot never actually reads it before being overwritten). */
+    readBuffer(name) {
+        return this.rawBufferPairs[name][this.currentIndex[name]];
+    }
+    /** The buffer transform feedback should bind as its transform-feedback (write) target this tick
+     *  - the stale half of the pair, about to become current once `swapBuffers` runs. */
+    writeBuffer(name) {
+        return this.rawBufferPairs[name][this.currentIndex[name] === 0 ? 1 : 0];
+    }
+    /**
+     * Call once per state buffer after a tick's transform-feedback pass has finished writing
+     * `writeBuffer(name)`: flips which half is current, and replaces the whole attribute object on
+     * the geometry - never just `.setBuffer()` + `.needsUpdate` on the existing one. Confirmed by
+     * reading `WebGLBindingStates.needsUpdate()` (`WebGLBindingStates.js:166-209`): it decides
+     * whether to rebind a cached VAO's vertex-attribute pointers purely by comparing attribute
+     * OBJECT identity, never `.version`/`.buffer` - reusing the same attribute instance across a
+     * swap would leave the render draw silently bound to the FIRST buffer forever (independently
+     * confirmed against three.js issue #22843, which describes the identical root cause). Mirrors
+     * `FXInstancedParticle.ensureCapacity`, which replaces the whole `InstancedBufferAttribute` for
+     * the same reason - there discovered as an array-reallocation side effect, here load-bearing on
+     * its own since nothing about capacity itself ever changes.
+     */
+    swapBuffers(name) {
+        const nextIndex = this.currentIndex[name] === 0 ? 1 : 0;
+        this.currentIndex[name] = nextIndex;
+        const stride = this.strides[name];
+        const attribute = new FXGLInstancedBufferAttribute(this.rawBufferPairs[name][nextIndex], this.gl.FLOAT, stride, 4, this.capacity);
+        setInstancedGLAttribute(this.instancedGeometry, `a_${name}`, attribute);
+        this.propertyBuffers[name] = attribute;
+    }
+    drop() {
+        // No live-particle count to reset for a GPU-driven emitter (instanceCount is always
+        // `capacity`) - a reset instead means "everything currently alive should read as dead", which
+        // is the simulation holder's job (it owns dt/age, not this buffer-holding class).
+    }
+    /**
+     * Swaps the mounted material and base geometry in place for a render-only structural edit -
+     * every ping-pong state buffer and `capacity` are left completely untouched, so playback never
+     * resets. Never called when the varyings shape itself changed (the driver's own
+     * `applyRenderArtifact` guards that) - only the constructor path handles a real buffer-layout
+     * change.
+     */
+    replaceMaterialAndBaseGeometry(material, baseGeometry) {
+        // Detach the previous base attributes first, same as destroy()'s dance: they were borrowed by
+        // reference from a caller-owned geometry (possibly shared with other live consumers), so they
+        // must never be disposed here.
+        this.instancedGeometry.deleteAttribute("position");
+        this.instancedGeometry.deleteAttribute("uv");
+        this.instancedGeometry.deleteAttribute("normal");
+        this.instancedGeometry.setIndex(null);
+        const baseIndex = baseGeometry.getIndex();
+        if (baseIndex !== null) {
+            this.instancedGeometry.setIndex(baseIndex);
+        }
+        this.instancedGeometry.setAttribute("position", baseGeometry.getAttribute("position"));
+        this.instancedGeometry.setAttribute("uv", baseGeometry.getAttribute("uv"));
+        this.instancedGeometry.setAttribute("normal", baseGeometry.getAttribute("normal"));
+        // The mounted material IS disposable here (unlike the base geometry attributes above) - it was
+        // built exclusively for this mesh, never shared.
+        this.material?.dispose();
+        this.material = material;
+    }
+    // Disposes the instanced geometry, the currently mounted material, and every raw ping-pong
+    // buffer this instance owns - never the base geometry's borrowed position/uv/normal/index.
+    destroy() {
+        this.instancedGeometry.deleteAttribute("position");
+        this.instancedGeometry.deleteAttribute("uv");
+        this.instancedGeometry.deleteAttribute("normal");
+        this.instancedGeometry.setIndex(null);
+        this.instancedGeometry.dispose();
+        this.material?.dispose();
+        for (const name in this.rawBufferPairs) {
+            const [bufferA, bufferB] = this.rawBufferPairs[name];
+            this.gl.deleteBuffer(bufferA);
+            this.gl.deleteBuffer(bufferB);
+        }
+    }
+    createSizedBuffer(itemSize, count) {
+        const buffer = this.gl.createBuffer();
+        this.gl.bindBuffer(this.gl.ARRAY_BUFFER, buffer);
+        // Sized but uninitialized (garbage) - the spawn branch's zero-default (see the constructor
+        // doc) makes this safe for every buffer, core and attribute alike.
+        this.gl.bufferData(this.gl.ARRAY_BUFFER, itemSize * count * Float32Array.BYTES_PER_ELEMENT, this.gl.DYNAMIC_DRAW);
+        this.gl.bindBuffer(this.gl.ARRAY_BUFFER, null);
+        return buffer;
+    }
+}

package/dist/miscellaneous/fxMath.d.ts

@@ -1,5 +1,5 @@
 /**
- * CPU-side twins of the compiler's math/noise builtins (`fxMix`, `fxSnoise3`, ...). A behavior
+ * CPU-side twins of the compiler's math/noise builtins (`fxMix`, `fxNoise3`, ...). A behavior
  * kernel's authored `spawn`/`update` body calls these by name - the editor's compiler prints those
  * exact calls - so every exported name here is a frozen contract with already-compiled kernels,
  * like the `a_`/`p_` buffer prefixes. Never rename one without updating the compiler side in
@@ -9,18 +9,25 @@ export declare function fxFract(x: number): number;
 export declare function fxMod(a: number, b: number): number;
 export declare function fxMix(a: number, b: number, t: number): number;
 export declare function fxSmoothstep(edge0: number, edge1: number, x: number): number;
-export declare function fxHash(n: number): number;
-/** Cheap deterministic 1D value-noise (smoothed hash interpolation), range [-1, 1]. */
-export declare function fxValueNoise(x: number): number;
-/** Fractal Brownian motion over {@link fxValueNoise} (gain 0.5, lacunarity 2). */
+/** Fractal Brownian motion over {@link fxNoise1} (gain 0.5, lacunarity 2). */
 export declare function fxFbm(x: number, octaves: number): number;
+/**
+ * Fractal Brownian motion over the full {@link fxNoise3} domain (gain 0.5, lacunarity 2) - unlike
+ * {@link fxFbm}, which walks a single scalar axis, this samples all three input components
+ * together so the field varies with the whole position, not just one of its axes.
+ */
+export declare function fxFbm3(x: number, y: number, z: number, octaves: number): number;
 /** Linearly samples a curve LUT at `t` in [0, 1] (clamped), interpolating between entries. */
 export declare function fxSampleLut(lut: ArrayLike<number>, t: number): number;
 /**
- * Ashima/Gustavson "webgl-noise" simplex noise, 2D - the CPU twin of the compiler's GLSL `snoise`
- * helper. Component arguments (rather than a vector) so it mirrors how the scalarized JS backend calls
- * it; the arithmetic tracks the GLSL version op-for-op. Output is roughly `[-1, 1]`.
+ * Cheap deterministic 1D value-noise (smoothed integer-hash interpolation), range [-1, 1]. The
+ * CPU twin of the compiler's GLSL `noise(float)` standard-tier form - see {@link fxIntHash1}.
+ */
+export declare function fxNoise1(x: number): number;
+/**
+ * 2D twin of {@link fxNoise1}, mirroring the GLSL `noise(vec2)` standard-tier overload op-for-op.
+ * Component arguments (rather than a vector) so it mirrors how the scalarized JS backend calls it.
  */
-export declare function fxSnoise2(vx: number, vy: number): number;
-/** 3D twin of {@link fxSnoise2}, mirroring the GLSL `snoise(vec3)` overload op-for-op. */
-export declare function fxSnoise3(vx: number, vy: number, vz: number): number;
+export declare function fxNoise2(vx: number, vy: number): number;
+/** 3D twin of {@link fxNoise1}, mirroring the GLSL `noise(vec3)` standard-tier overload op-for-op. */
+export declare function fxNoise3(vx: number, vy: number, vz: number): number;

package/dist/miscellaneous/fxMath.js

@@ -1,5 +1,5 @@
 /**
- * CPU-side twins of the compiler's math/noise builtins (`fxMix`, `fxSnoise3`, ...). A behavior
+ * CPU-side twins of the compiler's math/noise builtins (`fxMix`, `fxNoise3`, ...). A behavior
  * kernel's authored `spawn`/`update` body calls these by name - the editor's compiler prints those
  * exact calls - so every exported name here is a frozen contract with already-compiled kernels,
  * like the `a_`/`p_` buffer prefixes. Never rename one without updating the compiler side in
@@ -18,28 +18,34 @@ export function fxSmoothstep(edge0, edge1, x) {
     const t = Math.min(Math.max((x - edge0) / (edge1 - edge0), 0.0), 1.0);
     return t * t * (3.0 - 2.0 * t);
 }
-export function fxHash(n) {
-    const s = Math.sin(n * 127.1) * 43758.5453123;
-    return s - Math.floor(s);
-}
-/** Cheap deterministic 1D value-noise (smoothed hash interpolation), range [-1, 1]. */
-export function fxValueNoise(x) {
-    const i = Math.floor(x);
-    const fractional = x - i;
-    const u = fractional * fractional * (3 - 2 * fractional);
-    return (fxHash(i) * (1 - u) + fxHash(i + 1) * u) * 2 - 1;
-}
 // Mirrors FBM_MAX_OCTAVES in the editor engine: clamps a runaway octave count (a
 // value parameter rebinds with no recompile/sanity gate) so it cannot blow up the update kernel.
 const FBM_MAX_OCTAVES = 8;
-/** Fractal Brownian motion over {@link fxValueNoise} (gain 0.5, lacunarity 2). */
+/** Fractal Brownian motion over {@link fxNoise1} (gain 0.5, lacunarity 2). */
 export function fxFbm(x, octaves) {
     const octaveCount = Math.min(Math.max(Math.floor(octaves), 0), FBM_MAX_OCTAVES);
     let sum = 0;
     let amplitude = 1;
     let frequency = 1;
     for (let i = 0; i < octaveCount; i += 1) {
-        sum += fxValueNoise(x * frequency) * amplitude;
+        sum += fxNoise1(x * frequency) * amplitude;
+        amplitude *= 0.5;
+        frequency *= 2;
+    }
+    return sum;
+}
+/**
+ * Fractal Brownian motion over the full {@link fxNoise3} domain (gain 0.5, lacunarity 2) - unlike
+ * {@link fxFbm}, which walks a single scalar axis, this samples all three input components
+ * together so the field varies with the whole position, not just one of its axes.
+ */
+export function fxFbm3(x, y, z, octaves) {
+    const octaveCount = Math.min(Math.max(Math.floor(octaves), 0), FBM_MAX_OCTAVES);
+    let sum = 0;
+    let amplitude = 1;
+    let frequency = 1;
+    for (let i = 0; i < octaveCount; i += 1) {
+        sum += fxNoise3(x * frequency, y * frequency, z * frequency) * amplitude;
         amplitude *= 0.5;
         frequency *= 2;
     }
@@ -57,205 +63,79 @@ export function fxSampleLut(lut, t) {
     const upperValue = lut[i + 1 < length ? i + 1 : last];
     return lowerValue + (upperValue - lowerValue) * fraction;
 }
-// Ashima/Gustavson simplex-noise sub-helpers (mod289/permute/fract), private to fxSnoise2/3.
-function fxsnMod289(x) {
-    return x - Math.floor(x * (1.0 / 289.0)) * 289.0;
+/**
+ * Integer-hash sub-primitive, private to `fxNoise1/2/3` - Ken Perlin's classic `IntNoise` bit
+ * scramble. `Math.imul` plus `| 0` truncation at each step forces genuine 32-bit wraparound so
+ * this tracks the compiler's GLSL `int` version bit-for-bit (see the `noise` case in the editor's
+ * `FXFunctions.Internal.ts` standard-tier helper).
+ */
+function fxIntHash1(n) {
+    const shifted = (n << 13) | 0;
+    const mixed = (shifted ^ n) | 0;
+    const squared = Math.imul(mixed, mixed);
+    const step1 = (Math.imul(squared, 15731) + Math.imul(mixed, 789221)) | 0;
+    const step2 = (Math.imul(step1, step1) + 1376312589) | 0;
+    return (step2 & 0x00ffffff) / 16777216.0;
 }
-function fxsnPermute(x) {
-    return fxsnMod289((x * 34.0 + 1.0) * x);
+function fxIntHash2(ix, iy) {
+    return fxIntHash1((ix + Math.imul(iy, 57)) | 0);
 }
-function fxsnFract(x) {
-    return x - Math.floor(x);
+function fxIntHash3(ix, iy, iz) {
+    return fxIntHash1((ix + Math.imul(iy, 57) + Math.imul(iz, 113)) | 0);
 }
 /**
- * Ashima/Gustavson "webgl-noise" simplex noise, 2D - the CPU twin of the compiler's GLSL `snoise`
- * helper. Component arguments (rather than a vector) so it mirrors how the scalarized JS backend calls
- * it; the arithmetic tracks the GLSL version op-for-op. Output is roughly `[-1, 1]`.
+ * Cheap deterministic 1D value-noise (smoothed integer-hash interpolation), range [-1, 1]. The
+ * CPU twin of the compiler's GLSL `noise(float)` standard-tier form - see {@link fxIntHash1}.
  */
-export function fxSnoise2(vx, vy) {
-    const cx = 0.211324865405187;
-    const cy = 0.366025403784439;
-    const cz = -0.577350269189626;
-    const cw = 0.024390243902439;
-    const s = (vx + vy) * cy;
-    let ix = Math.floor(vx + s);
-    let iy = Math.floor(vy + s);
-    const t = (ix + iy) * cx;
-    const x0x = vx - ix + t;
-    const x0y = vy - iy + t;
-    let i1x;
-    let i1y;
-    if (x0x > x0y) {
-        i1x = 1.0;
-        i1y = 0.0;
-    }
-    else {
-        i1x = 0.0;
-        i1y = 1.0;
-    }
-    const x1x = x0x - i1x + cx;
-    const x1y = x0y - i1y + cx;
-    const x2x = x0x + cz;
-    const x2y = x0y + cz;
-    ix = fxsnMod289(ix);
-    iy = fxsnMod289(iy);
-    const p0 = fxsnPermute(fxsnPermute(iy + 0.0) + ix + 0.0);
-    const p1 = fxsnPermute(fxsnPermute(iy + i1y) + ix + i1x);
-    const p2 = fxsnPermute(fxsnPermute(iy + 1.0) + ix + 1.0);
-    let m0 = Math.max(0.5 - (x0x * x0x + x0y * x0y), 0.0);
-    let m1 = Math.max(0.5 - (x1x * x1x + x1y * x1y), 0.0);
-    let m2 = Math.max(0.5 - (x2x * x2x + x2y * x2y), 0.0);
-    m0 = m0 * m0;
-    m0 = m0 * m0;
-    m1 = m1 * m1;
-    m1 = m1 * m1;
-    m2 = m2 * m2;
-    m2 = m2 * m2;
-    const gx0 = 2.0 * fxsnFract(p0 * cw) - 1.0;
-    const gx1 = 2.0 * fxsnFract(p1 * cw) - 1.0;
-    const gx2 = 2.0 * fxsnFract(p2 * cw) - 1.0;
-    const h0 = Math.abs(gx0) - 0.5;
-    const h1 = Math.abs(gx1) - 0.5;
-    const h2 = Math.abs(gx2) - 0.5;
-    const ox0 = Math.floor(gx0 + 0.5);
-    const ox1 = Math.floor(gx1 + 0.5);
-    const ox2 = Math.floor(gx2 + 0.5);
-    const a0 = gx0 - ox0;
-    const a1 = gx1 - ox1;
-    const a2 = gx2 - ox2;
-    m0 *= 1.79284291400159 - 0.85373472095314 * (a0 * a0 + h0 * h0);
-    m1 *= 1.79284291400159 - 0.85373472095314 * (a1 * a1 + h1 * h1);
-    m2 *= 1.79284291400159 - 0.85373472095314 * (a2 * a2 + h2 * h2);
-    const g0 = a0 * x0x + h0 * x0y;
-    const g1 = a1 * x1x + h1 * x1y;
-    const g2 = a2 * x2x + h2 * x2y;
-    return 130.0 * (m0 * g0 + m1 * g1 + m2 * g2);
+export function fxNoise1(x) {
+    const i = Math.floor(x);
+    const f = x - i;
+    const u = f * f * (3 - 2 * f);
+    return (fxIntHash1(i) * (1 - u) + fxIntHash1(i + 1) * u) * 2 - 1;
 }
-/** 3D twin of {@link fxSnoise2}, mirroring the GLSL `snoise(vec3)` overload op-for-op. */
-export function fxSnoise3(vx, vy, vz) {
-    const cx = 1.0 / 6.0;
-    const cy = 1.0 / 3.0;
-    const s = (vx + vy + vz) * cy;
-    let ix = Math.floor(vx + s);
-    let iy = Math.floor(vy + s);
-    let iz = Math.floor(vz + s);
-    const t = (ix + iy + iz) * cx;
-    const x0x = vx - ix + t;
-    const x0y = vy - iy + t;
-    const x0z = vz - iz + t;
-    const gx = x0x >= x0y ? 1.0 : 0.0;
-    const gy = x0y >= x0z ? 1.0 : 0.0;
-    const gz = x0z >= x0x ? 1.0 : 0.0;
-    const lx = 1.0 - gx;
-    const ly = 1.0 - gy;
-    const lz = 1.0 - gz;
-    const i1x = Math.min(gx, lz);
-    const i1y = Math.min(gy, lx);
-    const i1z = Math.min(gz, ly);
-    const i2x = Math.max(gx, lz);
-    const i2y = Math.max(gy, lx);
-    const i2z = Math.max(gz, ly);
-    const x1x = x0x - i1x + cx;
-    const x1y = x0y - i1y + cx;
-    const x1z = x0z - i1z + cx;
-    const x2x = x0x - i2x + cy;
-    const x2y = x0y - i2y + cy;
-    const x2z = x0z - i2z + cy;
-    const x3x = x0x - 0.5;
-    const x3y = x0y - 0.5;
-    const x3z = x0z - 0.5;
-    ix = fxsnMod289(ix);
-    iy = fxsnMod289(iy);
-    iz = fxsnMod289(iz);
-    const offz = [0.0, i1z, i2z, 1.0];
-    const offy = [0.0, i1y, i2y, 1.0];
-    const offx = [0.0, i1x, i2x, 1.0];
-    const p = [0.0, 0.0, 0.0, 0.0];
-    for (let k = 0; k < 4; k += 1) {
-        p[k] = fxsnPermute(fxsnPermute(fxsnPermute(iz + offz[k]) + iy + offy[k]) + ix + offx[k]);
-    }
-    const oneOverSeven = 1.0 / 7.0;
-    const nsx = oneOverSeven * 2.0;
-    const nsy = oneOverSeven * 0.5 - 1.0;
-    const nsz = oneOverSeven;
-    const xx = [0.0, 0.0, 0.0, 0.0];
-    const yy = [0.0, 0.0, 0.0, 0.0];
-    const hh = [0.0, 0.0, 0.0, 0.0];
-    for (let k = 0; k < 4; k += 1) {
-        const j = p[k] - 49.0 * Math.floor(p[k] * nsz * nsz);
-        const xf = Math.floor(j * nsz);
-        const yf = Math.floor(j - 7.0 * xf);
-        xx[k] = xf * nsx + nsy;
-        yy[k] = yf * nsx + nsy;
-        hh[k] = 1.0 - Math.abs(xx[k]) - Math.abs(yy[k]);
-    }
-    const b0 = [xx[0], xx[1], yy[0], yy[1]];
-    const b1 = [xx[2], xx[3], yy[2], yy[3]];
-    const s0 = [
-        Math.floor(b0[0]) * 2.0 + 1.0,
-        Math.floor(b0[1]) * 2.0 + 1.0,
-        Math.floor(b0[2]) * 2.0 + 1.0,
-        Math.floor(b0[3]) * 2.0 + 1.0,
-    ];
-    const s1 = [
-        Math.floor(b1[0]) * 2.0 + 1.0,
-        Math.floor(b1[1]) * 2.0 + 1.0,
-        Math.floor(b1[2]) * 2.0 + 1.0,
-        Math.floor(b1[3]) * 2.0 + 1.0,
-    ];
-    const sh = [
-        -(hh[0] <= 0.0 ? 1.0 : 0.0),
-        -(hh[1] <= 0.0 ? 1.0 : 0.0),
-        -(hh[2] <= 0.0 ? 1.0 : 0.0),
-        -(hh[3] <= 0.0 ? 1.0 : 0.0),
-    ];
-    const a00 = b0[0] + s0[0] * sh[0];
-    const a01 = b0[2] + s0[2] * sh[0];
-    const a02 = b0[1] + s0[1] * sh[1];
-    const a03 = b0[3] + s0[3] * sh[1];
-    const a10 = b1[0] + s1[0] * sh[2];
-    const a11 = b1[2] + s1[2] * sh[2];
-    const a12 = b1[1] + s1[1] * sh[3];
-    const a13 = b1[3] + s1[3] * sh[3];
-    let p0x = a00;
-    let p0y = a01;
-    let p0z = hh[0];
-    let p1x = a02;
-    let p1y = a03;
-    let p1z = hh[1];
-    let p2x = a10;
-    let p2y = a11;
-    let p2z = hh[2];
-    let p3x = a12;
-    let p3y = a13;
-    let p3z = hh[3];
-    const nrm0 = 1.79284291400159 - 0.85373472095314 * (p0x * p0x + p0y * p0y + p0z * p0z);
-    const nrm1 = 1.79284291400159 - 0.85373472095314 * (p1x * p1x + p1y * p1y + p1z * p1z);
-    const nrm2 = 1.79284291400159 - 0.85373472095314 * (p2x * p2x + p2y * p2y + p2z * p2z);
-    const nrm3 = 1.79284291400159 - 0.85373472095314 * (p3x * p3x + p3y * p3y + p3z * p3z);
-    p0x *= nrm0;
-    p0y *= nrm0;
-    p0z *= nrm0;
-    p1x *= nrm1;
-    p1y *= nrm1;
-    p1z *= nrm1;
-    p2x *= nrm2;
-    p2y *= nrm2;
-    p2z *= nrm2;
-    p3x *= nrm3;
-    p3y *= nrm3;
-    p3z *= nrm3;
-    let m0 = Math.max(0.6 - (x0x * x0x + x0y * x0y + x0z * x0z), 0.0);
-    let m1 = Math.max(0.6 - (x1x * x1x + x1y * x1y + x1z * x1z), 0.0);
-    let m2 = Math.max(0.6 - (x2x * x2x + x2y * x2y + x2z * x2z), 0.0);
-    let m3 = Math.max(0.6 - (x3x * x3x + x3y * x3y + x3z * x3z), 0.0);
-    m0 = m0 * m0;
-    m1 = m1 * m1;
-    m2 = m2 * m2;
-    m3 = m3 * m3;
-    const dp0 = p0x * x0x + p0y * x0y + p0z * x0z;
-    const dp1 = p1x * x1x + p1y * x1y + p1z * x1z;
-    const dp2 = p2x * x2x + p2y * x2y + p2z * x2z;
-    const dp3 = p3x * x3x + p3y * x3y + p3z * x3z;
-    return 42.0 * (m0 * m0 * dp0 + m1 * m1 * dp1 + m2 * m2 * dp2 + m3 * m3 * dp3);
+/**
+ * 2D twin of {@link fxNoise1}, mirroring the GLSL `noise(vec2)` standard-tier overload op-for-op.
+ * Component arguments (rather than a vector) so it mirrors how the scalarized JS backend calls it.
+ */
+export function fxNoise2(vx, vy) {
+    const ix = Math.floor(vx);
+    const iy = Math.floor(vy);
+    const fx = vx - ix;
+    const fy = vy - iy;
+    const ux = fx * fx * (3 - 2 * fx);
+    const uy = fy * fy * (3 - 2 * fy);
+    const a = fxIntHash2(ix, iy);
+    const b = fxIntHash2(ix + 1, iy);
+    const c = fxIntHash2(ix, iy + 1);
+    const d = fxIntHash2(ix + 1, iy + 1);
+    const ab = a + (b - a) * ux;
+    const cd = c + (d - c) * ux;
+    return (ab + (cd - ab) * uy) * 2 - 1;
+}
+/** 3D twin of {@link fxNoise1}, mirroring the GLSL `noise(vec3)` standard-tier overload op-for-op. */
+export function fxNoise3(vx, vy, vz) {
+    const ix = Math.floor(vx);
+    const iy = Math.floor(vy);
+    const iz = Math.floor(vz);
+    const fx = vx - ix;
+    const fy = vy - iy;
+    const fz = vz - iz;
+    const ux = fx * fx * (3 - 2 * fx);
+    const uy = fy * fy * (3 - 2 * fy);
+    const uz = fz * fz * (3 - 2 * fz);
+    const a = fxIntHash3(ix, iy, iz);
+    const b = fxIntHash3(ix + 1, iy, iz);
+    const c = fxIntHash3(ix, iy + 1, iz);
+    const d = fxIntHash3(ix + 1, iy + 1, iz);
+    const e = fxIntHash3(ix, iy, iz + 1);
+    const f = fxIntHash3(ix + 1, iy, iz + 1);
+    const g = fxIntHash3(ix, iy + 1, iz + 1);
+    const h = fxIntHash3(ix + 1, iy + 1, iz + 1);
+    const ab = a + (b - a) * ux;
+    const cd = c + (d - c) * ux;
+    const abcd = ab + (cd - ab) * uy;
+    const ef = e + (f - e) * ux;
+    const gh = g + (h - g) * ux;
+    const efgh = ef + (gh - ef) * uy;
+    return (abcd + (efgh - abcd) * uz) * 2 - 1;
 }