@woosh/meep-engine 3.67.0 → 3.69.0

package/src/shade/renderer/postprocess/velocity/VELOCITY_BUFFER.js

@@ -0,0 +1,16 @@
+/**
+ * The velocity buffer's format: how each pixel's surface point moved since the last frame, four half floats
+ * (`chunk_velocity_texel` makes the texel):
+ *
+ * - **x, y**: internal pixels from the point's place on last frame's screen to its place on this one;
+ * - **z**: the point's view depth now less its view depth then, in world units: negative for a surface coming
+ *   nearer, zero for one moving across the view at its depth, and zero for the sky;
+ * - **w**: zero.
+ *
+ * Both frames' projections are taken free of the TAA jitter, so a still surface under a still camera holds zero
+ * throughout. A delta rather than last frame's depth itself: a half float holds it to a share of the motion, and so
+ * holds the depth recovered from it, `depth − z`, to that share of the motion rather than of the depth.
+ *
+ * @type {GPUTextureFormat}
+ */
+export const VELOCITY_FORMAT = 'rgba16float';

package/src/shade/renderer/postprocess/velocity/chunk_velocity_texel.d.ts

@@ -0,0 +1,21 @@
+/**
+ * A pixel's texel of the velocity buffer (`VELOCITY_FORMAT`), from its surface point now and where that point stood a
+ * frame ago:
+ *
+ * ```wgsl
+ * fn velocity_texel(pixel: vec2<f32>, depth: f32, before: vec4<f32>, size: vec2<f32>) -> vec4<f32>
+ * ```
+ *
+ * - `pixel`: the pixel's centre, in the view's internal pixels; `size`: the view's size in them.
+ * - `depth`: the point's clip w this frame.
+ * - `before`: the point a frame ago, in last frame's clip space.
+ *
+ * Both clip spaces are the un-jittered projections' (`view_velocity_matrices`). The texel's z is the clip w now less
+ * then, which a perspective projection makes the view depth; under an orthographic one, whose w is always one, it is
+ * zero.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_velocity_texel: CodeChunk;
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_velocity_texel.d.ts.map

package/src/shade/renderer/postprocess/velocity/chunk_velocity_texel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_velocity_texel.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/velocity/chunk_velocity_texel.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;GAiBG;AACH,mCAFU,SAAS,CAWhB;0BA7BuB,oCAAoC"}

package/src/shade/renderer/postprocess/velocity/chunk_velocity_texel.js

@@ -0,0 +1,30 @@
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+
+/**
+ * A pixel's texel of the velocity buffer (`VELOCITY_FORMAT`), from its surface point now and where that point stood a
+ * frame ago:
+ *
+ * ```wgsl
+ * fn velocity_texel(pixel: vec2<f32>, depth: f32, before: vec4<f32>, size: vec2<f32>) -> vec4<f32>
+ * ```
+ *
+ * - `pixel`: the pixel's centre, in the view's internal pixels; `size`: the view's size in them.
+ * - `depth`: the point's clip w this frame.
+ * - `before`: the point a frame ago, in last frame's clip space.
+ *
+ * Both clip spaces are the un-jittered projections' (`view_velocity_matrices`). The texel's z is the clip w now less
+ * then, which a perspective projection makes the view depth; under an orthographic one, whose w is always one, it is
+ * zero.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_velocity_texel = CodeChunk.from(
+    //language=WGSL
+    `
+fn velocity_texel(pixel: vec2<f32>, depth: f32, before: vec4<f32>, size: vec2<f32>) -> vec4<f32> {
+    let ndc = before.xy / before.w;
+    let previous = vec2<f32>((ndc.x + 1.0) * 0.5 * size.x, (1.0 - ndc.y) * 0.5 * size.y);
+
+    return vec4<f32>(pixel - previous, depth - before.w, 0.0);
+}
+`);

package/src/shade/renderer/postprocess/velocity/graph_add_per_object_velocity.d.ts

@@ -27,10 +27,12 @@ export function enquire_per_object_velocity_pipelines(enquiry: PipelineEnquiry):
  *     per-vertex skin deformation (the limb-ghosting case Stage 1
  *     couldn't address) on top of the per-object motion.
  *
- * The skinned and rigid foreground branches both produce
- * pixel-space deltas in the same units, so downstream consumers
- * (TAA, motion blur) just see velocity — no skinning-awareness
- * needed at any layer above this pass.
+ * The skinned and rigid foreground branches both produce the
+ * velocity buffer's texel (`VELOCITY_FORMAT`: pixel deltas and the
+ * view depth moved through), so downstream consumers (TAA, motion
+ * blur, the screen probes) just see velocity — no
+ * skinning-awareness needed at any layer above this pass. The
+ * background's depth delta is zero.
  *
  * Un-jittered matrices are CPU-built from
  * `camera.projection_matrix × camera.view_matrix` — viewport
@@ -51,7 +53,7 @@ export function enquire_per_object_velocity_pipelines(enquiry: PipelineEnquiry):
  *      placeholders and the shader forces the rigid path.
  * @param {number[]} args.resolution
  * @param {GPUViewContext} args.view
- * @returns {number} FrameGraph handle to the velocity texture (rg16float)
+ * @returns {number} FrameGraph handle to the velocity texture (`VELOCITY_FORMAT`)
  */
 export function graph_add_per_object_velocity({ graph, texture_depth, texture_visibility, buffer_visible_meshlets, buffer_scene_database, buffer_meshlet_metadata, buffer_meshlet_data, buffer_prev_position_offsets, buffer_prev_positions, skinning_active, resolution, view, }: {
     graph: FrameGraph;

package/src/shade/renderer/postprocess/velocity/graph_add_per_object_velocity.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"graph_add_per_object_velocity.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/velocity/graph_add_per_object_velocity.js"],"names":[],"mappings":"AA8QA;;;;GAIG;AACH,+DAFW,eAAe,QAIzB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;AACH;IAhB4B,KAAK;IACT,aAAa,EAA1B,MAAM;IACO,kBAAkB,EAA/B,MAAM;IACO,uBAAuB,EAApC,MAAM;IACO,qBAAqB,EAAlC,MAAM;IACO,uBAAuB,EAApC,MAAM;IACO,mBAAmB,EAAhC,MAAM;IACO,4BAA4B,EAAzC,MAAM;IACO,qBAAqB,EAAlC,MAAM;IACQ,eAAe,EAA7B,OAAO;IAGQ,UAAU,EAAzB,MAAM,EAAE;IACa,IAAI;IACvB,MAAM,CA+DlB;8BA9VY,OAAO,6CAA6C,EAAE,eAAe"}
+{"version":3,"file":"graph_add_per_object_velocity.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/velocity/graph_add_per_object_velocity.js"],"names":[],"mappings":"AA8QA;;;;GAIG;AACH,+DAFW,eAAe,QAIzB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkDG;AACH;IAhB4B,KAAK;IACT,aAAa,EAA1B,MAAM;IACO,kBAAkB,EAA/B,MAAM;IACO,uBAAuB,EAApC,MAAM;IACO,qBAAqB,EAAlC,MAAM;IACO,uBAAuB,EAApC,MAAM;IACO,mBAAmB,EAAhC,MAAM;IACO,4BAA4B,EAAzC,MAAM;IACO,qBAAqB,EAAlC,MAAM;IACQ,eAAe,EAA7B,OAAO;IAGQ,UAAU,EAAzB,MAAM,EAAE;IACa,IAAI;IACvB,MAAM,CA+DlB;8BA9VY,OAAO,6CAA6C,EAAE,eAAe"}

