@woosh/meep-engine 3.67.0 → 3.69.0

package/src/shade/renderer/dynamic/shader_dynamic_mesh_avboit_splat.js

@@ -1,18 +1,8 @@
-import { PipelineLayoutDescriptor } from "../../descriptor/pipeline/PipelineLayoutDescriptor.js";
-import { RenderPipelineDescriptor } from "../../descriptor/pipeline/render/RenderPipelineDescriptor.js";
-import { AVBOIT_WARP_STRUCT } from "../rasterize/native/avboit/AVBOIT_WARP_STRUCT.js";
-import { chunk_avboit_coverage } from "../rasterize/native/avboit/chunk_avboit_coverage.js";
-import { chunk_avboit_splat_slice } from "../rasterize/native/avboit/chunk_avboit_splat_slice.js";
-import {
-    chunk_avboit_transmittance_to_extinction
-} from "../rasterize/native/avboit/chunk_avboit_transmittance_to_extinction.js";
-import { chunk_avboit_view_depth_to_physical } from "../rasterize/native/avboit/chunk_avboit_view_depth_to_physical.js";
-import { AVBOIT_SPLAT_DUMMY_FORMAT } from "../rasterize/native/avboit/shader_avboit_splat.js";
+import { avboit_unlit_splat_pipeline, AVBOIT_UNLIT_SPLAT_PASS_GROUP, chunk_avboit_unlit_splat_fragment } from "../rasterize/native/avboit/avboit_unlit_splat.js";
+import { AVBOIT_SPLAT_VOLUME_GROUP } from "../rasterize/native/avboit/shader_avboit_splat.js";
 import { CodeChunk } from "../shader/compiler/CodeChunk.js";
 import { ShaderResourceSetDescriptor } from "../shader/resource/ShaderResourceSetDescriptor.js";
 import { ShaderDescriptor } from "../shader/ShaderDescriptor.js";
