@woosh/meep-engine 3.68.0 → 3.69.0

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

@@ -1,21 +1,7 @@
-import { DepthStencilState } from "../../descriptor/pipeline/render/DepthStencilState.js";
-import { RenderPipelineDescriptor } from "../../descriptor/pipeline/render/RenderPipelineDescriptor.js";
-import { chunk_sample_volumetrics } from "../deferred/chunk_sample_volumetrics.js";
-import { AVBOIT_EXTINCT_TRANSMITTANCE } from "../rasterize/native/avboit/AVBOIT_CONSTANTS.js";
-import { AVBOIT_WARP_STRUCT } from "../rasterize/native/avboit/AVBOIT_WARP_STRUCT.js";
-import { AVBOIT_DRAW_TARGETS } from "../rasterize/native/avboit/avboit_draw_fragment_body.js";
-import {
-    chunk_avboit_premultiplied_contribution
-} from "../rasterize/native/avboit/chunk_avboit_premultiplied_contribution.js";
-import { chunk_avboit_view_depth_to_virtual } from "../rasterize/native/avboit/chunk_avboit_view_depth_to_virtual.js";
-import { chunk_avboit_footprint_bias } from "../rasterize/native/avboit/chunk_avboit_footprint_bias.js";
-import { chunk_avboit_sample_transmittance } from "../rasterize/native/avboit/chunk_avboit_sample_transmittance.js";
+import { avboit_unlit_draw_pipeline, AVBOIT_UNLIT_DRAW_PASS_GROUP, chunk_avboit_unlit_draw_fragment } from "../rasterize/native/avboit/avboit_unlit_draw.js";
 import { CodeChunk } from "../shader/compiler/CodeChunk.js";
 import { ShaderResourceSetDescriptor } from "../shader/resource/ShaderResourceSetDescriptor.js";
 import { ShaderDescriptor } from "../shader/ShaderDescriptor.js";
