@woosh/meep-engine 3.30.0 → 3.31.0

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

@@ -1 +1 @@
-{"version":3,"file":"shader_dynamic_mesh.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/dynamic/shader_dynamic_mesh.js"],"names":[],"mappings":"AAoHA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH;IAN4B,YAAY,GAA7B,MAAM;IACW,YAAY,GAA7B,MAAM;IACuB,aAAa;IACxB,MAAM,GAAxB,OAAO;IACL,wBAAwB,CAgCpC;AAzJD;;;GAGG;AACH,oDAY6B;AA2I7B;;;;GAIG;AACH,qCAFU,2BAA2B,CAEW;yCA9KP,8DAA8D;6BAO1E,gCAAgC;4CAJjB,mDAAmD"}
+{"version":3,"file":"shader_dynamic_mesh.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/dynamic/shader_dynamic_mesh.js"],"names":[],"mappings":"AA4FA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH;IAN4B,YAAY,GAA7B,MAAM;IACW,YAAY,GAA7B,MAAM;IACuB,aAAa;IACxB,MAAM,GAAxB,OAAO;IACL,wBAAwB,CAgCpC;AArID;;;GAGG;AACH,oDAY6B;AAuH7B;;;;GAIG;AACH,qCAFU,2BAA2B,CAEW;yCAtJP,8DAA8D;6BAO1E,gCAAgC;4CAJjB,mDAAmD"}

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