-import { atomic_u32 } from "../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
-import { WebGPUArray } from "../shader/type/WebGPUArray.js";
 import { chunk_dynamic_mesh_avboit_vertex } from "./chunk_dynamic_mesh_avboit_vertex.js";
 import {
     DYNAMIC_MESH_BIND_GROUP_DRAWS,
@@ -21,53 +11,22 @@ import {
 } from "./shader_dynamic_mesh.js";
 
 /**
- * Bind group of the warp, set once per pass. Groups 0 and 1 are the dynamic-mesh groups: the draw
- * constants per chunk, the geometry per mesh.
+ * Bind group of the warp (`AVBOIT_UNLIT_SPLAT_PASS_GROUP`), set once per pass. Groups 0 and 1 are the
+ * dynamic-mesh groups: the draw constants per chunk, the geometry per mesh.
  * @type {number}
  */
 export const DYNAMIC_MESH_AVBOIT_SPLAT_BIND_GROUP_PASS = 2;
 
 /**
- * Bind group of the volume atomics, set once per pass.
+ * Bind group of the volume atomics (`AVBOIT_SPLAT_VOLUME_GROUP`), set once per pass.
  * @type {number}
  */
 export const DYNAMIC_MESH_AVBOIT_SPLAT_BIND_GROUP_VOLUME = 3;
 
 /**
- * Samples per pixel of the splat's raster, which is what a fragment's extinction is weighted by the
- * share of. Four, being the only count above one that WebGPU guarantees.
- * @type {number}
- */
-export const DYNAMIC_MESH_AVBOIT_SPLAT_SAMPLES = 4;
-
-/**
- * The dynamic meshes' AVBOIT splat: every mesh's triangles rasterized at the volume's resolution,
- * each fragment's extinction added into the voxel volume through `avboit_splat_slice` — the same
- * write path as the meshlet and particle splats, so a trail, a particle and a surface at one depth
- * pile up in one field.
- *
- * Coverage is the vertex colour's alpha times the mesh's, through `avboit_coverage` — the function
- * the draw weights the same fragment by — and `T_self = 1 - coverage`, untinted. A fragment that
- * has faded to nothing covers nothing and writes nothing, which on a trail is its whole aged-out
- * tail.
- *
- * **Weighted by the share of the voxel the triangle covers.** A voxel is eight pixels across, and a
- * trail is often narrower than that. Sampled at the voxel's centre alone, a thin trail either
- * crosses the centre and writes its full extinction there or misses it and writes nothing, so its
- * occlusion of what lies behind it came and went as it moved by a fraction of a voxel — beaded along
- * a curve, flickering in motion. Here the raster has {@link DYNAMIC_MESH_AVBOIT_SPLAT_SAMPLES}
- * samples per pixel, the fragment runs wherever any of them is covered, and its extinction is scaled
- * by the covered fraction: the voxel gets the triangle's extinction averaged over its footprint, as
- * a volume that coarse can hold it. The triangles of one mesh cover disjoint samples, so the
- * fractions of the triangles sharing a voxel add up to at most one layer; a fully covered voxel is
- * written exactly as before. What remains is the average's own bias — a trail a fraction of a voxel
- * wide occludes what is behind it by that fraction of its extinction — which holds still as the
- * trail moves.
- *
- * Depth is the fragment's own view depth from the shared vertex stage, through curve → warp →
- * physical and the two-slice linear split the other splats make. No depth attachment, for the
- * reason the meshlet splat has none: a splat behind an opaque surface lies deeper than anything the
- * draw will look it up for.
+ * The dynamic meshes' AVBOIT splat: every mesh's triangles rasterized at the volume's resolution by the
+ * dynamic-mesh vertex stage, into the unlit splat's fragment stage (`chunk_avboit_unlit_splat_fragment`,
+ * which says what a fragment writes). Coverage is the vertex colour's alpha times the mesh's.
  *
  * Groups 0 and 1 are `DYNAMIC_MESH_RESOURCES`' own groups, the same objects, so their layouts are
  * the ones every dynamic-mesh pipeline declares and a geometry's one group serves them all. The AVBOIT
@@ -78,93 +37,34 @@ const resources = new ShaderResourceSetDescriptor();
 
 resources.addGroup(DYNAMIC_MESH_RESOURCES.groups[DYNAMIC_MESH_BIND_GROUP_DRAWS]);
 resources.addGroup(DYNAMIC_MESH_RESOURCES.groups[DYNAMIC_MESH_BIND_GROUP_GEOMETRY]);
-
-resources.createGroup()
-    .addStorageBuffer("warp", AVBOIT_WARP_STRUCT);
-
-resources.createGroup()
-    .addStorageBuffer("extinction_volume", WebGPUArray.from(atomic_u32), true)
-    .addStorageBuffer("overflow_slice", WebGPUArray.from(atomic_u32), true);
+resources.addGroup(AVBOIT_UNLIT_SPLAT_PASS_GROUP);
+resources.addGroup(AVBOIT_SPLAT_VOLUME_GROUP);
 
 const body = CodeChunk.from(
     //language=WGSL
     `
 @vertex
-fn vs_main(@builtin(vertex_index) vi : u32, @builtin(instance_index) draw_index : u32) -> DynamicMeshAVBOITVertexOut {
+fn vs_main(@builtin(vertex_index) vi : u32, @builtin(instance_index) draw_index : u32) -> AVBOITUnlitVaryings {
     return dynamic_mesh_avboit_vertex(vi, draw_index);
 }
-
-@fragment
-fn fs_main(in : DynamicMeshAVBOITVertexOut, @builtin(sample_mask) sample_mask : u32) {
-    // the coverage the draw weights this fragment by, through the same function
-    let coverage = avboit_coverage(in.color.a);
-
-    if (coverage <= 0.0) {
-        // faded out: occludes nothing
-        return;
-    }
-
-    // the share of the voxel's samples this triangle covers
-    let footprint = f32(countOneBits(sample_mask)) / ${DYNAMIC_MESH_AVBOIT_SPLAT_SAMPLES}.0;
-
-    let extinction = avboit_transmittance_to_extinction(vec3<f32>(1.0 - coverage)) * footprint;
-
-    let p = avboit_view_depth_to_physical(&warp, in.view_depth);
-
-    // in.clip is @builtin(position): .xy the low-resolution pixel
-    let texel = vec2<u32>(in.clip.xy);
-    let column = texel.y * warp.voxel_width + texel.x;
-
-    // linear splat between the two slices around the fragment
-    let c = p - 0.5;
-    let slice = i32(floor(c));
-    let fraction = c - floor(c);
-
-    avboit_splat_slice(column, slice, extinction * (1.0 - fraction), texel);
-    avboit_splat_slice(column, slice + 1, extinction * fraction, texel);
-}
 `, [
     chunk_dynamic_mesh_avboit_vertex,
-    chunk_avboit_coverage,
-    chunk_avboit_transmittance_to_extinction,
-    chunk_avboit_view_depth_to_physical,
-    chunk_avboit_splat_slice,
+    chunk_avboit_unlit_splat_fragment,
 ]);
 
 const descriptor = ShaderDescriptor.from({ label: "Dynamic Mesh AVBOIT Splat", body, resources });
 
-// Built group by group: the atomics are fragment-only, and WebGPU refuses a read-write storage
-// buffer that is visible to the vertex stage. The dynamic-mesh groups keep the visibility they have
-// in the pass over the scene, so the layouts agree and one geometry group serves every pipeline.
-const groups = resources.groups;
-const layout = PipelineLayoutDescriptor.from([
-    groups[DYNAMIC_MESH_BIND_GROUP_DRAWS].generateBindGroupLayoutDescriptor(GPUShaderStage.VERTEX | GPUShaderStage.FRAGMENT),
-    groups[DYNAMIC_MESH_BIND_GROUP_GEOMETRY].generateBindGroupLayoutDescriptor(GPUShaderStage.VERTEX | GPUShaderStage.FRAGMENT),
-    groups[DYNAMIC_MESH_AVBOIT_SPLAT_BIND_GROUP_PASS].generateBindGroupLayoutDescriptor(GPUShaderStage.VERTEX | GPUShaderStage.FRAGMENT),
-    groups[DYNAMIC_MESH_AVBOIT_SPLAT_BIND_GROUP_VOLUME].generateBindGroupLayoutDescriptor(GPUShaderStage.FRAGMENT),
-], resources.immediateSize);
-
 /**
- * The splat pipeline: no depth, one never-written attachment to size the raster, multisampled so a
- * fragment knows how much of its voxel it covers, both faces — a trail is seen from inside and out.
- * The attachment is the splat's own ({@link DYNAMIC_MESH_AVBOIT_SPLAT_SAMPLES} samples), not the
- * volume's single-sampled one the meshlet and particle splats share.
- * @type {RenderPipelineDescriptor}
+ * The splat pipeline, as every unlit splat is built (`avboit_unlit_splat_pipeline`).
+ * @type {import("../../descriptor/pipeline/render/RenderPipelineDescriptor.js").RenderPipelineDescriptor}
  */
-export const DYNAMIC_MESH_AVBOIT_SPLAT_PIPELINE = RenderPipelineDescriptor.from({
+export const DYNAMIC_MESH_AVBOIT_SPLAT_PIPELINE = avboit_unlit_splat_pipeline({
     label: "Dynamic Mesh AVBOIT Splat",
-    layout,
-    vertex: { module: { code: descriptor.source }, entryPoint: "vs_main" },
-    fragment: {
-        module: { code: descriptor.source },
-        entryPoint: "fs_main",
-        targets: [{ format: AVBOIT_SPLAT_DUMMY_FORMAT, writeMask: 0 }],
-    },
-    primitive: { topology: "triangle-list", cullMode: "none" },
-    multisample: { count: DYNAMIC_MESH_AVBOIT_SPLAT_SAMPLES },
+    resources,
+    source: descriptor.source,
 });
 
-/** The splat shader's resource set, for building its pass-level bind groups. */
+/** The splat shader's resource set. */
 export const DYNAMIC_MESH_AVBOIT_SPLAT_RESOURCES = resources;
 
 /** The assembled shader, for the validity tier. */

package/src/shade/renderer/extension/ViewTextures.d.ts

@@ -41,8 +41,9 @@ export class ViewTextures extends FrameRecord {
     get visible_meshlets(): number;
     set velocity(handle: number);
     /**
-     * How far each pixel's surface moved on screen since the last frame: `rg16float`, in pixels, this
-     * frame's place less last frame's, free of the sub-pixel jitter. The renderer fills it from depth and
+     * How far each pixel's surface moved since the last frame, `VELOCITY_FORMAT`: in xy the pixels from last
+     * frame's place to this frame's, in z the view depth now less then, free of the sub-pixel jitter
+     * (`chunk_velocity_texel` makes the texel). The renderer fills it from depth and
      * {@link visibility} before {@link FramePhase.AfterGBuffer}; an extension that draws surfaces the
      * visibility buffer cannot describe writes their pixels' motion over it at that phase and publishes
      * the handle it wrote. What is published later than that phase reaches nothing the renderer runs.

package/src/shade/renderer/extension/ViewTextures.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ViewTextures.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/extension/ViewTextures.js"],"names":[],"mappings":"AAGA;;;;;;;GAOG;AACH;IAOI,0CAKC;IASD,0BAEC;IATD;;OAEG;IACH,oBAEC;IAgBD,mCAEC;IAZD;;;;;OAKG;IACH,6BAEC;IAiBD,+BAEC;IAbD;;;;;;OAMG;IACH,yBAEC;IAiBD,qCAEC;IAbD;;;;;;OAMG;IACH,+BAEC;IAmBD,6BAEC;IAfD;;;;;;;;OAQG;IACH,uBAEC;;CAKJ;4BA/F2B,kBAAkB"}
+{"version":3,"file":"ViewTextures.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/extension/ViewTextures.js"],"names":[],"mappings":"AAGA;;;;;;;GAOG;AACH;IAOI,0CAKC;IASD,0BAEC;IATD;;OAEG;IACH,oBAEC;IAgBD,mCAEC;IAZD;;;;;OAKG;IACH,6BAEC;IAiBD,+BAEC;IAbD;;;;;;OAMG;IACH,yBAEC;IAiBD,qCAEC;IAbD;;;;;;OAMG;IACH,+BAEC;IAoBD,6BAEC;IAhBD;;;;;;;;;OASG;IACH,uBAEC;;CAKJ;4BAhG2B,kBAAkB"}

package/src/shade/renderer/extension/ViewTextures.js

@@ -79,8 +79,9 @@ export class ViewTextures extends FrameRecord {
     }
 
     /**
-     * How far each pixel's surface moved on screen since the last frame: `rg16float`, in pixels, this
-     * frame's place less last frame's, free of the sub-pixel jitter. The renderer fills it from depth and
+     * How far each pixel's surface moved since the last frame, `VELOCITY_FORMAT`: in xy the pixels from last
+     * frame's place to this frame's, in z the view depth now less then, free of the sub-pixel jitter
+     * (`chunk_velocity_texel` makes the texel). The renderer fills it from depth and
      * {@link visibility} before {@link FramePhase.AfterGBuffer}; an extension that draws surfaces the
      * visibility buffer cannot describe writes their pixels' motion over it at that phase and publishes
      * the handle it wrote. What is published later than that phase reaches nothing the renderer runs.

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

@@ -143,7 +143,7 @@ export class GPUFluidCascade {
      * @param {*} _resources
      * @param {{encoder: ShadeGPUCommandContext}} context
      */
-    static "__#289@#execute_restrict"(record: object, _resources: any, context: {
+    static "__#292@#execute_restrict"(record: object, _resources: any, context: {
         encoder: ShadeGPUCommandContext;
     }): void;
     /**
@@ -151,7 +151,7 @@ export class GPUFluidCascade {
      * @param {*} _resources
      * @param {{encoder: ShadeGPUCommandContext}} context
      */
-    static "__#289@#execute_fill"(record: object, _resources: any, context: {
+    static "__#292@#execute_fill"(record: object, _resources: any, context: {
         encoder: ShadeGPUCommandContext;
     }): void;
     /**
@@ -159,7 +159,7 @@ export class GPUFluidCascade {
      * @param {import("../../../engine/graphics/render/frame_graph/FramePassResources.js").FramePassResources} resources
      * @param {{encoder: ShadeGPUCommandContext}} context
      */
-    static "__#289@#execute"(record: object, resources: import("../../../engine/graphics/render/frame_graph/FramePassResources.js").FramePassResources, context: {
+    static "__#292@#execute"(record: object, resources: import("../../../engine/graphics/render/frame_graph/FramePassResources.js").FramePassResources, context: {
         encoder: ShadeGPUCommandContext;
     }): void;
     /**

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

@@ -63,7 +63,7 @@ export class GPUFluidCascadeStack {
      * @param {*} _resources
      * @param {{encoder: import("../../device/ShadeGPUCommandContext.js").ShadeGPUCommandContext}} context
      */
-    static "__#291@#execute_publish"(pass: object, _resources: any, context: {
+    static "__#294@#execute_publish"(pass: object, _resources: any, context: {
         encoder: import("../../device/ShadeGPUCommandContext.js").ShadeGPUCommandContext;
     }): void;
     /**

package/src/shade/renderer/fluid/forcing/FLUID_FORCING.d.ts

@@ -57,6 +57,20 @@ export const FLUID_SOLID_FLAG: number;
  * @type {number}
  */
 export const FLUID_FORCED_FLAG: number;
+/**
+ * Bit 2 of a cell's solid flags: the forcing wrote the cell's drag this tick, from the porous obstacles
+ * in it (the cell's words of the forcing buffer's porous block). A reader of the drag reads a cell only
+ * under it. Never set on a solid cell.
+ * @type {number}
+ */
+export const FLUID_POROUS_FLAG: number;
+/**
+ * Words a cell takes in the forcing buffer's porous block: its drag over the step, `k·dt`, 1/(m/s),
+ * and the velocity of what drags on it, world m/s (`chunk_fluid_forcing_cell`'s
+ * `fluid_forcing_porous`).
+ * @type {number}
+ */
+export const FLUID_FORCING_POROUS_WORDS: number;
 /**
  * The flags as WGSL constants.
  * @type {CodeChunk}

package/src/shade/renderer/fluid/forcing/FLUID_FORCING.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"FLUID_FORCING.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/fluid/forcing/FLUID_FORCING.js"],"names":[],"mappings":"AAGA;;;;;GAKG;AACH,kCAFU,MAAM,CAEqB;AAErC;;;GAGG;AACH,wCAFU,MAAM,CAEkD;AAElE;;;;;GAKG;AACH,2CAFU,MAAM,CAE+B;AAE/C;;;;;GAKG;AACH,2CAFU,MAAM,CAE+B;AAE/C;;;;;GAKG;AACH,4CAFU,MAAM,CAE6F;AAE7G;;;;;;GAMG;AACH,+CAFU,MAAM,CAEkE;AAElF;;;;GAIG;AACH,wCAFU,MAAM,CAE4B;AAE5C;;;GAGG;AACH,+BAFU,MAAM,CAEkB;AAElC;;;;;GAKG;AACH,gCAFU,MAAM,CAEmB;AAEnC;;;GAGG;AACH,wCAFU,SAAS,CAQjB;AAEF;;;GAGG;AACH,4CAFU,SAAS,CAcjB;0BAlGwB,oCAAoC"}
+{"version":3,"file":"FLUID_FORCING.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/fluid/forcing/FLUID_FORCING.js"],"names":[],"mappings":"AAGA;;;;;GAKG;AACH,kCAFU,MAAM,CAEqB;AAErC;;;GAGG;AACH,wCAFU,MAAM,CAEkD;AAElE;;;;;GAKG;AACH,2CAFU,MAAM,CAE+B;AAE/C;;;;;GAKG;AACH,2CAFU,MAAM,CAE+B;AAE/C;;;;;GAKG;AACH,4CAFU,MAAM,CAE6F;AAE7G;;;;;;GAMG;AACH,+CAFU,MAAM,CAEkE;AAElF;;;;GAIG;AACH,wCAFU,MAAM,CAE4B;AAE5C;;;GAGG;AACH,+BAFU,MAAM,CAEkB;AAElC;;;;;GAKG;AACH,gCAFU,MAAM,CAEmB;AAEnC;;;;;GAKG;AACH,gCAFU,MAAM,CAEmB;AAEnC;;;;;GAKG;AACH,yCAFU,MAAM,CAE4B;AAE5C;;;GAGG;AACH,wCAFU,SAAS,CAUjB;AAEF;;;GAGG;AACH,4CAFU,SAAS,CAcjB;0BApHwB,oCAAoC"}

package/src/shade/renderer/fluid/forcing/FLUID_FORCING.js

@@ -69,6 +69,22 @@ export const FLUID_SOLID_FLAG = 1;
  */
 export const FLUID_FORCED_FLAG = 2;
 
+/**
+ * Bit 2 of a cell's solid flags: the forcing wrote the cell's drag this tick, from the porous obstacles
+ * in it (the cell's words of the forcing buffer's porous block). A reader of the drag reads a cell only
+ * under it. Never set on a solid cell.
+ * @type {number}
+ */
+export const FLUID_POROUS_FLAG = 4;
+
+/**
+ * Words a cell takes in the forcing buffer's porous block: its drag over the step, `k·dt`, 1/(m/s),
+ * and the velocity of what drags on it, world m/s (`chunk_fluid_forcing_cell`'s
+ * `fluid_forcing_porous`).
+ * @type {number}
+ */
+export const FLUID_FORCING_POROUS_WORDS = 4;
+
 /**
  * The flags as WGSL constants.
  * @type {CodeChunk}
@@ -78,6 +94,8 @@ export const chunk_fluid_forcing_flags = CodeChunk.from(
     `
 const FLUID_SOLID_FLAG: u32 = ${FLUID_SOLID_FLAG}u;
 const FLUID_FORCED_FLAG: u32 = ${FLUID_FORCED_FLAG}u;
+const FLUID_POROUS_FLAG: u32 = ${FLUID_POROUS_FLAG}u;
+const FLUID_FORCING_POROUS_WORDS: u32 = ${FLUID_FORCING_POROUS_WORDS}u;
 `
 );
 

package/src/shade/renderer/fluid/forcing/FLUID_FORCING_APPLY_STRUCT.d.ts

@@ -12,7 +12,9 @@
  * - `inverse_frame_dt`: `1 / (frame_dt · fixedStepTimeScale)`, 0 when no game time passed, which a
  *   wake's node velocity is taken with;
  * - `forcing_v`, `forcing_w`: where the v and w faces start in the forcing buffer, which holds the u
- *   faces from 0, each component's faces laid out over its own face lattice, x fastest.
+ *   faces from 0, each component's faces laid out over its own face lattice, x fastest;
+ * - `forcing_porous`: where the cells' porous block starts in it, after the w faces,
+ *   `FLUID_FORCING_POROUS_WORDS` a cell, x fastest.
  *
  * @type {WebGPUStruct}
  */

package/src/shade/renderer/fluid/forcing/FLUID_FORCING_APPLY_STRUCT.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"FLUID_FORCING_APPLY_STRUCT.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/fluid/forcing/FLUID_FORCING_APPLY_STRUCT.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;GAiBG;AACH,yCAFU,YAAY,CAcE;6BAhCK,mCAAmC"}
+{"version":3,"file":"FLUID_FORCING_APPLY_STRUCT.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/fluid/forcing/FLUID_FORCING_APPLY_STRUCT.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,yCAFU,YAAY,CAeE;6BAnCK,mCAAmC"}

package/src/shade/renderer/fluid/forcing/FLUID_FORCING_APPLY_STRUCT.js

@@ -16,7 +16,9 @@ import { WebGPUStruct } from "../../shader/type/WebGPUStruct.js";
  * - `inverse_frame_dt`: `1 / (frame_dt · fixedStepTimeScale)`, 0 when no game time passed, which a
  *   wake's node velocity is taken with;
  * - `forcing_v`, `forcing_w`: where the v and w faces start in the forcing buffer, which holds the u
- *   faces from 0, each component's faces laid out over its own face lattice, x fastest.
+ *   faces from 0, each component's faces laid out over its own face lattice, x fastest;
+ * - `forcing_porous`: where the cells' porous block starts in it, after the w faces,
+ *   `FLUID_FORCING_POROUS_WORDS` a cell, x fastest.
  *
  * @type {WebGPUStruct}
  */
@@ -32,4 +34,5 @@ export const FLUID_FORCING_APPLY_STRUCT = WebGPUStruct.from({
     inverse_frame_dt: f32,
     forcing_v: u32,
     forcing_w: u32,
+    forcing_porous: u32,
 }, "FluidForcingApply");

package/src/shade/renderer/fluid/forcing/GPUFluidForcing.d.ts

@@ -78,6 +78,15 @@ export class GPUFluidForcing {
      * @param {PipelineEnquiry} enquiry
      */
     static enquirePipelines(enquiry: PipelineEnquiry): void;
+    /**
+     * How wide a record is for the resolution cull. A solid narrower than half a cascade's cell slips
+     * between its cell centres and is left out of that cascade; a porous one drags on every cell it
+     * fills part of, by as much as it fills it, so every cascade keeps it.
+     *
+     * @param {FluidObstacleRecord} record
+     * @returns {number} metres
+     */
+    static "__#295@#resolved_extent"(record: FluidObstacleRecord): number;
     /**
      * The descriptor of a transient of `role`, `size` bytes, from `kept` (by role): the one kept for
      * the role while its size holds, a new one when it moves. A role's usage and clear range never
@@ -90,19 +99,19 @@ export class GPUFluidForcing {
      * @param {number} clear_size bytes cleared from 0 when the pool reuses the buffer
      * @returns {BufferResourceDescriptor}
      */
-    static "__#292@#descriptor"(kept: BufferResourceDescriptor[], role: number, size: number, usage: number, clear_size: number): BufferResourceDescriptor;
+    static "__#295@#descriptor"(kept: BufferResourceDescriptor[], role: number, size: number, usage: number, clear_size: number): BufferResourceDescriptor;
     /**
      * @param {object} record
      * @param {FramePassResources} resources
      * @param {{encoder: ShadeGPUCommandContext}} context
      */
-    static "__#292@#execute_extract"(record: object, resources: FramePassResources, context: {
+    static "__#295@#execute_extract"(record: object, resources: FramePassResources, context: {
         encoder: ShadeGPUCommandContext;
     }): void;
-    static "__#292@#execute_clear"(record: any, _resources: any, context: any): void;
-    static "__#292@#execute_query"(record: any, resources: any, context: any): void;
-    static "__#292@#execute_command"(record: any, resources: any, context: any): void;
-    static "__#292@#execute_apply"(record: any, resources: any, context: any): void;
+    static "__#295@#execute_clear"(record: any, _resources: any, context: any): void;
+    static "__#295@#execute_query"(record: any, resources: any, context: any): void;
+    static "__#295@#execute_command"(record: any, resources: any, context: any): void;
+    static "__#295@#execute_apply"(record: any, resources: any, context: any): void;
     /**
      * @param {object} options
      * @param {GPUDevice} options.device

package/src/shade/renderer/fluid/forcing/GPUFluidForcing.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUFluidForcing.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/fluid/forcing/GPUFluidForcing.js"],"names":[],"mappings":"AAuIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwEG;AACH;IAEI;;;;OAIG;IACH,iCAFW,eAAe,QAUzB;IA2ID;;;;;;;;;;;OAWG;IACH,kCAPW,wBAAwB,EAAE,QAC1B,MAAM,QACN,MAAM,SACN,MAAM,cACN,MAAM,GACJ,wBAAwB,CAcpC;IAmmBD;;;;OAIG;IACH,yCAJW,MAAM,0CAEN;QAAC,OAAO,yBAAwB;KAAC,QAc3C;IA+MD,iFAcC;IAWD,gFAiCC;IAWD,kFAsBC;IA+GD,gFA0CC;IA3nCD;;;OAGG;IACH;QAF8B,MAAM;OAwCnC;IA4BD;;;OAGG;IACH,4BAEC;IAED;;;OAGG;IACH,6BAEC;IAED;;;OAGG;IACH,6BAEC;IAED;;;;;OAKG;IACH,2BAEC;IAED;;;OAGG;IACH,yBAEC;IAED;;;;;;;OAOG;IACH,mBAHW,MAAM,GACJ,MAAM,CAiBlB;IAED;;;;;OAKG;IACH,4BAEC;IAED;;;;;OAKG;IACH,2BAEC;IAED;;;;;OAKG;IACH,qBAHW,mBAAmB,GACjB,MAAM,CAQlB;IAED;;;;;OAKG;IACH,kBAHW,MAAM,UACN,mBAAmB,QAQ7B;IAED;;OAEG;IACH,qBAFW,MAAM,QAUhB;IAED;;;;;OAKG;IACH,uBAHW,mBAAmB,EAAE,GACnB,MAAM,CAsBlB;IAED;;;;;OAKG;IACH,kBAHW,MAAM,UACN,mBAAmB,QAgB7B;IAED;;;OAGG;IACH,wBAHW,MAAM,SACN,MAAM,QAYhB;IAED;;;;;OAKG;IACH,kBAHW,MAAM,GACJ,MAAM,CAuBlB;IAED;;;;;OAKG;IACH,kBAHW,MAAM,SACN,MAAM,QAmBhB;IAED;;;OAGG;IACH,qBAHW,MAAM,SACN,MAAM,QAUhB;IAyID;;;;;;;;;;;;;;;;;;;OAmBG;IACH;QAf+B,KAAK,EAAzB,UAAU;QACW,cAAc,EAAnC,WAAW;QAEgB,MAAM,EAAjC,UAAU,MAAM,CAAC;QAID,UAAU,EAA1B,MAAM;QAEU,gBAAgB,EAAhC,MAAM;QAEU,SAAS,EAAzB,MAAM;aA4ChB;IAyND;;;;;;;;;;;;OAYG;IACH;QAJ+B,KAAK,EAAzB,UAAU;QACe,KAAK,EAA9B,eAAe;QACe,MAAM,EAApC,eAAe,GAAC,IAAI;aA8H9B;IAmHD;;;;;;;;;;;OAWG;IACH;QAN+B,KAAK,EAAzB,UAAU;QACe,OAAO,EAAhC,eAAe;QACC,EAAE,EAAlB,MAAM;QACJ,MAAM,GAAC,IAAI,CAuFvB;IAyDD;;;OAGG;IACH,gBAwBC;;CACJ;yBAp7CY,OAAO,8DAA8D,EAAE,UAAU;8BACjF,OAAO,6CAA6C,EAAE,eAAe;8BACrE,OAAO,uBAAuB,EAAE,eAAe;kCAC/C,OAAO,kFAAkF,EAAE,mBAAmB;kCAC9G,OAAO,2EAA2E,EAAE,mBAAmB;4BAtCxF,mCAAmC;yCADtB,mDAAmD"}
+{"version":3,"file":"GPUFluidForcing.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/fluid/forcing/GPUFluidForcing.js"],"names":[],"mappings":"AAwIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwEG;AACH;IAEI;;;;OAIG;IACH,iCAFW,eAAe,QAUzB;IAqBD;;;;;;;OAOG;IACH,yCAHW,mBAAmB,GACjB,MAAM,CAIlB;IAyHD;;;;;;;;;;;OAWG;IACH,kCAPW,wBAAwB,EAAE,QAC1B,MAAM,QACN,MAAM,SACN,MAAM,cACN,MAAM,GACJ,wBAAwB,CAcpC;IAmmBD;;;;OAIG;IACH,yCAJW,MAAM,0CAEN;QAAC,OAAO,yBAAwB;KAAC,QAc3C;IA+MD,iFAcC;IAWD,gFAiCC;IAWD,kFAsBC;IAiHD,gFA0CC;IA7nCD;;;OAGG;IACH;QAF8B,MAAM;OAwCnC;IA4BD;;;OAGG;IACH,4BAEC;IAED;;;OAGG;IACH,6BAEC;IAED;;;OAGG;IACH,6BAEC;IAED;;;;;OAKG;IACH,2BAEC;IAED;;;OAGG;IACH,yBAEC;IAED;;;;;;;OAOG;IACH,mBAHW,MAAM,GACJ,MAAM,CAiBlB;IAED;;;;;OAKG;IACH,4BAEC;IAED;;;;;OAKG;IACH,2BAEC;IAED;;;;;OAKG;IACH,qBAHW,mBAAmB,GACjB,MAAM,CAQlB;IAED;;;;;OAKG;IACH,kBAHW,MAAM,UACN,mBAAmB,QAQ7B;IAED;;OAEG;IACH,qBAFW,MAAM,QAUhB;IAED;;;;;OAKG;IACH,uBAHW,mBAAmB,EAAE,GACnB,MAAM,CAsBlB;IAED;;;;;OAKG;IACH,kBAHW,MAAM,UACN,mBAAmB,QAgB7B;IAED;;;OAGG;IACH,wBAHW,MAAM,SACN,MAAM,QAYhB;IAED;;;;;OAKG;IACH,kBAHW,MAAM,GACJ,MAAM,CAuBlB;IAED;;;;;OAKG;IACH,kBAHW,MAAM,SACN,MAAM,QAmBhB;IAED;;;OAGG;IACH,qBAHW,MAAM,SACN,MAAM,QAUhB;IAyID;;;;;;;;;;;;;;;;;;;OAmBG;IACH;QAf+B,KAAK,EAAzB,UAAU;QACW,cAAc,EAAnC,WAAW;QAEgB,MAAM,EAAjC,UAAU,MAAM,CAAC;QAID,UAAU,EAA1B,MAAM;QAEU,gBAAgB,EAAhC,MAAM;QAEU,SAAS,EAAzB,MAAM;aA4ChB;IAyND;;;;;;;;;;;;OAYG;IACH;QAJ+B,KAAK,EAAzB,UAAU;QACe,KAAK,EAA9B,eAAe;QACe,MAAM,EAApC,eAAe,GAAC,IAAI;aA8H9B;IAmHD;;;;;;;;;;;OAWG;IACH;QAN+B,KAAK,EAAzB,UAAU;QACe,OAAO,EAAhC,eAAe;QACC,EAAE,EAAlB,MAAM;QACJ,MAAM,GAAC,IAAI,CAyFvB;IAyDD;;;OAGG;IACH,gBAwBC;;CACJ;yBAn8CY,OAAO,8DAA8D,EAAE,UAAU;8BACjF,OAAO,6CAA6C,EAAE,eAAe;8BACrE,OAAO,uBAAuB,EAAE,eAAe;kCAC/C,OAAO,kFAAkF,EAAE,mBAAmB;kCAC9G,OAAO,2EAA2E,EAAE,mBAAmB;4BAvCxF,mCAAmC;yCADtB,mDAAmD"}

package/src/shade/renderer/fluid/forcing/GPUFluidForcing.js

@@ -18,6 +18,7 @@ import {
 } from "./FLUID_DATABASE_SPEC.js";
 import {
     FLUID_FORCING_BRICK,
+    FLUID_FORCING_POROUS_WORDS,
     FLUID_FORCING_REBUILD_AGE,
     FLUID_FORCING_SURVIVOR_STRIDE
 } from "./FLUID_FORCING.js";
@@ -236,11 +237,24 @@ export class GPUFluidForcing {
     #plane_record = { plane: new Float32Array(4) };
 
     /**
-     * Each obstacle row's extent (`fluid_obstacle_record_extent`), metres, indexed by row.
+     * Each obstacle row's extent (`fluid_obstacle_record_extent`), metres, indexed by row; `Infinity` for
+     * a porous one, which every cascade resolves (`GPUFluidForcing.#resolved_extent`).
      * @type {Float64Array}
      */
     #obstacle_extent = new Float64Array(0);
 
+    /**
+     * How wide a record is for the resolution cull. A solid narrower than half a cascade's cell slips
+     * between its cell centres and is left out of that cascade; a porous one drags on every cell it
+     * fills part of, by as much as it fills it, so every cascade keeps it.
+     *
+     * @param {FluidObstacleRecord} record
+     * @returns {number} metres
+     */
+    static #resolved_extent(record) {
+        return record.drag > 0 ? Infinity : fluid_obstacle_record_extent(record);
+    }
+
     /** Bumped by every add and remove of an effector or obstacle row, and by an obstacle's extent changing. */
     #sets_version = 0;
 
@@ -536,7 +550,7 @@ export class GPUFluidForcing {
         }
 
         for (let i = 0; i < records.length; i++) {
-            this.#obstacle_extent[first + i] = fluid_obstacle_record_extent(records[i]);
+            this.#obstacle_extent[first + i] = GPUFluidForcing.#resolved_extent(records[i]);
         }
 
         return first;
@@ -555,7 +569,7 @@ export class GPUFluidForcing {
 
         table.set_record(row, record, OBSTACLE_WRITER);
 
-        const extent = fluid_obstacle_record_extent(record);
+        const extent = GPUFluidForcing.#resolved_extent(record);
 
         if (extent !== this.#obstacle_extent[row]) {
             // which cascades resolve it may have moved
@@ -1365,6 +1379,7 @@ export class GPUFluidForcing {
                 inverse_frame_dt: 0,
                 forcing_v: 0,
                 forcing_w: 0,
+                forcing_porous: 0,
             },
         };
 
@@ -1390,6 +1405,7 @@ export class GPUFluidForcing {
 
         settings.forcing_v = faces_u;
         settings.forcing_w = faces_u + faces_v;
+        settings.forcing_porous = faces_u + faces_v + faces_w;
 
         apply.cascade = cascade;
         apply.tree = tick.trees[slot];
@@ -1400,7 +1416,7 @@ export class GPUFluidForcing {
         apply.list = pass.read(tick.lists[slot]);
         apply.survivors = pass.read(tick.survivors);
         apply.commands = pass.read(tick.commands);
-        apply.output = pass.create('Fluid / forcing / forcing', GPUFluidForcing.#descriptor(this.#descriptors, ROLE_FORCING, 4 * (faces_u + faces_v + faces_w), GPUBufferUsage.STORAGE, 0));
+        apply.output = pass.create('Fluid / forcing / forcing', GPUFluidForcing.#descriptor(this.#descriptors, ROLE_FORCING, 4 * (faces_u + faces_v + faces_w + nx * ny * nz * FLUID_FORCING_POROUS_WORDS), GPUBufferUsage.STORAGE, 0));
 
         // it writes the cascade's flags and persistent faces
         pass.make_side_effect();

package/src/shade/renderer/fluid/forcing/chunk_fluid_forcing_cell.d.ts

@@ -6,9 +6,18 @@
  *   centred at `c`, u face `i` at `i − ½` along x) in world metres, the window's world cell `corner` at
  *   window-local 0: `(corner + p + ½)·h`.
  * - `fluid_forcing_solid(x, count) -> u32`: the solid test at a cell centre, the first of the brick's
- *   `count` obstacles (its lowest row) whose field at `x` is within its inflation,
+ *   `count` solid obstacles (its lowest row) whose field at `x` is within its inflation,
  *   `fluid_obstacle_record_signed_distance(record, global, x) ≤ inflation`; `FLUID_FORCING_NONE` for
- *   fluid. At most `FLUID_FORCING_OBSTACLE_LIMIT` fields, each at most 16 hull planes.
+ *   fluid. A porous obstacle (`drag` above 0) is never solid. At most `FLUID_FORCING_OBSTACLE_LIMIT`
+ *   fields, each at most 16 hull planes.
+ * - `fluid_forcing_porous(x, cell_size, count) -> vec4<f32>`: the drag of the brick's porous obstacles
+ *   on the cell of side `cell_size` centred at `x`: in `x`, the sum of each one's `drag` times the
+ *   share of the cell it fills, 1/m; in `yzw`, the velocity it drags toward, each obstacle's wall
+ *   velocity at `x` weighed by its part of the drag, world m/s, zero where there is no drag. The
+ *   share is the part of the cell's height inside the obstacle along four vertical lines through it,
+ *   at a quarter of the cell in from each side (`fluid_obstacle_record_line_span`), so a layer
+ *   thinner than the cell drags on it by as much as it fills it, and a layer whose sides are vertical
+ *   fills it exactly.
  * - `fluid_forcing_wall_velocity(slot, x) -> vec3<f32>`: the wall's velocity at `x` of the brick's
  *   obstacle `slot`, `rigid_velocity_at_point(v, ω, t, x)` (`fluid_obstacle_record_wall_velocity`).
  * - `fluid_forcing_deposit(x, dt, cell_size, count) -> vec3<f32>`: what the brick's `count` effectors

package/src/shade/renderer/fluid/forcing/chunk_fluid_forcing_cell.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_fluid_forcing_cell.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/fluid/forcing/chunk_fluid_forcing_cell.js"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,uCAFU,SAAS,CAqDjB;0BAnFwB,oCAAoC"}
+{"version":3,"file":"chunk_fluid_forcing_cell.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/fluid/forcing/chunk_fluid_forcing_cell.js"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,uCAFU,SAAS,CAqGjB;0BA5IwB,oCAAoC"}

package/src/shade/renderer/fluid/forcing/chunk_fluid_forcing_cell.js

@@ -12,9 +12,18 @@ import { chunk_fluid_forcing_constants } from "./FLUID_FORCING.js";
  *   centred at `c`, u face `i` at `i − ½` along x) in world metres, the window's world cell `corner` at
  *   window-local 0: `(corner + p + ½)·h`.
  * - `fluid_forcing_solid(x, count) -> u32`: the solid test at a cell centre, the first of the brick's
- *   `count` obstacles (its lowest row) whose field at `x` is within its inflation,
+ *   `count` solid obstacles (its lowest row) whose field at `x` is within its inflation,
  *   `fluid_obstacle_record_signed_distance(record, global, x) ≤ inflation`; `FLUID_FORCING_NONE` for
- *   fluid. At most `FLUID_FORCING_OBSTACLE_LIMIT` fields, each at most 16 hull planes.
+ *   fluid. A porous obstacle (`drag` above 0) is never solid. At most `FLUID_FORCING_OBSTACLE_LIMIT`
+ *   fields, each at most 16 hull planes.
+ * - `fluid_forcing_porous(x, cell_size, count) -> vec4<f32>`: the drag of the brick's porous obstacles
+ *   on the cell of side `cell_size` centred at `x`: in `x`, the sum of each one's `drag` times the
+ *   share of the cell it fills, 1/m; in `yzw`, the velocity it drags toward, each obstacle's wall
+ *   velocity at `x` weighed by its part of the drag, world m/s, zero where there is no drag. The
+ *   share is the part of the cell's height inside the obstacle along four vertical lines through it,
+ *   at a quarter of the cell in from each side (`fluid_obstacle_record_line_span`), so a layer
+ *   thinner than the cell drags on it by as much as it fills it, and a layer whose sides are vertical
+ *   fills it exactly.
  * - `fluid_forcing_wall_velocity(slot, x) -> vec3<f32>`: the wall's velocity at `x` of the brick's
  *   obstacle `slot`, `rigid_velocity_at_point(v, ω, t, x)` (`fluid_obstacle_record_wall_velocity`).
  * - `fluid_forcing_deposit(x, dt, cell_size, count) -> vec3<f32>`: what the brick's `count` effectors
@@ -52,6 +61,10 @@ fn fluid_forcing_solid(x: vec3<f32>, count: u32) -> u32 {
 
         let record = fluid_forcing_obstacle(slot);
 
+        if (record.drag != 0.0) {
+            continue;
+        }
+
         if (fluid_obstacle_record_signed_distance(record, fluid_forcing_obstacle_global(slot), x) <= record.inflation) {
             found = slot;
             break;
@@ -61,6 +74,50 @@ fn fluid_forcing_solid(x: vec3<f32>, count: u32) -> u32 {
     return found;
 }
 
+fn fluid_forcing_porous(x: vec3<f32>, cell_size: f32, count: u32) -> vec4<f32> {
+    var drag = 0.0;
+    var moving = vec3<f32>(0.0);
+
+    for (var slot = 0u; slot < FLUID_FORCING_OBSTACLE_LIMIT; slot++) {
+        if (slot >= count) {
+            break;
+        }
+
+        let record = fluid_forcing_obstacle(slot);
+
+        if (record.drag <= 0.0) {
+            continue;
+        }
+
+        let global = fluid_forcing_obstacle_global(slot);
+
+        // up four vertical lines from the cell's floor, a quarter of the cell in from its sides
+        var filled = 0.0;
+
+        for (var line = 0u; line < 4u; line++) {
+            let across = vec2<f32>(f32(line & 1u), f32(line >> 1u)) * 0.5 - vec2<f32>(0.25);
+            let foot = x + vec3<f32>(across.x, -0.5, across.y) * cell_size;
+
+            let span = fluid_obstacle_record_line_span(record, global, foot, vec3<f32>(0.0, 1.0, 0.0));
+
+            filled += max(min(span.y, cell_size) - max(span.x, 0.0), 0.0);
+        }
+
+        let part = record.drag * filled / (4.0 * cell_size);
+
+        if (part > 0.0) {
+            drag += part;
+            moving += fluid_obstacle_record_wall_velocity(record, global, x) * part;
+        }
+    }
+
+    if (drag <= 0.0) {
+        return vec4<f32>(0.0);
+    }
+
+    return vec4<f32>(drag, moving * (1.0 / drag));
+}
+
 fn fluid_forcing_wall_velocity(slot: u32, x: vec3<f32>) -> vec3<f32> {
     return fluid_obstacle_record_wall_velocity(fluid_forcing_obstacle(slot), fluid_forcing_obstacle_global(slot), x);
 }

package/src/shade/renderer/fluid/forcing/shader_fluid_forcing_apply.d.ts

@@ -10,7 +10,10 @@
  * 2. **The solid test** (`fluid_forcing_solid_prenorm`) at the centre of every cell of the brick and
  *    the layer before it on each axis (125 cells, two rounds), recording the solid's obstacle; a cell
  *    before the window is fluid, as the step reads it. One barrier.
- * 3. **Per cell:** its solid flags, `FLUID_FORCED_FLAG` with `FLUID_SOLID_FLAG` where solid; then each
+ * 3. **Per cell:** its solid flags, `FLUID_FORCED_FLAG` with `FLUID_SOLID_FLAG` where solid, and
+ *    `FLUID_POROUS_FLAG` where a porous obstacle drags on a cell that is not solid, whose drag over the
+ *    step and the velocity it drags toward go into the forcing buffer's porous block
+ *    (`fluid_forcing_porous`, the drag times `dt_c`); then each
  *    of its −x, −y, −z faces, and the window's last cells their +boundary faces: a face with a solid
  *    cell on either side is pinned, as every pass of the step will find it from the flags, and takes
  *    the wall's velocity (`fluid_forcing_wall_velocity`, the solid cell's obstacle, the + side's when

package/src/shade/renderer/fluid/forcing/shader_fluid_forcing_apply.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_fluid_forcing_apply.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/fluid/forcing/shader_fluid_forcing_apply.js"],"names":[],"mappings":"AA4SA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,yCAFU,aAAa,CAMpB;8BA1U2B,+BAA+B"}
+{"version":3,"file":"shader_fluid_forcing_apply.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/fluid/forcing/shader_fluid_forcing_apply.js"],"names":[],"mappings":"AAmUA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,yCAFU,aAAa,CAMpB;8BApW2B,+BAA+B"}