@woosh/meep-engine 3.67.0 → 3.69.0

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

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