-import { SAMPLER_LINEAR_UPSCALE } from "../texture/SAMPLER_LINEAR_UPSCALE.js";
-import { VIEW_UNIFORM_STRUCT } from "../view/VIEW_UNIFORM_STRUCT.js";
-import { VOLUMETRICS_METADATA_STRUCT } from "../volumetrics/VOLUMETRICS_METADATA_STRUCT.js";
 import { chunk_dynamic_mesh_avboit_vertex } from "./chunk_dynamic_mesh_avboit_vertex.js";
 import {
     DYNAMIC_MESH_BIND_GROUP_DRAWS,
@@ -24,126 +10,51 @@ import {
 } from "./shader_dynamic_mesh.js";
 
 /**
- * Bind group of everything the draw reads once per pass — the view, the warp, the integral and the
- * fog. Groups 0 and 1 are the dynamic-mesh groups: the draw constants per chunk, the geometry per
- * mesh.
+ * Bind group of everything the draw reads once per pass (`AVBOIT_UNLIT_DRAW_PASS_GROUP`) — the view,
+ * the warp, the integral and the fog. 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_DRAW_BIND_GROUP_PASS = 2;
 
 /**
- * The dynamic meshes' AVBOIT draw: every mesh's triangles at internal resolution, depth-tested
- * against the opaque scene, into the four accumulators the transparent meshes and the particles
- * draw into (`avboit_draw_fragment_body`) — so a trail composites against both order-independently.
- *
- * Per fragment: nothing at all if it has faded out (the splat recorded nothing for it either), then
- * the transmittance of everything in front from the integral texture — a fragment the volume
- * already calls extinct is discarded unshaded — the volumetric fog at its depth, and the
- * accumulators through `avboit_premultiplied_contribution`, the routing every side channel shares.
- *
- * A dynamic mesh is straight alpha and unlit, as the pass over the scene draws it: its colour is
- * premultiplied here and never emits — a fragment that can get past the first test covers
- * something — so the pipeline does not write the emission target at all rather than blend zeros
- * into it over every covered pixel.
+ * The dynamic meshes' AVBOIT draw: every mesh's triangles at internal resolution by the dynamic-mesh
+ * vertex stage, into the unlit draw's fragment stage (`chunk_avboit_unlit_draw_fragment`, which says
+ * what a fragment contributes). A dynamic mesh is straight alpha and unlit, as the pass over the scene
+ * draws it.
  */
 
 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()
-    .addUniform("view", VIEW_UNIFORM_STRUCT)
-    .addStorageBuffer("warp", AVBOIT_WARP_STRUCT)
-    // sampled through sLinear: linear, clamped on every axis, which is what the integral needs
-    .addTexture("tIntegral", "float", "3d")
-    .addSampler("sLinear", "filtering", SAMPLER_LINEAR_UPSCALE)
-    // volumetrics (composited inline)
-    .addUniform("volumetrics_metadata", VOLUMETRICS_METADATA_STRUCT)
-    .addTexture("tVolumetrics", "float", "3d")
-    .addTexture("tSTBN_vec3", "float", "3d");
+resources.addGroup(AVBOIT_UNLIT_DRAW_PASS_GROUP);
 
 const body = CodeChunk.from(
     //language=WGSL
     `
-struct DynamicMeshAVBOITDrawOutput {
-    @location(0) color : vec4<f32>,
-    @location(1) norm : vec4<f32>,
-    @location(2) extinction : vec4<f32>,
-    @location(3) emission : vec4<f32>,
-}
-
 @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) -> DynamicMeshAVBOITDrawOutput {
-    // a ribbon seen at an angle runs through depth across a voxel; see avboit_footprint_bias. Taken
-    // first, in uniform control flow
-    let footprint = avboit_footprint_bias(&warp, fwidth(avboit_view_depth_to_virtual(&warp, in.view_depth)));
-
-    if (in.color.a <= 0.0) {
-        // faded out: covers nothing, and straight alpha carries no light without coverage
-        discard;
-    }
-
-    let screen_uv = in.clip.xy / vec2<f32>(f32(view.width), f32(view.height));
-
-    let transmittance = avboit_sample_transmittance(&warp, tIntegral, sLinear, screen_uv, in.view_depth, footprint);
-
-    if (all(transmittance <= vec3<f32>(${AVBOIT_EXTINCT_TRANSMITTANCE}))) {
-        // nothing this fragment contributes survives what is in front of it; skip the shading
-        discard;
-    }
-
-    let volumetrics = sample_volumetrics(in.view_depth, screen_uv, in.clip.xy);
-
-    let premultiplied = vec4<f32>(in.color.rgb * in.color.a, in.color.a);
-
-    let contribution = avboit_premultiplied_contribution(premultiplied, transmittance, volumetrics);
-
-    var out : DynamicMeshAVBOITDrawOutput;
-
-    out.color = contribution.color;
-    out.norm = contribution.norm;
-    out.extinction = contribution.extinction;
-    out.emission = contribution.emission;
-
-    return out;
-}
 `, [
     chunk_dynamic_mesh_avboit_vertex,
-    chunk_avboit_view_depth_to_virtual,
-    chunk_avboit_footprint_bias,
-    chunk_avboit_sample_transmittance,
-    chunk_sample_volumetrics,
-    chunk_avboit_premultiplied_contribution,
+    chunk_avboit_unlit_draw_fragment,
 ]);
 
 const descriptor = ShaderDescriptor.from({ label: "Dynamic Mesh AVBOIT Draw", body, resources });
 
 /**
- * The draw pipeline: additive into the accumulators with the emission target masked off, the scene
- * depth tested and never written, both faces.
- * @type {RenderPipelineDescriptor}
+ * The draw pipeline, as every unlit draw is built (`avboit_unlit_draw_pipeline`).
+ * @type {import("../../descriptor/pipeline/render/RenderPipelineDescriptor.js").RenderPipelineDescriptor}
  */
-export const DYNAMIC_MESH_AVBOIT_DRAW_PIPELINE = RenderPipelineDescriptor.from({
+export const DYNAMIC_MESH_AVBOIT_DRAW_PIPELINE = avboit_unlit_draw_pipeline({
     label: "Dynamic Mesh AVBOIT Draw",
-    layout: resources.generatePipelineLayout(GPUShaderStage.VERTEX | GPUShaderStage.FRAGMENT),
-    vertex: { module: { code: descriptor.source }, entryPoint: "vs_main" },
-    fragment: {
-        module: { code: descriptor.source },
-        entryPoint: "fs_main",
-        // color, norm, extinction — and not emission
-        targets: AVBOIT_DRAW_TARGETS.map((target, i) => ({ ...target, writeMask: [0xF, 0xF, 0xF, 0][i] })),
-    },
-    depthStencil: DepthStencilState.from({ format: "depth32float", depthWriteEnabled: false, depthCompare: "greater" }),
-    primitive: { topology: "triangle-list", cullMode: "none" },
+    resources,
+    source: descriptor.source,
 });
 
-/** The draw shader's resource set, for building its pass-level bind group. */
+/** The draw shader's resource set. */
 export const DYNAMIC_MESH_AVBOIT_DRAW_RESOURCES = resources;
 
 /** The assembled shader, for the validity tier. */

package/src/shade/renderer/dynamic/shader_dynamic_mesh_avboit_splat.d.ts

@@ -1,33 +1,23 @@
 /**
- * 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: number;
 /**
- * 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: number;
 /**
- * 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: number;
-/**
- * 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;
-/** The splat shader's resource set, for building its pass-level bind groups. */
+export const DYNAMIC_MESH_AVBOIT_SPLAT_PIPELINE: import("../../descriptor/pipeline/render/RenderPipelineDescriptor.js").RenderPipelineDescriptor;
+/** The splat shader's resource set. */
 export const DYNAMIC_MESH_AVBOIT_SPLAT_RESOURCES: ShaderResourceSetDescriptor;
 /** The assembled shader, for the validity tier. */
 export const shader_dynamic_mesh_avboit_splat: ShaderDescriptor;
-import { RenderPipelineDescriptor } from "../../descriptor/pipeline/render/RenderPipelineDescriptor.js";
 import { ShaderResourceSetDescriptor } from "../shader/resource/ShaderResourceSetDescriptor.js";
 import { ShaderDescriptor } from "../shader/ShaderDescriptor.js";
 //# sourceMappingURL=shader_dynamic_mesh_avboit_splat.d.ts.map

package/src/shade/renderer/dynamic/shader_dynamic_mesh_avboit_splat.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_dynamic_mesh_avboit_splat.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/dynamic/shader_dynamic_mesh_avboit_splat.js"],"names":[],"mappings":"AAsBA;;;;GAIG;AACH,wDAFU,MAAM,CAE2C;AAE3D;;;GAGG;AACH,0DAFU,MAAM,CAE6C;AAE7D;;;;GAIG;AACH,gDAFU,MAAM,CAEmC;AA0GnD;;;;;;GAMG;AACH,iDAFU,wBAAwB,CAa/B;AAEH,gFAAgF;AAChF,8EAA6D;AAE7D,mDAAmD;AACnD,gEAA2D;yCAzKlB,8DAA8D;4CAU3D,mDAAmD;iCAC9D,+BAA+B"}
+{"version":3,"file":"shader_dynamic_mesh_avboit_splat.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/dynamic/shader_dynamic_mesh_avboit_splat.js"],"names":[],"mappings":"AAYA;;;;GAIG;AACH,wDAFU,MAAM,CAE2C;AAE3D;;;GAGG;AACH,0DAFU,MAAM,CAE6C;AAiC7D;;;GAGG;AACH,iDAFU,OAAO,8DAA8D,EAAE,wBAAwB,CAMtG;AAEH,uCAAuC;AACvC,8EAA6D;AAE7D,mDAAmD;AACnD,gEAA2D;4CAnEf,mDAAmD;iCAC9D,+BAA+B"}

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/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

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"}