@@ -1,177 +1,153 @@
-import { ColorTargetState } from "../../descriptor/pipeline/render/ColorTargetState.js";
-import { DepthStencilState } from "../../descriptor/pipeline/render/DepthStencilState.js";
-import { RenderPipelineDescriptor } from "../../descriptor/pipeline/render/RenderPipelineDescriptor.js";
-import { CAMERA_UNIFORM_STRUCT } from "../camera/CAMERA_UNIFORM_STRUCT.js";
-import { CodeChunk } from "../shader/compiler/CodeChunk.js";
-import { ShaderResourceSetDescriptor } from "../shader/resource/ShaderResourceSetDescriptor.js";
-import { ShaderDescriptor } from "../shader/ShaderDescriptor.js";
-import { mat4x4f, vec4f } from "../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
-import { WebGPUArray } from "../shader/type/WebGPUArray.js";
-import { WebGPUStruct } from "../shader/type/WebGPUStruct.js";
-import {
-    DYNAMIC_MESH_VERTEX_COLOR_OFFSET,
-    DYNAMIC_MESH_VERTEX_POSITION_OFFSET,
-    DYNAMIC_MESH_VERTEX_STRIDE
-} from "./DYNAMIC_MESH_VERTEX.js";
-
-/**
- * Per-draw constants. One dynamic mesh is one draw, so this is small and rewritten per mesh per
- * frame rather than tabled.
- */
-export const DYNAMIC_MESH_DRAW_STRUCT = WebGPUStruct.from({
-    /**
-     * Object → world. Dynamic meshes are usually built in world space already, in which case this
-     * is identity, but a trail rigidly attached to something is cheaper to build once in local
-     * space and transform.
-     */
-    model: mat4x4f,
-
-    /**
-     * Multiplied into every vertex colour. Alpha is what fades a whole effect out at once.
-     */
-    color: vec4f,
-}, "DynamicMeshDraw").pack();
-
-const resources = new ShaderResourceSetDescriptor();
-
-resources.createGroup()
-    .addUniform("camera", CAMERA_UNIFORM_STRUCT)
-    .addUniform("draw", DYNAMIC_MESH_DRAW_STRUCT)
-    .addStorageBuffer("vertices", WebGPUArray.f32, false)
-    .addStorageBuffer("indices", WebGPUArray.u32, false);
-
-const body = CodeChunk.from(
-    //language=WGSL
-    `
-const VERTEX_STRIDE : u32 = ${DYNAMIC_MESH_VERTEX_STRIDE}u;
-const POSITION_OFFSET : u32 = ${DYNAMIC_MESH_VERTEX_POSITION_OFFSET}u;
-const COLOR_OFFSET : u32 = ${DYNAMIC_MESH_VERTEX_COLOR_OFFSET}u;
-
-struct DynamicMeshVertexOut {
-    @builtin(position) clip : vec4<f32>,
-    @location(0) color : vec4<f32>,
-}
-
-// Vertices are pulled from storage rather than bound as vertex buffers, which is how the rest of
-// the engine reads geometry: one pipeline then serves every dynamic mesh, whatever it holds.
-@vertex
-fn vs_main(@builtin(vertex_index) vi : u32) -> DynamicMeshVertexOut {
-    let vertex = indices[vi];
-    let base = vertex * VERTEX_STRIDE;
-
-    let position = vec3<f32>(
-        vertices[base + POSITION_OFFSET],
-        vertices[base + POSITION_OFFSET + 1u],
-        vertices[base + POSITION_OFFSET + 2u],
-    );
-
-    let color = vec4<f32>(
-        vertices[base + COLOR_OFFSET],
-        vertices[base + COLOR_OFFSET + 1u],
-        vertices[base + COLOR_OFFSET + 2u],
-        vertices[base + COLOR_OFFSET + 3u],
-    );
-
-    let world = draw.model * vec4<f32>(position, 1.0);
-
-    var out : DynamicMeshVertexOut;
-
-    out.clip = camera.view_projection_matrix * world;
-    out.color = color * draw.color;
-
-    return out;
-}
-
-@fragment
-fn fs_main(in : DynamicMeshVertexOut) -> @location(0) vec4<f32> {
-    return in.color;
-}
-    `, []
-);
-
-/**
- * The shader itself. One compilation, shared by every pipeline built from it — the options below
- * vary the pipeline state, never the WGSL.
- *
- * @type {ShaderDescriptor}
- */
-const descriptor = ShaderDescriptor.from({ label: "Dynamic Mesh", body, resources });
-
-/**
- * Straight alpha over what is already there. Effect content — trails, ribbons, CPU particles —
- * composites over a finished scene rather than participating in it.
- */
-const DYNAMIC_MESH_BLEND = {
-    color: {
-        srcFactor: "src-alpha",
-        dstFactor: "one-minus-src-alpha",
-        operation: "add",
-    },
-    alpha: {
-        srcFactor: "one",
-        dstFactor: "one-minus-src-alpha",
-        operation: "add",
-    },
-};
-
-/**
- * Build the dynamic-mesh pipeline.
- *
- * Two modes, and `opaque` picks between them wholesale because the two halves of each are not
- * separable: blending over the scene only makes sense for something that must not occlude it, and
- * writing depth only makes sense for something that replaces what it covers.
- *
- * - **Effect (default).** Alpha over the frame, depth tested and never written. Trails, ribbons and
- *   CPU particles draw after the standard geometry path has finished, so they must be occluded by
- *   the scene without occluding anything themselves.
- * - **Opaque.** No blend, depth written. A solid surface going down this path — a decoded LOD cut,
- *   a generated mesh with no meshlet build behind it — has to occlude both the scene and itself,
- *   and the depth buffer is the only thing that orders its own triangles against each other.
- *
- * `greater` is the comparison either way, because the engine is reverse-Z.
- *
- * @param {object} [options]
- * @param {string} [options.color_format]
- * @param {string} [options.depth_format]
- * @param {GPUCompareFunction} [options.depth_compare]
- * @param {boolean} [options.opaque] write depth and skip blending, rather than the reverse
- * @returns {RenderPipelineDescriptor}
- */
-export function create_dynamic_mesh_pipeline({
-                                                 color_format = "rgba16float",
-                                                 depth_format = "depth32float",
-                                                 depth_compare = "greater",
-                                                 opaque = false,
-                                             } = {}) {
-    const code = descriptor.source;
-
-    return RenderPipelineDescriptor.from({
-        label: opaque ? "Dynamic Mesh (opaque)" : "Dynamic Mesh",
-        layout: resources.generatePipelineLayout(GPUShaderStage.VERTEX | GPUShaderStage.FRAGMENT),
-        vertex: { module: { code }, entryPoint: "vs_main" },
-        fragment: {
-            module: { code },
-            entryPoint: "fs_main",
-            targets: [ColorTargetState.from({
-                format: color_format,
-                blend: opaque ? undefined : DYNAMIC_MESH_BLEND,
-            })],
-        },
-        depthStencil: DepthStencilState.from({
-            format: depth_format,
-            depthWriteEnabled: opaque,
-            depthCompare: depth_compare,
-        }),
-        // Nothing on this path promises a winding. Ribbons and trails are viewed from both sides by
-        // definition, and a mesh decoded from a container carries whatever its source had — so
-        // culling here would silently erase geometry rather than save work.
-        primitive: { topology: "triangle-list", cullMode: "none" },
-    });
-}
-
-/**
- * The pipeline's resource set, for building bind groups.
- *
- * @type {ShaderResourceSetDescriptor}
- */
-export const DYNAMIC_MESH_RESOURCES = resources;
+import { ColorTargetState } from "../../descriptor/pipeline/render/ColorTargetState.js";
+import { DepthStencilState } from "../../descriptor/pipeline/render/DepthStencilState.js";
+import { RenderPipelineDescriptor } from "../../descriptor/pipeline/render/RenderPipelineDescriptor.js";
+import { CAMERA_UNIFORM_STRUCT } from "../camera/CAMERA_UNIFORM_STRUCT.js";
+import { CodeChunk } from "../shader/compiler/CodeChunk.js";
+import { ShaderResourceSetDescriptor } from "../shader/resource/ShaderResourceSetDescriptor.js";
+import { ShaderDescriptor } from "../shader/ShaderDescriptor.js";
+import { mat4x4f, vec4f } from "../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUArray } from "../shader/type/WebGPUArray.js";
+import { WebGPUStruct } from "../shader/type/WebGPUStruct.js";
+import { chunk_dynamic_mesh_vertex } from "./chunk_dynamic_mesh_vertex.js";
+
+/**
+ * Per-draw constants. One dynamic mesh is one draw, so this is small and rewritten per mesh per
+ * frame rather than tabled.
+ */
+export const DYNAMIC_MESH_DRAW_STRUCT = WebGPUStruct.from({
+    /**
+     * Object → world. Dynamic meshes are usually built in world space already, in which case this
+     * is identity, but a trail rigidly attached to something is cheaper to build once in local
+     * space and transform.
+     */
+    model: mat4x4f,
+
+    /**
+     * Multiplied into every vertex colour. Alpha is what fades a whole effect out at once.
+     */
+    color: vec4f,
+}, "DynamicMeshDraw").pack();
+
+const resources = new ShaderResourceSetDescriptor();
+
+resources.createGroup()
+    .addUniform("camera", CAMERA_UNIFORM_STRUCT)
+    .addUniform("draw", DYNAMIC_MESH_DRAW_STRUCT)
+    .addStorageBuffer("vertices", WebGPUArray.f32, false)
+    .addStorageBuffer("indices", WebGPUArray.u32, false);
+
+const body = CodeChunk.from(
+    //language=WGSL
+    `
+struct DynamicMeshVertexOut {
+    @builtin(position) clip : vec4<f32>,
+    @location(0) color : vec4<f32>,
+}
+
+@vertex
+fn vs_main(@builtin(vertex_index) vi : u32) -> DynamicMeshVertexOut {
+    let vertex = dynamic_mesh_vertex(vi);
+
+    var out : DynamicMeshVertexOut;
+
+    out.clip = camera.view_projection_matrix * vertex.world;
+    out.color = vertex.color;
+
+    return out;
+}
+
+@fragment
+fn fs_main(in : DynamicMeshVertexOut) -> @location(0) vec4<f32> {
+    return in.color;
+}
+    `, [
+        chunk_dynamic_mesh_vertex,
+    ]
+);
+
+/**
+ * The shader itself. One compilation, shared by every pipeline built from it — the options below
+ * vary the pipeline state, never the WGSL.
+ *
+ * @type {ShaderDescriptor}
+ */
+const descriptor = ShaderDescriptor.from({ label: "Dynamic Mesh", body, resources });
+
+/**
+ * Straight alpha over what is already there. Effect content — trails, ribbons, CPU particles —
+ * composites over a finished scene rather than participating in it.
+ */
+const DYNAMIC_MESH_BLEND = {
+    color: {
+        srcFactor: "src-alpha",
+        dstFactor: "one-minus-src-alpha",
+        operation: "add",
+    },
+    alpha: {
+        srcFactor: "one",
+        dstFactor: "one-minus-src-alpha",
+        operation: "add",
+    },
+};
+
+/**
+ * Build the dynamic-mesh pipeline.
+ *
+ * Two modes, and `opaque` picks between them wholesale because the two halves of each are not
+ * separable: blending over the scene only makes sense for something that must not occlude it, and
+ * writing depth only makes sense for something that replaces what it covers.
+ *
+ * - **Effect (default).** Alpha over the frame, depth tested and never written. Trails, ribbons and
+ *   CPU particles draw after the standard geometry path has finished, so they must be occluded by
+ *   the scene without occluding anything themselves.
+ * - **Opaque.** No blend, depth written. A solid surface going down this path — a decoded LOD cut,
+ *   a generated mesh with no meshlet build behind it — has to occlude both the scene and itself,
+ *   and the depth buffer is the only thing that orders its own triangles against each other.
+ *
+ * `greater` is the comparison either way, because the engine is reverse-Z.
+ *
+ * @param {object} [options]
+ * @param {string} [options.color_format]
+ * @param {string} [options.depth_format]
+ * @param {GPUCompareFunction} [options.depth_compare]
+ * @param {boolean} [options.opaque] write depth and skip blending, rather than the reverse
+ * @returns {RenderPipelineDescriptor}
+ */
+export function create_dynamic_mesh_pipeline({
+                                                 color_format = "rgba16float",
+                                                 depth_format = "depth32float",
+                                                 depth_compare = "greater",
+                                                 opaque = false,
+                                             } = {}) {
+    const code = descriptor.source;
+
+    return RenderPipelineDescriptor.from({
+        label: opaque ? "Dynamic Mesh (opaque)" : "Dynamic Mesh",
+        layout: resources.generatePipelineLayout(GPUShaderStage.VERTEX | GPUShaderStage.FRAGMENT),
+        vertex: { module: { code }, entryPoint: "vs_main" },
+        fragment: {
+            module: { code },
+            entryPoint: "fs_main",
+            targets: [ColorTargetState.from({
+                format: color_format,
+                blend: opaque ? undefined : DYNAMIC_MESH_BLEND,
+            })],
+        },
+        depthStencil: DepthStencilState.from({
+            format: depth_format,
+            depthWriteEnabled: opaque,
+            depthCompare: depth_compare,
+        }),
+        // Nothing on this path promises a winding. Ribbons and trails are viewed from both sides by
+        // definition, and a mesh decoded from a container carries whatever its source had — so
+        // culling here would silently erase geometry rather than save work.
+        primitive: { topology: "triangle-list", cullMode: "none" },
+    });
+}
+
+/**
+ * The pipeline's resource set, for building bind groups.
+ *
+ * @type {ShaderResourceSetDescriptor}
+ */
+export const DYNAMIC_MESH_RESOURCES = resources;

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

