@woosh/meep-engine 3.52.0 → 3.53.0

package/src/shade/renderer/fluid/GPUFluidCascade.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUFluidCascade.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/fluid/GPUFluidCascade.js"],"names":[],"mappings":"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"}
+{"version":3,"file":"GPUFluidCascade.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/fluid/GPUFluidCascade.js"],"names":[],"mappings":"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"}

package/src/shade/renderer/fluid/GPUFluidCascade.js

@@ -223,6 +223,21 @@ function restrict_value() {
  * solve's inputs live in retained records, and several steps may be recorded into one graph.
  */
 export class GPUFluidCascade {
+    /**
+     * Offer the compute pipelines a cascade's step, scroll fill, and child restriction dispatch —
+     * see {@link PipelineEnquiry}.
+     *
+     * @param {import("../../device/pipeline/PipelineEnquiry.js").PipelineEnquiry} enquiry
+     */
+    static enquirePipelines(enquiry) {
+        FluidMacPasses.enquirePipelines(enquiry);
+        GPUFluidPressureSolve.enquirePipelines(enquiry);
+        enquiry.compute.push(
+            shader_fluid_cascade_fill.pipeline,
+            shader_fluid_cascade_restrict.pipeline,
+        );
+    }
+
     /** @type {Uint32Array} */
     #resolution = new Uint32Array(3);
     /** @type {Int32Array} */

package/src/shade/renderer/fluid/GPUFluidCascadeStack.d.ts

@@ -51,6 +51,13 @@ export const GPU_FLUID_CASCADE_STACK_LIMIT: number;
  * pressure 0); after that nothing is allocated per tick.
  */
 export class GPUFluidCascadeStack {
+    /**
+     * Offer the compute pipelines a cascade stack's tick and publish dispatch — see
+     * {@link PipelineEnquiry}.
+     *
+     * @param {import("../../device/pipeline/PipelineEnquiry.js").PipelineEnquiry} enquiry
+     */
+    static enquirePipelines(enquiry: import("../../device/pipeline/PipelineEnquiry.js").PipelineEnquiry): void;
     /**
      * @param {object} pass
      * @param {*} _resources

package/src/shade/renderer/fluid/GPUFluidCascadeStack.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUFluidCascadeStack.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/fluid/GPUFluidCascadeStack.js"],"names":[],"mappings":"AASA;;;;GAIG;AAEH;;;GAGG;AACH,4CAFU,MAAM,CAE+B;AAE/C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH;IA0VI;;;;OAIG;IACH,uCAJW,MAAM,4BAEN;QAAC,OAAO,EAAE,OAAO,wCAAwC,EAAE,sBAAsB,CAAA;KAAC,QAkC5F;IAhVD;;;;;;;;;;OAUG;IACH;QAT8B,MAAM;QACE,UAAU,EAArC,UAAU,MAAM,CAAC;QAED,SAAS,EAAzB,MAAM;QACU,aAAa,EAA7B,MAAM;QACqB,MAAM,EAAjC,UAAU,MAAM,CAAC;QACc,UAAU,EAAzC,YAAY,GAAC,MAAM,EAAE;QACL,iBAAiB,EAAjC,MAAM;OAwChB;IA/DD;;;;OAIG;IACH,iBAFU,OAAO,CAEM;IAEvB;;;;OAIG;IACH,UAFU,OAAO,CAED;IAqDhB,wBAAwB;IACxB,4BAEC;IAED;;;OAGG;IACH,uCAEC;IAED;;;OAGG;IACH,wBAEC;IAED;;;;OAIG;IACH,WAHW,MAAM,GACJ,eAAe,CAI3B;IAED;;;;;OAKG;IACH,qBAFW,YAAY,GAAC,MAAM,EAAE,QAY/B;IAED;;;;;;OAMG;IACH,wBAHW,YAAY,GAAC,MAAM,EAAE,UACrB,MAAM,QAMhB;IAED;;;;;;;;;;;;;;;;;OAiBG;IACH;QAd+B,KAAK,EAAzB,UAAU;QACM,IAAI,EAApB,MAAM;QAEU,EAAE,EAAlB,MAAM;QACqB,MAAM,EAAjC,UAAU,MAAM,CAAC;QACc,UAAU,EAAzC,YAAY,GAAC,MAAM,EAAE;QAEL,iBAAiB,EAAjC,MAAM;QACyB,OAAO,GAAtC,eAAe,GAAC,IAAI;QAEH,qBAAqB,GAAtC,MAAM;aA8FhB;IAED;;;;;;;;;;;;;;;;;;;OAmBG;IACH;QAN+B,KAAK,EAAzB,UAAU;QACY,IAAI,EAA1B,YAAY;QACmB,UAAU,EAAzC,YAAY,GAAC,MAAM,EAAE;QAEL,iBAAiB,EAAjC,MAAM;aAsDhB;IA4CD;;OAEG;IACH,gBAUC;;CACJ;yBApcY,OAAO,2DAA2D,EAAE,UAAU;2BAC9E,OAAO,yBAAyB,EAAE,YAAY;8BAC9C,OAAO,8BAA8B,EAAE,eAAe;gCARnC,sBAAsB"}
+{"version":3,"file":"GPUFluidCascadeStack.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/fluid/GPUFluidCascadeStack.js"],"names":[],"mappings":"AASA;;;;GAIG;AAEH;;;GAGG;AACH,4CAFU,MAAM,CAE+B;AAE/C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH;IACI;;;;;OAKG;IACH,iCAFW,OAAO,0CAA0C,EAAE,eAAe,QAK5E;IA2VD;;;;OAIG;IACH,uCAJW,MAAM,4BAEN;QAAC,OAAO,EAAE,OAAO,wCAAwC,EAAE,sBAAsB,CAAA;KAAC,QAkC5F;IAhVD;;;;;;;;;;OAUG;IACH;QAT8B,MAAM;QACE,UAAU,EAArC,UAAU,MAAM,CAAC;QAED,SAAS,EAAzB,MAAM;QACU,aAAa,EAA7B,MAAM;QACqB,MAAM,EAAjC,UAAU,MAAM,CAAC;QACc,UAAU,EAAzC,YAAY,GAAC,MAAM,EAAE;QACL,iBAAiB,EAAjC,MAAM;OAwChB;IA/DD;;;;OAIG;IACH,iBAFU,OAAO,CAEM;IAEvB;;;;OAIG;IACH,UAFU,OAAO,CAED;IAqDhB,wBAAwB;IACxB,4BAEC;IAED;;;OAGG;IACH,uCAEC;IAED;;;OAGG;IACH,wBAEC;IAED;;;;OAIG;IACH,WAHW,MAAM,GACJ,eAAe,CAI3B;IAED;;;;;OAKG;IACH,qBAFW,YAAY,GAAC,MAAM,EAAE,QAY/B;IAED;;;;;;OAMG;IACH,wBAHW,YAAY,GAAC,MAAM,EAAE,UACrB,MAAM,QAMhB;IAED;;;;;;;;;;;;;;;;;OAiBG;IACH;QAd+B,KAAK,EAAzB,UAAU;QACM,IAAI,EAApB,MAAM;QAEU,EAAE,EAAlB,MAAM;QACqB,MAAM,EAAjC,UAAU,MAAM,CAAC;QACc,UAAU,EAAzC,YAAY,GAAC,MAAM,EAAE;QAEL,iBAAiB,EAAjC,MAAM;QACyB,OAAO,GAAtC,eAAe,GAAC,IAAI;QAEH,qBAAqB,GAAtC,MAAM;aA8FhB;IAED;;;;;;;;;;;;;;;;;;;OAmBG;IACH;QAN+B,KAAK,EAAzB,UAAU;QACY,IAAI,EAA1B,YAAY;QACmB,UAAU,EAAzC,YAAY,GAAC,MAAM,EAAE;QAEL,iBAAiB,EAAjC,MAAM;aAsDhB;IA4CD;;OAEG;IACH,gBAUC;;CACJ;yBA/cY,OAAO,2DAA2D,EAAE,UAAU;2BAC9E,OAAO,yBAAyB,EAAE,YAAY;8BAC9C,OAAO,8BAA8B,EAAE,eAAe;gCARnC,sBAAsB"}

package/src/shade/renderer/fluid/GPUFluidCascadeStack.js

@@ -62,6 +62,17 @@ export const GPU_FLUID_CASCADE_STACK_LIMIT = 8;
  * pressure 0); after that nothing is allocated per tick.
  */
 export class GPUFluidCascadeStack {
+    /**
+     * Offer the compute pipelines a cascade stack's tick and publish dispatch — see
+     * {@link PipelineEnquiry}.
+     *
+     * @param {import("../../device/pipeline/PipelineEnquiry.js").PipelineEnquiry} enquiry
+     */
+    static enquirePipelines(enquiry) {
+        GPUFluidCascade.enquirePipelines(enquiry);
+        FluidWindPublish.enquirePipelines(enquiry);
+    }
+
     /** @type {GPUFluidCascade[]} */
     #cascades = [];
 

package/src/shade/renderer/fluid/coupling/chunk_fluid_cascade_parent.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_fluid_cascade_parent.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/fluid/coupling/chunk_fluid_cascade_parent.js"],"names":[],"mappings":"AAsBA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,kDAFU,SAAS,CAiIjB;AAEF;;;;;;;;;;;;;;;GAeG;AACH,kDAFU,SAAS,CAmDjB;0BAxOwB,oCAAoC"}
+{"version":3,"file":"chunk_fluid_cascade_parent.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/fluid/coupling/chunk_fluid_cascade_parent.js"],"names":[],"mappings":"AAsBA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,kDAFU,SAAS,CAoIjB;AAEF;;;;;;;;;;;;;;;GAeG;AACH,kDAFU,SAAS,CAmDjB;0BA3OwB,oCAAoC"}

package/src/shade/renderer/fluid/coupling/chunk_fluid_cascade_parent.js

@@ -76,7 +76,8 @@ fn fluid_parent_deviation_w(lattice: vec3<i32>) -> f32 {
 
 fn fluid_parent_face_u(face: vec3<i32>, offset: vec3<i32>) -> f32 {
     // the far field: nothing to read, every corner would count 0
-    if (parent.faces_u.size.x == 0u) {
+    let n_corners = select(0u, 8u, parent.faces_u.size.x != 0u);
+    if (n_corners == 0u) {
         return parent.read_far_velocity.x;
     }
 
@@ -84,29 +85,30 @@ fn fluid_parent_face_u(face: vec3<i32>, offset: vec3<i32>) -> f32 {
     let base = floor(lattice);
     let lo = vec3<i32>(base);
     let hi = lo + vec3<i32>(1);
+    var z0 = vec4<f32>(0.0);
+    var z1 = vec4<f32>(0.0);
+
+    for (var i = 0u; i < n_corners; i++) {
+        let pt = vec3<i32>(
+            select(lo.x, hi.x, (i & 1u) != 0u),
+            select(lo.y, hi.y, (i & 2u) != 0u),
+            select(lo.z, hi.z, (i & 4u) != 0u)
+        );
+        let v = vec4<f32>(fluid_parent_deviation_u(pt));
+        let mask = vec4<u32>(i & 3u) == vec4<u32>(0u, 1u, 2u, 3u);
+        z0 = select(z0, v, mask & vec4<bool>(i < 4u));
+        z1 = select(z1, v, mask & vec4<bool>(i >= 4u));
+    }
 
-    let corners = ${TEXTURE3D_TRILINEAR_CORNERS_STRUCT.wgsl_ref}(
-        vec4<f32>(
-            fluid_parent_deviation_u(lo),
-            fluid_parent_deviation_u(vec3<i32>(hi.x, lo.y, lo.z)),
-            fluid_parent_deviation_u(vec3<i32>(lo.x, hi.y, lo.z)),
-            fluid_parent_deviation_u(vec3<i32>(hi.x, hi.y, lo.z))
-        ),
-        vec4<f32>(
-            fluid_parent_deviation_u(vec3<i32>(lo.x, lo.y, hi.z)),
-            fluid_parent_deviation_u(vec3<i32>(hi.x, lo.y, hi.z)),
-            fluid_parent_deviation_u(vec3<i32>(lo.x, hi.y, hi.z)),
-            fluid_parent_deviation_u(hi)
-        ),
-        lattice - base
-    );
+    let corners = ${TEXTURE3D_TRILINEAR_CORNERS_STRUCT.wgsl_ref}(z0, z1, lattice - base);
 
     return parent.read_far_velocity.x + parent.keep * texture3d_trilinear_interpolate(corners);
 }
 
 fn fluid_parent_face_v(face: vec3<i32>, offset: vec3<i32>) -> f32 {
     // the far field: nothing to read, every corner would count 0
-    if (parent.faces_v.size.x == 0u) {
+    let n_corners = select(0u, 8u, parent.faces_v.size.x != 0u);
+    if (n_corners == 0u) {
         return parent.read_far_velocity.y;
     }
 
@@ -114,29 +116,30 @@ fn fluid_parent_face_v(face: vec3<i32>, offset: vec3<i32>) -> f32 {
     let base = floor(lattice);
     let lo = vec3<i32>(base);
     let hi = lo + vec3<i32>(1);
+    var z0 = vec4<f32>(0.0);
+    var z1 = vec4<f32>(0.0);
+
+    for (var i = 0u; i < n_corners; i++) {
+        let pt = vec3<i32>(
+            select(lo.x, hi.x, (i & 1u) != 0u),
+            select(lo.y, hi.y, (i & 2u) != 0u),
+            select(lo.z, hi.z, (i & 4u) != 0u)
+        );
+        let v = vec4<f32>(fluid_parent_deviation_v(pt));
+        let mask = vec4<u32>(i & 3u) == vec4<u32>(0u, 1u, 2u, 3u);
+        z0 = select(z0, v, mask & vec4<bool>(i < 4u));
+        z1 = select(z1, v, mask & vec4<bool>(i >= 4u));
+    }
 
-    let corners = ${TEXTURE3D_TRILINEAR_CORNERS_STRUCT.wgsl_ref}(
-        vec4<f32>(
-            fluid_parent_deviation_v(lo),
-            fluid_parent_deviation_v(vec3<i32>(hi.x, lo.y, lo.z)),
-            fluid_parent_deviation_v(vec3<i32>(lo.x, hi.y, lo.z)),
-            fluid_parent_deviation_v(vec3<i32>(hi.x, hi.y, lo.z))
-        ),
-        vec4<f32>(
-            fluid_parent_deviation_v(vec3<i32>(lo.x, lo.y, hi.z)),
-            fluid_parent_deviation_v(vec3<i32>(hi.x, lo.y, hi.z)),
-            fluid_parent_deviation_v(vec3<i32>(lo.x, hi.y, hi.z)),
-            fluid_parent_deviation_v(hi)
-        ),
-        lattice - base
-    );
+    let corners = ${TEXTURE3D_TRILINEAR_CORNERS_STRUCT.wgsl_ref}(z0, z1, lattice - base);
 
     return parent.read_far_velocity.y + parent.keep * texture3d_trilinear_interpolate(corners);
 }
 
 fn fluid_parent_face_w(face: vec3<i32>, offset: vec3<i32>) -> f32 {
     // the far field: nothing to read, every corner would count 0
-    if (parent.faces_w.size.x == 0u) {
+    let n_corners = select(0u, 8u, parent.faces_w.size.x != 0u);
+    if (n_corners == 0u) {
         return parent.read_far_velocity.z;
     }
 
@@ -144,22 +147,22 @@ fn fluid_parent_face_w(face: vec3<i32>, offset: vec3<i32>) -> f32 {
     let base = floor(lattice);
     let lo = vec3<i32>(base);
     let hi = lo + vec3<i32>(1);
+    var z0 = vec4<f32>(0.0);
+    var z1 = vec4<f32>(0.0);
+
+    for (var i = 0u; i < n_corners; i++) {
+        let pt = vec3<i32>(
+            select(lo.x, hi.x, (i & 1u) != 0u),
+            select(lo.y, hi.y, (i & 2u) != 0u),
+            select(lo.z, hi.z, (i & 4u) != 0u)
+        );
+        let v = vec4<f32>(fluid_parent_deviation_w(pt));
+        let mask = vec4<u32>(i & 3u) == vec4<u32>(0u, 1u, 2u, 3u);
+        z0 = select(z0, v, mask & vec4<bool>(i < 4u));
+        z1 = select(z1, v, mask & vec4<bool>(i >= 4u));
+    }
 
-    let corners = ${TEXTURE3D_TRILINEAR_CORNERS_STRUCT.wgsl_ref}(
-        vec4<f32>(
-            fluid_parent_deviation_w(lo),
-            fluid_parent_deviation_w(vec3<i32>(hi.x, lo.y, lo.z)),
-            fluid_parent_deviation_w(vec3<i32>(lo.x, hi.y, lo.z)),
-            fluid_parent_deviation_w(vec3<i32>(hi.x, hi.y, lo.z))
-        ),
-        vec4<f32>(
-            fluid_parent_deviation_w(vec3<i32>(lo.x, lo.y, hi.z)),
-            fluid_parent_deviation_w(vec3<i32>(hi.x, lo.y, hi.z)),
-            fluid_parent_deviation_w(vec3<i32>(lo.x, hi.y, hi.z)),
-            fluid_parent_deviation_w(hi)
-        ),
-        lattice - base
-    );
+    let corners = ${TEXTURE3D_TRILINEAR_CORNERS_STRUCT.wgsl_ref}(z0, z1, lattice - base);
 
     return parent.read_far_velocity.z + parent.keep * texture3d_trilinear_interpolate(corners);
 }

package/src/shade/renderer/fluid/mac/FluidMacPasses.d.ts

@@ -43,6 +43,12 @@
  * the parameters, bindings and dispatch arguments are retained and rewritten in place.
  */
 export class FluidMacPasses {
+    /**
+     * Offer the compute pipelines the MAC step passes dispatch — see {@link PipelineEnquiry}.
+     *
+     * @param {import("../../../device/pipeline/PipelineEnquiry.js").PipelineEnquiry} enquiry
+     */
+    static enquirePipelines(enquiry: import("../../../device/pipeline/PipelineEnquiry.js").PipelineEnquiry): void;
     /**
      * Where the cascade's window is.
      *

package/src/shade/renderer/fluid/mac/FluidMacPasses.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"FluidMacPasses.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/fluid/mac/FluidMacPasses.js"],"names":[],"mappings":"AAcA;;;;;;;;;;;;;;GAcG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH;IAsEI;;;;;OAKG;IACH,kBAHW,UAAU,MAAM,CAAC,UACjB,UAAU,MAAM,CAAC,QAkC3B;IAED;;;;;;;;;;;;OAYG;IACH,YAVW,MAAM,MACN,MAAM,gBACN,UAAU,MAAM,CAAC,oBAEjB,UAAU,MAAM,CAAC,QACjB,MAAM,QACN,OAAO,eACP,MAAM,QA+BhB;IAaD;;;;;;;;;OASG;IACH,qBALW,sBAAsB,UACtB,qBAAqB,kDAmB/B;IAED;;;;;;;;;;;;;;;;OAgBG;IACH,uBAbW,sBAAsB,UACtB,qBAAqB,WACrB,qBAAqB,OACrB,qBAAqB,wEAOrB,0BAA0B,UAC1B,yBAAyB,QA0CnC;IAED;;;;;;;OAOG;IACH,uBAJW,sBAAsB,UACtB,0BAA0B,UAC1B,yBAAyB,QAgBnC;IAED;;;;;;;OAOG;IACH,2BALW,sBAAsB,YACtB,qBAAqB,0CAgB/B;IAED;;;;;;;;;OASG;IACH,yBAPW,sBAAsB,YACtB,qBAAqB,8CAGrB,qBAAqB,UACrB,yBAAyB,QAmBnC;;CACJ;qCAhXY,OAAO,2CAA2C,EAAE,sBAAsB;kCAC1E,OAAO,0BAA0B,EAAE,mBAAmB;;;;;;oCACtD;IAAC,CAAC,iBAAiB;IAAC,CAAC,iBAAiB;IAAC,CAAC,iBAAgB;CAAC;;;;;;yCAGzD;IAAC,OAAO,YAAY;IAAC,CAAC,iBAAiB;IAAC,CAAC,iBAAiB;IAAC,CAAC,iBAAiB;IAAC,QAAQ,YAAW;CAAC;;;;;;wCAIlG;IAAC,CAAC,iBAAiB;IAAC,CAAC,iBAAiB;IAAC,CAAC,iBAAiB;IAAC,QAAQ,YAAW;CAAC"}
+{"version":3,"file":"FluidMacPasses.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/fluid/mac/FluidMacPasses.js"],"names":[],"mappings":"AAcA;;;;;;;;;;;;;;GAcG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH;IACI;;;;OAIG;IACH,iCAFW,OAAO,6CAA6C,EAAE,eAAe,QAW/E;IAuED;;;;;OAKG;IACH,kBAHW,UAAU,MAAM,CAAC,UACjB,UAAU,MAAM,CAAC,QAkC3B;IAED;;;;;;;;;;;;OAYG;IACH,YAVW,MAAM,MACN,MAAM,gBACN,UAAU,MAAM,CAAC,oBAEjB,UAAU,MAAM,CAAC,QACjB,MAAM,QACN,OAAO,eACP,MAAM,QA+BhB;IAaD;;;;;;;;;OASG;IACH,qBALW,sBAAsB,UACtB,qBAAqB,kDAmB/B;IAED;;;;;;;;;;;;;;;;OAgBG;IACH,uBAbW,sBAAsB,UACtB,qBAAqB,WACrB,qBAAqB,OACrB,qBAAqB,wEAOrB,0BAA0B,UAC1B,yBAAyB,QA0CnC;IAED;;;;;;;OAOG;IACH,uBAJW,sBAAsB,UACtB,0BAA0B,UAC1B,yBAAyB,QAgBnC;IAED;;;;;;;OAOG;IACH,2BALW,sBAAsB,YACtB,qBAAqB,0CAgB/B;IAED;;;;;;;;;OASG;IACH,yBAPW,sBAAsB,YACtB,qBAAqB,8CAGrB,qBAAqB,UACrB,yBAAyB,QAmBnC;;CACJ;qCAhYY,OAAO,2CAA2C,EAAE,sBAAsB;kCAC1E,OAAO,0BAA0B,EAAE,mBAAmB;;;;;;oCACtD;IAAC,CAAC,iBAAiB;IAAC,CAAC,iBAAiB;IAAC,CAAC,iBAAgB;CAAC;;;;;;yCAGzD;IAAC,OAAO,YAAY;IAAC,CAAC,iBAAiB;IAAC,CAAC,iBAAiB;IAAC,CAAC,iBAAiB;IAAC,QAAQ,YAAW;CAAC;;;;;;wCAIlG;IAAC,CAAC,iBAAiB;IAAC,CAAC,iBAAiB;IAAC,CAAC,iBAAiB;IAAC,QAAQ,YAAW;CAAC"}

package/src/shade/renderer/fluid/mac/FluidMacPasses.js

@@ -58,6 +58,22 @@ import { FLUID_CASCADE_GHOST_DEPTH } from "../coupling/FLUID_CASCADE_GHOSTS.js";
  * the parameters, bindings and dispatch arguments are retained and rewritten in place.
  */
 export class FluidMacPasses {
+    /**
+     * Offer the compute pipelines the MAC step passes dispatch — see {@link PipelineEnquiry}.
+     *
+     * @param {import("../../../device/pipeline/PipelineEnquiry.js").PipelineEnquiry} enquiry
+     */
+    static enquirePipelines(enquiry) {
+        enquiry.compute.push(
+            shader_fluid_mac_advect_correct.pipeline,
+            shader_fluid_mac_advect_predict.pipeline,
+            shader_fluid_mac_curl.pipeline,
+            shader_fluid_mac_divergence.pipeline,
+            shader_fluid_mac_gradient.pipeline,
+            shader_fluid_cascade_ghosts.pipeline,
+        );
+    }
+
     /** The value of {@link FLUID_MAC_STEP_STRUCT}, rewritten in place. */
     #step = {
         cells: fluid_cascade_window_value(),

package/src/shade/renderer/fluid/mac/chunk_fluid_mac_seams.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_fluid_mac_seams.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/fluid/mac/chunk_fluid_mac_seams.js"],"names":[],"mappings":"AAmBA;;;;;GAKG;AACH,yCAFU,SAAS,CAgBjB;AAEF;;;;;;;GAOG;AACH,yCAFU,SAAS,CAuCjB;AAEF;;;;;;GAMG;AACH,0CAFU,SAAS,CA4CjB;AAEF;;;;;;;GAOG;AACH,2CAFU,SAAS,CAgCjB;0BAjLwB,oCAAoC"}
+{"version":3,"file":"chunk_fluid_mac_seams.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/fluid/mac/chunk_fluid_mac_seams.js"],"names":[],"mappings":"AAmBA;;;;;GAKG;AACH,yCAFU,SAAS,CAgBjB;AAEF;;;;;;;GAOG;AACH,yCAFU,SAAS,CAuCjB;AAEF;;;;;;GAMG;AACH,0CAFU,SAAS,CAwDjB;AAEF;;;;;;;GAOG;AACH,2CAFU,SAAS,CAgCjB;0BA7LwB,oCAAoC"}

package/src/shade/renderer/fluid/mac/chunk_fluid_mac_seams.js

@@ -121,15 +121,27 @@ fn mac_source_w(face: vec3<i32>) -> f32 {
 }
 
 fn mac_carrier_u(face: vec3<i32>) -> f32 {
-    return mac_source_u(face);
+    if (grid_tile_window_contains(face, step.faces_u.size)) {
+        return textureLoad(source_u, grid_tile_window_storage(face, step.faces_u.corner_storage, step.faces_u.period), 0).r;
+    }
+
+    return textureLoad(ghost_u, vec3<u32>(face + vec3<i32>(FLUID_MAC_GHOST_DEPTH)), 0).r;
 }
 
 fn mac_carrier_v(face: vec3<i32>) -> f32 {
-    return mac_source_v(face);
+    if (grid_tile_window_contains(face, step.faces_v.size)) {
+        return textureLoad(source_v, grid_tile_window_storage(face, step.faces_v.corner_storage, step.faces_v.period), 0).r;
+    }
+
+    return textureLoad(ghost_v, vec3<u32>(face + vec3<i32>(FLUID_MAC_GHOST_DEPTH)), 0).r;
 }
 
 fn mac_carrier_w(face: vec3<i32>) -> f32 {
-    return mac_source_w(face);
+    if (grid_tile_window_contains(face, step.faces_w.size)) {
+        return textureLoad(source_w, grid_tile_window_storage(face, step.faces_w.corner_storage, step.faces_w.period), 0).r;
+    }
+
+    return textureLoad(ghost_w, vec3<u32>(face + vec3<i32>(FLUID_MAC_GHOST_DEPTH)), 0).r;
 }
 `, [
         chunk_grid_tile_window,

package/src/shade/renderer/fluid/mac/chunk_v3_mac_lattice_corners.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_v3_mac_lattice_corners.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/fluid/mac/chunk_v3_mac_lattice_corners.js"],"names":[],"mappings":"AAqBA;;;;;GAKG;AACH,uCAFU,SAAS,CAkBjB;AAEF;;;;;GAKG;AACH,iCAFU,SAAS,CAkBjB;AAEF;;;;;;;GAOG;AACH,0CAFU,SAAS,CA0EjB;AAEF;;;;;;GAMG;AACH,2CAFU,SAAS,CA0EjB;0BAtOwB,oCAAoC"}
+{"version":3,"file":"chunk_v3_mac_lattice_corners.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/fluid/mac/chunk_v3_mac_lattice_corners.js"],"names":[],"mappings":"AAqBA;;;;;GAKG;AACH,uCAFU,SAAS,CAkBjB;AAEF;;;;;GAKG;AACH,iCAFU,SAAS,CAkBjB;AAEF;;;;;;;GAOG;AACH,0CAFU,SAAS,CA6EjB;AAEF;;;;;;GAMG;AACH,2CAFU,SAAS,CA6EjB;0BA5OwB,oCAAoC"}

package/src/shade/renderer/fluid/mac/chunk_v3_mac_lattice_corners.js

@@ -82,66 +82,69 @@ fn v3_mac_source_corners_u(position: vec3<f32>) -> ${TEXTURE3D_TRILINEAR_CORNERS
     let tap = v3_mac_lattice_tap(position);
     let lo = tap.lo;
     let hi = tap.hi;
-
-    return ${TEXTURE3D_TRILINEAR_CORNERS_STRUCT.wgsl_ref}(
-        vec4<f32>(
-            mac_source_u(lo),
-            mac_source_u(vec3<i32>(hi.x, lo.y, lo.z)),
-            mac_source_u(vec3<i32>(lo.x, hi.y, lo.z)),
-            mac_source_u(vec3<i32>(hi.x, hi.y, lo.z))
-        ),
-        vec4<f32>(
-            mac_source_u(vec3<i32>(lo.x, lo.y, hi.z)),
-            mac_source_u(vec3<i32>(hi.x, lo.y, hi.z)),
-            mac_source_u(vec3<i32>(lo.x, hi.y, hi.z)),
-            mac_source_u(hi)
-        ),
-        tap.weight
-    );
+    let n_corners = select(0u, 8u, abs(position.x) < 1e30);
+    var z0 = vec4<f32>(0.0);
+    var z1 = vec4<f32>(0.0);
+
+    for (var i = 0u; i < n_corners; i++) {
+        let pt = vec3<i32>(
+            select(lo.x, hi.x, (i & 1u) != 0u),
+            select(lo.y, hi.y, (i & 2u) != 0u),
+            select(lo.z, hi.z, (i & 4u) != 0u)
+        );
+        let v = vec4<f32>(mac_source_u(pt));
+        let mask = vec4<u32>(i & 3u) == vec4<u32>(0u, 1u, 2u, 3u);
+        z0 = select(z0, v, mask & vec4<bool>(i < 4u));
+        z1 = select(z1, v, mask & vec4<bool>(i >= 4u));
+    }
+
+    return ${TEXTURE3D_TRILINEAR_CORNERS_STRUCT.wgsl_ref}(z0, z1, tap.weight);
 }
 
 fn v3_mac_source_corners_v(position: vec3<f32>) -> ${TEXTURE3D_TRILINEAR_CORNERS_STRUCT.wgsl_ref} {
     let tap = v3_mac_lattice_tap(position);
     let lo = tap.lo;
     let hi = tap.hi;
-
-    return ${TEXTURE3D_TRILINEAR_CORNERS_STRUCT.wgsl_ref}(
-        vec4<f32>(
-            mac_source_v(lo),
-            mac_source_v(vec3<i32>(hi.x, lo.y, lo.z)),
-            mac_source_v(vec3<i32>(lo.x, hi.y, lo.z)),
-            mac_source_v(vec3<i32>(hi.x, hi.y, lo.z))
-        ),
-        vec4<f32>(
-            mac_source_v(vec3<i32>(lo.x, lo.y, hi.z)),
-            mac_source_v(vec3<i32>(hi.x, lo.y, hi.z)),
-            mac_source_v(vec3<i32>(lo.x, hi.y, hi.z)),
-            mac_source_v(hi)
-        ),
-        tap.weight
-    );
+    let n_corners = select(0u, 8u, abs(position.x) < 1e30);
+    var z0 = vec4<f32>(0.0);
+    var z1 = vec4<f32>(0.0);
+
+    for (var i = 0u; i < n_corners; i++) {
+        let pt = vec3<i32>(
+            select(lo.x, hi.x, (i & 1u) != 0u),
+            select(lo.y, hi.y, (i & 2u) != 0u),
+            select(lo.z, hi.z, (i & 4u) != 0u)
+        );
+        let v = vec4<f32>(mac_source_v(pt));
+        let mask = vec4<u32>(i & 3u) == vec4<u32>(0u, 1u, 2u, 3u);
+        z0 = select(z0, v, mask & vec4<bool>(i < 4u));
+        z1 = select(z1, v, mask & vec4<bool>(i >= 4u));
+    }
+
+    return ${TEXTURE3D_TRILINEAR_CORNERS_STRUCT.wgsl_ref}(z0, z1, tap.weight);
 }
 
 fn v3_mac_source_corners_w(position: vec3<f32>) -> ${TEXTURE3D_TRILINEAR_CORNERS_STRUCT.wgsl_ref} {
     let tap = v3_mac_lattice_tap(position);
     let lo = tap.lo;
     let hi = tap.hi;
-
-    return ${TEXTURE3D_TRILINEAR_CORNERS_STRUCT.wgsl_ref}(
-        vec4<f32>(
-            mac_source_w(lo),
-            mac_source_w(vec3<i32>(hi.x, lo.y, lo.z)),
-            mac_source_w(vec3<i32>(lo.x, hi.y, lo.z)),
-            mac_source_w(vec3<i32>(hi.x, hi.y, lo.z))
-        ),
-        vec4<f32>(
-            mac_source_w(vec3<i32>(lo.x, lo.y, hi.z)),
-            mac_source_w(vec3<i32>(hi.x, lo.y, hi.z)),
-            mac_source_w(vec3<i32>(lo.x, hi.y, hi.z)),
-            mac_source_w(hi)
-        ),
-        tap.weight
-    );
+    let n_corners = select(0u, 8u, abs(position.x) < 1e30);
+    var z0 = vec4<f32>(0.0);
+    var z1 = vec4<f32>(0.0);
+
+    for (var i = 0u; i < n_corners; i++) {
+        let pt = vec3<i32>(
+            select(lo.x, hi.x, (i & 1u) != 0u),
+            select(lo.y, hi.y, (i & 2u) != 0u),
+            select(lo.z, hi.z, (i & 4u) != 0u)
+        );
+        let v = vec4<f32>(mac_source_w(pt));
+        let mask = vec4<u32>(i & 3u) == vec4<u32>(0u, 1u, 2u, 3u);
+        z0 = select(z0, v, mask & vec4<bool>(i < 4u));
+        z1 = select(z1, v, mask & vec4<bool>(i >= 4u));
+    }
+
+    return ${TEXTURE3D_TRILINEAR_CORNERS_STRUCT.wgsl_ref}(z0, z1, tap.weight);
 }
 `, [
         TEXTURE3D_TRILINEAR_CORNERS_STRUCT.declaration_chunk,
@@ -163,66 +166,69 @@ fn v3_mac_forward_corners_u(position: vec3<f32>) -> ${TEXTURE3D_TRILINEAR_CORNER
     let tap = v3_mac_lattice_tap(position);
     let lo = tap.lo;
     let hi = tap.hi;
-
-    return ${TEXTURE3D_TRILINEAR_CORNERS_STRUCT.wgsl_ref}(
-        vec4<f32>(
-            mac_forward_u(lo),
-            mac_forward_u(vec3<i32>(hi.x, lo.y, lo.z)),
-            mac_forward_u(vec3<i32>(lo.x, hi.y, lo.z)),
-            mac_forward_u(vec3<i32>(hi.x, hi.y, lo.z))
-        ),
-        vec4<f32>(
-            mac_forward_u(vec3<i32>(lo.x, lo.y, hi.z)),
-            mac_forward_u(vec3<i32>(hi.x, lo.y, hi.z)),
-            mac_forward_u(vec3<i32>(lo.x, hi.y, hi.z)),
-            mac_forward_u(hi)
-        ),
-        tap.weight
-    );
+    let n_corners = select(0u, 8u, abs(position.x) < 1e30);
+    var z0 = vec4<f32>(0.0);
+    var z1 = vec4<f32>(0.0);
+
+    for (var i = 0u; i < n_corners; i++) {
+        let pt = vec3<i32>(
+            select(lo.x, hi.x, (i & 1u) != 0u),
+            select(lo.y, hi.y, (i & 2u) != 0u),
+            select(lo.z, hi.z, (i & 4u) != 0u)
+        );
+        let v = vec4<f32>(mac_forward_u(pt));
+        let mask = vec4<u32>(i & 3u) == vec4<u32>(0u, 1u, 2u, 3u);
+        z0 = select(z0, v, mask & vec4<bool>(i < 4u));
+        z1 = select(z1, v, mask & vec4<bool>(i >= 4u));
+    }
+
+    return ${TEXTURE3D_TRILINEAR_CORNERS_STRUCT.wgsl_ref}(z0, z1, tap.weight);
 }
 
 fn v3_mac_forward_corners_v(position: vec3<f32>) -> ${TEXTURE3D_TRILINEAR_CORNERS_STRUCT.wgsl_ref} {
     let tap = v3_mac_lattice_tap(position);
     let lo = tap.lo;
     let hi = tap.hi;
-
-    return ${TEXTURE3D_TRILINEAR_CORNERS_STRUCT.wgsl_ref}(
-        vec4<f32>(
-            mac_forward_v(lo),
-            mac_forward_v(vec3<i32>(hi.x, lo.y, lo.z)),
-            mac_forward_v(vec3<i32>(lo.x, hi.y, lo.z)),
-            mac_forward_v(vec3<i32>(hi.x, hi.y, lo.z))
-        ),
-        vec4<f32>(
-            mac_forward_v(vec3<i32>(lo.x, lo.y, hi.z)),
-            mac_forward_v(vec3<i32>(hi.x, lo.y, hi.z)),
-            mac_forward_v(vec3<i32>(lo.x, hi.y, hi.z)),
-            mac_forward_v(hi)
-        ),
-        tap.weight
-    );
+    let n_corners = select(0u, 8u, abs(position.x) < 1e30);
+    var z0 = vec4<f32>(0.0);
+    var z1 = vec4<f32>(0.0);
+
+    for (var i = 0u; i < n_corners; i++) {
+        let pt = vec3<i32>(
+            select(lo.x, hi.x, (i & 1u) != 0u),
+            select(lo.y, hi.y, (i & 2u) != 0u),
+            select(lo.z, hi.z, (i & 4u) != 0u)
+        );
+        let v = vec4<f32>(mac_forward_v(pt));
+        let mask = vec4<u32>(i & 3u) == vec4<u32>(0u, 1u, 2u, 3u);
+        z0 = select(z0, v, mask & vec4<bool>(i < 4u));
+        z1 = select(z1, v, mask & vec4<bool>(i >= 4u));
+    }
+
+    return ${TEXTURE3D_TRILINEAR_CORNERS_STRUCT.wgsl_ref}(z0, z1, tap.weight);
 }
 
 fn v3_mac_forward_corners_w(position: vec3<f32>) -> ${TEXTURE3D_TRILINEAR_CORNERS_STRUCT.wgsl_ref} {
     let tap = v3_mac_lattice_tap(position);
     let lo = tap.lo;
     let hi = tap.hi;
-
-    return ${TEXTURE3D_TRILINEAR_CORNERS_STRUCT.wgsl_ref}(
-        vec4<f32>(
-            mac_forward_w(lo),
-            mac_forward_w(vec3<i32>(hi.x, lo.y, lo.z)),
-            mac_forward_w(vec3<i32>(lo.x, hi.y, lo.z)),
-            mac_forward_w(vec3<i32>(hi.x, hi.y, lo.z))
-        ),
-        vec4<f32>(
-            mac_forward_w(vec3<i32>(lo.x, lo.y, hi.z)),
-            mac_forward_w(vec3<i32>(hi.x, lo.y, hi.z)),
-            mac_forward_w(vec3<i32>(lo.x, hi.y, hi.z)),
-            mac_forward_w(hi)
-        ),
-        tap.weight
-    );
+    let n_corners = select(0u, 8u, abs(position.x) < 1e30);
+    var z0 = vec4<f32>(0.0);
+    var z1 = vec4<f32>(0.0);
+
+    for (var i = 0u; i < n_corners; i++) {
+        let pt = vec3<i32>(
+            select(lo.x, hi.x, (i & 1u) != 0u),
+            select(lo.y, hi.y, (i & 2u) != 0u),
+            select(lo.z, hi.z, (i & 4u) != 0u)
+        );
+        let v = vec4<f32>(mac_forward_w(pt));
+        let mask = vec4<u32>(i & 3u) == vec4<u32>(0u, 1u, 2u, 3u);
+        z0 = select(z0, v, mask & vec4<bool>(i < 4u));
+        z1 = select(z1, v, mask & vec4<bool>(i >= 4u));
+    }
+
+    return ${TEXTURE3D_TRILINEAR_CORNERS_STRUCT.wgsl_ref}(z0, z1, tap.weight);
 }
 `, [
         TEXTURE3D_TRILINEAR_CORNERS_STRUCT.declaration_chunk,

package/src/shade/renderer/fluid/mac/shader_fluid_mac_advect_correct.js

@@ -168,20 +168,20 @@ fn main(@builtin(global_invocation_id) id: vec3<u32>) {
     let cell = vec3<i32>(id);
     let last = vec3<i32>(step.cells.size) - vec3<i32>(1);
 
-    // each cell's -x, -y and -z faces
-    fluid_mac_correct_store_u(cell);
-    fluid_mac_correct_store_v(cell);
-    fluid_mac_correct_store_w(cell);
-
-    // the +boundary face planes, owned by the last tile along each axis
-    if (cell.x == last.x) {
-        fluid_mac_correct_store_u(cell + vec3<i32>(1, 0, 0));
+    // each cell's -x, -y and -z faces, and the +boundary face planes on the last tile along each axis
+    let u_end = select(1, 2, cell.x == last.x);
+    for (var dx = 0; dx < u_end; dx++) {
+        fluid_mac_correct_store_u(cell + vec3<i32>(dx, 0, 0));
     }
-    if (cell.y == last.y) {
-        fluid_mac_correct_store_v(cell + vec3<i32>(0, 1, 0));
+
+    let v_end = select(1, 2, cell.y == last.y);
+    for (var dy = 0; dy < v_end; dy++) {
+        fluid_mac_correct_store_v(cell + vec3<i32>(0, dy, 0));
     }
-    if (cell.z == last.z) {
-        fluid_mac_correct_store_w(cell + vec3<i32>(0, 0, 1));
+
+    let w_end = select(1, 2, cell.z == last.z);
+    for (var dz = 0; dz < w_end; dz++) {
+        fluid_mac_correct_store_w(cell + vec3<i32>(0, 0, dz));
     }
 }
 `, [

package/src/shade/renderer/fluid/mac/shader_fluid_mac_advect_predict.js

@@ -49,20 +49,20 @@ fn main(@builtin(global_invocation_id) id: vec3<u32>) {
     let cell = vec3<i32>(id);
     let last = vec3<i32>(step.cells.size) - vec3<i32>(1);
 
-    // each cell's -x, -y and -z faces
-    fluid_mac_predict_store_u(cell);
-    fluid_mac_predict_store_v(cell);
-    fluid_mac_predict_store_w(cell);
-
-    // the +boundary face planes, owned by the last tile along each axis
-    if (cell.x == last.x) {
-        fluid_mac_predict_store_u(cell + vec3<i32>(1, 0, 0));
+    // each cell's -x, -y and -z faces, and the +boundary face planes on the last tile along each axis
+    let u_end = select(1, 2, cell.x == last.x);
+    for (var dx = 0; dx < u_end; dx++) {
+        fluid_mac_predict_store_u(cell + vec3<i32>(dx, 0, 0));
     }
-    if (cell.y == last.y) {
-        fluid_mac_predict_store_v(cell + vec3<i32>(0, 1, 0));
+
+    let v_end = select(1, 2, cell.y == last.y);
+    for (var dy = 0; dy < v_end; dy++) {
+        fluid_mac_predict_store_v(cell + vec3<i32>(0, dy, 0));
     }
-    if (cell.z == last.z) {
-        fluid_mac_predict_store_w(cell + vec3<i32>(0, 0, 1));
+
+    let w_end = select(1, 2, cell.z == last.z);
+    for (var dz = 0; dz < w_end; dz++) {
+        fluid_mac_predict_store_w(cell + vec3<i32>(0, 0, dz));
     }
 }
 `, [

package/src/shade/renderer/fluid/pressure/GPUFluidPressureSolve.d.ts

@@ -29,6 +29,13 @@
  * the far field, a parent with no window, reads 0.
  */
 export class GPUFluidPressureSolve {
+    /**
+     * Offer the compute pipelines the multigrid and SOR pressure solvers dispatch — see
+     * {@link PipelineEnquiry}.
+     *
+     * @param {import("../../../device/pipeline/PipelineEnquiry.js").PipelineEnquiry} enquiry
+     */
+    static enquirePipelines(enquiry: import("../../../device/pipeline/PipelineEnquiry.js").PipelineEnquiry): void;
     /**
      * @param {{solve: GPUFluidPressureSolve, arm: number, count: number, inputs: FluidPressureSolveInputs}} data
      * @param {*} _resources