@woosh/meep-engine 3.68.0 → 3.69.0

package/src/shade/renderer/deferred/tonemap/ColorGrade.js

@@ -1,6 +1,7 @@
 import { assert } from "../../../../core/assert.js";
 import { Vector4 } from "../../../../core/geom/Vector4.js";
 import { AnimationCurve } from "../../../../engine/animation/curve/AnimationCurve.js";
+import { ANIMATION_CURVE_KEYFRAME_FLOATS, animation_curve_write_keys } from "../../animation/animation_curve_write_keys.js";
 import { vec4f, vec4u } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
 import { WebGPUStruct } from "../../shader/type/WebGPUStruct.js";
 import { m3_white_balance_rec709, WHITE_BALANCE_NEUTRAL_TEMPERATURE, WHITE_BALANCE_NEUTRAL_TINT } from "./m3_white_balance_rec709.js";
@@ -60,7 +61,7 @@ export const COLOR_GRADE_HEADER_FLOATS = 88;
  * Floats of one keyframe in `grade_keys`: time, value, in tangent, out tangent.
  * @type {number}
  */
-export const COLOR_GRADE_KEY_FLOATS = 4;
+export const COLOR_GRADE_KEY_FLOATS = ANIMATION_CURVE_KEYFRAME_FLOATS;
 
 /**
  * One zone of Unreal's primary grade: shadows, midtones, highlights, or all of them. Each vector is RGB and a master
@@ -148,30 +149,6 @@ function write_zone(out, at, zone, global) {
     write_sum(out, at + 16, zone.offset, global.offset);
 }
 
-/**
- * @param {Float32Array} out
- * @param {number} at float index
- * @param {AnimationCurve} curve
- * @returns {number} the float index after the curve's keys
- */
-function write_keys(out, at, curve) {
-    const keys = curve.keys;
-    const count = keys.length;
-
-    for (let i = 0; i < count; i++) {
-        const key = keys[i];
-
-        out[at] = key.time;
-        out[at + 1] = key.value;
-        out[at + 2] = key.inTangent;
-        out[at + 3] = key.outTangent;
-
-        at += COLOR_GRADE_KEY_FLOATS;
-    }
-
-    return at;
-}
-
 /**
  * A colour grade on the exposed scene colour, ahead of the tone-mapping operator, baked into the tone mapper's LUTs.
  * Neutral as constructed. In order:
@@ -424,17 +401,17 @@ export class ColorGrade {
         words[87] = exposure_count;
 
         let at = COLOR_GRADE_HEADER_FLOATS;
-        at = write_keys(out, at, this.hue_shift);
-        at = write_keys(out, at, this.hue_saturation);
-        at = write_keys(out, at, this.hue_lightness);
-        at = write_keys(out, at, this.luma_saturation_red);
-        at = write_keys(out, at, this.luma_saturation_green);
-        at = write_keys(out, at, this.luma_saturation_blue);
-        at = write_keys(out, at, this.luma_saturation);
-        at = write_keys(out, at, this.luma_gain_red);
-        at = write_keys(out, at, this.luma_gain_green);
-        at = write_keys(out, at, this.luma_gain_blue);
-        at = write_keys(out, at, this.luma_exposure);
+        at = animation_curve_write_keys(out, at, this.hue_shift);
+        at = animation_curve_write_keys(out, at, this.hue_saturation);
+        at = animation_curve_write_keys(out, at, this.hue_lightness);
+        at = animation_curve_write_keys(out, at, this.luma_saturation_red);
+        at = animation_curve_write_keys(out, at, this.luma_saturation_green);
+        at = animation_curve_write_keys(out, at, this.luma_saturation_blue);
+        at = animation_curve_write_keys(out, at, this.luma_saturation);
+        at = animation_curve_write_keys(out, at, this.luma_gain_red);
+        at = animation_curve_write_keys(out, at, this.luma_gain_green);
+        at = animation_curve_write_keys(out, at, this.luma_gain_blue);
+        at = animation_curve_write_keys(out, at, this.luma_exposure);
 
         out.fill(0, at);
 

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

@@ -126,8 +126,8 @@ export class GPUDynamicMeshResidency {
          guard; index_count is left truthful, and the draw-time index_count === 0 test skips it.
 
          Reachable on the first upload rather than on a shrink: a geometry that shrinks has already
-         grown its buffers, and Trail3DSystem.link and PathDisplaySystem both build a DynamicMesh
-         from a Geometry that can already be empty.
+         grown its buffers, and PathDisplaySystem builds a DynamicMesh from a Geometry that can
+         already be empty.
         */
         if (vertex_bytes > 0) {
             device.queue.writeBuffer(this.#vertices, 0, staging.buffer, staging.byteOffset, vertex_bytes);

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

@@ -1,19 +1,8 @@
 /**
  * The vertex stage both AVBOIT passes draw a dynamic mesh with — the splat at the volume's
  * resolution and the draw at internal resolution — so the two see the same fragments at the same
- * depths.
- *
- * `view_depth` is the vertex's own view-space depth, interpolated across the triangle: what the
- * splat positions a fragment's extinction by and what the draw looks the volume up at. Both passes
- * take it from here rather than reconstructing it from `@builtin(position).z`, the arrangement the
- * particles' billboard stage has for the same reason. `color` is straight — not premultiplied — as
- * the vertices hold it.
- *
- * Both are interpolated at the **centroid** of the samples the triangle covers. The splat is
- * multisampled, and a thin triangle can cover some of a pixel's samples but not its centre; at the
- * centre its depth and alpha would be extrapolated off the triangle's edge, which on a ribbon seen
- * nearly edge-on lands the extinction slices away from the ribbon. The draw has one sample, where a
- * fragment exists only if the centre is covered and the centroid is the centre.
+ * depths. It hands the unlit fragment stages their `AVBOITUnlitVaryings`: the clip position, the
+ * vertex colour straight as the vertices hold it, and the vertex's own view-space depth.
  *
  * The enclosing shader binds the dynamic-mesh groups (`DYNAMIC_MESH_RESOURCES`), `camera` included,
  * and hands over `instance_index` as the draw's row, as for {@link chunk_dynamic_mesh_vertex}.

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

@@ -1 +1 @@
-{"version":3,"file":"chunk_dynamic_mesh_avboit_vertex.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/dynamic/chunk_dynamic_mesh_avboit_vertex.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,+CAFU,SAAS,CA0BjB;0BAjDwB,iCAAiC"}
+{"version":3,"file":"chunk_dynamic_mesh_avboit_vertex.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/dynamic/chunk_dynamic_mesh_avboit_vertex.js"],"names":[],"mappings":"AAIA;;;;;;;;;;GAUG;AACH,+CAFU,SAAS,CAqBjB;0BAjCwB,iCAAiC"}

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

@@ -1,22 +1,12 @@
+import { chunk_avboit_unlit_varyings } from "../rasterize/native/avboit/chunk_avboit_unlit_varyings.js";
 import { CodeChunk } from "../shader/compiler/CodeChunk.js";
 import { chunk_dynamic_mesh_vertex } from "./chunk_dynamic_mesh_vertex.js";
 
 /**
  * The vertex stage both AVBOIT passes draw a dynamic mesh with — the splat at the volume's
  * resolution and the draw at internal resolution — so the two see the same fragments at the same
- * depths.
- *
- * `view_depth` is the vertex's own view-space depth, interpolated across the triangle: what the
- * splat positions a fragment's extinction by and what the draw looks the volume up at. Both passes
- * take it from here rather than reconstructing it from `@builtin(position).z`, the arrangement the
- * particles' billboard stage has for the same reason. `color` is straight — not premultiplied — as
- * the vertices hold it.
- *
- * Both are interpolated at the **centroid** of the samples the triangle covers. The splat is
- * multisampled, and a thin triangle can cover some of a pixel's samples but not its centre; at the
- * centre its depth and alpha would be extrapolated off the triangle's edge, which on a ribbon seen
- * nearly edge-on lands the extinction slices away from the ribbon. The draw has one sample, where a
- * fragment exists only if the centre is covered and the centroid is the centre.
+ * depths. It hands the unlit fragment stages their `AVBOITUnlitVaryings`: the clip position, the
+ * vertex colour straight as the vertices hold it, and the vertex's own view-space depth.
  *
  * The enclosing shader binds the dynamic-mesh groups (`DYNAMIC_MESH_RESOURCES`), `camera` included,
  * and hands over `instance_index` as the draw's row, as for {@link chunk_dynamic_mesh_vertex}.
@@ -26,16 +16,10 @@ import { chunk_dynamic_mesh_vertex } from "./chunk_dynamic_mesh_vertex.js";
 export const chunk_dynamic_mesh_avboit_vertex = CodeChunk.from(
     //language=WGSL
     `
-struct DynamicMeshAVBOITVertexOut {
-    @builtin(position) clip : vec4<f32>,
-    @location(0) @interpolate(perspective, centroid) color : vec4<f32>,
-    @location(1) @interpolate(perspective, centroid) view_depth : f32,
-}
-
-fn dynamic_mesh_avboit_vertex(vertex_index : u32, draw_index : u32) -> DynamicMeshAVBOITVertexOut {
+fn dynamic_mesh_avboit_vertex(vertex_index : u32, draw_index : u32) -> AVBOITUnlitVaryings {
     let vertex = dynamic_mesh_vertex(vertex_index, draw_index);
 
-    var out : DynamicMeshAVBOITVertexOut;
+    var out : AVBOITUnlitVaryings;
 
     out.clip = camera.view_projection_matrix * vertex.world;
     out.color = vertex.color;
@@ -45,6 +29,7 @@ fn dynamic_mesh_avboit_vertex(vertex_index : u32, draw_index : u32) -> DynamicMe
     return out;
 }
     `, [
+        chunk_avboit_unlit_varyings,
         chunk_dynamic_mesh_vertex,
     ]
 );

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

@@ -1,3 +1,16 @@
+/**
+ * The dynamic meshes' three contributions to the AVBOIT transparency pipeline — the
+ * `AVBOITSideChannel` contract, recorded into the frame graph the way the AVBOIT orchestrator records
+ * its own passes. `DynamicMeshAVBOITChannel` calls these with what it decided for the frame — the
+ * occupancy with the meshes it found live, the splat and the draw with the list the occupancy writes
+ * their draws into — and the handles the orchestrator hands it.
+ *
+ * One draw per mesh in the splat and in the draw, as in the pass over the scene, out of one
+ * {@link GPUDynamicMeshDrawList} per frame: the occupancy writes it, the splat and the draw both draw
+ * it, so the meshes' constants go up once a frame and the two passes read the same ones. Order does
+ * not matter to any of them — the volume and the accumulators are sums — which is why nothing here
+ * sorts.
+ */
 /**
  * Upload the live meshes and write their draws, then mark the depth slices their world boxes span
  * (`shader_dynamic_mesh_avboit_occupancy`).
@@ -29,11 +42,8 @@ export function graph_dynamic_mesh_avboit_occupancy({ graph, camera, cluster_par
     draws: GPUDynamicMeshDrawList;
 }): number;
 /**
- * Splat the live meshes' extinction into the voxel volume (`shader_dynamic_mesh_avboit_splat`).
- *
- * The raster is multisampled ({@link DYNAMIC_MESH_AVBOIT_SPLAT_SAMPLES}), so it cannot use the
- * volume's single-sampled splat target: the pass makes its own at the volume's resolution, and hands
- * the volume's back untouched.
+ * Splat the live meshes' extinction into the voxel volume: the unlit splat
+ * (`graph_avboit_unlit_splat`) with the dynamic-mesh pipeline, one draw per mesh out of the frame's list.
  *
  * @param {object} params
  * @param {import("../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph} params.graph
@@ -61,7 +71,8 @@ export function graph_dynamic_mesh_avboit_splat({ graph, camera, warp, voxel_res
     dummy: number;
 };
 /**
- * Draw the live meshes into the four accumulators (`shader_dynamic_mesh_avboit_draw`).
+ * Draw the live meshes into the four accumulators: the unlit draw (`graph_avboit_unlit_draw`) with the
+ * dynamic-mesh pipeline, one draw per mesh out of the frame's list.
  *
  * @param {object} params
  * @param {import("../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph} params.graph

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

@@ -1 +1 @@
-{"version":3,"file":"graph_dynamic_mesh_avboit.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/dynamic/graph_dynamic_mesh_avboit.js"],"names":[],"mappings":"AA4CA;;;;;;;;;;;;;;;;;;;GAmBG;AACH;IAXkG,KAAK,EAA5F,OAAO,2DAA2D,EAAE,UAAU;IAC/D,MAAM,EAArB,MAAM;IACoB,kBAAkB,EAA5C,UAAU,MAAM,CAAC;IACF,SAAS,EAAxB,MAAM;IAC+B,SAAS;IACxB,MAAM,EAA5B,aAAa;IACQ,KAAK,EAA1B,YAAY;IACmB,KAAK;IAElC,MAAM,CAwDlB;AAED;;;;;;;;;;;;;;;GAeG;AACH;IARkG,KAAK,EAA5F,OAAO,2DAA2D,EAAE,UAAU;IAC/D,MAAM,EAArB,MAAM;IACS,IAAI,EAAnB,MAAM;IACW,gBAAgB,EAAjC,MAAM,EAAE;IACsD,MAAM,EAApE;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAC;IACtB,KAAK;IAClC;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAC,CAuFjE;AAED;;;;;;;;;;;;;;;GAeG;AACH;IAZkG,KAAK,EAA5F,OAAO,2DAA2D,EAAE,UAAU;IACnB,QAAQ,EAAnE,OAAO,2BAA2B,EAAE,cAAc;IACnC,MAAM,EAArB,MAAM;IACS,aAAa,EAA5B,MAAM;IACS,IAAI,EAAnB,MAAM;IACS,QAAQ,EAAvB,MAAM;IACS,eAAe,EAA9B,MAAM;IACS,oBAAoB,EAAnC,MAAM;IACsE,YAAY,EAAxF;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAC;IACpC,KAAK;IAClC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAC,CA4F/E"}
+{"version":3,"file":"graph_dynamic_mesh_avboit.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/dynamic/graph_dynamic_mesh_avboit.js"],"names":[],"mappings":"AAWA;;;;;;;;;;;;GAYG;AAEH;;;;;;;;;;;;;;;;;;;GAmBG;AACH;IAXkG,KAAK,EAA5F,OAAO,2DAA2D,EAAE,UAAU;IAC/D,MAAM,EAArB,MAAM;IACoB,kBAAkB,EAA5C,UAAU,MAAM,CAAC;IACF,SAAS,EAAxB,MAAM;IAC+B,SAAS;IACxB,MAAM,EAA5B,aAAa;IACQ,KAAK,EAA1B,YAAY;IACmB,KAAK;IAElC,MAAM,CAwDlB;AAED;;;;;;;;;;;;GAYG;AACH;IARkG,KAAK,EAA5F,OAAO,2DAA2D,EAAE,UAAU;IAC/D,MAAM,EAArB,MAAM;IACS,IAAI,EAAnB,MAAM;IACW,gBAAgB,EAAjC,MAAM,EAAE;IACsD,MAAM,EAApE;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAC;IACtB,KAAK;IAClC;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAC,CA0BjE;AAED;;;;;;;;;;;;;;;;GAgBG;AACH;IAZkG,KAAK,EAA5F,OAAO,2DAA2D,EAAE,UAAU;IACnB,QAAQ,EAAnE,OAAO,2BAA2B,EAAE,cAAc;IACnC,MAAM,EAArB,MAAM;IACS,aAAa,EAA5B,MAAM;IACS,IAAI,EAAnB,MAAM;IACS,QAAQ,EAAvB,MAAM;IACS,eAAe,EAA9B,MAAM;IACS,oBAAoB,EAAnC,MAAM;IACsE,YAAY,EAAxF;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAC;IACpC,KAAK;IAClC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAC,CAkC/E"}

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

@@ -1,29 +1,13 @@
 import { assert } from "../../../core/assert.js";
-import { GPUTextureUsage } from "../../descriptor/GPUTextureUsage.js";
-import { TextureViewDescriptor } from "../../descriptor/texture/TextureViewDescriptor.js";
-import { TextureResourceDescriptor } from "../../device/graph/TextureResourceDescriptor.js";
-import { DEFAULT_DEPTH_TEXTURE_VIEW } from "../depth/DEFAULT_DEPTH_TEXTURE_VIEW.js";
-import { AVBOIT_SPLAT_DUMMY_FORMAT } from "../rasterize/native/avboit/shader_avboit_splat.js";
-import { STATIC_GRAPHICS_ENGINE_ASSETS } from "../STATIC_GRAPHICS_ENGINE_ASSETS.js";
-import { SAMPLER_LINEAR_UPSCALE } from "../texture/SAMPLER_LINEAR_UPSCALE.js";
-import {
-    DYNAMIC_MESH_AVBOIT_DRAW_BIND_GROUP_PASS,
-    DYNAMIC_MESH_AVBOIT_DRAW_PIPELINE,
-    DYNAMIC_MESH_AVBOIT_DRAW_RESOURCES,
-} from "./shader_dynamic_mesh_avboit_draw.js";
+import { graph_avboit_unlit_draw, graph_avboit_unlit_splat } from "../rasterize/native/avboit/graph_avboit_unlit.js";
+import { DYNAMIC_MESH_AVBOIT_DRAW_PIPELINE, DYNAMIC_MESH_AVBOIT_DRAW_RESOURCES } from "./shader_dynamic_mesh_avboit_draw.js";
 import {
     DYNAMIC_MESH_AVBOIT_BOX_FLOATS,
     DYNAMIC_MESH_AVBOIT_OCCUPANCY_GROUP_SIZE,
     DYNAMIC_MESH_AVBOIT_OCCUPANCY_SETTINGS_STRUCT,
     shader_dynamic_mesh_avboit_occupancy,
 } from "./shader_dynamic_mesh_avboit_occupancy.js";
-import {
-    DYNAMIC_MESH_AVBOIT_SPLAT_BIND_GROUP_PASS,
-    DYNAMIC_MESH_AVBOIT_SPLAT_BIND_GROUP_VOLUME,
-    DYNAMIC_MESH_AVBOIT_SPLAT_PIPELINE,
-    DYNAMIC_MESH_AVBOIT_SPLAT_RESOURCES,
-    DYNAMIC_MESH_AVBOIT_SPLAT_SAMPLES,
-} from "./shader_dynamic_mesh_avboit_splat.js";
+import { DYNAMIC_MESH_AVBOIT_SPLAT_PIPELINE, DYNAMIC_MESH_AVBOIT_SPLAT_RESOURCES } from "./shader_dynamic_mesh_avboit_splat.js";
 
 /**
  * The dynamic meshes' three contributions to the AVBOIT transparency pipeline — the
@@ -39,9 +23,6 @@ import {
  * sorts.
  */
 
-/** The accumulators' and the splat target's view: one mip, the one the frame draws into. */
-const COLOR_VIEW = TextureViewDescriptor.from({ mipLevelCount: 1, baseMipLevel: 0 });
-
 /**
  * Upload the live meshes and write their draws, then mark the depth slices their world boxes span
  * (`shader_dynamic_mesh_avboit_occupancy`).
@@ -119,11 +100,8 @@ export function graph_dynamic_mesh_avboit_occupancy({
 }
 
 /**
- * Splat the live meshes' extinction into the voxel volume (`shader_dynamic_mesh_avboit_splat`).
- *
- * The raster is multisampled ({@link DYNAMIC_MESH_AVBOIT_SPLAT_SAMPLES}), so it cannot use the
- * volume's single-sampled splat target: the pass makes its own at the volume's resolution, and hands
- * the volume's back untouched.
+ * Splat the live meshes' extinction into the voxel volume: the unlit splat
+ * (`graph_avboit_unlit_splat`) with the dynamic-mesh pipeline, one draw per mesh out of the frame's list.
  *
  * @param {object} params
  * @param {import("../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph} params.graph
@@ -143,86 +121,26 @@ export function graph_dynamic_mesh_avboit_splat({
                                                     draws,
                                                 }) {
     assert.isNonNegativeInteger(camera, "camera");
-    assert.isNonNegativeInteger(warp, "warp");
-    assert.isArrayLike(voxel_resolution, "voxel_resolution");
-    assert.defined(volume, "volume");
-
-    function execute(data, resources, context) {
-        const encoder = context.encoder;
-        const graphics = context.graphics;
-
-        if (draws.count === 0) {
-            return;
-        }
-
-        const pipeline = DYNAMIC_MESH_AVBOIT_SPLAT_PIPELINE;
-
-        // By name, never by position (ledger entry 21): the order a shader declares its bindings in
-        // is the shader's business.
-        const groups = DYNAMIC_MESH_AVBOIT_SPLAT_RESOURCES.groups;
-
-        const pass_group = groups[DYNAMIC_MESH_AVBOIT_SPLAT_BIND_GROUP_PASS].generateBindings({
-            warp: resources.get(data.warp),
-        }, encoder);
-
-        const volume_group = groups[DYNAMIC_MESH_AVBOIT_SPLAT_BIND_GROUP_VOLUME].generateBindings({
-            extinction_volume: resources.get(data.extinction),
-            overflow_slice: resources.get(data.overflow),
-        }, encoder);
 
-        // the target is never written; it only sizes the raster and gives it its samples
-        const pass_encoder = encoder.constructRenderPass({
-            label: "Dynamic Mesh AVBOIT Splat",
-            pipeline,
-            // the pass's groups are set once, just below; the draws set their own
-            bindings: [],
-            colorAttachments: [{
-                view: resources.get(data.target).obtainView(COLOR_VIEW),
-                loadOp: "clear",
-                storeOp: "discard",
-            }],
-        });
-
-        graphics.setPipelineBindGroup(pass_encoder, pipeline, DYNAMIC_MESH_AVBOIT_SPLAT_BIND_GROUP_PASS, pass_group);
-        graphics.setPipelineBindGroup(pass_encoder, pipeline, DYNAMIC_MESH_AVBOIT_SPLAT_BIND_GROUP_VOLUME, volume_group);
-
-        draws.draw(pass_encoder, graphics, pipeline, resources.get(data.camera));
-
-        pass_encoder.end();
-    }
-
-    const pass_data = {};
-    const pass = graph.add("Dynamic Mesh AVBOIT Splat", pass_data, execute);
-
-    pass_data.camera = pass.read(camera);
-    pass_data.warp = pass.read(warp);
-
-    pass.read(volume.extinction);
-    pass_data.extinction = pass.write(volume.extinction);
-    pass.read(volume.overflow);
-    pass_data.overflow = pass.write(volume.overflow);
-
-    const target = TextureResourceDescriptor.from({
-        resolution: voxel_resolution,
-        format: AVBOIT_SPLAT_DUMMY_FORMAT,
-        usage: GPUTextureUsage.RENDER_ATTACHMENT,
+    const pipeline = DYNAMIC_MESH_AVBOIT_SPLAT_PIPELINE;
+
+    return graph_avboit_unlit_splat({
+        graph,
+        label: "Dynamic Mesh AVBOIT Splat",
+        pipeline,
+        resources: DYNAMIC_MESH_AVBOIT_SPLAT_RESOURCES,
+        inputs: { camera },
+        warp,
+        voxel_resolution,
+        volume,
+        is_empty: () => draws.count === 0,
+        record: (pass_encoder, graphics, inputs) => draws.draw(pass_encoder, graphics, pipeline, inputs.camera),
     });
-
-    // `from` takes no sample count
-    target.sampleCount = DYNAMIC_MESH_AVBOIT_SPLAT_SAMPLES;
-
-    pass_data.target = pass.create("Dynamic Mesh AVBOIT splat target", target);
-
-    return {
-        extinction: pass_data.extinction,
-        overflow: pass_data.overflow,
-        // not this pass's to touch
-        dummy: volume.dummy,
-    };
 }
 
 /**
- * Draw the live meshes into the four accumulators (`shader_dynamic_mesh_avboit_draw`).
+ * Draw the live meshes into the four accumulators: the unlit draw (`graph_avboit_unlit_draw`) with the
+ * dynamic-mesh pipeline, one draw per mesh out of the frame's list.
  *
  * @param {object} params
  * @param {import("../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph} params.graph
@@ -250,81 +168,23 @@ export function graph_dynamic_mesh_avboit_draw({
                                                    draws,
                                                }) {
     assert.isNonNegativeInteger(camera, "camera");
-    assert.isNonNegativeInteger(depth_texture, "depth_texture");
-    assert.isNonNegativeInteger(warp, "warp");
-    assert.isNonNegativeInteger(integral, "integral");
-    assert.defined(accumulators, "accumulators");
-
-    function execute(data, resources, context) {
-        const encoder = context.encoder;
-        const graphics = context.graphics;
-
-        if (draws.count === 0) {
-            return;
-        }
-
-        const pipeline = DYNAMIC_MESH_AVBOIT_DRAW_PIPELINE;
-
-        // by name rather than by position, for the reason the splat gives
-        const pass_group = DYNAMIC_MESH_AVBOIT_DRAW_RESOURCES.groups[DYNAMIC_MESH_AVBOIT_DRAW_BIND_GROUP_PASS].generateBindings({
-            view: view_ctx.uniform_buffer.buffer,
-            warp: resources.get(data.warp),
-            tIntegral: resources.get(data.integral).obtainView(),
-            sLinear: graphics.samplers.obtain(SAMPLER_LINEAR_UPSCALE),
-            volumetrics_metadata: resources.get(data.volumetrics_metadata),
-            tVolumetrics: resources.get(data.volumetrics_lut).obtainView(),
-            tSTBN_vec3: graphics.textures.obtain(STATIC_GRAPHICS_ENGINE_ASSETS.stbn_vec3).obtainView(),
-        }, encoder);
-
-        const attachment = (handle) => ({
-            view: resources.get(handle).obtainView(COLOR_VIEW),
-            loadOp: "load",
-            storeOp: "store",
-        });
-
-        const pass_encoder = encoder.constructRenderPass({
-            label: "Dynamic Mesh AVBOIT Draw",
-            pipeline,
-            // the pass's group is set once, just below; the draws set their own
-            bindings: [],
-            colorAttachments: [
-                attachment(data.color),
-                attachment(data.norm),
-                attachment(data.extinction),
-                attachment(data.emission),
-            ],
-            depthStencilAttachment: {
-                view: resources.get(data.depth).obtainView(DEFAULT_DEPTH_TEXTURE_VIEW),
-                depthReadOnly: true,
-            },
-        });
-
-        graphics.setPipelineBindGroup(pass_encoder, pipeline, DYNAMIC_MESH_AVBOIT_DRAW_BIND_GROUP_PASS, pass_group);
-
-        draws.draw(pass_encoder, graphics, pipeline, resources.get(data.camera));
-
-        pass_encoder.end();
-    }
-
-    const pass_data = {};
-    const pass = graph.add("Dynamic Mesh AVBOIT Draw", pass_data, execute);
-
-    pass_data.camera = pass.read(camera);
-    pass_data.depth = pass.read(depth_texture);
-    pass_data.warp = pass.read(warp);
-    pass_data.integral = pass.read(integral);
-    pass_data.volumetrics_lut = pass.read(volumetrics_lut);
-    pass_data.volumetrics_metadata = pass.read(volumetrics_metadata);
 
-    for (const name of ["color", "norm", "extinction", "emission"]) {
-        pass.read(accumulators[name]);
-        pass_data[name] = pass.write(accumulators[name]);
-    }
-
-    return {
-        color: pass_data.color,
-        norm: pass_data.norm,
-        extinction: pass_data.extinction,
-        emission: pass_data.emission,
-    };
+    const pipeline = DYNAMIC_MESH_AVBOIT_DRAW_PIPELINE;
+
+    return graph_avboit_unlit_draw({
+        graph,
+        label: "Dynamic Mesh AVBOIT Draw",
+        pipeline,
+        resources: DYNAMIC_MESH_AVBOIT_DRAW_RESOURCES,
+        inputs: { camera },
+        view_ctx,
+        depth_texture,
+        warp,
+        integral,
+        volumetrics_lut,
+        volumetrics_metadata,
+        accumulators,
+        is_empty: () => draws.count === 0,
+        record: (pass_encoder, graphics, inputs) => draws.draw(pass_encoder, graphics, pipeline, inputs.camera),
+    });
 }

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

@@ -1,21 +1,19 @@
 /**
- * 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: number;
 /**
- * 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;
-/** The draw shader's resource set, for building its pass-level bind group. */
+export const DYNAMIC_MESH_AVBOIT_DRAW_PIPELINE: import("../../descriptor/pipeline/render/RenderPipelineDescriptor.js").RenderPipelineDescriptor;
+/** The draw shader's resource set. */
 export const DYNAMIC_MESH_AVBOIT_DRAW_RESOURCES: ShaderResourceSetDescriptor;
 /** The assembled shader, for the validity tier. */
 export const shader_dynamic_mesh_avboit_draw: 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_draw.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"shader_dynamic_mesh_avboit_draw.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/dynamic/shader_dynamic_mesh_avboit_draw.js"],"names":[],"mappings":"AAyBA;;;;;GAKG;AACH,uDAFU,MAAM,CAE0C;AA+F1D;;;;GAIG;AACH,gDAFU,wBAAwB,CAc/B;AAEH,8EAA8E;AAC9E,6EAA4D;AAE5D,mDAAmD;AACnD,+DAA0D;yCApJjB,8DAA8D;4CAY3D,mDAAmD;iCAC9D,+BAA+B"}
+{"version":3,"file":"shader_dynamic_mesh_avboit_draw.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/dynamic/shader_dynamic_mesh_avboit_draw.js"],"names":[],"mappings":"AAWA;;;;;GAKG;AACH,uDAFU,MAAM,CAE0C;AA6B1D;;;GAGG;AACH,gDAFU,OAAO,8DAA8D,EAAE,wBAAwB,CAMtG;AAEH,sCAAsC;AACtC,6EAA4D;AAE5D,mDAAmD;AACnD,+DAA0D;4CA1Dd,mDAAmD;iCAC9D,+BAA+B"}