@@ -0,0 +1,20 @@
+/**
+ * Bind group of everything the draw reads once per pass — the view, the warp, the integral and the
+ * fog. Group 0 is the dynamic-mesh group, 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}
+ */
+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_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

@@ -0,0 +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":"AAmBA;;;;GAIG;AACH,uDAFU,MAAM,CAE0C;AAwF1D;;;;GAIG;AACH,gDAFU,wBAAwB,CAc/B;AAEH,8EAA8E;AAC9E,6EAA4D;AAE5D,mDAAmD;AACnD,+DAA0D;yCAtIjB,8DAA8D;4CAU3D,mDAAmD;iCAC9D,+BAA+B"}

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

@@ -0,0 +1,136 @@
+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_sample_transmittance } from "../rasterize/native/avboit/chunk_avboit_sample_transmittance.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_RESOURCES } from "./shader_dynamic_mesh.js";
+
+/**
+ * Bind group of everything the draw reads once per pass — the view, the warp, the integral and the
+ * fog. Group 0 is the dynamic-mesh group, per mesh.
+ * @type {number}
+ */
+export const DYNAMIC_MESH_AVBOIT_DRAW_BIND_GROUP_PASS = 1;
+
+/**
+ * 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.
+ */
+
+const resources = new ShaderResourceSetDescriptor();
+
+resources.addGroup(DYNAMIC_MESH_RESOURCES.groups[0]);
+
+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");
+
+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) -> DynamicMeshAVBOITVertexOut {
+    return dynamic_mesh_avboit_vertex(vi);
+}
+
+@fragment
+fn fs_main(in : DynamicMeshAVBOITVertexOut) -> DynamicMeshAVBOITDrawOutput {
+    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);
+
+    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_sample_transmittance,
+    chunk_sample_volumetrics,
+    chunk_avboit_premultiplied_contribution,
+]);
+
+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}
+ */
+export const DYNAMIC_MESH_AVBOIT_DRAW_PIPELINE = RenderPipelineDescriptor.from({
+    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" },
+});
+
+/** The draw shader's resource set, for building its pass-level bind group. */
+export const DYNAMIC_MESH_AVBOIT_DRAW_RESOURCES = resources;
+
+/** The assembled shader, for the validity tier. */
+export const shader_dynamic_mesh_avboit_draw = descriptor;

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

