@woosh/meep-engine 2.139.0 → 2.141.0

package/src/engine/physics/fluid/FluidField.d.ts

@@ -45,17 +45,21 @@ export class FluidField {
      * Per-cell pre-baked neighbourhood mask consumed by the pressure SOR loop.
      * One byte per cell encoding which of the 6 cardinal neighbours are fluid:
      *
-     *     bit 0 (= 1)  : -x neighbour is fluid (in-bounds AND non-solid)
-     *     bit 1 (= 2)  : +x neighbour is fluid
-     *     bit 2 (= 4)  : -y neighbour is fluid
-     *     bit 3 (= 8)  : +y neighbour is fluid
-     *     bit 4 (= 16) : -z neighbour is fluid
-     *     bit 5 (= 32) : +z neighbour is fluid
+     *     bit 0 (= 1)   : -x neighbour is fluid (in-bounds AND non-solid)
+     *     bit 1 (= 2)   : +x neighbour is fluid
+     *     bit 2 (= 4)   : -y neighbour is fluid
+     *     bit 3 (= 8)   : +y neighbour is fluid
+     *     bit 4 (= 16)  : -z neighbour is fluid
+     *     bit 5 (= 32)  : +z neighbour is fluid
+     *     bit 7 (= 128) : this cell is itself solid
      *
-     * Solid cells themselves are encoded as `mask = 0` so the SOR loop's
-     * `if (mask === 0) continue` skip handles both "this cell is solid" and
-     * "this fluid cell is isolated" with a single comparison instead of one
-     * solid-self-check plus six solid-neighbour-checks plus six boundary checks.
+     * A solid cell encodes as `128` (bit 7 set, neighbour bits clear) and an
+     * isolated fluid cell as `0`, so the SOR / PCG loops' `if ((mask & 63) === 0)
+     * continue` skip handles both "this cell is solid" and "this fluid cell is
+     * isolated" with a single comparison instead of one solid-self-check plus six
+     * solid-neighbour-checks plus six boundary checks. Bit 7 additionally lets
+     * {@link v3_grid_subtract_pressure_gradient} zero solid-cell velocity without
+     * consulting the {@link solid} array.
      *
      * Computed once by {@link recomputeSolidNeighbourMask} after every solid-mask
      * mutation. The simulator runs that recompute at the top of every project()

package/src/engine/physics/fluid/FluidField.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"FluidField.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/fluid/FluidField.js"],"names":[],"mappings":"AASA;;;;;;;;;;;;;;;;;;;GAmBG;AACH;IAQI;;;;OAIG;IACH,YAFU,YAAY,GAAC,IAAI,CAET;IAElB;;OAEG;IACH,YAFU,YAAY,GAAC,IAAI,CAET;IAElB;;OAEG;IACH,YAFU,YAAY,GAAC,IAAI,CAET;IAElB;;;;;;OAMG;IACH,OAFU,UAAU,GAAC,IAAI,CAEZ;IAEb;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACH,sBAFU,UAAU,GAAC,IAAI,CAEG;IAE5B;;;;;;;;;;;;;OAaG;IACH,UAFU,YAAY,kBAAc,IAAI,CAExB;IAEhB;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA4BG;IACH,yBAFU,OAAO,CAEe;IAShC;;;;;;OAMG;IACH,qBAJW,MAAM,SACN,MAAM,SACN,MAAM,QAWhB;IAED;;;OAGG;IACH,iBAHY,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAKnC;IAED;;;OAGG;IACH,aAHY,MAAM,CAKjB;IAED;;;;;;;;;OASG;IACH,gBAHW,MAAM,GACL,MAAM,CAejB;IAED;;;OAGG;IACH,kBAHW,MAAM,GACL,MAAM,CAIjB;IAED;;;;OAIG;IACH,oBAJW,MAAM,GACL,YAAY,GAAC,IAAI,CAM5B;IAED;;OAEG;IACH,uBAFY;QAAE,MAAM,MAAM,CAAC;QAAC,IAAI,EAAE,YAAY,CAAA;KAAE,EAAE,CAIjD;IAED;;;OAGG;IACH,cAmBC;IAED;;;;;;OAMG;IACH,aALW,MAAM,KACN,MAAM,KACN,MAAM,GACL,MAAM,CAajB;IAED;;;;;;;;OAQG;IACH,iBAPW,MAAM,KACN,MAAM,KACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QAOhB;IAED;;;;;;;;OAQG;IACH,iBAPW,MAAM,KACN,MAAM,KACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,QAOhB;IAED;;;;;;OAMG;IACH,kCANW,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,SACN,MAAM,QAOhB;IAED;;;;;;OAMG;IACH,cALW,MAAM,KACN,MAAM,KACN,MAAM,YACN,OAAO,QAIjB;IAED;;;;;OAKG;IACH,aALW,MAAM,KACN,MAAM,KACN,MAAM,GACL,OAAO,CAIlB;IAED;;;;;;;;OAQG;IACH,oBANW,YAAY,GAAC,MAAM,EAAE,KACrB,MAAM,KACN,MAAM,KACN,MAAM,GACL,YAAY,GAAC,MAAM,EAAE,CAUhC;IAED;;;;;;;OAOG;IACH,mBANW,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,GACL,MAAM,CAMjB;IAED;;;;;;;;;;OAUG;IACH,cAHW,UAAU,GACT,OAAO,CAqDlB;IAED;;;;;;;;;;;OAWG;IACH,QAFY,MAAM,CAajB;IAED;;;;;;;;;OASG;IACH,oCASC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;OA0BG;IACH,eAJW,MAAM,WACN,MAAM,WACN,MAAM,QAyChB;IAED;;;;OAIG;IACH,cASC;;CACJ"}
+{"version":3,"file":"FluidField.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/fluid/FluidField.js"],"names":[],"mappings":"AASA;;;;;;;;;;;;;;;;;;;GAmBG;AACH;IAQI;;;;OAIG;IACH,YAFU,YAAY,GAAC,IAAI,CAET;IAElB;;OAEG;IACH,YAFU,YAAY,GAAC,IAAI,CAET;IAElB;;OAEG;IACH,YAFU,YAAY,GAAC,IAAI,CAET;IAElB;;;;;;OAMG;IACH,OAFU,UAAU,GAAC,IAAI,CAEZ;IAEb;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2BG;IACH,sBAFU,UAAU,GAAC,IAAI,CAEG;IAE5B;;;;;;;;;;;;;OAaG;IACH,UAFU,YAAY,kBAAc,IAAI,CAExB;IAEhB;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA4BG;IACH,yBAFU,OAAO,CAEe;IAShC;;;;;;OAMG;IACH,qBAJW,MAAM,SACN,MAAM,SACN,MAAM,QAWhB;IAED;;;OAGG;IACH,iBAHY,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAKnC;IAED;;;OAGG;IACH,aAHY,MAAM,CAKjB;IAED;;;;;;;;;OASG;IACH,gBAHW,MAAM,GACL,MAAM,CAejB;IAED;;;OAGG;IACH,kBAHW,MAAM,GACL,MAAM,CAIjB;IAED;;;;OAIG;IACH,oBAJW,MAAM,GACL,YAAY,GAAC,IAAI,CAM5B;IAED;;OAEG;IACH,uBAFY;QAAE,MAAM,MAAM,CAAC;QAAC,IAAI,EAAE,YAAY,CAAA;KAAE,EAAE,CAIjD;IAED;;;OAGG;IACH,cAmBC;IAED;;;;;;OAMG;IACH,aALW,MAAM,KACN,MAAM,KACN,MAAM,GACL,MAAM,CAajB;IAED;;;;;;;;OAQG;IACH,iBAPW,MAAM,KACN,MAAM,KACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QAOhB;IAED;;;;;;;;OAQG;IACH,iBAPW,MAAM,KACN,MAAM,KACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,QAOhB;IAED;;;;;;OAMG;IACH,kCANW,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,SACN,MAAM,QAOhB;IAED;;;;;;OAMG;IACH,cALW,MAAM,KACN,MAAM,KACN,MAAM,YACN,OAAO,QAIjB;IAED;;;;;OAKG;IACH,aALW,MAAM,KACN,MAAM,KACN,MAAM,GACL,OAAO,CAIlB;IAED;;;;;;;;OAQG;IACH,oBANW,YAAY,GAAC,MAAM,EAAE,KACrB,MAAM,KACN,MAAM,KACN,MAAM,GACL,YAAY,GAAC,MAAM,EAAE,CAUhC;IAED;;;;;;;OAOG;IACH,mBANW,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,GACL,MAAM,CAMjB;IAED;;;;;;;;;;OAUG;IACH,cAHW,UAAU,GACT,OAAO,CAqDlB;IAED;;;;;;;;;;;OAWG;IACH,QAFY,MAAM,CAajB;IAED;;;;;;;;;OASG;IACH,oCASC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;OA0BG;IACH,eAJW,MAAM,WACN,MAAM,WACN,MAAM,QAyChB;IAED;;;;OAIG;IACH,cASC;;CACJ"}

package/src/engine/physics/fluid/FluidField.js

@@ -65,17 +65,21 @@ export class FluidField {
      * Per-cell pre-baked neighbourhood mask consumed by the pressure SOR loop.
      * One byte per cell encoding which of the 6 cardinal neighbours are fluid:
      *
-     *     bit 0 (= 1)  : -x neighbour is fluid (in-bounds AND non-solid)
-     *     bit 1 (= 2)  : +x neighbour is fluid
-     *     bit 2 (= 4)  : -y neighbour is fluid
-     *     bit 3 (= 8)  : +y neighbour is fluid
-     *     bit 4 (= 16) : -z neighbour is fluid
-     *     bit 5 (= 32) : +z neighbour is fluid
+     *     bit 0 (= 1)   : -x neighbour is fluid (in-bounds AND non-solid)
+     *     bit 1 (= 2)   : +x neighbour is fluid
+     *     bit 2 (= 4)   : -y neighbour is fluid
+     *     bit 3 (= 8)   : +y neighbour is fluid
+     *     bit 4 (= 16)  : -z neighbour is fluid
+     *     bit 5 (= 32)  : +z neighbour is fluid
+     *     bit 7 (= 128) : this cell is itself solid
      *
-     * Solid cells themselves are encoded as `mask = 0` so the SOR loop's
-     * `if (mask === 0) continue` skip handles both "this cell is solid" and
-     * "this fluid cell is isolated" with a single comparison instead of one
-     * solid-self-check plus six solid-neighbour-checks plus six boundary checks.
+     * A solid cell encodes as `128` (bit 7 set, neighbour bits clear) and an
+     * isolated fluid cell as `0`, so the SOR / PCG loops' `if ((mask & 63) === 0)
+     * continue` skip handles both "this cell is solid" and "this fluid cell is
+     * isolated" with a single comparison instead of one solid-self-check plus six
+     * solid-neighbour-checks plus six boundary checks. Bit 7 additionally lets
+     * {@link v3_grid_subtract_pressure_gradient} zero solid-cell velocity without
+     * consulting the {@link solid} array.
      *
      * Computed once by {@link recomputeSolidNeighbourMask} after every solid-mask
      * mutation. The simulator runs that recompute at the top of every project()

package/src/engine/physics/fluid/FluidSimulator.js

@@ -332,7 +332,7 @@ export class FluidSimulator {
             field.velocity_x, field.velocity_y, field.velocity_z,
             field.pressure,
             res[0], res[1], res[2],
-            solid
+            field.solid_neighbour_mask
         );
     }
 

package/src/engine/physics/fluid/solver/v3_grid_compute_solid_neighbour_mask.d.ts

@@ -4,18 +4,25 @@
  * {@link v3_grid_solve_pressure}, which uses the mask to skip boundary checks
  * and solid-neighbour checks entirely.
  *
- * Encoding (one byte per cell, low 6 bits):
+ * Encoding (one byte per cell):
  *
- *     bit 0 (= 1)  : -x neighbour is fluid
- *     bit 1 (= 2)  : +x neighbour is fluid
- *     bit 2 (= 4)  : -y neighbour is fluid
- *     bit 3 (= 8)  : +y neighbour is fluid
- *     bit 4 (= 16) : -z neighbour is fluid
- *     bit 5 (= 32) : +z neighbour is fluid
+ *     bit 0 (= 1)   : -x neighbour is fluid
+ *     bit 1 (= 2)   : +x neighbour is fluid
+ *     bit 2 (= 4)   : -y neighbour is fluid
+ *     bit 3 (= 8)   : +y neighbour is fluid
+ *     bit 4 (= 16)  : -z neighbour is fluid
+ *     bit 5 (= 32)  : +z neighbour is fluid
+ *     bit 7 (= 128) : this cell is itself solid
  *
- * Solid cells themselves are encoded as `mask = 0` (not "their own neighbours
- * are fluid") so the SOR loop's `mask === 0 → skip` branch covers both
- * "self-solid" and "fluid but no fluid neighbours" with one comparison.
+ * The low 6 bits are the fluid-neighbour set; bit 7 flags the cell as solid.
+ * A solid cell encodes as exactly `128` — bit 7 set, every neighbour bit clear
+ * — and an isolated fluid cell (no fluid neighbours) as `0`. Both therefore
+ * satisfy `(mask & 63) === 0`, so the SOR / PCG loops' "no fluid neighbours →
+ * skip" branch is a single `(mask & 63) === 0` comparison that covers
+ * "self-solid" and "fluid but no fluid neighbours" alike. The dedicated bit 7
+ * additionally lets {@link v3_grid_subtract_pressure_gradient} tell solid cells
+ * (zero the velocity) apart from isolated fluid (leave it) without the original
+ * `solid` array.
  *
  * O(N) — one byte-write per cell, up to six byte-reads per cell. The output
  * fully replaces whatever was in `mask` before; no need to zero-init.

package/src/engine/physics/fluid/solver/v3_grid_compute_solid_neighbour_mask.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"v3_grid_compute_solid_neighbour_mask.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/fluid/solver/v3_grid_compute_solid_neighbour_mask.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,2DANW,UAAU,SACV,UAAU,SACV,MAAM,SACN,MAAM,SACN,MAAM,QAqChB"}
+{"version":3,"file":"v3_grid_compute_solid_neighbour_mask.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/fluid/solver/v3_grid_compute_solid_neighbour_mask.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,2DANW,UAAU,SACV,UAAU,SACV,MAAM,SACN,MAAM,SACN,MAAM,QAqChB"}

package/src/engine/physics/fluid/solver/v3_grid_compute_solid_neighbour_mask.js

@@ -6,18 +6,25 @@ import { assert } from "../../../../core/assert.js";
  * {@link v3_grid_solve_pressure}, which uses the mask to skip boundary checks
  * and solid-neighbour checks entirely.
  *
- * Encoding (one byte per cell, low 6 bits):
+ * Encoding (one byte per cell):
  *
- *     bit 0 (= 1)  : -x neighbour is fluid
- *     bit 1 (= 2)  : +x neighbour is fluid
- *     bit 2 (= 4)  : -y neighbour is fluid
- *     bit 3 (= 8)  : +y neighbour is fluid
- *     bit 4 (= 16) : -z neighbour is fluid
- *     bit 5 (= 32) : +z neighbour is fluid
+ *     bit 0 (= 1)   : -x neighbour is fluid
+ *     bit 1 (= 2)   : +x neighbour is fluid
+ *     bit 2 (= 4)   : -y neighbour is fluid
+ *     bit 3 (= 8)   : +y neighbour is fluid
+ *     bit 4 (= 16)  : -z neighbour is fluid
+ *     bit 5 (= 32)  : +z neighbour is fluid
+ *     bit 7 (= 128) : this cell is itself solid
  *
- * Solid cells themselves are encoded as `mask = 0` (not "their own neighbours
- * are fluid") so the SOR loop's `mask === 0 → skip` branch covers both
- * "self-solid" and "fluid but no fluid neighbours" with one comparison.
+ * The low 6 bits are the fluid-neighbour set; bit 7 flags the cell as solid.
+ * A solid cell encodes as exactly `128` — bit 7 set, every neighbour bit clear
+ * — and an isolated fluid cell (no fluid neighbours) as `0`. Both therefore
+ * satisfy `(mask & 63) === 0`, so the SOR / PCG loops' "no fluid neighbours →
+ * skip" branch is a single `(mask & 63) === 0` comparison that covers
+ * "self-solid" and "fluid but no fluid neighbours" alike. The dedicated bit 7
+ * additionally lets {@link v3_grid_subtract_pressure_gradient} tell solid cells
+ * (zero the velocity) apart from isolated fluid (leave it) without the original
+ * `solid` array.
  *
  * O(N) — one byte-write per cell, up to six byte-reads per cell. The output
  * fully replaces whatever was in `mask` before; no need to zero-init.
@@ -49,7 +56,7 @@ export function v3_grid_compute_solid_neighbour_mask(mask, solid, res_x, res_y,
             for (let x = 0; x < res_x; x++) {
                 const c = y_off + x;
                 if (solid[c] !== 0) {
-                    mask[c] = 0;
+                    mask[c] = 128; // bit 7 = this cell is solid; neighbour bits stay clear
                     continue;
                 }
                 let m = 0;

package/src/engine/physics/fluid/solver/v3_grid_solve_pressure.d.ts

@@ -11,17 +11,20 @@
  * a Uint8Array allocated and populated by {@link FluidField} via
  * {@link FluidField.recomputeSolidNeighbourMask}. The encoding is:
  *
- *     bit 0 (= 1)  : -x neighbour is fluid
- *     bit 1 (= 2)  : +x neighbour is fluid
- *     bit 2 (= 4)  : -y neighbour is fluid
- *     bit 3 (= 8)  : +y neighbour is fluid
- *     bit 4 (= 16) : -z neighbour is fluid
- *     bit 5 (= 32) : +z neighbour is fluid
+ *     bit 0 (= 1)   : -x neighbour is fluid
+ *     bit 1 (= 2)   : +x neighbour is fluid
+ *     bit 2 (= 4)   : -y neighbour is fluid
+ *     bit 3 (= 8)   : +y neighbour is fluid
+ *     bit 4 (= 16)  : -z neighbour is fluid
+ *     bit 5 (= 32)  : +z neighbour is fluid
+ *     bit 7 (= 128) : this cell is itself solid (consumed by
+ *                     {@link v3_grid_subtract_pressure_gradient}, ignored here)
  *
- * Solid cells encode as `mask = 0`, so the inner loop's `mask === 0 ? skip` covers
- * both self-solid AND fluid-with-no-fluid-neighbours in one comparison. This
- * eliminates six boundary checks plus six solid-neighbour checks per cell per
- * iteration, replacing them with a single mask read and six bit-tests on a
+ * The low 6 bits are the fluid-neighbour set. A solid cell encodes as `128` and
+ * an isolated fluid cell as `0`, so the inner loop's `(mask & 63) === 0 ? skip`
+ * covers both self-solid AND fluid-with-no-fluid-neighbours in one comparison.
+ * This eliminates six boundary checks plus six solid-neighbour checks per cell
+ * per iteration, replacing them with a single mask read and six bit-tests on a
  * register-resident value. Boundary handling (cells at x=0, x=last, etc.) is
  * implicit — the recompute step writes 0 into the boundary-facing bit, so the
  * SOR loop never reads out-of-range memory.

package/src/engine/physics/fluid/solver/v3_grid_solve_pressure.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"v3_grid_solve_pressure.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/fluid/solver/v3_grid_solve_pressure.js"],"names":[],"mappings":"AAmBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;AACH,iDAdW,YAAY,eAAa,cAEzB,YAAY,eAAa,SAEzB,MAAM,SACN,MAAM,SACN,MAAM,cACN,MAAM,SACN,MAAM,kBAEN,UAAU,QA+DpB"}
+{"version":3,"file":"v3_grid_solve_pressure.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/fluid/solver/v3_grid_solve_pressure.js"],"names":[],"mappings":"AAmBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiDG;AACH,iDAdW,YAAY,eAAa,cAEzB,YAAY,eAAa,SAEzB,MAAM,SACN,MAAM,SACN,MAAM,cACN,MAAM,SACN,MAAM,kBAEN,UAAU,QAiEpB"}

package/src/engine/physics/fluid/solver/v3_grid_solve_pressure.js

@@ -30,17 +30,20 @@ const POPCOUNT_6 = (function () {
  * a Uint8Array allocated and populated by {@link FluidField} via
  * {@link FluidField.recomputeSolidNeighbourMask}. The encoding is:
  *
- *     bit 0 (= 1)  : -x neighbour is fluid
- *     bit 1 (= 2)  : +x neighbour is fluid
- *     bit 2 (= 4)  : -y neighbour is fluid
- *     bit 3 (= 8)  : +y neighbour is fluid
- *     bit 4 (= 16) : -z neighbour is fluid
- *     bit 5 (= 32) : +z neighbour is fluid
+ *     bit 0 (= 1)   : -x neighbour is fluid
+ *     bit 1 (= 2)   : +x neighbour is fluid
+ *     bit 2 (= 4)   : -y neighbour is fluid
+ *     bit 3 (= 8)   : +y neighbour is fluid
+ *     bit 4 (= 16)  : -z neighbour is fluid
+ *     bit 5 (= 32)  : +z neighbour is fluid
+ *     bit 7 (= 128) : this cell is itself solid (consumed by
+ *                     {@link v3_grid_subtract_pressure_gradient}, ignored here)
  *
- * Solid cells encode as `mask = 0`, so the inner loop's `mask === 0 ? skip` covers
- * both self-solid AND fluid-with-no-fluid-neighbours in one comparison. This
- * eliminates six boundary checks plus six solid-neighbour checks per cell per
- * iteration, replacing them with a single mask read and six bit-tests on a
+ * The low 6 bits are the fluid-neighbour set. A solid cell encodes as `128` and
+ * an isolated fluid cell as `0`, so the inner loop's `(mask & 63) === 0 ? skip`
+ * covers both self-solid AND fluid-with-no-fluid-neighbours in one comparison.
+ * This eliminates six boundary checks plus six solid-neighbour checks per cell
+ * per iteration, replacing them with a single mask read and six bit-tests on a
  * register-resident value. Boundary handling (cells at x=0, x=last, etc.) is
  * implicit — the recompute step writes 0 into the boundary-facing bit, so the
  * SOR loop never reads out-of-range memory.
@@ -101,9 +104,11 @@ export function v3_grid_solve_pressure(pressure, divergence, res_x, res_y, res_z
                         const c = z_off + y_off + x;
 
                         const mask = neighbour_mask[c];
-                        if (mask === 0) {
-                            // Solid cell OR isolated fluid with no fluid neighbours.
-                            // Either way, no degrees of freedom — skip.
+                        if ((mask & 63) === 0) {
+                            // No fluid neighbours: solid cell (bit 7 set) OR isolated
+                            // fluid. Either way, no degrees of freedom — skip. Cells
+                            // that reach past here have bit 7 clear, so `mask` indexes
+                            // POPCOUNT_6 (sized 64) in range.
                             continue;
                         }
 

package/src/engine/physics/fluid/solver/v3_grid_solve_pressure_pcg.d.ts

@@ -69,9 +69,10 @@
  * the hot path that prevents MIC-PCG from parallelizing onto a GPU without
  * substantial reformulation. On single-thread JS that's not a concern.
  *
- * Solid cells (mask = 0) are excluded from the system: their pressure stays at
- * whatever it was (typically 0), their entries in r, z, s, As stay 0, and they
- * contribute nothing to dot products.
+ * Cells with no fluid neighbours — solid cells (mask bit 7 set) and isolated
+ * fluid (mask = 0), both identified by `(mask & 63) === 0` — are excluded from
+ * the system: their pressure stays at whatever it was (typically 0), their
+ * entries in r, z, s, As stay 0, and they contribute nothing to dot products.
  *
  * @param {Float32Array|Float16Array} pressure  Mutated in place. Pre-fill with 0
  *     or with the previous step's solution to warm-start.

package/src/engine/physics/fluid/solver/v3_grid_solve_pressure_pcg.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"v3_grid_solve_pressure_pcg.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/fluid/solver/v3_grid_solve_pressure_pcg.js"],"names":[],"mappings":"AAuCA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0FG;AACH,qDAhBW,YAAY,eAAa,cAEzB,YAAY,eAAa,SACzB,MAAM,SACN,MAAM,SACN,MAAM,kBACN,MAAM,kBAEN,UAAU,aACV,YAAY,aACZ,YAAY,aACZ,YAAY,cACZ,YAAY,kBACZ,YAAY,QAuNtB"}
+{"version":3,"file":"v3_grid_solve_pressure_pcg.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/fluid/solver/v3_grid_solve_pressure_pcg.js"],"names":[],"mappings":"AAuCA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2FG;AACH,qDAhBW,YAAY,eAAa,cAEzB,YAAY,eAAa,SACzB,MAAM,SACN,MAAM,SACN,MAAM,kBACN,MAAM,kBAEN,UAAU,aACV,YAAY,aACZ,YAAY,aACZ,YAAY,cACZ,YAAY,kBACZ,YAAY,QA0NtB"}

package/src/engine/physics/fluid/solver/v3_grid_solve_pressure_pcg.js

@@ -108,9 +108,10 @@ const MIC_SIGMA = 0.25;
  * the hot path that prevents MIC-PCG from parallelizing onto a GPU without
  * substantial reformulation. On single-thread JS that's not a concern.
  *
- * Solid cells (mask = 0) are excluded from the system: their pressure stays at
- * whatever it was (typically 0), their entries in r, z, s, As stay 0, and they
- * contribute nothing to dot products.
+ * Cells with no fluid neighbours — solid cells (mask bit 7 set) and isolated
+ * fluid (mask = 0), both identified by `(mask & 63) === 0` — are excluded from
+ * the system: their pressure stays at whatever it was (typically 0), their
+ * entries in r, z, s, As stay 0, and they contribute nothing to dot products.
  *
  * @param {Float32Array|Float16Array} pressure  Mutated in place. Pre-fill with 0
  *     or with the previous step's solution to warm-start.
@@ -173,9 +174,12 @@ export function v3_grid_solve_pressure_pcg(
     // (Standard fluids practice — see Bridson §5.5. The alternative is to pin
     // one cell to a Dirichlet value and exclude it from the system, but mean
     // subtraction has the same effect with simpler bookkeeping.)
+    // A cell is a degree of freedom iff it has ≥1 fluid neighbour, i.e. any of
+    // the low 6 bits set. Solid cells (bit 7) and isolated fluid (all-zero) are
+    // both excluded by masking off bit 7 with & 63.
     let fluid_count = 0;
     for (let c = 0; c < cells; c++) {
-        if (neighbour_mask[c] !== 0) fluid_count++;
+        if ((neighbour_mask[c] & 63) !== 0) fluid_count++;
     }
     if (fluid_count === 0) {
         return;
@@ -193,7 +197,7 @@ export function v3_grid_solve_pressure_pcg(
     precon.fill(0);
     for (let c = 0; c < cells; c++) {
         const mask = neighbour_mask[c];
-        if (mask === 0) {
+        if ((mask & 63) === 0) {
             continue;
         }
         const a_diag = POPCOUNT_6[mask];
@@ -246,7 +250,7 @@ export function v3_grid_solve_pressure_pcg(
 
     for (let c = 0; c < cells; c++) {
         const mask = neighbour_mask[c];
-        if (mask === 0) {
+        if ((mask & 63) === 0) {
             r[c] = 0;
             continue;
         }
@@ -285,7 +289,7 @@ export function v3_grid_solve_pressure_pcg(
         let s_dot_As = 0;
         for (let c = 0; c < cells; c++) {
             const mask = neighbour_mask[c];
-            if (mask === 0) {
+            if ((mask & 63) === 0) {
                 As[c] = 0;
                 continue;
             }
@@ -379,11 +383,11 @@ export function v3_grid_solve_pressure_pcg(
 function subtract_mean_fluid(v, mask_array, cells, fluid_count) {
     let sum = 0;
     for (let c = 0; c < cells; c++) {
-        if (mask_array[c] !== 0) sum += v[c];
+        if ((mask_array[c] & 63) !== 0) sum += v[c];
     }
     const mean = sum / fluid_count;
     for (let c = 0; c < cells; c++) {
-        if (mask_array[c] !== 0) v[c] -= mean;
+        if ((mask_array[c] & 63) !== 0) v[c] -= mean;
     }
 }
 
@@ -391,7 +395,7 @@ function apply_preconditioner(r, z, precon, mask_array, cells, rx, slice) {
     // Forward solve L · y = r. Store y in z (we won't read z[c'] for c' > c).
     for (let c = 0; c < cells; c++) {
         const mask = mask_array[c];
-        if (mask === 0) {
+        if ((mask & 63) === 0) {
             z[c] = 0;
             continue;
         }
@@ -410,7 +414,7 @@ function apply_preconditioner(r, z, precon, mask_array, cells, rx, slice) {
     // indices, processed first in reverse).
     for (let c = cells - 1; c >= 0; c--) {
         const mask = mask_array[c];
-        if (mask === 0) {
+        if ((mask & 63) === 0) {
             continue;
         }
         let t = z[c]; // = y[c] from forward pass

package/src/engine/physics/fluid/solver/v3_grid_subtract_pressure_gradient.d.ts

@@ -13,14 +13,38 @@
  * pressure (consistent with the Neumann condition used in the solve), which keeps the
  * flow tangent to the boundary.
  *
- * @param {Float32Array} vel_x       Mutated in place.
- * @param {Float32Array} vel_y       Mutated in place.
- * @param {Float32Array} vel_z       Mutated in place.
- * @param {Float32Array} pressure    From {@link v3_grid_solve_pressure}.
+ * Everything this needs is read straight from `neighbour_mask`, the same pre-baked
+ * per-cell bitmask {@link v3_grid_solve_pressure} consumes (populated by
+ * {@link FluidField.recomputeSolidNeighbourMask}). Encoding:
+ *
+ *     bit 0 (= 1)   : -x neighbour is fluid
+ *     bit 1 (= 2)   : +x neighbour is fluid
+ *     bit 2 (= 4)   : -y neighbour is fluid
+ *     bit 3 (= 8)   : +y neighbour is fluid
+ *     bit 4 (= 16)  : -z neighbour is fluid
+ *     bit 5 (= 32)  : +z neighbour is fluid
+ *     bit 7 (= 128) : this cell is itself solid
+ *
+ * A set neighbour bit means "that neighbour is fluid (in-bounds AND non-solid)", so a
+ * clear bit reflects the cell's own pressure — folding the boundary check and the
+ * solid-neighbour check into one register-resident bit-test per face.
+ *
+ * Bit 7 carries the self-solid flag that used to require the separate `solid` array.
+ * The solve can't use the low 6 bits for this (a solid cell and an isolated fluid cell
+ * both have zero fluid-neighbour bits) but needs opposite handling here — the solid
+ * must be zeroed for no-slip, while the isolated fluid's gradient already nets to zero
+ * (every face reflects its own pressure) and must be left alone. Bit 7 distinguishes
+ * them, so a single mask read drives both the zeroing and the gradient.
+ *
+ * @param {Float32Array} vel_x          Mutated in place.
+ * @param {Float32Array} vel_y          Mutated in place.
+ * @param {Float32Array} vel_z          Mutated in place.
+ * @param {Float32Array} pressure       From {@link v3_grid_solve_pressure}.
  * @param {number} res_x
  * @param {number} res_y
  * @param {number} res_z
- * @param {Uint8Array} solid         Required (zero-filled for a wall-free domain).
+ * @param {Uint8Array} neighbour_mask   Length ≥ res_x*res_y*res_z. Same buffer the
+ *     pressure solve uses; MUST be recomputed whenever the solid mask changes.
  */
-export function v3_grid_subtract_pressure_gradient(vel_x: Float32Array, vel_y: Float32Array, vel_z: Float32Array, pressure: Float32Array, res_x: number, res_y: number, res_z: number, solid: Uint8Array): void;
+export function v3_grid_subtract_pressure_gradient(vel_x: Float32Array, vel_y: Float32Array, vel_z: Float32Array, pressure: Float32Array, res_x: number, res_y: number, res_z: number, neighbour_mask: Uint8Array): void;
 //# sourceMappingURL=v3_grid_subtract_pressure_gradient.d.ts.map

package/src/engine/physics/fluid/solver/v3_grid_subtract_pressure_gradient.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"v3_grid_subtract_pressure_gradient.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/fluid/solver/v3_grid_subtract_pressure_gradient.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,0DATW,YAAY,SACZ,YAAY,SACZ,YAAY,YACZ,YAAY,SACZ,MAAM,SACN,MAAM,SACN,MAAM,SACN,UAAU,QA6CpB"}
+{"version":3,"file":"v3_grid_subtract_pressure_gradient.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/fluid/solver/v3_grid_subtract_pressure_gradient.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+CG;AACH,0DAVW,YAAY,SACZ,YAAY,SACZ,YAAY,YACZ,YAAY,SACZ,MAAM,SACN,MAAM,SACN,MAAM,kBACN,UAAU,QAgDpB"}

package/src/engine/physics/fluid/solver/v3_grid_subtract_pressure_gradient.js

@@ -15,26 +15,48 @@ import { assert } from "../../../../core/assert.js";
  * pressure (consistent with the Neumann condition used in the solve), which keeps the
  * flow tangent to the boundary.
  *
- * @param {Float32Array} vel_x       Mutated in place.
- * @param {Float32Array} vel_y       Mutated in place.
- * @param {Float32Array} vel_z       Mutated in place.
- * @param {Float32Array} pressure    From {@link v3_grid_solve_pressure}.
+ * Everything this needs is read straight from `neighbour_mask`, the same pre-baked
+ * per-cell bitmask {@link v3_grid_solve_pressure} consumes (populated by
+ * {@link FluidField.recomputeSolidNeighbourMask}). Encoding:
+ *
+ *     bit 0 (= 1)   : -x neighbour is fluid
+ *     bit 1 (= 2)   : +x neighbour is fluid
+ *     bit 2 (= 4)   : -y neighbour is fluid
+ *     bit 3 (= 8)   : +y neighbour is fluid
+ *     bit 4 (= 16)  : -z neighbour is fluid
+ *     bit 5 (= 32)  : +z neighbour is fluid
+ *     bit 7 (= 128) : this cell is itself solid
+ *
+ * A set neighbour bit means "that neighbour is fluid (in-bounds AND non-solid)", so a
+ * clear bit reflects the cell's own pressure — folding the boundary check and the
+ * solid-neighbour check into one register-resident bit-test per face.
+ *
+ * Bit 7 carries the self-solid flag that used to require the separate `solid` array.
+ * The solve can't use the low 6 bits for this (a solid cell and an isolated fluid cell
+ * both have zero fluid-neighbour bits) but needs opposite handling here — the solid
+ * must be zeroed for no-slip, while the isolated fluid's gradient already nets to zero
+ * (every face reflects its own pressure) and must be left alone. Bit 7 distinguishes
+ * them, so a single mask read drives both the zeroing and the gradient.
+ *
+ * @param {Float32Array} vel_x          Mutated in place.
+ * @param {Float32Array} vel_y          Mutated in place.
+ * @param {Float32Array} vel_z          Mutated in place.
+ * @param {Float32Array} pressure       From {@link v3_grid_solve_pressure}.
  * @param {number} res_x
  * @param {number} res_y
  * @param {number} res_z
- * @param {Uint8Array} solid         Required (zero-filled for a wall-free domain).
+ * @param {Uint8Array} neighbour_mask   Length ≥ res_x*res_y*res_z. Same buffer the
+ *     pressure solve uses; MUST be recomputed whenever the solid mask changes.
  */
-export function v3_grid_subtract_pressure_gradient(vel_x, vel_y, vel_z, pressure, res_x, res_y, res_z, solid) {
+export function v3_grid_subtract_pressure_gradient(vel_x, vel_y, vel_z, pressure, res_x, res_y, res_z, neighbour_mask) {
     const cell_count = res_x * res_y * res_z;
     assert.greaterThanOrEqual(vel_x.length, cell_count, "vel_x covers grid");
     assert.greaterThanOrEqual(vel_y.length, cell_count, "vel_y covers grid");
     assert.greaterThanOrEqual(vel_z.length, cell_count, "vel_z covers grid");
     assert.greaterThanOrEqual(pressure.length, cell_count, "pressure covers grid");
+    assert.greaterThanOrEqual(neighbour_mask.length, cell_count, "neighbour_mask covers grid");
 
     const slice_size = res_x * res_y;
-    const last_x = res_x - 1;
-    const last_y = res_y - 1;
-    const last_z = res_z - 1;
 
     for (let z = 0; z < res_z; z++) {
         const z_off = z * slice_size;
@@ -45,21 +67,25 @@ export function v3_grid_subtract_pressure_gradient(vel_x, vel_y, vel_z, pressure
             for (let x = 0; x < res_x; x++) {
                 const c = z_off + y_off + x;
 
-                if (solid[c] !== 0) {
+                const mask = neighbour_mask[c];
+
+                if (mask & 128) {
+                    // Solid cell (bit 7): enforce no-slip.
                     vel_x[c] = 0;
                     vel_y[c] = 0;
                     vel_z[c] = 0;
                     continue;
                 }
 
-                // Reflect pressure across a solid neighbour: that face contributes 0
-                // to the gradient, consistent with ∂p/∂n = 0 at the wall.
-                const p_xm = (x > 0      && solid[c - 1] === 0)          ? pressure[c - 1]          : pressure[c];
-                const p_xp = (x < last_x && solid[c + 1] === 0)          ? pressure[c + 1]          : pressure[c];
-                const p_ym = (y > 0      && solid[c - res_x] === 0)      ? pressure[c - res_x]      : pressure[c];
-                const p_yp = (y < last_y && solid[c + res_x] === 0)      ? pressure[c + res_x]      : pressure[c];
-                const p_zm = (z > 0      && solid[c - slice_size] === 0) ? pressure[c - slice_size] : pressure[c];
-                const p_zp = (z < last_z && solid[c + slice_size] === 0) ? pressure[c + slice_size] : pressure[c];
+                // A clear bit means the neighbour is out-of-bounds or solid; reflect
+                // the cell's own pressure so that face contributes 0 to the gradient,
+                // consistent with ∂p/∂n = 0 at the wall.
+                const p_xm = (mask & 1)  ? pressure[c - 1]          : pressure[c];
+                const p_xp = (mask & 2)  ? pressure[c + 1]          : pressure[c];
+                const p_ym = (mask & 4)  ? pressure[c - res_x]      : pressure[c];
+                const p_yp = (mask & 8)  ? pressure[c + res_x]      : pressure[c];
+                const p_zm = (mask & 16) ? pressure[c - slice_size] : pressure[c];
+                const p_zp = (mask & 32) ? pressure[c + slice_size] : pressure[c];
 
                 vel_x[c] -= 0.5 * (p_xp - p_xm);
                 vel_y[c] -= 0.5 * (p_yp - p_ym);

package/src/engine/physics/gjk/expanding_polytope_algorithm.d.ts

@@ -1,13 +1,13 @@
 /**
  * TODO: needs to be tested thoroughly, intended to be working with GJK
- * @param {number[]} result
+ * @param {number[]|Float64Array} result
  * @param {number} result_offset
- * @param {number[]} a
- * @param {number[]} b
- * @param {number[]} c
- * @param {number[]} d
+ * @param {number[]|Float64Array} a
+ * @param {number[]|Float64Array} b
+ * @param {number[]|Float64Array} c
+ * @param {number[]|Float64Array} d
  * @param {AbstractShape3D} coll1
  * @param {AbstractShape3D} coll2
  */
-export function expanding_polytope_algorithm(result: number[], result_offset: number, a: number[], b: number[], c: number[], d: number[], coll1: AbstractShape3D, coll2: AbstractShape3D): void;
+export function expanding_polytope_algorithm(result: number[] | Float64Array, result_offset: number, a: number[] | Float64Array, b: number[] | Float64Array, c: number[] | Float64Array, d: number[] | Float64Array, coll1: AbstractShape3D, coll2: AbstractShape3D): void;
 //# sourceMappingURL=expanding_polytope_algorithm.d.ts.map

package/src/engine/physics/gjk/expanding_polytope_algorithm.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"expanding_polytope_algorithm.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/gjk/expanding_polytope_algorithm.js"],"names":[],"mappings":"AAgEA;;;;;;;;;;GAUG;AACH,qDATW,MAAM,EAAE,iBACR,MAAM,KACN,MAAM,EAAE,KACR,MAAM,EAAE,KACR,MAAM,EAAE,KACR,MAAM,EAAE,wDA8PlB"}
+{"version":3,"file":"expanding_polytope_algorithm.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/gjk/expanding_polytope_algorithm.js"],"names":[],"mappings":"AAqGA;;;;;;;;;;GAUG;AACH,qDATW,MAAM,EAAE,GAAC,YAAY,iBACrB,MAAM,KACN,MAAM,EAAE,GAAC,YAAY,KACrB,MAAM,EAAE,GAAC,YAAY,KACrB,MAAM,EAAE,GAAC,YAAY,KACrB,MAAM,EAAE,GAAC,YAAY,wDAuQ/B"}