package/src/shade/renderer/postprocess/velocity/graph_add_per_object_velocity.js

@@ -30,7 +30,9 @@ import { graph_image_pass } from "../../shader/graph/graph_image_pass.js";
 import { ImageShader } from "../../shader/ImageShader.js";
 import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
 import { ShaderDescriptor } from "../../shader/ShaderDescriptor.js";
+import { chunk_velocity_texel } from "./chunk_velocity_texel.js";
 import { construct_pixel_reprojection_matrix } from "./construct_pixel_reprojection_matrix.js";
+import { VELOCITY_FORMAT } from "./VELOCITY_BUFFER.js";
 import { view_velocity_matrices } from "./view_velocity_matrices.js";
 import {
     construct_reprojection_matrix_rotation_only,
@@ -92,7 +94,7 @@ fn read_prev_position(base: u32, vertex_index: u32) -> vec3<f32> {
 @fragment
 fn main(
     @builtin(position) coord: vec4<f32>,
-) -> @location(0) vec2<f32> {
+) -> @location(0) vec4<f32> {
 
     let cur_px = coord.xy;
     let texel = vec2<u32>(cur_px);
@@ -103,12 +105,13 @@ fn main(
     // Visibility-buffer clears leave VISIBILITY_NONE on sky
     // pixels, where reverse-Z depth is always 0.0. Passing 0.0
     // directly avoids a tDepth textureLoad on every background pixel.
+    // The sky stands infinitely far, so it has no depth to move through.
     if visibility_word == VISIBILITY_NONE {
         let position_previous = v3_matrix4_project(
             vec3<f32>(cur_px, 0.0),
             mReprojectionRotation
         );
-        return cur_px - position_previous.xy;
+        return vec4<f32>(cur_px - position_previous.xy, 0.0, 0.0);
     }
 
     // ── Reconstruct world-space position for this pixel ─────────
@@ -233,15 +236,11 @@ fn main(
         prev_world = prev_world_h.xyz / prev_world_h.w;
     }
 
-    // ── Project to previous frame, compute pixel delta ──────────
-    let prev_clip = mViewProjPrevious * vec4<f32>(prev_world, 1.0);
-    let prev_ndc = prev_clip.xyz / prev_clip.w;
-    let prev_px = vec2<f32>(
-        (prev_ndc.x + 1.0) * 0.5 * res.x,
-        (1.0 - prev_ndc.y) * 0.5 * res.y,
-    );
-
-    return cur_px - prev_px;
+    // ── Project to previous frame: the pixel and depth deltas ───
+    //
+    // This frame's clip w, the point's view depth, is the reciprocal of
+    // the w its unprojection came out with.
+    return velocity_texel(cur_px, 1.0 / cur_world_h.w, mViewProjPrevious * vec4<f32>(prev_world, 1.0), res);
 }
 `, [
         chunk_v3_matrix4_project,
@@ -251,6 +250,7 @@ fn main(
         chunk_read_meshlet_vertex_position,
         MESHLET_METADATA_STRUCT.declaration_chunk,
         chunk_visibility_decode,
+        chunk_velocity_texel,
     ]
 );
 
@@ -261,7 +261,7 @@ const shader = new ImageShader({
         body
     }),
     targets: [{
-        format: "rg16float",
+        format: VELOCITY_FORMAT,
     }]
 });
 
@@ -300,10 +300,12 @@ export function enquire_per_object_velocity_pipelines(enquiry) {
  *     per-vertex skin deformation (the limb-ghosting case Stage 1
  *     couldn't address) on top of the per-object motion.
  *
- * The skinned and rigid foreground branches both produce
- * pixel-space deltas in the same units, so downstream consumers
- * (TAA, motion blur) just see velocity — no skinning-awareness
- * needed at any layer above this pass.
+ * The skinned and rigid foreground branches both produce the
+ * velocity buffer's texel (`VELOCITY_FORMAT`: pixel deltas and the
+ * view depth moved through), so downstream consumers (TAA, motion
+ * blur, the screen probes) just see velocity — no
+ * skinning-awareness needed at any layer above this pass. The
+ * background's depth delta is zero.
  *
  * Un-jittered matrices are CPU-built from
  * `camera.projection_matrix × camera.view_matrix` — viewport
@@ -324,7 +326,7 @@ export function enquire_per_object_velocity_pipelines(enquiry) {
  *      placeholders and the shader forces the rigid path.
  * @param {number[]} args.resolution
  * @param {GPUViewContext} args.view
- * @returns {number} FrameGraph handle to the velocity texture (rg16float)
+ * @returns {number} FrameGraph handle to the velocity texture (`VELOCITY_FORMAT`)
  */
 export function graph_add_per_object_velocity({
                                                   graph,

package/src/shade/renderer/rasterize/forward/chunk_forward_sample_indirect.js

@@ -35,3 +35,5 @@ chunk_forward_sample_indirect.add(ShadeIndirectLightingMode.IBL, chunk_forward_s
 chunk_forward_sample_indirect.add(ShadeIndirectLightingMode.Brick4, chunk_forward_sample_indirect_brick4);
 chunk_forward_sample_indirect.add(ShadeIndirectLightingMode.LPV, chunk_forward_sample_indirect_environment);
 chunk_forward_sample_indirect.add(ShadeIndirectLightingMode.ProbeClipmap, chunk_forward_sample_indirect_probe_clipmap);
+// the screen probes light only the deferred opaque surfaces: every other reader takes the world-space probes
+chunk_forward_sample_indirect.add(ShadeIndirectLightingMode.ScreenProbes, chunk_forward_sample_indirect_probe_clipmap);

package/src/shade/renderer/rasterize/native/avboit/avboit_unlit_draw.d.ts

@@ -0,0 +1,49 @@
+/**
+ * The render pipeline for an unlit draw shader: additive into the accumulators with the emission
+ * target masked off, the opaque scene's depth tested and never written, both faces.
+ *
+ * @param {object} params
+ * @param {string} params.label
+ * @param {import("../../../shader/resource/ShaderResourceSetDescriptor.js").ShaderResourceSetDescriptor} params.resources
+ * the shader's resources; must hold {@link AVBOIT_UNLIT_DRAW_PASS_GROUP}
+ * @param {string} params.source the assembled shader, with a vertex entry point named `vs_main` and
+ * {@link chunk_avboit_unlit_draw_fragment}'s `fs_main`
+ * @returns {RenderPipelineDescriptor}
+ */
+export function avboit_unlit_draw_pipeline({ label, resources, source }: {
+    label: string;
+    resources: import("../../../shader/resource/ShaderResourceSetDescriptor.js").ShaderResourceSetDescriptor;
+    source: string;
+}): RenderPipelineDescriptor;
+/**
+ * What the unlit draw reads once per pass: the view, the warp, the integral and the fog.
+ *
+ * @type {ShaderResourceGroupDescriptor}
+ */
+export const AVBOIT_UNLIT_DRAW_PASS_GROUP: ShaderResourceGroupDescriptor;
+/**
+ * The unlit AVBOIT draw's fragment stage, `fs_main`: unlit straight-alpha geometry — a dynamic mesh, a
+ * trail — drawn at internal resolution into the four accumulators the transparent meshes and the
+ * particles draw into (`avboit_draw_fragment_body`), so it composites against both order-independently.
+ * Any vertex stage that hands it `AVBOITUnlitVaryings` (`chunk_avboit_unlit_varyings`) can be linked
+ * with it.
+ *
+ * Per fragment: nothing at all if it has faded out (the unlit 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.
+ *
+ * The colour is straight alpha and unlit: it is premultiplied here and never emits — a fragment that
+ * can get past the first test covers something — so {@link avboit_unlit_draw_pipeline} does not write
+ * the emission target at all rather than blend zeros into it over every covered pixel.
+ *
+ * The enclosing shader binds {@link AVBOIT_UNLIT_DRAW_PASS_GROUP} and names its vertex entry point
+ * anything but `fs_main`.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_avboit_unlit_draw_fragment: CodeChunk;
+import { RenderPipelineDescriptor } from "../../../../descriptor/pipeline/render/RenderPipelineDescriptor.js";
+import { ShaderResourceGroupDescriptor } from "../../../shader/resource/ShaderResourceGroupDescriptor.js";
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=avboit_unlit_draw.d.ts.map

package/src/shade/renderer/rasterize/native/avboit/avboit_unlit_draw.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"avboit_unlit_draw.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/native/avboit/avboit_unlit_draw.js"],"names":[],"mappings":"AAiHA;;;;;;;;;;;GAWG;AACH;IAP0B,KAAK,EAApB,MAAM;IACgG,SAAS,EAA/G,OAAO,yDAAyD,EAAE,2BAA2B;IAE9E,MAAM,EAArB,MAAM;IAEJ,wBAAwB,CAoBpC;AA5HD;;;;GAIG;AACH,2CAFU,6BAA6B,CAEyC;AAahF;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,+CAFU,SAAS,CAuDjB;yCA7GuC,oEAAoE;8CAI/D,2DAA2D;0BAD/E,uCAAuC"}

package/src/shade/renderer/rasterize/native/avboit/avboit_unlit_draw.js

@@ -0,0 +1,144 @@
+import { GPUShaderStage } from "../../../../descriptor/GPUShaderStage.js";
+import { DepthStencilState } from "../../../../descriptor/pipeline/render/DepthStencilState.js";
+import { RenderPipelineDescriptor } from "../../../../descriptor/pipeline/render/RenderPipelineDescriptor.js";
+import { assert } from "../../../../../core/assert.js";
+import { chunk_sample_volumetrics } from "../../../deferred/chunk_sample_volumetrics.js";
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+import { ShaderResourceGroupDescriptor } from "../../../shader/resource/ShaderResourceGroupDescriptor.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 { AVBOIT_EXTINCT_TRANSMITTANCE } from "./AVBOIT_CONSTANTS.js";
+import { AVBOIT_WARP_STRUCT } from "./AVBOIT_WARP_STRUCT.js";
+import { AVBOIT_DRAW_TARGETS } from "./avboit_draw_fragment_body.js";
+import { chunk_avboit_footprint_bias } from "./chunk_avboit_footprint_bias.js";
+import { chunk_avboit_premultiplied_contribution } from "./chunk_avboit_premultiplied_contribution.js";
+import { chunk_avboit_sample_transmittance } from "./chunk_avboit_sample_transmittance.js";
+import { chunk_avboit_unlit_varyings } from "./chunk_avboit_unlit_varyings.js";
+import { chunk_avboit_view_depth_to_virtual } from "./chunk_avboit_view_depth_to_virtual.js";
+
+/**
+ * What the unlit draw reads once per pass: the view, the warp, the integral and the fog.
+ *
+ * @type {ShaderResourceGroupDescriptor}
+ */
+export const AVBOIT_UNLIT_DRAW_PASS_GROUP = new ShaderResourceGroupDescriptor();
+
+AVBOIT_UNLIT_DRAW_PASS_GROUP
+    .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");
+
+/**
+ * The unlit AVBOIT draw's fragment stage, `fs_main`: unlit straight-alpha geometry — a dynamic mesh, a
+ * trail — drawn at internal resolution into the four accumulators the transparent meshes and the
+ * particles draw into (`avboit_draw_fragment_body`), so it composites against both order-independently.
+ * Any vertex stage that hands it `AVBOITUnlitVaryings` (`chunk_avboit_unlit_varyings`) can be linked
+ * with it.
+ *
+ * Per fragment: nothing at all if it has faded out (the unlit 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.
+ *
+ * The colour is straight alpha and unlit: it is premultiplied here and never emits — a fragment that
+ * can get past the first test covers something — so {@link avboit_unlit_draw_pipeline} does not write
+ * the emission target at all rather than blend zeros into it over every covered pixel.
+ *
+ * The enclosing shader binds {@link AVBOIT_UNLIT_DRAW_PASS_GROUP} and names its vertex entry point
+ * anything but `fs_main`.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_avboit_unlit_draw_fragment = CodeChunk.from(
+    //language=WGSL
+    `
+struct AVBOITUnlitDrawOutput {
+    @location(0) color : vec4<f32>,
+    @location(1) norm : vec4<f32>,
+    @location(2) extinction : vec4<f32>,
+    @location(3) emission : vec4<f32>,
+}
+
+@fragment
+fn fs_main(fragment : AVBOITUnlitVaryings) -> AVBOITUnlitDrawOutput {
+    // 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, fragment.view_depth)));
+
+    if (fragment.color.a <= 0.0) {
+        // faded out: covers nothing, and straight alpha carries no light without coverage
+        discard;
+    }
+
+    let screen_uv = fragment.clip.xy / vec2<f32>(f32(view.width), f32(view.height));
+
+    let transmittance = avboit_sample_transmittance(&warp, tIntegral, sLinear, screen_uv, fragment.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(fragment.view_depth, screen_uv, fragment.clip.xy);
+
+    let premultiplied = vec4<f32>(fragment.color.rgb * fragment.color.a, fragment.color.a);
+
+    let contribution = avboit_premultiplied_contribution(premultiplied, transmittance, volumetrics);
+
+    var out : AVBOITUnlitDrawOutput;
+
+    out.color = contribution.color;
+    out.norm = contribution.norm;
+    out.extinction = contribution.extinction;
+    out.emission = contribution.emission;
+
+    return out;
+}
+`, [
+        chunk_avboit_unlit_varyings,
+        chunk_avboit_view_depth_to_virtual,
+        chunk_avboit_footprint_bias,
+        chunk_avboit_sample_transmittance,
+        chunk_sample_volumetrics,
+        chunk_avboit_premultiplied_contribution,
+    ]
+);
+
+/**
+ * The render pipeline for an unlit draw shader: additive into the accumulators with the emission
+ * target masked off, the opaque scene's depth tested and never written, both faces.
+ *
+ * @param {object} params
+ * @param {string} params.label
+ * @param {import("../../../shader/resource/ShaderResourceSetDescriptor.js").ShaderResourceSetDescriptor} params.resources
+ * the shader's resources; must hold {@link AVBOIT_UNLIT_DRAW_PASS_GROUP}
+ * @param {string} params.source the assembled shader, with a vertex entry point named `vs_main` and
+ * {@link chunk_avboit_unlit_draw_fragment}'s `fs_main`
+ * @returns {RenderPipelineDescriptor}
+ */
+export function avboit_unlit_draw_pipeline({ label, resources, source }) {
+    assert.isString(label, "label");
+    assert.isString(source, "source");
+    assert.notEqual(resources.groups.indexOf(AVBOIT_UNLIT_DRAW_PASS_GROUP), -1, "resources must hold the unlit draw's pass group");
+
+    return RenderPipelineDescriptor.from({
+        label,
+        layout: resources.generatePipelineLayout(GPUShaderStage.VERTEX | GPUShaderStage.FRAGMENT),
+        vertex: { module: { code: source }, entryPoint: "vs_main" },
+        fragment: {
+            module: { code: 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" },
+    });
+}

package/src/shade/renderer/rasterize/native/avboit/avboit_unlit_splat.d.ts

@@ -0,0 +1,71 @@
+/**
+ * The render pipeline for an unlit splat shader: no depth, one never-written attachment to size the
+ * raster ({@link AVBOIT_UNLIT_SPLAT_SAMPLES} samples, not the volume's single-sampled one the meshlet
+ * and particle splats share), both faces — a trail is seen from inside and out.
+ *
+ * The layout is built group by group: the volume's atomics are fragment-only, and WebGPU refuses a
+ * read-write storage buffer that is visible to the vertex stage. Every other group is visible to both
+ * stages, so a group the shader shares with other pipelines keeps the one layout they all declare.
+ *
+ * @param {object} params
+ * @param {string} params.label
+ * @param {import("../../../shader/resource/ShaderResourceSetDescriptor.js").ShaderResourceSetDescriptor} params.resources
+ * the shader's resources; must hold {@link AVBOIT_UNLIT_SPLAT_PASS_GROUP} and `AVBOIT_SPLAT_VOLUME_GROUP`
+ * @param {string} params.source the assembled shader, with a vertex entry point named `vs_main` and
+ * {@link chunk_avboit_unlit_splat_fragment}'s `fs_main`
+ * @returns {RenderPipelineDescriptor}
+ */
+export function avboit_unlit_splat_pipeline({ label, resources, source }: {
+    label: string;
+    resources: import("../../../shader/resource/ShaderResourceSetDescriptor.js").ShaderResourceSetDescriptor;
+    source: string;
+}): RenderPipelineDescriptor;
+/**
+ * Samples per pixel of the unlit 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 AVBOIT_UNLIT_SPLAT_SAMPLES: number;
+/**
+ * What the unlit splat reads once per pass: the warp, which places a view depth in the volume.
+ *
+ * @type {ShaderResourceGroupDescriptor}
+ */
+export const AVBOIT_UNLIT_SPLAT_PASS_GROUP: ShaderResourceGroupDescriptor;
+/**
+ * The unlit AVBOIT splat's fragment stage, `fs_main`: unlit straight-alpha geometry — a dynamic mesh,
+ * a trail — adding its extinction 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. Any vertex stage that hands it `AVBOITUnlitVaryings` (`chunk_avboit_unlit_varyings`) can
+ * be linked with it.
+ *
+ * Coverage is the varyings' alpha through `avboit_coverage` — the function the unlit 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 comes and goes as it moves by a fraction of a voxel. The raster has
+ * {@link AVBOIT_UNLIT_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 an unweighted splat would write it. 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 varyings, 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 enclosing shader binds {@link AVBOIT_UNLIT_SPLAT_PASS_GROUP} and `AVBOIT_SPLAT_VOLUME_GROUP`,
+ * and names its vertex entry point anything but `fs_main`.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_avboit_unlit_splat_fragment: CodeChunk;
+import { RenderPipelineDescriptor } from "../../../../descriptor/pipeline/render/RenderPipelineDescriptor.js";
+import { ShaderResourceGroupDescriptor } from "../../../shader/resource/ShaderResourceGroupDescriptor.js";
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=avboit_unlit_splat.d.ts.map

package/src/shade/renderer/rasterize/native/avboit/avboit_unlit_splat.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"avboit_unlit_splat.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/native/avboit/avboit_unlit_splat.js"],"names":[],"mappings":"AAwGA;;;;;;;;;;;;;;;;GAgBG;AACH;IAP0B,KAAK,EAApB,MAAM;IACgG,SAAS,EAA/G,OAAO,yDAAyD,EAAE,2BAA2B;IAE9E,MAAM,EAArB,MAAM;IAEJ,wBAAwB,CAgCpC;AAzID;;;;GAIG;AACH,yCAFU,MAAM,CAE4B;AAE5C;;;;GAIG;AACH,4CAFU,6BAA6B,CAE0C;AAKjF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,gDAFU,SAAS,CAyCjB;yCApGuC,oEAAoE;8CAG/D,2DAA2D;0BAD/E,uCAAuC"}

package/src/shade/renderer/rasterize/native/avboit/avboit_unlit_splat.js

@@ -0,0 +1,152 @@
+import { GPUShaderStage } from "../../../../descriptor/GPUShaderStage.js";
+import { PipelineLayoutDescriptor } from "../../../../descriptor/pipeline/PipelineLayoutDescriptor.js";
+import { RenderPipelineDescriptor } from "../../../../descriptor/pipeline/render/RenderPipelineDescriptor.js";
+import { assert } from "../../../../../core/assert.js";
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+import { ShaderResourceGroupDescriptor } from "../../../shader/resource/ShaderResourceGroupDescriptor.js";
+import { AVBOIT_WARP_STRUCT } from "./AVBOIT_WARP_STRUCT.js";
+import { chunk_avboit_coverage } from "./chunk_avboit_coverage.js";
+import { chunk_avboit_splat_slice } from "./chunk_avboit_splat_slice.js";
+import { chunk_avboit_transmittance_to_extinction } from "./chunk_avboit_transmittance_to_extinction.js";
+import { chunk_avboit_unlit_varyings } from "./chunk_avboit_unlit_varyings.js";
+import { chunk_avboit_view_depth_to_physical } from "./chunk_avboit_view_depth_to_physical.js";
+import { AVBOIT_SPLAT_DUMMY_FORMAT, AVBOIT_SPLAT_VOLUME_GROUP } from "./shader_avboit_splat.js";
+
+/**
+ * Samples per pixel of the unlit 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 AVBOIT_UNLIT_SPLAT_SAMPLES = 4;
+
+/**
+ * What the unlit splat reads once per pass: the warp, which places a view depth in the volume.
+ *
+ * @type {ShaderResourceGroupDescriptor}
+ */
+export const AVBOIT_UNLIT_SPLAT_PASS_GROUP = new ShaderResourceGroupDescriptor();
+
+AVBOIT_UNLIT_SPLAT_PASS_GROUP
+    .addStorageBuffer("warp", AVBOIT_WARP_STRUCT);
+
+/**
+ * The unlit AVBOIT splat's fragment stage, `fs_main`: unlit straight-alpha geometry — a dynamic mesh,
+ * a trail — adding its extinction 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. Any vertex stage that hands it `AVBOITUnlitVaryings` (`chunk_avboit_unlit_varyings`) can
+ * be linked with it.
+ *
+ * Coverage is the varyings' alpha through `avboit_coverage` — the function the unlit 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 comes and goes as it moves by a fraction of a voxel. The raster has
+ * {@link AVBOIT_UNLIT_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 an unweighted splat would write it. 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 varyings, 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 enclosing shader binds {@link AVBOIT_UNLIT_SPLAT_PASS_GROUP} and `AVBOIT_SPLAT_VOLUME_GROUP`,
+ * and names its vertex entry point anything but `fs_main`.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_avboit_unlit_splat_fragment = CodeChunk.from(
+    //language=WGSL
+    `
+@fragment
+fn fs_main(fragment : AVBOITUnlitVaryings, @builtin(sample_mask) sample_mask : u32) {
+    // the coverage the draw weights this fragment by, through the same function
+    let coverage = avboit_coverage(fragment.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)) / ${AVBOIT_UNLIT_SPLAT_SAMPLES}.0;
+
+    let extinction = avboit_transmittance_to_extinction(vec3<f32>(1.0 - coverage)) * footprint;
+
+    let p = avboit_view_depth_to_physical(&warp, fragment.view_depth);
+
+    // fragment.clip is @builtin(position): .xy the low-resolution pixel
+    let texel = vec2<u32>(fragment.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_avboit_unlit_varyings,
+        chunk_avboit_coverage,
+        chunk_avboit_transmittance_to_extinction,
+        chunk_avboit_view_depth_to_physical,
+        chunk_avboit_splat_slice,
+    ]
+);
+
+/**
+ * The render pipeline for an unlit splat shader: no depth, one never-written attachment to size the
+ * raster ({@link AVBOIT_UNLIT_SPLAT_SAMPLES} samples, not the volume's single-sampled one the meshlet
+ * and particle splats share), both faces — a trail is seen from inside and out.
+ *
+ * The layout is built group by group: the volume's atomics are fragment-only, and WebGPU refuses a
+ * read-write storage buffer that is visible to the vertex stage. Every other group is visible to both
+ * stages, so a group the shader shares with other pipelines keeps the one layout they all declare.
+ *
+ * @param {object} params
+ * @param {string} params.label
+ * @param {import("../../../shader/resource/ShaderResourceSetDescriptor.js").ShaderResourceSetDescriptor} params.resources
+ * the shader's resources; must hold {@link AVBOIT_UNLIT_SPLAT_PASS_GROUP} and `AVBOIT_SPLAT_VOLUME_GROUP`
+ * @param {string} params.source the assembled shader, with a vertex entry point named `vs_main` and
+ * {@link chunk_avboit_unlit_splat_fragment}'s `fs_main`
+ * @returns {RenderPipelineDescriptor}
+ */
+export function avboit_unlit_splat_pipeline({ label, resources, source }) {
+    assert.isString(label, "label");
+    assert.isString(source, "source");
+
+    const groups = resources.groups;
+
+    assert.notEqual(groups.indexOf(AVBOIT_UNLIT_SPLAT_PASS_GROUP), -1, "resources must hold the unlit splat's pass group");
+    assert.notEqual(groups.indexOf(AVBOIT_SPLAT_VOLUME_GROUP), -1, "resources must hold the splat volume group");
+
+    const layout = PipelineLayoutDescriptor.from(
+        groups.map(group => group.generateBindGroupLayoutDescriptor(
+            group === AVBOIT_SPLAT_VOLUME_GROUP
+                ? GPUShaderStage.FRAGMENT
+                : GPUShaderStage.VERTEX | GPUShaderStage.FRAGMENT
+        )),
+        resources.immediateSize
+    );
+
+    return RenderPipelineDescriptor.from({
+        label,
+        layout,
+        vertex: { module: { code: source }, entryPoint: "vs_main" },
+        fragment: {
+            module: { code: source },
+            entryPoint: "fs_main",
+            targets: [{ format: AVBOIT_SPLAT_DUMMY_FORMAT, writeMask: 0 }],
+        },
+        primitive: { topology: "triangle-list", cullMode: "none" },
+        multisample: { count: AVBOIT_UNLIT_SPLAT_SAMPLES },
+    });
+}