@woosh/meep-engine 3.11.3 → 3.12.0

package/src/shade/renderer/buffer/util/shader_buffer_copy_storage_to_storage.js

@@ -1,43 +1,42 @@
-import { u32 } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
-import { WebGPUArray } from "../../shader/type/WebGPUArray.js";
-import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
-import { COMPUTE_SHADER_DEFAULT_GROUP_SIZE } from "../../shader/COMPUTE_SHADER_DEFAULT_GROUP_SIZE.js";
-import { ComputeShader } from "../../shader/ComputeShader.js";
-import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
-
-const resources = new ShaderResourceSetDescriptor();
-
-resources.createGroup()
-    .addStorageBuffer("source", WebGPUArray.u32)
-    .addStorageBuffer("destination", WebGPUArray.u32, true)
-    .addUniform("size", u32)
-
-const body = CodeChunk.from(
-    //language=WGSL
-    `
-@compute @workgroup_size(${COMPUTE_SHADER_DEFAULT_GROUP_SIZE})
-fn main(
-    @builtin(global_invocation_id) global_id : vec3<u32>
-){
-    let index = global_id.x;
-     
-    if(index >= size){
-        return;
-    }
-    
-    destination[index] = source[index];
-}
-    `
-)
-
-/**
- * Shader is useful for copying buffers where the buffers are missing `GPUBufferUsage.COPY_DST` or `GPUBufferUsage.COPY_SRC`.
- * This is a pure utility shader.
- * @type {ComputeShader}
- */
-export const shader_buffer_copy_storage_to_storage = ComputeShader.from({
-    label: "Copy GPU Buffer/ STORAGE -> STORAGE",
-    body,
-    resources,
-    group_size: [COMPUTE_SHADER_DEFAULT_GROUP_SIZE]
+import { u32 } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUArray } from "../../shader/type/WebGPUArray.js";
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { COMPUTE_SHADER_DEFAULT_GROUP_SIZE } from "../../shader/COMPUTE_SHADER_DEFAULT_GROUP_SIZE.js";
+import { ComputeShader } from "../../shader/ComputeShader.js";
+import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
+
+const resources = new ShaderResourceSetDescriptor();
+
+resources.createGroup()
+    .addStorageBuffer("source", WebGPUArray.u32)
+    .addStorageBuffer("destination", WebGPUArray.u32, true)
+    .addUniform("size", u32)
+
+const body = CodeChunk.from(
+    //language=WGSL
+    `
+@compute @workgroup_size(${COMPUTE_SHADER_DEFAULT_GROUP_SIZE})
+fn main(
+    @builtin(global_invocation_id) global_id : vec3<u32>
+){
+    let index = global_id.x;
+     
+    if(index >= size){
+        return;
+    }
+    
+    destination[index] = source[index];
+}
+    `
+)
+
+/**
+ * Shader is useful for copying buffers where the buffers are missing `GPUBufferUsage.COPY_DST` or `GPUBufferUsage.COPY_SRC`.
+ * This is a pure utility shader.
+ * @type {ComputeShader}
+ */
+export const shader_buffer_copy_storage_to_storage = ComputeShader.from({
+    label: "Copy GPU Buffer/ STORAGE -> STORAGE",
+    body,
+    resources,
 });

package/src/shade/renderer/buffer/util/shader_buffer_intra_copy_regions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_buffer_intra_copy_regions.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/buffer/util/shader_buffer_intra_copy_regions.js"],"names":[],"mappings":"AAOA;;;;;GAKG;AACH,kDAAmD;AAEnD;;;;GAIG;AACH,2DAI4B;AAmC5B;;;;;;;;;;;;;;;;;;GAkBG;AACH,6DAKG;6BAjF0B,mCAAmC;8BAElC,+BAA+B"}
+{"version":3,"file":"shader_buffer_intra_copy_regions.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/buffer/util/shader_buffer_intra_copy_regions.js"],"names":[],"mappings":"AAOA;;;;;GAKG;AACH,kDAAmD;AAEnD;;;;GAIG;AACH,2DAI4B;AAmC5B;;;;;;;;;;;;;;;;;;GAkBG;AACH,6DAIG;6BAhF0B,mCAAmC;8BAElC,+BAA+B"}