@@ -0,0 +1,20 @@
+/**
+ * Threads per workgroup; one box per thread.
+ * @type {number}
+ */
+export const DYNAMIC_MESH_AVBOIT_OCCUPANCY_GROUP_SIZE: number;
+/**
+ * Floats per box in the `boxes` buffer: `min_x, min_y, min_z, max_x, max_y, max_z`, packed.
+ * @type {number}
+ */
+export const DYNAMIC_MESH_AVBOIT_BOX_FLOATS: number;
+/**
+ * The depth curve (`avboit_build_depth_curve`) and how many boxes this frame's buffer holds — the
+ * buffer comes out of a pool and may be longer than the frame's boxes, so its length is not the
+ * count.
+ */
+export const DYNAMIC_MESH_AVBOIT_OCCUPANCY_SETTINGS_STRUCT: WebGPUStruct;
+export const shader_dynamic_mesh_avboit_occupancy: ComputeShader;
+import { WebGPUStruct } from "../shader/type/WebGPUStruct.js";
+import { ComputeShader } from "../shader/ComputeShader.js";
+//# sourceMappingURL=shader_dynamic_mesh_avboit_occupancy.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"shader_dynamic_mesh_avboit_occupancy.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/dynamic/shader_dynamic_mesh_avboit_occupancy.js"],"names":[],"mappings":"AAaA;;;GAGG;AACH,uDAFU,MAAM,CAE2C;AAE3D;;;GAGG;AACH,6CAFU,MAAM,CAEgC;AAEhD;;;;GAIG;AACH,yEAGgD;AAoEhD,iEAIG;6BA9F0B,gCAAgC;8BAJ/B,4BAA4B"}

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

