@triforge/fluid-core 0.1.0

package/dist/index.js

@@ -0,0 +1,1742 @@
+import { BufferGeometry, BufferAttribute } from 'three';
+
+function getDefaultExportFromCjs (x) {
+	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
+}
+
+var twiddle = {};
+
+/**
+ * Bit twiddling hacks for JavaScript.
+ *
+ * Author: Mikola Lysenko
+ *
+ * Ported from Stanford bit twiddling hack library:
+ *    http://graphics.stanford.edu/~seander/bithacks.html
+ */
+
+var hasRequiredTwiddle;
+
+function requireTwiddle () {
+	if (hasRequiredTwiddle) return twiddle;
+	hasRequiredTwiddle = 1;
+
+	//Number of bits in an integer
+	var INT_BITS = 32;
+
+	//Constants
+	twiddle.INT_BITS  = INT_BITS;
+	twiddle.INT_MAX   =  0x7fffffff;
+	twiddle.INT_MIN   = -1<<(INT_BITS-1);
+
+	//Returns -1, 0, +1 depending on sign of x
+	twiddle.sign = function(v) {
+	  return (v > 0) - (v < 0);
+	};
+
+	//Computes absolute value of integer
+	twiddle.abs = function(v) {
+	  var mask = v >> (INT_BITS-1);
+	  return (v ^ mask) - mask;
+	};
+
+	//Computes minimum of integers x and y
+	twiddle.min = function(x, y) {
+	  return y ^ ((x ^ y) & -(x < y));
+	};
+
+	//Computes maximum of integers x and y
+	twiddle.max = function(x, y) {
+	  return x ^ ((x ^ y) & -(x < y));
+	};
+
+	//Checks if a number is a power of two
+	twiddle.isPow2 = function(v) {
+	  return !(v & (v-1)) && (!!v);
+	};
+
+	//Computes log base 2 of v
+	twiddle.log2 = function(v) {
+	  var r, shift;
+	  r =     (v > 0xFFFF) << 4; v >>>= r;
+	  shift = (v > 0xFF  ) << 3; v >>>= shift; r |= shift;
+	  shift = (v > 0xF   ) << 2; v >>>= shift; r |= shift;
+	  shift = (v > 0x3   ) << 1; v >>>= shift; r |= shift;
+	  return r | (v >> 1);
+	};
+
+	//Computes log base 10 of v
+	twiddle.log10 = function(v) {
+	  return  (v >= 1000000000) ? 9 : (v >= 100000000) ? 8 : (v >= 10000000) ? 7 :
+	          (v >= 1000000) ? 6 : (v >= 100000) ? 5 : (v >= 10000) ? 4 :
+	          (v >= 1000) ? 3 : (v >= 100) ? 2 : (v >= 10) ? 1 : 0;
+	};
+
+	//Counts number of bits
+	twiddle.popCount = function(v) {
+	  v = v - ((v >>> 1) & 0x55555555);
+	  v = (v & 0x33333333) + ((v >>> 2) & 0x33333333);
+	  return ((v + (v >>> 4) & 0xF0F0F0F) * 0x1010101) >>> 24;
+	};
+
+	//Counts number of trailing zeros
+	function countTrailingZeros(v) {
+	  var c = 32;
+	  v &= -v;
+	  if (v) c--;
+	  if (v & 0x0000FFFF) c -= 16;
+	  if (v & 0x00FF00FF) c -= 8;
+	  if (v & 0x0F0F0F0F) c -= 4;
+	  if (v & 0x33333333) c -= 2;
+	  if (v & 0x55555555) c -= 1;
+	  return c;
+	}
+	twiddle.countTrailingZeros = countTrailingZeros;
+
+	//Rounds to next power of 2
+	twiddle.nextPow2 = function(v) {
+	  v += v === 0;
+	  --v;
+	  v |= v >>> 1;
+	  v |= v >>> 2;
+	  v |= v >>> 4;
+	  v |= v >>> 8;
+	  v |= v >>> 16;
+	  return v + 1;
+	};
+
+	//Rounds down to previous power of 2
+	twiddle.prevPow2 = function(v) {
+	  v |= v >>> 1;
+	  v |= v >>> 2;
+	  v |= v >>> 4;
+	  v |= v >>> 8;
+	  v |= v >>> 16;
+	  return v - (v>>>1);
+	};
+
+	//Computes parity of word
+	twiddle.parity = function(v) {
+	  v ^= v >>> 16;
+	  v ^= v >>> 8;
+	  v ^= v >>> 4;
+	  v &= 0xf;
+	  return (0x6996 >>> v) & 1;
+	};
+
+	var REVERSE_TABLE = new Array(256);
+
+	(function(tab) {
+	  for(var i=0; i<256; ++i) {
+	    var v = i, r = i, s = 7;
+	    for (v >>>= 1; v; v >>>= 1) {
+	      r <<= 1;
+	      r |= v & 1;
+	      --s;
+	    }
+	    tab[i] = (r << s) & 0xff;
+	  }
+	})(REVERSE_TABLE);
+
+	//Reverse bits in a 32 bit word
+	twiddle.reverse = function(v) {
+	  return  (REVERSE_TABLE[ v         & 0xff] << 24) |
+	          (REVERSE_TABLE[(v >>> 8)  & 0xff] << 16) |
+	          (REVERSE_TABLE[(v >>> 16) & 0xff] << 8)  |
+	           REVERSE_TABLE[(v >>> 24) & 0xff];
+	};
+
+	//Interleave bits of 2 coordinates with 16 bits.  Useful for fast quadtree codes
+	twiddle.interleave2 = function(x, y) {
+	  x &= 0xFFFF;
+	  x = (x | (x << 8)) & 0x00FF00FF;
+	  x = (x | (x << 4)) & 0x0F0F0F0F;
+	  x = (x | (x << 2)) & 0x33333333;
+	  x = (x | (x << 1)) & 0x55555555;
+
+	  y &= 0xFFFF;
+	  y = (y | (y << 8)) & 0x00FF00FF;
+	  y = (y | (y << 4)) & 0x0F0F0F0F;
+	  y = (y | (y << 2)) & 0x33333333;
+	  y = (y | (y << 1)) & 0x55555555;
+
+	  return x | (y << 1);
+	};
+
+	//Extracts the nth interleaved component
+	twiddle.deinterleave2 = function(v, n) {
+	  v = (v >>> n) & 0x55555555;
+	  v = (v | (v >>> 1))  & 0x33333333;
+	  v = (v | (v >>> 2))  & 0x0F0F0F0F;
+	  v = (v | (v >>> 4))  & 0x00FF00FF;
+	  v = (v | (v >>> 16)) & 0x000FFFF;
+	  return (v << 16) >> 16;
+	};
+
+
+	//Interleave bits of 3 coordinates, each with 10 bits.  Useful for fast octree codes
+	twiddle.interleave3 = function(x, y, z) {
+	  x &= 0x3FF;
+	  x  = (x | (x<<16)) & 4278190335;
+	  x  = (x | (x<<8))  & 251719695;
+	  x  = (x | (x<<4))  & 3272356035;
+	  x  = (x | (x<<2))  & 1227133513;
+
+	  y &= 0x3FF;
+	  y  = (y | (y<<16)) & 4278190335;
+	  y  = (y | (y<<8))  & 251719695;
+	  y  = (y | (y<<4))  & 3272356035;
+	  y  = (y | (y<<2))  & 1227133513;
+	  x |= (y << 1);
+	  
+	  z &= 0x3FF;
+	  z  = (z | (z<<16)) & 4278190335;
+	  z  = (z | (z<<8))  & 251719695;
+	  z  = (z | (z<<4))  & 3272356035;
+	  z  = (z | (z<<2))  & 1227133513;
+	  
+	  return x | (z << 2);
+	};
+
+	//Extracts nth interleaved component of a 3-tuple
+	twiddle.deinterleave3 = function(v, n) {
+	  v = (v >>> n)       & 1227133513;
+	  v = (v | (v>>>2))   & 3272356035;
+	  v = (v | (v>>>4))   & 251719695;
+	  v = (v | (v>>>8))   & 4278190335;
+	  v = (v | (v>>>16))  & 0x3FF;
+	  return (v<<22)>>22;
+	};
+
+	//Computes next combination in colexicographic order (this is mistakenly called nextPermutation on the bit twiddling hacks page)
+	twiddle.nextCombination = function(v) {
+	  var t = v | (v - 1);
+	  return (t + 1) | (((~t & -~t) - 1) >>> (countTrailingZeros(v) + 1));
+	};
+	return twiddle;
+}
+
+var almost_equal;
+var hasRequiredAlmost_equal;
+
+function requireAlmost_equal () {
+	if (hasRequiredAlmost_equal) return almost_equal;
+	hasRequiredAlmost_equal = 1;
+
+	var abs = Math.abs
+	  , min = Math.min;
+
+	function almostEqual(a, b, absoluteError, relativeError) {
+	  var d = abs(a - b);
+	  if(d <= absoluteError) {
+	    return true
+	  }
+	  if(d <= relativeError * min(abs(a), abs(b))) {
+	    return true
+	  }
+	  return a === b
+	}
+
+	almostEqual.FLT_EPSILON = 1.19209290e-7;
+	almostEqual.DBL_EPSILON = 2.2204460492503131e-16;
+
+	almost_equal = almostEqual;
+	return almost_equal;
+}
+
+var pcg$1;
+var hasRequiredPcg;
+
+function requirePcg () {
+	if (hasRequiredPcg) return pcg$1;
+	hasRequiredPcg = 1;
+
+	var bits = requireTwiddle()
+	  , almostEqual = requireAlmost_equal();
+
+	var R = new Float64Array(1024);
+	var P = new Float64Array(1024);
+	var D = new Float64Array(1024);
+	var Z = new Float64Array(1024);
+
+	function reserve(n) {
+	  if(n < R.length) {
+	    return
+	  }
+	  var nsize = bits.nextPow2(n);
+	  R = new Float64Array(nsize);
+	  P = new Float64Array(nsize);
+	  Z = new Float64Array(nsize);
+	  D = new Float64Array(nsize);
+	}
+
+	function conjugateGradient(A, b, x, tolerance, max_iter) {
+	  var abs = Math.abs
+	    , max = Math.max
+	    , EPSILON = almostEqual.FLT_EPSILON
+	    , n = A.rowCount
+	    , i, k
+	    , alpha_n, alpha_d, alpha, beta, rnorm, s;
+	  if(!tolerance) {
+	    tolerance = 1e-5;
+	  }
+	  if(!max_iter) {
+	    max_iter = Math.min(n, 20);
+	  }
+	  if(!x) {
+	    if(b.buffer) {
+	      x = new b.constructor(b.buffer.slice(0));
+	    } else {
+	      x = b.slice(0);
+	    }
+	  }
+	  reserve(n);
+	  //Compute preconditioner
+	  for(i=0; i<n; ++i) {
+	    s = A.get(i, i);
+	    if(abs(s) > EPSILON) {
+	      D[i] = 1.0 / s;
+	    } else {
+	      D[i] = 1.0;
+	    }
+	  }
+	  //Initialize 
+	  A.apply(x, R);
+	  for(i=0; i<n; ++i) {
+	    R[i] = b[i] - R[i];
+	    Z[i] = D[i] * R[i];
+	    P[i] = Z[i];
+	  }
+	  //Iterate
+	  for(k=0; k<max_iter; ++k) {
+	    alpha_n = 0.0;
+	    for(i=0; i<n; ++i) {
+	      alpha_n += R[i] * Z[i];
+	    }
+	    A.apply(P, Z);
+	    alpha_d = 0.0;
+	    for(i=0; i<n; ++i) {
+	      alpha_d +=  P[i] * Z[i];
+	    }
+	    alpha = alpha_n / alpha_d;
+	    beta = 0.0;
+	    rnorm = 0.0;
+	    for(i=0; i<n; ++i) {
+	      x[i] += alpha * P[i];
+	      R[i] -= alpha * Z[i];
+	      Z[i]  = D[i] * R[i];
+	      beta += R[i] * Z[i];
+	      rnorm = max(rnorm, abs(R[i]));
+	    }
+	    if(rnorm < tolerance) {
+	      break
+	    }
+	    beta /= alpha_n;
+	    for(i=0; i<n; ++i) {
+	      P[i] = Z[i] + beta * P[i];
+	    }
+	  }
+	  return x
+	}
+
+	pcg$1 = conjugateGradient;
+	return pcg$1;
+}
+
+var pcgExports = requirePcg();
+var pcg = /*@__PURE__*/getDefaultExportFromCjs(pcgExports);
+
+/**
+ * MACGrid — Marker-And-Cell staggered velocity grid.
+ *
+ * Velocity components are stored at face centres (staggered):
+ *   u[i][j][k]  — X-velocity at face (i-½, j, k)
+ *   v[i][j][k]  — Y-velocity at face (i, j-½, k)
+ *   w[i][j][k]  — Z-velocity at face (i, j, k-½)
+ * Pressure p[i][j][k] is at cell centres.
+ *
+ * Grid cell (i,j,k) covers world-space region:
+ *   [ox + i*h, ox + (i+1)*h] × [oy + j*h, ...] × [oz + k*h, ...]
+ */
+class MACGrid {
+    constructor(nx, ny, nz, h, ox = 0, oy = 0, oz = 0) {
+        this.nx = nx;
+        this.ny = ny;
+        this.nz = nz;
+        this.h = h;
+        this.ox = ox;
+        this.oy = oy;
+        this.oz = oz;
+        this.u = new Float64Array((nx + 1) * ny * nz);
+        this.v = new Float64Array(nx * (ny + 1) * nz);
+        this.w = new Float64Array(nx * ny * (nz + 1));
+        this.uOld = new Float64Array(this.u.length);
+        this.vOld = new Float64Array(this.v.length);
+        this.wOld = new Float64Array(this.w.length);
+        this.uW = new Float64Array(this.u.length);
+        this.vW = new Float64Array(this.v.length);
+        this.wW = new Float64Array(this.w.length);
+        this.pressure = new Float64Array(nx * ny * nz);
+        this.cellType = new Uint8Array(nx * ny * nz);
+    }
+    // ── Index helpers ─────────────────────────────────────────────────────────
+    /** Flat index for cell (i,j,k). */
+    idx(i, j, k) {
+        return i + this.nx * (j + this.ny * k);
+    }
+    /** Flat index for u-face (i,j,k) — grid is (nx+1)*ny*nz. */
+    uIdx(i, j, k) {
+        return i + (this.nx + 1) * (j + this.ny * k);
+    }
+    /** Flat index for v-face (i,j,k) — grid is nx*(ny+1)*nz. */
+    vIdx(i, j, k) {
+        return i + this.nx * (j + (this.ny + 1) * k);
+    }
+    /** Flat index for w-face (i,j,k) — grid is nx*ny*(nz+1). */
+    wIdx(i, j, k) {
+        return i + this.nx * (j + this.ny * k);
+    }
+    // ── Interpolation ─────────────────────────────────────────────────────────
+    /** Trilinear interpolation of u-velocity at world position (wx,wy,wz). */
+    interpU(wx, wy, wz) {
+        return this._interp(this.u, wx - this.ox, wy - this.oy - 0.5 * this.h, wz - this.oz - 0.5 * this.h, this.nx + 1, this.ny, this.nz);
+    }
+    /** Trilinear interpolation of v-velocity at world position. */
+    interpV(wx, wy, wz) {
+        return this._interp(this.v, wx - this.ox - 0.5 * this.h, wy - this.oy, wz - this.oz - 0.5 * this.h, this.nx, this.ny + 1, this.nz);
+    }
+    /** Trilinear interpolation of w-velocity at world position. */
+    interpW(wx, wy, wz) {
+        return this._interp(this.w, wx - this.ox - 0.5 * this.h, wy - this.oy - 0.5 * this.h, wz - this.oz, this.nx, this.ny, this.nz + 1);
+    }
+    _interp(arr, lx, ly, lz, Nx, Ny, Nz) {
+        const h = this.h;
+        let fi = lx / h, fj = ly / h, fk = lz / h;
+        fi = Math.max(0, Math.min(Nx - 1.0001, fi));
+        fj = Math.max(0, Math.min(Ny - 1.0001, fj));
+        fk = Math.max(0, Math.min(Nz - 1.0001, fk));
+        const i0 = Math.floor(fi), i1 = i0 + 1;
+        const j0 = Math.floor(fj), j1 = j0 + 1;
+        const k0 = Math.floor(fk), k1 = k0 + 1;
+        const tx = fi - i0, ty = fj - j0, tz = fk - k0;
+        const idx = (i, j, k) => i + Nx * (j + Ny * k);
+        return (1 - tz) * ((1 - ty) * ((1 - tx) * arr[idx(i0, j0, k0)] + tx * arr[idx(i1, j0, k0)]) +
+            ty * ((1 - tx) * arr[idx(i0, j1, k0)] + tx * arr[idx(i1, j1, k0)])) +
+            tz * ((1 - ty) * ((1 - tx) * arr[idx(i0, j0, k1)] + tx * arr[idx(i1, j0, k1)]) +
+                ty * ((1 - tx) * arr[idx(i0, j1, k1)] + tx * arr[idx(i1, j1, k1)]));
+    }
+    // ── Utilities ─────────────────────────────────────────────────────────────
+    clearVelocities() {
+        this.u.fill(0);
+        this.v.fill(0);
+        this.w.fill(0);
+        this.uW.fill(0);
+        this.vW.fill(0);
+        this.wW.fill(0);
+    }
+    saveVelocities() {
+        this.uOld.set(this.u);
+        this.vOld.set(this.v);
+        this.wOld.set(this.w);
+    }
+    normalizeWeights() {
+        for (let i = 0; i < this.u.length; i++)
+            if (this.uW[i] > 0)
+                this.u[i] /= this.uW[i];
+        for (let i = 0; i < this.v.length; i++)
+            if (this.vW[i] > 0)
+                this.v[i] /= this.vW[i];
+        for (let i = 0; i < this.w.length; i++)
+            if (this.wW[i] > 0)
+                this.w[i] /= this.wW[i];
+    }
+    /** Mark border cells as solid, fluid cells from a predicate. */
+    markCells(isFluid) {
+        const { nx, ny, nz } = this;
+        for (let k = 0; k < nz; k++)
+            for (let j = 0; j < ny; j++)
+                for (let i = 0; i < nx; i++) {
+                    const solid = i === 0 || i === nx - 1 || j === 0 || j === ny - 1 || k === 0 || k === nz - 1;
+                    this.cellType[this.idx(i, j, k)] = solid ? 2 : (isFluid(i, j, k) ? 1 : 0);
+                }
+    }
+    /** Enforce solid (no-through) boundary: zero normal velocity at solid faces. */
+    enforceBoundary() {
+        const { nx, ny, nz } = this;
+        // Left/right walls (i=0 and i=nx)
+        for (let k = 0; k < nz; k++)
+            for (let j = 0; j < ny; j++) {
+                this.u[this.uIdx(0, j, k)] = 0;
+                this.u[this.uIdx(nx, j, k)] = 0;
+            }
+        // Bottom/top walls
+        for (let k = 0; k < nz; k++)
+            for (let i = 0; i < nx; i++) {
+                this.v[this.vIdx(i, 0, k)] = 0;
+                this.v[this.vIdx(i, ny, k)] = 0;
+            }
+        // Front/back walls
+        for (let j = 0; j < ny; j++)
+            for (let i = 0; i < nx; i++) {
+                this.w[this.wIdx(i, j, 0)] = 0;
+                this.w[this.wIdx(i, j, nz)] = 0;
+            }
+    }
+    /** Apply gravity to grid v velocities over timestep dt. */
+    applyGravity(gx, gy, gz, dt) {
+        const { nx, ny, nz } = this;
+        for (let k = 0; k < nz; k++)
+            for (let j = 0; j <= ny; j++)
+                for (let i = 0; i < nx; i++)
+                    this.v[this.vIdx(i, j, k)] += gy * dt;
+        for (let k = 0; k < nz; k++)
+            for (let j = 0; j < ny; j++)
+                for (let i = 0; i <= nx; i++)
+                    this.u[this.uIdx(i, j, k)] += gx * dt;
+        for (let k = 0; k <= nz; k++)
+            for (let j = 0; j < ny; j++)
+                for (let i = 0; i < nx; i++)
+                    this.w[this.wIdx(i, j, k)] += gz * dt;
+    }
+}
+
+/**
+ * FLIPSimulator — full FLIP (Fluid-Implicit-Particle) fluid simulation.
+ *
+ * Implements the Zhu & Bridson 2005 FLIP algorithm:
+ *   1. Transfer particle velocities → MAC grid (P2G, trilinear splat)
+ *   2. Apply body forces (gravity) on grid
+ *   3. Enforce solid boundary conditions
+ *   4. Solve pressure Poisson equation (conjugate gradient)
+ *   5. Subtract pressure gradient from grid velocity (projection)
+ *   6. Transfer grid velocity change back to particles (G2P, FLIP blend)
+ *   7. Advect particles through the corrected velocity field
+ *
+ * All parameters live in `parameters` for GSAP/st-keyframe animation.
+ *
+ * ```typescript
+ * const sim = new FLIPSimulator({ resolution: 20, particleCount: 1500 })
+ * sim.fillBox(-0.5, -0.5, -0.5, 0.5, 0.5, 0.5)
+ *
+ * // Each frame:
+ * sim.step(dt)
+ * const pts = sim.getPositions()  // Float32Array  [x,y,z, x,y,z, ...]
+ * ```
+ */
+class FLIPSimulator {
+    constructor(opts = {}) {
+        const res = opts.resolution ?? 24;
+        const domainSize = opts.domainSize ?? 2;
+        const origin = opts.origin ?? [-1, -1, -1];
+        const h = domainSize / res;
+        this._nx = res;
+        this._ny = res;
+        this._nz = res;
+        this._grid = new MACGrid(res, res, res, h, origin[0], origin[1], origin[2]);
+        this.particleCount = opts.particleCount ?? 2000;
+        this._particles = [];
+        this._b = new Float64Array(res * res * res);
+        this._x = new Float64Array(res * res * res);
+        const g = opts.gravity ?? [0, -9.8, 0];
+        this.parameters = {
+            flipRatio: opts.flipRatio ?? 0.95,
+            gravityX: g[0],
+            gravityY: g[1],
+            gravityZ: g[2],
+            substeps: opts.substeps ?? 3,
+            solverMaxIter: opts.solverMaxIter ?? 80,
+            solverTolerance: opts.solverTolerance ?? 1e-4,
+        };
+    }
+    // ── Particle placement ────────────────────────────────────────────────────
+    /**
+     * Fill a world-space axis-aligned box with fluid particles.
+     * Particles are distributed using a jittered grid to avoid clumping.
+     * Multiple calls accumulate particles (capped at particleCount).
+     */
+    fillBox(x0, y0, z0, x1, y1, z1) {
+        this._particles.length = 0;
+        const h = this._grid.h;
+        const pph = 2; // particles per cell per axis (2³ = 8 per cell, standard FLIP)
+        const sp = h / pph;
+        for (let z = z0; z < z1; z += sp)
+            for (let y = y0; y < y1; y += sp)
+                for (let x = x0; x < x1; x += sp) {
+                    if (this._particles.length >= this.particleCount)
+                        break;
+                    this._particles.push({
+                        x: x + sp * Math.random(),
+                        y: y + sp * Math.random(),
+                        z: z + sp * Math.random(),
+                        vx: 0, vy: 0, vz: 0,
+                    });
+                }
+    }
+    // ── Main step ─────────────────────────────────────────────────────────────
+    /** Advance the simulation by `dt` seconds (call once per frame, e.g. dt=1/60). */
+    step(dt) {
+        const substeps = Math.max(1, Math.round(this.parameters.substeps));
+        const subDt = dt / substeps;
+        for (let s = 0; s < substeps; s++)
+            this._substep(subDt);
+    }
+    _substep(dt) {
+        const grid = this._grid;
+        const { nx, ny, nz, h } = grid;
+        // 1. Mark cells as fluid / air based on particle positions
+        const fluidSet = new Set();
+        for (const p of this._particles) {
+            const i = Math.floor((p.x - grid.ox) / h);
+            const j = Math.floor((p.y - grid.oy) / h);
+            const k = Math.floor((p.z - grid.oz) / h);
+            if (i >= 1 && i < nx - 1 && j >= 1 && j < ny - 1 && k >= 1 && k < nz - 1)
+                fluidSet.add(grid.idx(i, j, k));
+        }
+        grid.markCells((i, j, k) => fluidSet.has(grid.idx(i, j, k)));
+        // 2. P2G — splat particle velocities to grid faces
+        grid.clearVelocities();
+        this._p2g();
+        grid.normalizeWeights();
+        grid.saveVelocities();
+        // 3. Body forces + boundary
+        grid.applyGravity(this.parameters.gravityX, this.parameters.gravityY, this.parameters.gravityZ, dt);
+        grid.enforceBoundary();
+        // 4. Pressure projection
+        this._pressureSolve(dt);
+        // 5. G2P — transfer corrected grid velocities back to particles (FLIP blend)
+        this._g2p();
+        // 6. Advect particles
+        this._advect(dt);
+        // 7. Clamp particles inside domain
+        this._clampParticles();
+    }
+    // ── P2G (particle → grid) ─────────────────────────────────────────────────
+    _p2g() {
+        const grid = this._grid;
+        const { nx, ny, nz, h, ox, oy, oz } = grid;
+        for (const p of this._particles) {
+            // U faces (i-½, j, k) — offset by (0, h/2, h/2)
+            this._splatToFace(grid.u, grid.uW, p.vx, p.x - ox, p.y - oy - 0.5 * h, p.z - oz - 0.5 * h, nx + 1, ny, nz, h);
+            // V faces (i, j-½, k) — offset by (h/2, 0, h/2)
+            this._splatToFace(grid.v, grid.vW, p.vy, p.x - ox - 0.5 * h, p.y - oy, p.z - oz - 0.5 * h, nx, ny + 1, nz, h);
+            // W faces (i, j, k-½) — offset by (h/2, h/2, 0)
+            this._splatToFace(grid.w, grid.wW, p.vz, p.x - ox - 0.5 * h, p.y - oy - 0.5 * h, p.z - oz, nx, ny, nz + 1, h);
+        }
+    }
+    _splatToFace(arr, wArr, val, lx, ly, lz, Nx, Ny, Nz, h) {
+        let fi = lx / h, fj = ly / h, fk = lz / h;
+        fi = Math.max(0, Math.min(Nx - 1.0001, fi));
+        fj = Math.max(0, Math.min(Ny - 1.0001, fj));
+        fk = Math.max(0, Math.min(Nz - 1.0001, fk));
+        const i0 = Math.floor(fi), i1 = i0 + 1;
+        const j0 = Math.floor(fj), j1 = j0 + 1;
+        const k0 = Math.floor(fk), k1 = k0 + 1;
+        const tx = fi - i0, ty = fj - j0, tz = fk - k0;
+        const idx = (i, j, k) => i + Nx * (j + Ny * k);
+        const w000 = (1 - tx) * (1 - ty) * (1 - tz);
+        arr[idx(i0, j0, k0)] += w000 * val;
+        wArr[idx(i0, j0, k0)] += w000;
+        const w100 = tx * (1 - ty) * (1 - tz);
+        arr[idx(i1, j0, k0)] += w100 * val;
+        wArr[idx(i1, j0, k0)] += w100;
+        const w010 = (1 - tx) * ty * (1 - tz);
+        arr[idx(i0, j1, k0)] += w010 * val;
+        wArr[idx(i0, j1, k0)] += w010;
+        const w110 = tx * ty * (1 - tz);
+        arr[idx(i1, j1, k0)] += w110 * val;
+        wArr[idx(i1, j1, k0)] += w110;
+        const w001 = (1 - tx) * (1 - ty) * tz;
+        arr[idx(i0, j0, k1)] += w001 * val;
+        wArr[idx(i0, j0, k1)] += w001;
+        const w101 = tx * (1 - ty) * tz;
+        arr[idx(i1, j0, k1)] += w101 * val;
+        wArr[idx(i1, j0, k1)] += w101;
+        const w011 = (1 - tx) * ty * tz;
+        arr[idx(i0, j1, k1)] += w011 * val;
+        wArr[idx(i0, j1, k1)] += w011;
+        const w111 = tx * ty * tz;
+        arr[idx(i1, j1, k1)] += w111 * val;
+        wArr[idx(i1, j1, k1)] += w111;
+    }
+    // ── Pressure projection ───────────────────────────────────────────────────
+    _pressureSolve(dt) {
+        const grid = this._grid;
+        const { nx, ny, nz, h } = grid;
+        const N = nx * ny * nz;
+        const invH2 = 1.0 / (h * h);
+        // Build RHS: b[i] = div(u)[i] / dt  (standard incompressible projection)
+        this._b.fill(0);
+        for (let k = 1; k < nz - 1; k++)
+            for (let j = 1; j < ny - 1; j++)
+                for (let i = 1; i < nx - 1; i++) {
+                    const ci = grid.idx(i, j, k);
+                    if (grid.cellType[ci] !== 1)
+                        continue;
+                    const div = (grid.u[grid.uIdx(i + 1, j, k)] - grid.u[grid.uIdx(i, j, k)]) / h
+                        + (grid.v[grid.vIdx(i, j + 1, k)] - grid.v[grid.vIdx(i, j, k)]) / h
+                        + (grid.w[grid.wIdx(i, j, k + 1)] - grid.w[grid.wIdx(i, j, k)]) / h;
+                    this._b[ci] = div / dt;
+                }
+        this._x.fill(0);
+        const cellType = grid.cellType;
+        const idxFn = (i, j, k) => grid.idx(i, j, k);
+        // A = discrete positive-definite Laplacian  (1/h² per neighbour pair)
+        const A = {
+            rowCount: N,
+            get: (row, _col) => {
+                if (cellType[row] !== 1)
+                    return 1;
+                const kk = Math.floor(row / (nx * ny));
+                const rem = row - kk * nx * ny;
+                const jj = Math.floor(rem / nx);
+                const ii = rem - jj * nx;
+                let d = 0;
+                if (ii > 0 && cellType[idxFn(ii - 1, jj, kk)] !== 2)
+                    d += invH2;
+                if (ii < nx - 1 && cellType[idxFn(ii + 1, jj, kk)] !== 2)
+                    d += invH2;
+                if (jj > 0 && cellType[idxFn(ii, jj - 1, kk)] !== 2)
+                    d += invH2;
+                if (jj < ny - 1 && cellType[idxFn(ii, jj + 1, kk)] !== 2)
+                    d += invH2;
+                if (kk > 0 && cellType[idxFn(ii, jj, kk - 1)] !== 2)
+                    d += invH2;
+                if (kk < nz - 1 && cellType[idxFn(ii, jj, kk + 1)] !== 2)
+                    d += invH2;
+                return d > 0 ? d : 1;
+            },
+            apply: (xVec, out) => {
+                out.fill(0);
+                for (let k2 = 0; k2 < nz; k2++)
+                    for (let j2 = 0; j2 < ny; j2++)
+                        for (let i2 = 0; i2 < nx; i2++) {
+                            const ci = idxFn(i2, j2, k2);
+                            if (cellType[ci] !== 1) {
+                                out[ci] = xVec[ci];
+                                continue;
+                            }
+                            let sum = 0, cnt = 0;
+                            if (i2 > 0 && cellType[idxFn(i2 - 1, j2, k2)] !== 2) {
+                                sum += xVec[idxFn(i2 - 1, j2, k2)];
+                                cnt++;
+                            }
+                            if (i2 < nx - 1 && cellType[idxFn(i2 + 1, j2, k2)] !== 2) {
+                                sum += xVec[idxFn(i2 + 1, j2, k2)];
+                                cnt++;
+                            }
+                            if (j2 > 0 && cellType[idxFn(i2, j2 - 1, k2)] !== 2) {
+                                sum += xVec[idxFn(i2, j2 - 1, k2)];
+                                cnt++;
+                            }
+                            if (j2 < ny - 1 && cellType[idxFn(i2, j2 + 1, k2)] !== 2) {
+                                sum += xVec[idxFn(i2, j2 + 1, k2)];
+                                cnt++;
+                            }
+                            if (k2 > 0 && cellType[idxFn(i2, j2, k2 - 1)] !== 2) {
+                                sum += xVec[idxFn(i2, j2, k2 - 1)];
+                                cnt++;
+                            }
+                            if (k2 < nz - 1 && cellType[idxFn(i2, j2, k2 + 1)] !== 2) {
+                                sum += xVec[idxFn(i2, j2, k2 + 1)];
+                                cnt++;
+                            }
+                            out[ci] = invH2 * (cnt * xVec[ci] - sum);
+                        }
+            },
+        };
+        try {
+            pcg(A, this._b, this._x, this.parameters.solverTolerance, Math.round(this.parameters.solverMaxIter));
+        }
+        catch (_) { /* degenerate — keep zero pressure */ }
+        // Guard against NaN (degenerate geometry — no fluid cells, etc.)
+        for (let i = 0; i < this._x.length; i++) {
+            if (!isFinite(this._x[i])) {
+                this._x.fill(0);
+                break;
+            }
+        }
+        // Subtract pressure gradient — loop over faces (each face updated exactly once)
+        // U-faces: (i, j, k) for i in [1, nx-1]
+        for (let k = 0; k < nz; k++)
+            for (let j = 0; j < ny; j++)
+                for (let i = 1; i < nx; i++) {
+                    const cL = grid.idx(i - 1, j, k);
+                    const cR = grid.idx(i, j, k);
+                    if ((cellType[cL] === 1 || cellType[cR] === 1) &&
+                        cellType[cL] !== 2 && cellType[cR] !== 2) {
+                        grid.u[grid.uIdx(i, j, k)] -= dt * (this._x[cR] - this._x[cL]) / h;
+                    }
+                }
+        // V-faces: (i, j, k) for j in [1, ny-1]
+        for (let k = 0; k < nz; k++)
+            for (let j = 1; j < ny; j++)
+                for (let i = 0; i < nx; i++) {
+                    const cB = grid.idx(i, j - 1, k);
+                    const cT = grid.idx(i, j, k);
+                    if ((cellType[cB] === 1 || cellType[cT] === 1) &&
+                        cellType[cB] !== 2 && cellType[cT] !== 2) {
+                        grid.v[grid.vIdx(i, j, k)] -= dt * (this._x[cT] - this._x[cB]) / h;
+                    }
+                }
+        // W-faces: (i, j, k) for k in [1, nz-1]
+        for (let k = 1; k < nz; k++)
+            for (let j = 0; j < ny; j++)
+                for (let i = 0; i < nx; i++) {
+                    const cN = grid.idx(i, j, k - 1);
+                    const cF = grid.idx(i, j, k);
+                    if ((cellType[cN] === 1 || cellType[cF] === 1) &&
+                        cellType[cN] !== 2 && cellType[cF] !== 2) {
+                        grid.w[grid.wIdx(i, j, k)] -= dt * (this._x[cF] - this._x[cN]) / h;
+                    }
+                }
+        grid.enforceBoundary();
+    }
+    // ── G2P (grid → particle) ─────────────────────────────────────────────────
+    _g2p() {
+        const grid = this._grid;
+        const ratio = this.parameters.flipRatio;
+        for (const p of this._particles) {
+            // New grid velocity at particle position
+            const nu = grid.interpU(p.x, p.y, p.z);
+            const nv = grid.interpV(p.x, p.y, p.z);
+            const nw = grid.interpW(p.x, p.y, p.z);
+            // Old grid velocity at particle position (before pressure solve)
+            const ou = this._interpOld(grid.uOld, p.x - grid.ox, p.y - grid.oy - 0.5 * grid.h, p.z - grid.oz - 0.5 * grid.h, grid.nx + 1, grid.ny, grid.nz);
+            const ov = this._interpOld(grid.vOld, p.x - grid.ox - 0.5 * grid.h, p.y - grid.oy, p.z - grid.oz - 0.5 * grid.h, grid.nx, grid.ny + 1, grid.nz);
+            const ow = this._interpOld(grid.wOld, p.x - grid.ox - 0.5 * grid.h, p.y - grid.oy - 0.5 * grid.h, p.z - grid.oz, grid.nx, grid.ny, grid.nz + 1);
+            // FLIP: particle velocity += (new - old) grid velocity
+            // PIC:  particle velocity  = new grid velocity
+            // Blend
+            p.vx = ratio * (p.vx + nu - ou) + (1 - ratio) * nu;
+            p.vy = ratio * (p.vy + nv - ov) + (1 - ratio) * nv;
+            p.vz = ratio * (p.vz + nw - ow) + (1 - ratio) * nw;
+        }
+    }
+    _interpOld(arr, lx, ly, lz, Nx, Ny, Nz) {
+        const h = this._grid.h;
+        let fi = lx / h, fj = ly / h, fk = lz / h;
+        fi = Math.max(0, Math.min(Nx - 1.0001, fi));
+        fj = Math.max(0, Math.min(Ny - 1.0001, fj));
+        fk = Math.max(0, Math.min(Nz - 1.0001, fk));
+        const i0 = Math.floor(fi), i1 = i0 + 1;
+        const j0 = Math.floor(fj), j1 = j0 + 1;
+        const k0 = Math.floor(fk), k1 = k0 + 1;
+        const tx = fi - i0, ty = fj - j0, tz = fk - k0;
+        const idx = (i, j, k) => i + Nx * (j + Ny * k);
+        return (1 - tz) * ((1 - ty) * ((1 - tx) * arr[idx(i0, j0, k0)] + tx * arr[idx(i1, j0, k0)]) +
+            ty * ((1 - tx) * arr[idx(i0, j1, k0)] + tx * arr[idx(i1, j1, k0)])) +
+            tz * ((1 - ty) * ((1 - tx) * arr[idx(i0, j0, k1)] + tx * arr[idx(i1, j0, k1)]) +
+                ty * ((1 - tx) * arr[idx(i0, j1, k1)] + tx * arr[idx(i1, j1, k1)]));
+    }
+    // ── Advection ─────────────────────────────────────────────────────────────
+    _advect(dt) {
+        for (const p of this._particles) {
+            p.x += p.vx * dt;
+            p.y += p.vy * dt;
+            p.z += p.vz * dt;
+        }
+    }
+    _clampParticles() {
+        const { ox, oy, oz, nx, ny, nz, h } = this._grid;
+        const margin = h * 0.5;
+        const xMin = ox + margin, xMax = ox + nx * h - margin;
+        const yMin = oy + margin, yMax = oy + ny * h - margin;
+        const zMin = oz + margin, zMax = oz + nz * h - margin;
+        for (const p of this._particles) {
+            if (p.x < xMin) {
+                p.x = xMin;
+                if (p.vx < 0)
+                    p.vx = 0;
+            }
+            if (p.x > xMax) {
+                p.x = xMax;
+                if (p.vx > 0)
+                    p.vx = 0;
+            }
+            if (p.y < yMin) {
+                p.y = yMin;
+                if (p.vy < 0)
+                    p.vy = 0;
+            }
+            if (p.y > yMax) {
+                p.y = yMax;
+                if (p.vy > 0)
+                    p.vy = 0;
+            }
+            if (p.z < zMin) {
+                p.z = zMin;
+                if (p.vz < 0)
+                    p.vz = 0;
+            }
+            if (p.z > zMax) {
+                p.z = zMax;
+                if (p.vz > 0)
+                    p.vz = 0;
+            }
+        }
+    }
+    // ── Output ────────────────────────────────────────────────────────────────
+    /** Returns particle positions as a flat Float32Array [x,y,z, x,y,z, ...]. */
+    getPositions() {
+        const out = new Float32Array(this._particles.length * 3);
+        for (let i = 0; i < this._particles.length; i++) {
+            out[i * 3] = this._particles[i].x;
+            out[i * 3 + 1] = this._particles[i].y;
+            out[i * 3 + 2] = this._particles[i].z;
+        }
+        return out;
+    }
+    /** Returns particle velocities as a flat Float32Array [vx,vy,vz, ...]. */
+    getVelocities() {
+        const out = new Float32Array(this._particles.length * 3);
+        for (let i = 0; i < this._particles.length; i++) {
+            out[i * 3] = this._particles[i].vx;
+            out[i * 3 + 1] = this._particles[i].vy;
+            out[i * 3 + 2] = this._particles[i].vz;
+        }
+        return out;
+    }
+    /** Number of live particles. */
+    get liveCount() { return this._particles.length; }
+    /** The underlying MAC grid (for advanced use / surface reconstruction). */
+    get grid() { return this._grid; }
+}
+
+/**
+ * SPHSimulator — Smoothed Particle Hydrodynamics fluid simulation.
+ * Blender: Fluid modifier (FLIP/SPH domain).
+ *
+ * Implements the Müller et al. 2003 SPH formulation:
+ *   - Poly6 kernel for density
+ *   - Spiky kernel gradient for pressure
+ *   - Viscosity kernel Laplacian for viscosity
+ *
+ * Workflow:
+ *   1. Construct with particle count + physics parameters
+ *   2. Call `setPositions(array)` to place particles in a volume
+ *   3. Call `step(dt)` each frame (dt ≈ 1/60)
+ *   4. Call `getGeometry()` to read back a THREE.BufferGeometry for rendering
+ *
+ * All physics parameters live in `parameters` for GSAP/st-keyframe:
+ *   gsap.to(sim.parameters, { viscosity: 0.5, duration: 1 })
+ */
+class SPHSimulator {
+    constructor(opts = {}) {
+        // Spatial grid for O(n) neighbour search
+        this._grid = new Map();
+        /** Simulation clock. */
+        this.time = 0;
+        // Domain bounds (AABB collider)
+        this._domainMin = [-2, -2, -2];
+        this._domainMax = [2, 2, 2];
+        this.particleCount = Math.max(1, Math.round(opts.particleCount ?? 500));
+        const h = opts.smoothingRadius ?? 0.3;
+        const g = opts.gravity ?? [0, -9.8, 0];
+        this.viscosityType = opts.viscosityType ?? 'standard';
+        this.parameters = {
+            smoothingRadius: h,
+            restDensity: opts.restDensity ?? 1000,
+            pressureK: opts.pressureK ?? 200,
+            viscosity: opts.viscosity ?? 0.1,
+            xsphFactor: 0.5,
+            stiffFactor: 0.5,
+            gravityX: g[0],
+            gravityY: g[1],
+            gravityZ: g[2],
+            substeps: opts.substeps ?? 4,
+            surfaceTension: opts.surfaceTension ?? 0.0728,
+        };
+        this._px = new Float32Array(this.particleCount);
+        this._py = new Float32Array(this.particleCount);
+        this._pz = new Float32Array(this.particleCount);
+        this._vx = new Float32Array(this.particleCount);
+        this._vy = new Float32Array(this.particleCount);
+        this._vz = new Float32Array(this.particleCount);
+        this._density = new Float32Array(this.particleCount);
+        this._pressure = new Float32Array(this.particleCount);
+        // Default: arrange in a 3D grid block
+        this._initGrid();
+    }
+    // ── Initialisation ────────────────────────────────────────────────────────
+    _initGrid() {
+        const n = this.particleCount;
+        const cbrt = Math.ceil(Math.cbrt(n));
+        const spacing = this.parameters.smoothingRadius * 0.9;
+        let i = 0;
+        outer: for (let z = 0; z < cbrt; z++) {
+            for (let y = 0; y < cbrt; y++) {
+                for (let x = 0; x < cbrt; x++) {
+                    if (i >= n)
+                        break outer;
+                    this._px[i] = (x - cbrt / 2) * spacing;
+                    this._py[i] = (y - cbrt / 2) * spacing;
+                    this._pz[i] = (z - cbrt / 2) * spacing;
+                    i++;
+                }
+            }
+        }
+    }
+    /**
+     * Set particle positions from a flat array [x0,y0,z0, x1,y1,z1, ...].
+     */
+    setPositions(arr) {
+        const n = Math.min(this.particleCount, Math.floor(arr.length / 3));
+        for (let i = 0; i < n; i++) {
+            this._px[i] = arr[i * 3];
+            this._py[i] = arr[i * 3 + 1];
+            this._pz[i] = arr[i * 3 + 2];
+        }
+        this._vx.fill(0);
+        this._vy.fill(0);
+        this._vz.fill(0);
+    }
+    /**
+     * Set simulation domain (AABB boundary collider).
+     * Particles bounce off the domain walls.
+     */
+    setDomain(min, max) {
+        this._domainMin = [...min];
+        this._domainMax = [...max];
+    }
+    // ── Simulation ────────────────────────────────────────────────────────────
+    /**
+     * Advance the simulation by dt seconds.
+     * Recommended: pass clock.getDelta() clamped to 0.05 s.
+     */
+    step(dt) {
+        const sub = Math.max(1, Math.round(this.parameters.substeps));
+        const subDt = dt / sub;
+        for (let s = 0; s < sub; s++)
+            this._substep(subDt);
+        this.time += dt;
+    }
+    /**
+     * Build and return a BufferGeometry with a 'position' attribute.
+     * Suitable for THREE.Points rendering.
+     */
+    getGeometry() {
+        const positions = new Float32Array(this.particleCount * 3);
+        for (let i = 0; i < this.particleCount; i++) {
+            positions[i * 3] = this._px[i];
+            positions[i * 3 + 1] = this._py[i];
+            positions[i * 3 + 2] = this._pz[i];
+        }
+        const geo = new BufferGeometry();
+        geo.setAttribute('position', new BufferAttribute(positions, 3));
+        return geo;
+    }
+    /**
+     * Copy current particle positions into an existing BufferGeometry.
+     * More efficient than getGeometry() in the render loop.
+     */
+    updateGeometry(geo) {
+        const attr = geo.getAttribute('position');
+        const n = Math.min(attr.count, this.particleCount);
+        for (let i = 0; i < n; i++) {
+            attr.setXYZ(i, this._px[i], this._py[i], this._pz[i]);
+        }
+        attr.needsUpdate = true;
+    }
+    /** Per-particle density (read-only, updated after each step). */
+    getDensity(i) { return this._density[i]; }
+    /** Per-particle pressure (read-only). */
+    getPressure(i) { return this._pressure[i]; }
+    // ── Internals ─────────────────────────────────────────────────────────────
+    _substep(dt) {
+        this._buildSpatialGrid();
+        this._computeDensityPressure();
+        this._integrate(dt);
+        if (this.viscosityType === 'xsph')
+            this._applyXSPH();
+        if (this.viscosityType === 'stiff')
+            this._applyStiffViscosity(dt);
+        this._enforceDomain();
+    }
+    // Uniform spatial grid: maps cell key → particle indices
+    _buildSpatialGrid() {
+        const h = this.parameters.smoothingRadius;
+        this._grid.clear();
+        for (let i = 0; i < this.particleCount; i++) {
+            const key = this._cellKey(Math.floor(this._px[i] / h), Math.floor(this._py[i] / h), Math.floor(this._pz[i] / h));
+            let cell = this._grid.get(key);
+            if (!cell) {
+                cell = [];
+                this._grid.set(key, cell);
+            }
+            cell.push(i);
+        }
+    }
+    _cellKey(cx, cy, cz) {
+        // Simple hash: large primes, bit-truncated to 32-bit int range
+        return ((cx * 92837111) ^ (cy * 689287499) ^ (cz * 283923481)) | 0;
+    }
+    _neighbours(i, callback) {
+        const h = this.parameters.smoothingRadius;
+        const h2 = h * h;
+        const cx = Math.floor(this._px[i] / h);
+        const cy = Math.floor(this._py[i] / h);
+        const cz = Math.floor(this._pz[i] / h);
+        for (let dz = -1; dz <= 1; dz++) {
+            for (let dy = -1; dy <= 1; dy++) {
+                for (let dx = -1; dx <= 1; dx++) {
+                    const cell = this._grid.get(this._cellKey(cx + dx, cy + dy, cz + dz));
+                    if (!cell)
+                        continue;
+                    for (const j of cell) {
+                        if (j === i)
+                            continue;
+                        const rx = this._px[j] - this._px[i];
+                        const ry = this._py[j] - this._py[i];
+                        const rz = this._pz[j] - this._pz[i];
+                        const r2 = rx * rx + ry * ry + rz * rz;
+                        if (r2 < h2)
+                            callback(j, r2);
+                    }
+                }
+            }
+        }
+    }
+    // Müller 2003 Poly6 kernel
+    _poly6(r2) {
+        const h = this.parameters.smoothingRadius;
+        const h2 = h * h;
+        if (r2 > h2)
+            return 0;
+        const diff = h2 - r2;
+        return (315 / (64 * Math.PI * Math.pow(h, 9))) * diff * diff * diff;
+    }
+    // Spiky kernel gradient magnitude ∂W/∂r (scalar, apply direction separately)
+    _spikyGrad(r) {
+        const h = this.parameters.smoothingRadius;
+        if (r > h || r < 1e-6)
+            return 0;
+        const diff = h - r;
+        return -(45 / (Math.PI * Math.pow(h, 6))) * diff * diff;
+    }
+    // Viscosity kernel Laplacian
+    _viscLaplacian(r) {
+        const h = this.parameters.smoothingRadius;
+        if (r > h)
+            return 0;
+        return (45 / (Math.PI * Math.pow(h, 6))) * (h - r);
+    }
+    _computeDensityPressure() {
+        const { restDensity, pressureK } = this.parameters;
+        const particleMass = restDensity * Math.pow(this.parameters.smoothingRadius, 3) * 0.02;
+        for (let i = 0; i < this.particleCount; i++) {
+            let rho = this._poly6(0) * particleMass; // self contribution
+            this._neighbours(i, (_j, r2) => {
+                rho += particleMass * this._poly6(r2);
+            });
+            this._density[i] = Math.max(rho, restDensity * 0.001);
+            // Tait equation of state (water)
+            this._pressure[i] = Math.max(0, pressureK * (this._density[i] / restDensity - 1));
+        }
+    }
+    _integrate(dt) {
+        const { gravityX, gravityY, gravityZ, viscosity } = this.parameters;
+        const particleMass = this.parameters.restDensity *
+            Math.pow(this.parameters.smoothingRadius, 3) * 0.02;
+        for (let i = 0; i < this.particleCount; i++) {
+            let fx = 0, fy = 0, fz = 0;
+            const pi = this._pressure[i];
+            const rhoi = this._density[i];
+            this._neighbours(i, (j, r2) => {
+                const rx = this._px[j] - this._px[i];
+                const ry = this._py[j] - this._py[i];
+                const rz = this._pz[j] - this._pz[i];
+                const r = Math.sqrt(r2);
+                if (r < 1e-6)
+                    return;
+                const nx = rx / r, ny = ry / r, nz = rz / r;
+                const rhoj = this._density[j];
+                const pj = this._pressure[j];
+                const m = particleMass;
+                // Pressure force (symmetric formulation)
+                const spg = this._spikyGrad(r);
+                const pf = -m * (pi + pj) / (2 * rhoj) * spg;
+                fx += pf * nx;
+                fy += pf * ny;
+                fz += pf * nz;
+                // Standard viscosity (Müller 2003) — skipped for xsph/stiff modes
+                if (this.viscosityType === 'standard') {
+                    const visc = viscosity * m / rhoj * this._viscLaplacian(r);
+                    fx += visc * (this._vx[j] - this._vx[i]);
+                    fy += visc * (this._vy[j] - this._vy[i]);
+                    fz += visc * (this._vz[j] - this._vz[i]);
+                }
+            });
+            // Gravity
+            fx += gravityX * rhoi;
+            fy += gravityY * rhoi;
+            fz += gravityZ * rhoi;
+            // Euler integration
+            const invRho = 1 / rhoi;
+            this._vx[i] += (fx * invRho) * dt;
+            this._vy[i] += (fy * invRho) * dt;
+            this._vz[i] += (fz * invRho) * dt;
+            this._px[i] += this._vx[i] * dt;
+            this._py[i] += this._vy[i] * dt;
+            this._pz[i] += this._vz[i] * dt;
+        }
+    }
+    /**
+     * XSPH viscosity (Schechter & Bridson 2012).
+     * Blends each particle's velocity toward a weighted average of its neighbours.
+     * More stable than Müller viscosity, good for thick/honey-like fluids.
+     * Controlled by parameters.xsphFactor [0–1].
+     */
+    _applyXSPH() {
+        const h = this.parameters.smoothingRadius;
+        const factor = this.parameters.xsphFactor;
+        const particleMass = this.parameters.restDensity * Math.pow(h, 3) * 0.02;
+        // Temporary correction arrays
+        const cx = new Float32Array(this.particleCount);
+        const cy = new Float32Array(this.particleCount);
+        const cz = new Float32Array(this.particleCount);
+        for (let i = 0; i < this.particleCount; i++) {
+            this._neighbours(i, (j, r2) => {
+                const w = this._poly6(r2);
+                const avgRho = (this._density[i] + this._density[j]) * 0.5;
+                const wm = w * particleMass / avgRho;
+                cx[i] += wm * (this._vx[j] - this._vx[i]);
+                cy[i] += wm * (this._vy[j] - this._vy[i]);
+                cz[i] += wm * (this._vz[j] - this._vz[i]);
+            });
+        }
+        for (let i = 0; i < this.particleCount; i++) {
+            this._vx[i] += factor * cx[i];
+            this._vy[i] += factor * cy[i];
+            this._vz[i] += factor * cz[i];
+        }
+    }
+    /**
+     * Stiff viscosity (position-based / divergence damping).
+     * Applies a velocity correction proportional to the local velocity divergence,
+     * strongly suppressing compressible motion.
+     * Best for near-incompressible high-viscosity simulations.
+     * Controlled by parameters.stiffFactor.
+     */
+    _applyStiffViscosity(dt) {
+        const h = this.parameters.smoothingRadius;
+        const stiff = this.parameters.stiffFactor;
+        const particleMass = this.parameters.restDensity * Math.pow(h, 3) * 0.02;
+        const cx = new Float32Array(this.particleCount);
+        const cy = new Float32Array(this.particleCount);
+        const cz = new Float32Array(this.particleCount);
+        for (let i = 0; i < this.particleCount; i++) {
+            this._neighbours(i, (j, r2) => {
+                const r = Math.sqrt(r2);
+                if (r < 1e-6)
+                    return;
+                const rx = this._px[j] - this._px[i];
+                const ry = this._py[j] - this._py[i];
+                const rz = this._pz[j] - this._pz[i];
+                const dvx = this._vx[j] - this._vx[i];
+                const dvy = this._vy[j] - this._vy[i];
+                const dvz = this._vz[j] - this._vz[i];
+                // Divergence contribution: (v_ij · r_ij) / |r_ij|²
+                const dot = dvx * rx + dvy * ry + dvz * rz;
+                const spg = this._spikyGrad(r);
+                const coef = particleMass / this._density[j] * spg / r;
+                // Velocity correction: push toward incompressibility
+                cx[i] += coef * dot / r2 * rx;
+                cy[i] += coef * dot / r2 * ry;
+                cz[i] += coef * dot / r2 * rz;
+            });
+        }
+        for (let i = 0; i < this.particleCount; i++) {
+            this._vx[i] -= stiff * dt * cx[i];
+            this._vy[i] -= stiff * dt * cy[i];
+            this._vz[i] -= stiff * dt * cz[i];
+        }
+    }
+    _enforceDomain() {
+        const [minX, minY, minZ] = this._domainMin;
+        const [maxX, maxY, maxZ] = this._domainMax;
+        for (let i = 0; i < this.particleCount; i++) {
+            if (this._px[i] < minX) {
+                this._px[i] = minX;
+                if (this._vx[i] < 0)
+                    this._vx[i] *= -0.3;
+            }
+            if (this._px[i] > maxX) {
+                this._px[i] = maxX;
+                if (this._vx[i] > 0)
+                    this._vx[i] *= -0.3;
+            }
+            if (this._py[i] < minY) {
+                this._py[i] = minY;
+                if (this._vy[i] < 0)
+                    this._vy[i] *= -0.3;
+            }
+            if (this._py[i] > maxY) {
+                this._py[i] = maxY;
+                if (this._vy[i] > 0)
+                    this._vy[i] *= -0.3;
+            }
+            if (this._pz[i] < minZ) {
+                this._pz[i] = minZ;
+                if (this._vz[i] < 0)
+                    this._vz[i] *= -0.3;
+            }
+            if (this._pz[i] > maxZ) {
+                this._pz[i] = maxZ;
+                if (this._vz[i] > 0)
+                    this._vz[i] *= -0.3;
+            }
+        }
+    }
+}
+
+class FluidEmitter {
+    constructor(opts = {}) {
+        this.enabled = true;
+        const p = opts.position ?? [0, 0, 0];
+        const v = opts.velocity ?? [0, 0, 0];
+        this.parameters = {
+            posX: p[0], posY: p[1], posZ: p[2],
+            radius: opts.radius ?? 0.5,
+            velX: v[0], velY: v[1], velZ: v[2],
+            jitter: opts.jitter ?? 0.1,
+        };
+    }
+    /** Sample a random spawn position within the emitter sphere. */
+    samplePosition() {
+        const r = this.parameters.radius * Math.cbrt(Math.random());
+        const theta = Math.random() * Math.PI * 2;
+        const phi = Math.acos(2 * Math.random() - 1);
+        const sinPhi = Math.sin(phi);
+        return [
+            this.parameters.posX + r * sinPhi * Math.cos(theta),
+            this.parameters.posY + r * sinPhi * Math.sin(theta),
+            this.parameters.posZ + r * Math.cos(phi),
+        ];
+    }
+    /** Sample initial velocity with jitter. */
+    sampleVelocity() {
+        const j = this.parameters.jitter;
+        return [
+            this.parameters.velX + (Math.random() - 0.5) * j * 2,
+            this.parameters.velY + (Math.random() - 0.5) * j * 2,
+            this.parameters.velZ + (Math.random() - 0.5) * j * 2,
+        ];
+    }
+}
+
+// Full 256-entry Marching Cubes triangle table (Lorensen & Cline 1987).
+// Each entry lists edge indices (0–11) forming triangles; -1 = end.
+// Encoded as flat Int8Array, 16 values per cube case.
+const TRI_TABLE_FLAT = new Int8Array([
+    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    0, 8, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    0, 1, 9, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    1, 8, 3, 9, 8, 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    1, 2, 10, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    0, 8, 3, 1, 2, 10, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    9, 2, 10, 0, 2, 9, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    2, 8, 3, 2, 10, 8, 10, 9, 8, -1, -1, -1, -1, -1, -1, -1,
+    3, 11, 2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    0, 11, 2, 8, 11, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    1, 9, 0, 2, 3, 11, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    1, 11, 2, 1, 9, 11, 9, 8, 11, -1, -1, -1, -1, -1, -1, -1,
+    3, 10, 1, 11, 10, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    0, 10, 1, 0, 8, 10, 8, 11, 10, -1, -1, -1, -1, -1, -1, -1,
+    3, 9, 0, 3, 11, 9, 11, 10, 9, -1, -1, -1, -1, -1, -1, -1,
+    9, 8, 10, 10, 8, 11, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    4, 7, 8, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    4, 3, 0, 7, 3, 4, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    0, 1, 9, 8, 4, 7, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    4, 1, 9, 4, 7, 1, 7, 3, 1, -1, -1, -1, -1, -1, -1, -1,
+    1, 2, 10, 8, 4, 7, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    3, 4, 7, 3, 0, 4, 1, 2, 10, -1, -1, -1, -1, -1, -1, -1,
+    9, 2, 10, 9, 0, 2, 8, 4, 7, -1, -1, -1, -1, -1, -1, -1,
+    2, 10, 9, 2, 9, 7, 2, 7, 3, 7, 9, 4, -1, -1, -1, -1,
+    8, 4, 7, 3, 11, 2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    11, 4, 7, 11, 2, 4, 2, 0, 4, -1, -1, -1, -1, -1, -1, -1,
+    9, 0, 1, 8, 4, 7, 2, 3, 11, -1, -1, -1, -1, -1, -1, -1,
+    4, 7, 11, 9, 4, 11, 9, 11, 2, 9, 2, 1, -1, -1, -1, -1,
+    3, 10, 1, 3, 11, 10, 7, 8, 4, -1, -1, -1, -1, -1, -1, -1,
+    1, 11, 10, 1, 4, 11, 1, 0, 4, 7, 11, 4, -1, -1, -1, -1,
+    4, 7, 8, 9, 0, 11, 9, 11, 10, 11, 0, 3, -1, -1, -1, -1,
+    4, 7, 11, 4, 11, 9, 9, 11, 10, -1, -1, -1, -1, -1, -1, -1,
+    9, 5, 4, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    9, 5, 4, 0, 8, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    0, 5, 4, 1, 5, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    8, 5, 4, 8, 3, 5, 3, 1, 5, -1, -1, -1, -1, -1, -1, -1,
+    1, 2, 10, 9, 5, 4, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    3, 0, 8, 1, 2, 10, 4, 9, 5, -1, -1, -1, -1, -1, -1, -1,
+    5, 2, 10, 5, 4, 2, 4, 0, 2, -1, -1, -1, -1, -1, -1, -1,
+    2, 10, 5, 3, 2, 5, 3, 5, 4, 3, 4, 8, -1, -1, -1, -1,
+    9, 5, 4, 2, 3, 11, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    0, 11, 2, 0, 8, 11, 4, 9, 5, -1, -1, -1, -1, -1, -1, -1,
+    0, 5, 4, 0, 1, 5, 2, 3, 11, -1, -1, -1, -1, -1, -1, -1,
+    2, 1, 5, 2, 5, 8, 2, 8, 11, 4, 8, 5, -1, -1, -1, -1,
+    10, 3, 11, 10, 1, 3, 9, 5, 4, -1, -1, -1, -1, -1, -1, -1,
+    4, 9, 5, 0, 8, 1, 8, 10, 1, 8, 11, 10, -1, -1, -1, -1,
+    5, 4, 0, 5, 0, 11, 5, 11, 10, 11, 0, 3, -1, -1, -1, -1,
+    5, 4, 8, 5, 8, 10, 10, 8, 11, -1, -1, -1, -1, -1, -1, -1,
+    9, 7, 8, 5, 7, 9, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    9, 3, 0, 9, 5, 3, 5, 7, 3, -1, -1, -1, -1, -1, -1, -1,
+    0, 7, 8, 0, 1, 7, 1, 5, 7, -1, -1, -1, -1, -1, -1, -1,
+    1, 5, 3, 3, 5, 7, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    9, 7, 8, 9, 5, 7, 10, 1, 2, -1, -1, -1, -1, -1, -1, -1,
+    10, 1, 2, 9, 5, 0, 5, 3, 0, 5, 7, 3, -1, -1, -1, -1,
+    8, 0, 2, 8, 2, 5, 8, 5, 7, 10, 5, 2, -1, -1, -1, -1,
+    2, 10, 5, 2, 5, 3, 3, 5, 7, -1, -1, -1, -1, -1, -1, -1,
+    7, 9, 5, 7, 8, 9, 3, 11, 2, -1, -1, -1, -1, -1, -1, -1,
+    9, 5, 7, 9, 7, 2, 9, 2, 0, 2, 7, 11, -1, -1, -1, -1,
+    2, 3, 11, 0, 1, 8, 1, 7, 8, 1, 5, 7, -1, -1, -1, -1,
+    11, 2, 1, 11, 1, 7, 7, 1, 5, -1, -1, -1, -1, -1, -1, -1,
+    9, 5, 8, 8, 5, 7, 10, 1, 3, 10, 3, 11, -1, -1, -1, -1,
+    5, 7, 0, 5, 0, 9, 7, 11, 0, 1, 0, 10, 11, 10, 0, -1,
+    11, 10, 0, 11, 0, 3, 10, 5, 0, 8, 0, 7, 5, 7, 0, -1,
+    11, 10, 5, 7, 11, 5, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    10, 6, 5, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    0, 8, 3, 5, 10, 6, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    9, 0, 1, 5, 10, 6, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    1, 8, 3, 1, 9, 8, 5, 10, 6, -1, -1, -1, -1, -1, -1, -1,
+    1, 6, 5, 2, 6, 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    1, 6, 5, 1, 2, 6, 3, 0, 8, -1, -1, -1, -1, -1, -1, -1,
+    9, 6, 5, 9, 0, 6, 0, 2, 6, -1, -1, -1, -1, -1, -1, -1,
+    5, 9, 8, 5, 8, 2, 5, 2, 6, 3, 2, 8, -1, -1, -1, -1,
+    2, 3, 11, 10, 6, 5, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    11, 0, 8, 11, 2, 0, 10, 6, 5, -1, -1, -1, -1, -1, -1, -1,
+    0, 1, 9, 2, 3, 11, 5, 10, 6, -1, -1, -1, -1, -1, -1, -1,
+    5, 10, 6, 1, 9, 2, 9, 11, 2, 9, 8, 11, -1, -1, -1, -1,
+    6, 3, 11, 6, 5, 3, 5, 1, 3, -1, -1, -1, -1, -1, -1, -1,
+    0, 8, 11, 0, 11, 5, 0, 5, 1, 5, 11, 6, -1, -1, -1, -1,
+    3, 11, 6, 0, 3, 6, 0, 6, 5, 0, 5, 9, -1, -1, -1, -1,
+    6, 5, 9, 6, 9, 11, 11, 9, 8, -1, -1, -1, -1, -1, -1, -1,
+    5, 10, 6, 4, 7, 8, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    4, 3, 0, 4, 7, 3, 6, 5, 10, -1, -1, -1, -1, -1, -1, -1,
+    1, 9, 0, 5, 10, 6, 8, 4, 7, -1, -1, -1, -1, -1, -1, -1,
+    10, 6, 5, 1, 9, 7, 1, 7, 3, 7, 9, 4, -1, -1, -1, -1,
+    6, 1, 2, 6, 5, 1, 4, 7, 8, -1, -1, -1, -1, -1, -1, -1,
+    1, 2, 5, 5, 2, 6, 3, 0, 4, 3, 4, 7, -1, -1, -1, -1,
+    8, 4, 7, 9, 0, 5, 0, 6, 5, 0, 2, 6, -1, -1, -1, -1,
+    7, 3, 9, 7, 9, 4, 3, 2, 9, 5, 9, 6, 2, 6, 9, -1,
+    3, 11, 2, 7, 8, 4, 10, 6, 5, -1, -1, -1, -1, -1, -1, -1,
+    5, 10, 6, 4, 7, 2, 4, 2, 0, 2, 7, 11, -1, -1, -1, -1,
+    0, 1, 9, 4, 7, 8, 2, 3, 11, 5, 10, 6, -1, -1, -1, -1,
+    9, 2, 1, 9, 11, 2, 9, 4, 11, 7, 11, 4, 5, 10, 6, -1,
+    8, 4, 7, 3, 11, 5, 3, 5, 1, 5, 11, 6, -1, -1, -1, -1,
+    5, 1, 11, 5, 11, 6, 1, 0, 11, 7, 11, 4, 0, 4, 11, -1,
+    0, 5, 9, 0, 6, 5, 0, 3, 6, 11, 6, 3, 8, 4, 7, -1,
+    6, 5, 9, 6, 9, 11, 4, 7, 9, 7, 11, 9, -1, -1, -1, -1,
+    10, 4, 9, 6, 4, 10, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    4, 10, 6, 4, 9, 10, 0, 8, 3, -1, -1, -1, -1, -1, -1, -1,
+    10, 0, 1, 10, 6, 0, 6, 4, 0, -1, -1, -1, -1, -1, -1, -1,
+    8, 3, 1, 8, 1, 6, 8, 6, 4, 6, 1, 10, -1, -1, -1, -1,
+    1, 4, 9, 1, 2, 4, 2, 6, 4, -1, -1, -1, -1, -1, -1, -1,
+    3, 0, 8, 1, 2, 9, 2, 4, 9, 2, 6, 4, -1, -1, -1, -1,
+    0, 2, 4, 4, 2, 6, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    8, 3, 2, 8, 2, 4, 4, 2, 6, -1, -1, -1, -1, -1, -1, -1,
+    10, 4, 9, 10, 6, 4, 11, 2, 3, -1, -1, -1, -1, -1, -1, -1,
+    0, 8, 2, 2, 8, 11, 4, 9, 10, 4, 10, 6, -1, -1, -1, -1,
+    3, 11, 2, 0, 1, 6, 0, 6, 4, 6, 1, 10, -1, -1, -1, -1,
+    6, 4, 1, 6, 1, 10, 4, 8, 1, 2, 1, 11, 8, 11, 1, -1,
+    9, 6, 4, 9, 3, 6, 9, 1, 3, 11, 6, 3, -1, -1, -1, -1,
+    8, 11, 1, 8, 1, 0, 11, 6, 1, 9, 1, 4, 6, 4, 1, -1,
+    3, 11, 6, 3, 6, 0, 0, 6, 4, -1, -1, -1, -1, -1, -1, -1,
+    6, 4, 8, 11, 6, 8, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    7, 10, 6, 7, 8, 10, 8, 9, 10, -1, -1, -1, -1, -1, -1, -1,
+    0, 7, 3, 0, 10, 7, 0, 9, 10, 6, 7, 10, -1, -1, -1, -1,
+    10, 6, 7, 1, 10, 7, 1, 7, 8, 1, 8, 0, -1, -1, -1, -1,
+    10, 6, 7, 10, 7, 1, 1, 7, 3, -1, -1, -1, -1, -1, -1, -1,
+    1, 2, 6, 1, 6, 8, 1, 8, 9, 8, 6, 7, -1, -1, -1, -1,
+    2, 6, 9, 2, 9, 1, 6, 7, 9, 0, 9, 3, 7, 3, 9, -1,
+    7, 8, 0, 7, 0, 6, 6, 0, 2, -1, -1, -1, -1, -1, -1, -1,
+    7, 3, 2, 6, 7, 2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    2, 3, 11, 10, 6, 8, 10, 8, 9, 8, 6, 7, -1, -1, -1, -1,
+    2, 0, 7, 2, 7, 11, 0, 9, 7, 6, 7, 10, 9, 10, 7, -1,
+    1, 8, 0, 1, 7, 8, 1, 10, 7, 6, 7, 10, 2, 3, 11, -1,
+    11, 2, 1, 11, 1, 7, 10, 6, 1, 6, 7, 1, -1, -1, -1, -1,
+    8, 9, 6, 8, 6, 7, 9, 1, 6, 11, 6, 3, 1, 3, 6, -1,
+    0, 9, 1, 11, 6, 7, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    7, 8, 0, 7, 0, 6, 3, 11, 0, 11, 6, 0, -1, -1, -1, -1,
+    7, 11, 6, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    7, 6, 11, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    3, 0, 8, 11, 7, 6, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    0, 1, 9, 11, 7, 6, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    8, 1, 9, 8, 3, 1, 11, 7, 6, -1, -1, -1, -1, -1, -1, -1,
+    10, 1, 2, 6, 11, 7, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    1, 2, 10, 3, 0, 8, 6, 11, 7, -1, -1, -1, -1, -1, -1, -1,
+    2, 9, 0, 2, 10, 9, 6, 11, 7, -1, -1, -1, -1, -1, -1, -1,
+    6, 11, 7, 2, 10, 3, 10, 8, 3, 10, 9, 8, -1, -1, -1, -1,
+    7, 2, 3, 6, 2, 7, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    7, 0, 8, 7, 6, 0, 6, 2, 0, -1, -1, -1, -1, -1, -1, -1,
+    2, 7, 6, 2, 3, 7, 0, 1, 9, -1, -1, -1, -1, -1, -1, -1,
+    1, 6, 2, 1, 8, 6, 1, 9, 8, 8, 7, 6, -1, -1, -1, -1,
+    10, 7, 6, 10, 1, 7, 1, 3, 7, -1, -1, -1, -1, -1, -1, -1,
+    10, 7, 6, 1, 7, 10, 1, 8, 7, 1, 0, 8, -1, -1, -1, -1,
+    0, 3, 7, 0, 7, 10, 0, 10, 9, 6, 10, 7, -1, -1, -1, -1,
+    7, 6, 10, 7, 10, 8, 8, 10, 9, -1, -1, -1, -1, -1, -1, -1,
+    6, 8, 4, 11, 8, 6, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    3, 6, 11, 3, 0, 6, 0, 4, 6, -1, -1, -1, -1, -1, -1, -1,
+    8, 6, 11, 8, 4, 6, 9, 0, 1, -1, -1, -1, -1, -1, -1, -1,
+    9, 4, 6, 9, 6, 3, 9, 3, 1, 11, 3, 6, -1, -1, -1, -1,
+    6, 8, 4, 6, 11, 8, 2, 10, 1, -1, -1, -1, -1, -1, -1, -1,
+    1, 2, 10, 3, 0, 11, 0, 6, 11, 0, 4, 6, -1, -1, -1, -1,
+    4, 11, 8, 4, 6, 11, 0, 2, 9, 2, 10, 9, -1, -1, -1, -1,
+    10, 9, 3, 10, 3, 2, 9, 4, 3, 11, 3, 6, 4, 6, 3, -1,
+    8, 2, 3, 8, 4, 2, 4, 6, 2, -1, -1, -1, -1, -1, -1, -1,
+    0, 4, 2, 4, 6, 2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    1, 9, 0, 2, 3, 4, 2, 4, 6, 4, 3, 8, -1, -1, -1, -1,
+    1, 9, 4, 1, 4, 2, 2, 4, 6, -1, -1, -1, -1, -1, -1, -1,
+    8, 1, 3, 8, 6, 1, 8, 4, 6, 6, 10, 1, -1, -1, -1, -1,
+    10, 1, 0, 10, 0, 6, 6, 0, 4, -1, -1, -1, -1, -1, -1, -1,
+    4, 6, 3, 4, 3, 8, 6, 10, 3, 0, 3, 9, 10, 9, 3, -1,
+    10, 9, 4, 6, 10, 4, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    4, 9, 5, 7, 6, 11, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    0, 8, 3, 4, 9, 5, 11, 7, 6, -1, -1, -1, -1, -1, -1, -1,
+    5, 0, 1, 5, 4, 0, 7, 6, 11, -1, -1, -1, -1, -1, -1, -1,
+    11, 7, 6, 8, 3, 4, 3, 5, 4, 3, 1, 5, -1, -1, -1, -1,
+    9, 5, 4, 10, 1, 2, 7, 6, 11, -1, -1, -1, -1, -1, -1, -1,
+    6, 11, 7, 1, 2, 10, 0, 8, 3, 4, 9, 5, -1, -1, -1, -1,
+    7, 6, 11, 5, 4, 10, 4, 2, 10, 4, 0, 2, -1, -1, -1, -1,
+    3, 4, 8, 3, 5, 4, 3, 2, 5, 10, 5, 2, 11, 7, 6, -1,
+    7, 2, 3, 7, 6, 2, 5, 4, 9, -1, -1, -1, -1, -1, -1, -1,
+    9, 5, 4, 0, 8, 6, 0, 6, 2, 6, 8, 7, -1, -1, -1, -1,
+    3, 6, 2, 3, 7, 6, 1, 5, 0, 5, 4, 0, -1, -1, -1, -1,
+    6, 2, 8, 6, 8, 7, 2, 1, 8, 4, 8, 5, 1, 5, 8, -1,
+    9, 5, 4, 10, 1, 6, 1, 7, 6, 1, 3, 7, -1, -1, -1, -1,
+    1, 6, 10, 1, 7, 6, 1, 0, 7, 8, 7, 0, 9, 5, 4, -1,
+    4, 0, 10, 4, 10, 5, 0, 3, 10, 6, 10, 7, 3, 7, 10, -1,
+    7, 6, 10, 7, 10, 8, 5, 4, 10, 4, 8, 10, -1, -1, -1, -1,
+    6, 9, 5, 6, 11, 9, 11, 8, 9, -1, -1, -1, -1, -1, -1, -1,
+    3, 6, 11, 0, 6, 3, 0, 5, 6, 0, 9, 5, -1, -1, -1, -1,
+    0, 11, 8, 0, 5, 11, 0, 1, 5, 5, 6, 11, -1, -1, -1, -1,
+    6, 11, 3, 6, 3, 5, 5, 3, 1, -1, -1, -1, -1, -1, -1, -1,
+    1, 2, 10, 9, 5, 11, 9, 11, 8, 11, 5, 6, -1, -1, -1, -1,
+    0, 11, 3, 0, 6, 11, 0, 9, 6, 5, 6, 9, 1, 2, 10, -1,
+    11, 8, 5, 11, 5, 6, 8, 0, 5, 10, 5, 2, 0, 2, 5, -1,
+    6, 11, 3, 6, 3, 5, 2, 10, 3, 10, 5, 3, -1, -1, -1, -1,
+    5, 8, 9, 5, 2, 8, 5, 6, 2, 3, 8, 2, -1, -1, -1, -1,
+    9, 5, 6, 9, 6, 0, 0, 6, 2, -1, -1, -1, -1, -1, -1, -1,
+    1, 5, 8, 1, 8, 0, 5, 6, 8, 3, 8, 2, 6, 2, 8, -1,
+    1, 5, 6, 2, 1, 6, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    1, 3, 6, 1, 6, 10, 3, 8, 6, 5, 6, 9, 8, 9, 6, -1,
+    10, 1, 0, 10, 0, 6, 9, 5, 0, 5, 6, 0, -1, -1, -1, -1,
+    0, 3, 8, 5, 6, 10, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    10, 5, 6, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    11, 5, 10, 7, 5, 11, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    11, 5, 10, 11, 7, 5, 8, 3, 0, -1, -1, -1, -1, -1, -1, -1,
+    5, 11, 7, 5, 10, 11, 1, 9, 0, -1, -1, -1, -1, -1, -1, -1,
+    10, 7, 5, 10, 11, 7, 9, 8, 1, 8, 3, 1, -1, -1, -1, -1,
+    11, 1, 2, 11, 7, 1, 7, 5, 1, -1, -1, -1, -1, -1, -1, -1,
+    0, 8, 3, 1, 2, 7, 1, 7, 5, 7, 2, 11, -1, -1, -1, -1,
+    9, 7, 5, 9, 2, 7, 9, 0, 2, 2, 11, 7, -1, -1, -1, -1,
+    7, 5, 2, 7, 2, 11, 5, 9, 2, 3, 2, 8, 9, 8, 2, -1,
+    2, 5, 10, 2, 3, 5, 3, 7, 5, -1, -1, -1, -1, -1, -1, -1,
+    8, 2, 0, 8, 5, 2, 8, 7, 5, 10, 2, 5, -1, -1, -1, -1,
+    9, 0, 1, 5, 10, 3, 5, 3, 7, 3, 10, 2, -1, -1, -1, -1,
+    9, 8, 2, 9, 2, 1, 8, 7, 2, 10, 2, 5, 7, 5, 2, -1,
+    1, 3, 5, 3, 7, 5, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    0, 8, 7, 0, 7, 1, 1, 7, 5, -1, -1, -1, -1, -1, -1, -1,
+    9, 0, 3, 9, 3, 5, 5, 3, 7, -1, -1, -1, -1, -1, -1, -1,
+    9, 8, 7, 5, 9, 7, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    5, 8, 4, 5, 10, 8, 10, 11, 8, -1, -1, -1, -1, -1, -1, -1,
+    5, 0, 4, 5, 11, 0, 5, 10, 11, 11, 3, 0, -1, -1, -1, -1,
+    0, 1, 9, 8, 4, 10, 8, 10, 11, 10, 4, 5, -1, -1, -1, -1,
+    10, 11, 4, 10, 4, 5, 11, 3, 4, 9, 4, 1, 3, 1, 4, -1,
+    2, 5, 1, 2, 8, 5, 2, 11, 8, 4, 5, 8, -1, -1, -1, -1,
+    0, 4, 11, 0, 11, 3, 4, 5, 11, 2, 11, 1, 5, 1, 11, -1,
+    0, 2, 5, 0, 5, 9, 2, 11, 5, 4, 5, 8, 11, 8, 5, -1,
+    9, 4, 5, 2, 11, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    2, 5, 10, 3, 5, 2, 3, 4, 5, 3, 8, 4, -1, -1, -1, -1,
+    5, 10, 2, 5, 2, 4, 4, 2, 0, -1, -1, -1, -1, -1, -1, -1,
+    3, 10, 2, 3, 5, 10, 3, 8, 5, 4, 5, 8, 0, 1, 9, -1,
+    5, 10, 2, 5, 2, 4, 1, 9, 2, 9, 4, 2, -1, -1, -1, -1,
+    8, 4, 5, 8, 5, 3, 3, 5, 1, -1, -1, -1, -1, -1, -1, -1,
+    0, 4, 5, 1, 0, 5, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    8, 4, 5, 8, 5, 3, 9, 0, 5, 0, 3, 5, -1, -1, -1, -1,
+    9, 4, 5, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    4, 11, 7, 4, 9, 11, 9, 10, 11, -1, -1, -1, -1, -1, -1, -1,
+    0, 8, 3, 4, 9, 7, 9, 11, 7, 9, 10, 11, -1, -1, -1, -1,
+    1, 10, 11, 1, 11, 4, 1, 4, 0, 7, 4, 11, -1, -1, -1, -1,
+    3, 1, 4, 3, 4, 8, 1, 10, 4, 7, 4, 11, 10, 11, 4, -1,
+    4, 11, 7, 9, 11, 4, 9, 2, 11, 9, 1, 2, -1, -1, -1, -1,
+    9, 7, 4, 9, 11, 7, 9, 1, 11, 2, 11, 1, 0, 8, 3, -1,
+    11, 7, 4, 11, 4, 2, 2, 4, 0, -1, -1, -1, -1, -1, -1, -1,
+    11, 7, 4, 11, 4, 2, 8, 3, 4, 3, 2, 4, -1, -1, -1, -1,
+    2, 9, 10, 2, 7, 9, 2, 3, 7, 7, 4, 9, -1, -1, -1, -1,
+    9, 10, 7, 9, 7, 4, 10, 2, 7, 8, 7, 0, 2, 0, 7, -1,
+    3, 7, 10, 3, 10, 2, 7, 4, 10, 1, 10, 0, 4, 0, 10, -1,
+    1, 10, 2, 8, 7, 4, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    4, 9, 1, 4, 1, 7, 7, 1, 3, -1, -1, -1, -1, -1, -1, -1,
+    4, 9, 1, 4, 1, 7, 0, 8, 1, 8, 7, 1, -1, -1, -1, -1,
+    4, 0, 3, 7, 4, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    4, 8, 7, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    9, 10, 8, 10, 11, 8, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    3, 0, 9, 3, 9, 11, 11, 9, 10, -1, -1, -1, -1, -1, -1, -1,
+    0, 1, 10, 0, 10, 8, 8, 10, 11, -1, -1, -1, -1, -1, -1, -1,
+    3, 1, 10, 11, 3, 10, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    1, 2, 11, 1, 11, 9, 9, 11, 8, -1, -1, -1, -1, -1, -1, -1,
+    3, 0, 9, 3, 9, 11, 1, 2, 9, 2, 11, 9, -1, -1, -1, -1,
+    0, 2, 11, 8, 0, 11, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    3, 2, 11, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    2, 3, 8, 2, 8, 10, 10, 8, 9, -1, -1, -1, -1, -1, -1, -1,
+    9, 10, 2, 0, 9, 2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    2, 3, 8, 2, 8, 10, 0, 1, 8, 1, 10, 8, -1, -1, -1, -1,
+    1, 10, 2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    1, 3, 8, 9, 1, 8, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    0, 9, 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    0, 3, 8, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+]);
+// Pre-computed cube vertex offsets
+const CUBE_VERTS = [
+    [0, 0, 0], [1, 0, 0], [1, 1, 0], [0, 1, 0],
+    [0, 0, 1], [1, 0, 1], [1, 1, 1], [0, 1, 1],
+];
+// Pre-computed cube edge endpoints
+const CUBE_EDGES = [
+    [0, 1], [1, 2], [2, 3], [3, 0],
+    [4, 5], [5, 6], [6, 7], [7, 4],
+    [0, 4], [1, 5], [2, 6], [3, 7],
+];
+// EDGE_TABLE from standard MC reference
+const EDGE_TABLE = new Uint16Array([
+    0x0, 0x109, 0x203, 0x30a, 0x406, 0x50f, 0x605, 0x70c,
+    0x80c, 0x905, 0xa0f, 0xb06, 0xc0a, 0xd03, 0xe09, 0xf00,
+    0x190, 0x99, 0x393, 0x29a, 0x596, 0x49f, 0x795, 0x69c,
+    0x99c, 0x895, 0xb9f, 0xa96, 0xd9a, 0xc93, 0xf99, 0xe90,
+    0x230, 0x339, 0x33, 0x13a, 0x636, 0x73f, 0x435, 0x53c,
+    0xa3c, 0xb35, 0x83f, 0x936, 0xe3a, 0xf33, 0xc39, 0xd30,
+    0x3a0, 0x2a9, 0x1a3, 0xaa, 0x7a6, 0x6af, 0x5a5, 0x4ac,
+    0xbac, 0xaa5, 0x9af, 0x8a6, 0xfaa, 0xea3, 0xda9, 0xca0,
+    0x460, 0x569, 0x663, 0x76a, 0x66, 0x16f, 0x265, 0x36c,
+    0xc6c, 0xd65, 0xe6f, 0xf66, 0x86a, 0x963, 0xa69, 0xb60,
+    0x5f0, 0x4f9, 0x7f3, 0x6fa, 0x1f6, 0xff, 0x3f5, 0x2fc,
+    0xdfc, 0xcf5, 0xfff, 0xef6, 0x9fa, 0x8f3, 0xbf9, 0xaf0,
+    0x650, 0x759, 0x453, 0x55a, 0x256, 0x35f, 0x55, 0x15c,
+    0xe5c, 0xf55, 0xc5f, 0xd56, 0xa5a, 0xb53, 0x859, 0x950,
+    0x7c0, 0x6c9, 0x5c3, 0x4ca, 0x3c6, 0x2cf, 0x1c5, 0xcc,
+    0xfcc, 0xec5, 0xdcf, 0xcc6, 0xbca, 0xac3, 0x9c9, 0x8c0,
+    0x8c0, 0x9c9, 0xac3, 0xbca, 0xcc6, 0xdcf, 0xec5, 0xfcc,
+    0xcc, 0x1c5, 0x2cf, 0x3c6, 0x4ca, 0x5c3, 0x6c9, 0x7c0,
+    0x950, 0x859, 0xb53, 0xa5a, 0xd56, 0xc5f, 0xf55, 0xe5c,
+    0x15c, 0x55, 0x35f, 0x256, 0x55a, 0x453, 0x759, 0x650,
+    0xaf0, 0xbf9, 0x8f3, 0x9fa, 0xef6, 0xfff, 0xcf5, 0xdfc,
+    0x2fc, 0x3f5, 0xff, 0x1f6, 0x6fa, 0x7f3, 0x4f9, 0x5f0,
+    0xb60, 0xa69, 0x963, 0x86a, 0xf66, 0xe6f, 0xd65, 0xc6c,
+    0x36c, 0x265, 0x16f, 0x66, 0x76a, 0x663, 0x569, 0x460,
+    0xca0, 0xda9, 0xea3, 0xfaa, 0x8a6, 0x9af, 0xaa5, 0xbac,
+    0x4ac, 0x5a5, 0x6af, 0x7a6, 0xaa, 0x1a3, 0x2a9, 0x3a0,
+    0xd30, 0xc39, 0xf33, 0xe3a, 0x936, 0x83f, 0xb35, 0xa3c,
+    0x53c, 0x435, 0x73f, 0x636, 0x13a, 0x33, 0x339, 0x230,
+    0xe90, 0xf99, 0xc93, 0xd9a, 0xa96, 0xb9f, 0x895, 0x99c,
+    0x69c, 0x795, 0x49f, 0x596, 0x29a, 0x393, 0x99, 0x190,
+    0xf00, 0xe09, 0xd03, 0xc0a, 0xb06, 0xa0f, 0x905, 0x80c,
+    0x70c, 0x605, 0x50f, 0x406, 0x30a, 0x203, 0x109, 0x0,
+]);
+/**
+ * MarchingCubes — extracts an iso-surface from a scalar field.
+ * Used to turn SPH particle density fields into a mesh.
+ * Blender: Fluid > Surface.
+ *
+ * Usage:
+ *   const mc = new MarchingCubes({ resolution: 32 })
+ *   mc.setField(myDensityFn)   // (x,y,z) => density
+ *   const geo = mc.extract()
+ */
+class MarchingCubes {
+    constructor(opts = {}) {
+        this._field = null;
+        this._boundsMin = [-2, -2, -2];
+        this._boundsMax = [2, 2, 2];
+        this.parameters = {
+            resolution: Math.max(4, Math.round(opts.resolution ?? 32)),
+            isoLevel: opts.isoLevel ?? 0.5,
+        };
+    }
+    /**
+     * Set the scalar field function: (x,y,z) → density.
+     * For SPH, use a metaball kernel summed over nearby particles.
+     */
+    setField(fn) {
+        this._field = fn;
+    }
+    /** Set world-space bounds of the sampling volume. */
+    setBounds(min, max) {
+        this._boundsMin = [...min];
+        this._boundsMax = [...max];
+    }
+    /**
+     * Sample the field and extract the iso-surface as a BufferGeometry.
+     * Returns null if no field is set.
+     */
+    extract() {
+        if (!this._field)
+            return null;
+        const { resolution, isoLevel } = this.parameters;
+        const [x0, y0, z0] = this._boundsMin;
+        const [x1, y1, z1] = this._boundsMax;
+        const dx = (x1 - x0) / resolution;
+        const dy = (y1 - y0) / resolution;
+        const dz = (z1 - z0) / resolution;
+        const vertices = [];
+        const size = resolution + 1;
+        // Sample field on a uniform grid
+        const field = new Float32Array(size * size * size);
+        for (let iz = 0; iz <= resolution; iz++) {
+            for (let iy = 0; iy <= resolution; iy++) {
+                for (let ix = 0; ix <= resolution; ix++) {
+                    field[iz * size * size + iy * size + ix] = this._field(x0 + ix * dx, y0 + iy * dy, z0 + iz * dz);
+                }
+            }
+        }
+        const idx = (ix, iy, iz) => field[iz * size * size + iy * size + ix];
+        // Edge vertex interpolation cache
+        const edgeVerts = new Array(12);
+        for (let iz = 0; iz < resolution; iz++) {
+            for (let iy = 0; iy < resolution; iy++) {
+                for (let ix = 0; ix < resolution; ix++) {
+                    let cubeIdx = 0;
+                    for (let v = 0; v < 8; v++) {
+                        const [vx, vy, vz] = CUBE_VERTS[v];
+                        if (idx(ix + vx, iy + vy, iz + vz) < isoLevel)
+                            cubeIdx |= (1 << v);
+                    }
+                    if (EDGE_TABLE[cubeIdx] === 0)
+                        continue;
+                    for (let e = 0; e < 12; e++) {
+                        if (EDGE_TABLE[cubeIdx] & (1 << e)) {
+                            const [v0, v1] = CUBE_EDGES[e];
+                            const [ax, ay, az] = CUBE_VERTS[v0];
+                            const [bx, by, bz] = CUBE_VERTS[v1];
+                            const fa = idx(ix + ax, iy + ay, iz + az);
+                            const fb = idx(ix + bx, iy + by, iz + bz);
+                            const t = Math.abs(fa - fb) < 1e-6 ? 0.5 : (isoLevel - fa) / (fb - fa);
+                            edgeVerts[e] = [
+                                x0 + (ix + ax + (bx - ax) * t) * dx,
+                                y0 + (iy + ay + (by - ay) * t) * dy,
+                                z0 + (iz + az + (bz - az) * t) * dz,
+                            ];
+                        }
+                    }
+                    // Walk triangle table at cubeIdx*16
+                    const base = cubeIdx * 16;
+                    for (let t = 0; t < 15; t += 3) {
+                        const i0 = TRI_TABLE_FLAT[base + t];
+                        if (i0 < 0)
+                            break;
+                        const i1 = TRI_TABLE_FLAT[base + t + 1];
+                        const i2 = TRI_TABLE_FLAT[base + t + 2];
+                        const [px, py, pz] = edgeVerts[i0];
+                        const [qx, qy, qz] = edgeVerts[i1];
+                        const [rx, ry, rz] = edgeVerts[i2];
+                        vertices.push(px, py, pz, qx, qy, qz, rx, ry, rz);
+                    }
+                }
+            }
+        }
+        const geo = new BufferGeometry();
+        geo.setAttribute('position', new BufferAttribute(new Float32Array(vertices), 3));
+        geo.computeVertexNormals();
+        return geo;
+    }
+}
+
+export { FLIPSimulator, FluidEmitter, MACGrid, MarchingCubes, SPHSimulator };