package/src/shade/renderer/buffer/util/shader_buffer_intra_copy_regions.js

@@ -1,84 +1,83 @@
-import { u32 } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
-import { WebGPUArray } from "../../shader/type/WebGPUArray.js";
-import { WebGPUStruct } from "../../shader/type/WebGPUStruct.js";
-import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
-import { ComputeShader } from "../../shader/ComputeShader.js";
-import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
-
-/**
- * Workgroup size for the per-region stride loop. Each workgroup
- * handles one region; threads in the workgroup walk the region's
- * words in WORKGROUP_SIZE-stride'd slots, so a region with N words
- * takes ceil(N / WORKGROUP_SIZE) iterations per thread.
- */
-export const BUFFER_INTRA_COPY_WORKGROUP_SIZE = 64;
-
-/**
- * One copy job: source and destination regions inside the same buffer.
- * Offsets and lengths are in `u32` words (not bytes). The shader does
- * not validate non-overlap — the caller is responsible.
- */
-export const BUFFER_INTRA_COPY_REGION_STRUCT = WebGPUStruct.from({
-    src_offset: u32,
-    dst_offset: u32,
-    word_count: u32,
-}, "BufferIntraCopyRegion");
-
-const resources = new ShaderResourceSetDescriptor();
-resources.createGroup()
-    .addStorageBuffer('buffer', WebGPUArray.from(u32), true)
-    .addStorageBuffer('regions', WebGPUArray.from(BUFFER_INTRA_COPY_REGION_STRUCT), false);
-
-// One workgroup per region, dispatch over the regions list. Threads
-// stride-loop over the region's words. WebGPU rejects same-buffer
-// `copyBufferToBuffer` even with non-overlapping ranges, which is why
-// we go via a compute shader for intra-buffer relocation. A single
-// `read_write` binding sidesteps the read+write-on-same-binding
-// resource conflict that would prevent binding the buffer twice with
-// different access modes.
-const body = CodeChunk.from(
-    //language=WGSL
-    `
-@compute @workgroup_size(${BUFFER_INTRA_COPY_WORKGROUP_SIZE},1,1)
-fn main(
-    @builtin(workgroup_id) wg_id: vec3<u32>,
-    @builtin(local_invocation_index) local_id: u32,
-) {
-    let region = regions[wg_id.x];
-
-    var i: u32 = local_id;
-    loop {
-        if(i >= region.word_count) { break; }
-
-        buffer[region.dst_offset + i] = buffer[region.src_offset + i];
-
-        i = i + ${BUFFER_INTRA_COPY_WORKGROUP_SIZE}u;
-    }
-}
-`);
-
-/**
- * Compute-shader memcpy across regions of a single storage buffer.
- * One workgroup per region; threads in the workgroup stride-loop
- * over the region's `word_count` u32 words.
- *
- * Why a compute shader rather than `copyBufferToBuffer`: WebGPU
- * forbids `copyBufferToBuffer` from passing the same buffer as both
- * source and destination, even when the byte ranges don't overlap —
- * the validation check is buffer-identity, not range-overlap. The
- * compute path sidesteps that by binding the buffer once as
- * `read_write` storage and reading + writing through the same
- * binding.
- *
- * Caller responsibility: the regions table must list non-overlapping
- * (src, dst) ranges. The shader does no overlap checks.
- *
- * Dispatch: one workgroup per entry in `regions`, i.e.
- * `group_count_x = region_count`. Skip when `region_count === 0`.
- */
-export const shader_buffer_intra_copy_regions = ComputeShader.from({
-    label: "Copy GPU Buffer/ Intra-buffer regions",
-    body,
-    resources,
-    group_size: [BUFFER_INTRA_COPY_WORKGROUP_SIZE, 1, 1],
-});
+import { u32 } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUArray } from "../../shader/type/WebGPUArray.js";
+import { WebGPUStruct } from "../../shader/type/WebGPUStruct.js";
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { ComputeShader } from "../../shader/ComputeShader.js";
+import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
+
+/**
+ * Workgroup size for the per-region stride loop. Each workgroup
+ * handles one region; threads in the workgroup walk the region's
+ * words in WORKGROUP_SIZE-stride'd slots, so a region with N words
+ * takes ceil(N / WORKGROUP_SIZE) iterations per thread.
+ */
+export const BUFFER_INTRA_COPY_WORKGROUP_SIZE = 64;
+
+/**
+ * One copy job: source and destination regions inside the same buffer.
+ * Offsets and lengths are in `u32` words (not bytes). The shader does
+ * not validate non-overlap — the caller is responsible.
+ */
+export const BUFFER_INTRA_COPY_REGION_STRUCT = WebGPUStruct.from({
+    src_offset: u32,
+    dst_offset: u32,
+    word_count: u32,
+}, "BufferIntraCopyRegion");
+
+const resources = new ShaderResourceSetDescriptor();
+resources.createGroup()
+    .addStorageBuffer('buffer', WebGPUArray.from(u32), true)
+    .addStorageBuffer('regions', WebGPUArray.from(BUFFER_INTRA_COPY_REGION_STRUCT), false);
+
+// One workgroup per region, dispatch over the regions list. Threads
+// stride-loop over the region's words. WebGPU rejects same-buffer
+// `copyBufferToBuffer` even with non-overlapping ranges, which is why
+// we go via a compute shader for intra-buffer relocation. A single
+// `read_write` binding sidesteps the read+write-on-same-binding
+// resource conflict that would prevent binding the buffer twice with
+// different access modes.
+const body = CodeChunk.from(
+    //language=WGSL
+    `
+@compute @workgroup_size(${BUFFER_INTRA_COPY_WORKGROUP_SIZE},1,1)
+fn main(
+    @builtin(workgroup_id) wg_id: vec3<u32>,
+    @builtin(local_invocation_index) local_id: u32,
+) {
+    let region = regions[wg_id.x];
+
+    var i: u32 = local_id;
+    loop {
+        if(i >= region.word_count) { break; }
+
+        buffer[region.dst_offset + i] = buffer[region.src_offset + i];
+
+        i = i + ${BUFFER_INTRA_COPY_WORKGROUP_SIZE}u;
+    }
+}
+`);
+
+/**
+ * Compute-shader memcpy across regions of a single storage buffer.
+ * One workgroup per region; threads in the workgroup stride-loop
+ * over the region's `word_count` u32 words.
+ *
+ * Why a compute shader rather than `copyBufferToBuffer`: WebGPU
+ * forbids `copyBufferToBuffer` from passing the same buffer as both
+ * source and destination, even when the byte ranges don't overlap —
+ * the validation check is buffer-identity, not range-overlap. The
+ * compute path sidesteps that by binding the buffer once as
+ * `read_write` storage and reading + writing through the same
+ * binding.
+ *
+ * Caller responsibility: the regions table must list non-overlapping
+ * (src, dst) ranges. The shader does no overlap checks.
+ *
+ * Dispatch: one workgroup per entry in `regions`, i.e.
+ * `group_count_x = region_count`. Skip when `region_count === 0`.
+ */
+export const shader_buffer_intra_copy_regions = ComputeShader.from({
+    label: "Copy GPU Buffer/ Intra-buffer regions",
+    body,
+    resources,
+});

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":"AA4GA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH;IAN4B,YAAY,GAA7B,MAAM;IACW,YAAY,GAA7B,MAAM;IACuB,aAAa;IACxB,MAAM,GAAxB,OAAO;IACL,wBAAwB,CAiCpC;AAlJD;;;GAGG;AACH,oDAY6B;AAoI7B;;;;GAIG;AACH,qCAFU,2BAA2B,CAEW;yCAvKP,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":"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"}

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

@@ -1,170 +1,177 @@
-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;
-}
-    `, []
-);
-
-/**
- * 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 descriptor = ShaderDescriptor.from({ label: "Dynamic Mesh", body, resources });
-    const code = descriptor.compile();
-
-    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 {
+    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;