@@ -0,0 +1,106 @@
+import { CAMERA_UNIFORM_STRUCT } from "../camera/CAMERA_UNIFORM_STRUCT.js";
+import { AVBOIT_OCCUPANCY_WORDS } from "../rasterize/native/avboit/AVBOIT_CONSTANTS.js";
+import { chunk_avboit_occupancy_mark } from "../rasterize/native/avboit/chunk_avboit_occupancy_mark.js";
+import { AABB3_STRUCT } from "../shader/chunk/geometry/aabb3/AABB3_STRUCT.js";
+import { chunk_aabb3_intersects_frustum } from "../shader/chunk/geometry/aabb3/chunk_aabb3_intersects_frustum.js";
+import { chunk_aabb3_view_depth_range } from "../shader/chunk/geometry/aabb3/chunk_aabb3_view_depth_range.js";
+import { CodeChunk } from "../shader/compiler/CodeChunk.js";
+import { ComputeShader } from "../shader/ComputeShader.js";
+import { ShaderResourceSetDescriptor } from "../shader/resource/ShaderResourceSetDescriptor.js";
+import { atomic_u32, u32, vec3f } from "../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUArray } from "../shader/type/WebGPUArray.js";
+import { WebGPUStruct } from "../shader/type/WebGPUStruct.js";
+
+/**
+ * Threads per workgroup; one box per thread.
+ * @type {number}
+ */
+export const DYNAMIC_MESH_AVBOIT_OCCUPANCY_GROUP_SIZE = 64;
+
+/**
+ * Floats per box in the `boxes` buffer: `min_x, min_y, min_z, max_x, max_y, max_z`, packed.
+ * @type {number}
+ */
+export const DYNAMIC_MESH_AVBOIT_BOX_FLOATS = 6;
+
+/**
+ * The depth curve (`avboit_build_depth_curve`) and how many boxes this frame's buffer holds — the
+ * buffer comes out of a pool and may be longer than the frame's boxes, so its length is not the
+ * count.
+ */
+export const DYNAMIC_MESH_AVBOIT_OCCUPANCY_SETTINGS_STRUCT = WebGPUStruct.from({
+    cluster_parameters: vec3f,
+    box_count: u32,
+}, "DynamicMeshAVBOITOccupancySettings").pack();
+
+const resources = new ShaderResourceSetDescriptor();
+
+resources.createGroup()
+    .addUniform("camera", CAMERA_UNIFORM_STRUCT)
+    .addUniform("settings", DYNAMIC_MESH_AVBOIT_OCCUPANCY_SETTINGS_STRUCT)
+    .addStorageBuffer("boxes", WebGPUArray.f32, false)
+    .addStorageBuffer("occupancy", WebGPUArray.from(atomic_u32, AVBOIT_OCCUPANCY_WORDS), true);
+
+/**
+ * The dynamic meshes' AVBOIT occupancy: one thread per box, marking the virtual depth slices it
+ * spans so the warp keeps resolution where the meshes are. The counterpart of
+ * `shader_avboit_occupancy` (per meshlet) and `shader_particle_avboit_occupancy` (per emitter).
+ *
+ * One box per mesh, built on the CPU from the triangles that can still put a fragment on screen
+ * (`dynamic_mesh_live_bounds`) and carried into world space by the mesh's own transform — the
+ * vertices are CPU data already, so that is cheaper than any pass over them here. What happens to a
+ * box from there is the particles' arithmetic, through the same two chunks: its view-depth interval
+ * (`aabb3_view_depth_range`), then the near-plane test, depth curve, dilation and word OR
+ * (`avboit_occupancy_mark`).
+ *
+ * **A box outside the view frustum marks nothing.** Its mesh puts no fragment on screen, so there is
+ * nothing to splat and nothing to draw — but a depth run reserved for it is a run the on-screen
+ * surfaces do not get: a trail behind the camera, or off to the side, would otherwise coarsen the
+ * warp for every transparent surface in the frame. A box that reaches into the frustum is marked
+ * whole, as before.
+ *
+ * @type {ComputeShader}
+ */
+const body = CodeChunk.from(
+    //language=WGSL
+    `
+@compute @workgroup_size(${DYNAMIC_MESH_AVBOIT_OCCUPANCY_GROUP_SIZE}, 1, 1)
+fn main(
+    @builtin(workgroup_id) wg_id : vec3<u32>,
+    @builtin(local_invocation_index) local_id : u32,
+) {
+    let index = wg_id.x * ${DYNAMIC_MESH_AVBOIT_OCCUPANCY_GROUP_SIZE}u + local_id;
+
+    if (index >= settings.box_count) {
+        return;
+    }
+
+    let base = index * ${DYNAMIC_MESH_AVBOIT_BOX_FLOATS}u;
+
+    let box = ${AABB3_STRUCT.make({
+        min: "vec3<f32>(boxes[base], boxes[base + 1u], boxes[base + 2u])",
+        max: "vec3<f32>(boxes[base + 3u], boxes[base + 4u], boxes[base + 5u])",
+    })};
+
+    if (!aabb3_intersects_frustum(box, camera.frustum)) {
+        // nothing of it is on screen: no fragment to splat, no depth to reserve
+        return;
+    }
+
+    let range_view = aabb3_view_depth_range(box, camera.view_matrix);
+
+    avboit_occupancy_mark(range_view.x, range_view.y, camera.clip_near_far.x, settings.cluster_parameters);
+}
+    `, [
+        AABB3_STRUCT.declaration_chunk,
+        chunk_aabb3_intersects_frustum,
+        chunk_aabb3_view_depth_range,
+        chunk_avboit_occupancy_mark,
+    ]
+);
+
+export const shader_dynamic_mesh_avboit_occupancy = ComputeShader.from({
+    label: "Dynamic Mesh AVBOIT Occupancy",
+    resources,
+    body,
+});