@woosh/meep-engine 3.68.0 → 3.70.0

package/src/shade/playground/trails/main.js

@@ -0,0 +1,258 @@
+import Vector3 from "../../../core/geom/Vector3.js";
+import { DEG_TO_RAD } from "../../../core/math/DEG_TO_RAD.js";
+import { Entity } from "../../../engine/ecs/Entity.js";
+import { EntityComponentDataset } from "../../../engine/ecs/EntityComponentDataset.js";
+import { EntityManager } from "../../../engine/ecs/EntityManager.js";
+import { t64_announce_change } from "../../../engine/ecs/transform/t64_announce_change.js";
+import { Transform64 } from "../../../engine/ecs/transform/Transform64.js";
+import Trail3D from "../../../engine/graphics/ecs/trail3d/Trail3D.js";
+import { GraphicsEngine } from "../../../engine/graphics3/GraphicsEngine.js";
+import { Trail3DSystem } from "../../../engine/graphics3/Trail3DSystem.js";
+import { OrbitalCameraController } from "../../renderer/camera/orbital/OrbitalCameraController.js";
+import { create_frame_loop } from "../../renderer/create_frame_loop.js";
+import { Scene } from "../../renderer/scene/Scene.js";
+import { ShadeTransparencyMode } from "../../renderer/ShadeTransparencyMode.js";
+
+/**
+ * A field of trails on figures-of-eight, simulated in compute and extruded in the vertex stage by
+ * `Trail3DSystem`, drawn through AVBOIT.
+ *
+ * Query: `n` trails (64), `age` maxAge in seconds (2), `radial` (8, or a list such as
+ * `4,8,16` taken in turn), `width` (0.08), `debug` to drive frames by hand through `__step(n, dt)`
+ * instead of the frame loop.
+ */
+
+const query = new URLSearchParams(location.search);
+
+const number = (name, fallback) => {
+    const value = Number(query.get(name));
+
+    return query.has(name) && Number.isFinite(value) ? value : fallback;
+};
+
+const COUNT = Math.max(1, Math.floor(number("n", 64)));
+const MAX_AGE = number("age", 2);
+/** Radial segments, one value or a comma list the trails take in turn: each distinct value is its own draw. */
+const RADIALS = (query.get("radial") ?? "8").split(",").map(v => Math.max(3, Math.floor(Number(v) || 8)));
+const WIDTH = number("width", 0.08);
+
+/** Trails per row of the field. */
+const ROW = Math.ceil(Math.sqrt(COUNT));
+
+/** Spacing of the field. */
+const SPACING = 3;
+
+const element = id => document.getElementById(id);
+
+const view_size = () => [Math.max(1, window.innerWidth), Math.max(1, window.innerHeight)];
+
+/**
+ * Where trail `i` is at time `t`: a figure-of-eight round its own place in the field, each at its own
+ * phase, rising and falling.
+ *
+ * @param {number} i
+ * @param {number} t
+ * @param {number[]} out
+ */
+function place(i, t, out) {
+    const column = i % ROW;
+    const row = Math.floor(i / ROW);
+
+    const phase = i * 0.6180339 * Math.PI * 2;
+    const a = phase + t * 1.3;
+
+    out[0] = (column - (ROW - 1) * 0.5) * SPACING + Math.sin(a) * 1.2;
+    out[1] = 1.5 + Math.sin(a * 2 + phase) * 0.5;
+    out[2] = (row - (ROW - 1) * 0.5) * SPACING + Math.sin(a * 2) * 0.8;
+}
+
+/**
+ * A colour per trail, bright and linear.
+ *
+ * @param {number} i
+ * @returns {number[]}
+ */
+function tint(i) {
+    const h = (i * 0.137) % 1;
+    const k = n => (n + h * 6) % 6;
+    const f = n => 1 - Math.max(0, Math.min(k(n), 4 - k(n), 1));
+
+    return [f(5) * 2, f(3) * 2, f(1) * 2];
+}
+
+async function main() {
+    const graphics = new GraphicsEngine();
+    const scene = new Scene();
+
+    graphics.set_scene(scene);
+
+    element("viewport").appendChild(graphics.viewport.el);
+
+    const [width, height] = view_size();
+
+    graphics.viewport.size.set(width, height);
+
+    const dataset = new EntityComponentDataset();
+    const entities = new EntityManager();
+
+    const system = new Trail3DSystem(graphics, scene);
+
+    entities.addSystem(system);
+    entities.attachDataset(dataset);
+
+    await new Promise((resolve, reject) => entities.startup(resolve, reject));
+
+    const transforms = [];
+    const position = [0, 0, 0];
+
+    for (let i = 0; i < COUNT; i++) {
+        const trail = new Trail3D();
+
+        trail.maxAge = MAX_AGE;
+        trail.width = WIDTH;
+        trail.radialSegments = RADIALS[i % RADIALS.length];
+
+        const [r, g, b] = tint(i);
+
+        trail.color.set(r, g, b, 0.9);
+
+        const transform = new Transform64();
+
+        place(i, 0, position);
+        transform.setTranslation(position[0], position[1], position[2]);
+        transform.updateMatrix();
+
+        const entity = new Entity().add(transform).add(trail).build(dataset);
+
+        transforms.push({ entity, transform });
+    }
+
+    const camera = graphics.camera.camera;
+    const extent = ROW * SPACING;
+
+    camera.near = 0.05;
+    camera.far = 1000;
+    camera.fov = 50 * DEG_TO_RAD;
+
+    const controller = new OrbitalCameraController(camera, document.body);
+
+    controller.look(new Vector3(0, extent * 0.55 + 4, extent * 0.75 + 6), new Vector3(0, 1.5, 0));
+
+    graphics.on.contextFailed.add(failure => show_message("There will be no rendering.\n\n" + failure.message));
+
+    try {
+        await graphics.start();
+    } catch (e) {
+        console.error(e);
+        return;
+    }
+
+    const renderer = graphics.renderer;
+
+    /** What the device reported on its own: validation failures and the like. */
+    const gpu_errors = [];
+
+    renderer.graphics.device.addEventListener("uncapturederror", event => {
+        gpu_errors.push(event.error.message);
+        console.error(event.error.message);
+    });
+
+    renderer.transparency_mode = ShadeTransparencyMode.AVBOIT;
+    renderer.feature_automatic_exposure_enabled = false;
+    renderer.exposure_compensation = 0;
+
+    let time = 0;
+    let frame_index = 0;
+
+    /** Frames the renderer drew: none while its pipelines compile. */
+    let drawn = 0;
+
+    /** CPU milliseconds of the last frames: the tick and the render call. */
+    const cpu_ms = [];
+
+    function frame(dt) {
+        const [w, h] = view_size();
+
+        if (w !== graphics.viewport.size.x || h !== graphics.viewport.size.y) {
+            graphics.viewport.size.set(w, h);
+        }
+
+        time += dt;
+
+        for (let i = 0; i < transforms.length; i++) {
+            const { entity, transform } = transforms[i];
+
+            place(i, time, position);
+            transform.setTranslation(position[0], position[1], position[2]);
+            transform.updateMatrix();
+
+            t64_announce_change(dataset, entity);
+        }
+
+        controller.update();
+
+        const t0 = performance.now();
+
+        entities.update(dt);
+        if (graphics.render(dt)) {
+            drawn++;
+        }
+
+        cpu_ms.push(performance.now() - t0);
+
+        if (cpu_ms.length > 600) {
+            cpu_ms.shift();
+        }
+
+        frame_index++;
+
+        if (frame_index % 30 === 0) {
+            const sorted = [...cpu_ms].sort((a, b) => a - b);
+
+            element("hud").textContent = `${COUNT} trails · ${MAX_AGE} s · radial ${RADIALS.join(",")} · `
+                + `CPU ${sorted[Math.floor(sorted.length / 2)].toFixed(2)} ms/frame (median)`;
+        }
+    }
+
+    Object.assign(globalThis, {
+        graphics, renderer, scene, dataset, entities, system, camera, controller, Vector3,
+        __cpu_ms: cpu_ms,
+        __gpu_errors: gpu_errors,
+        __frame_index: () => frame_index,
+        __drawn: () => drawn,
+        __seek: t => {
+            time = t;
+        },
+    });
+
+    if (query.has("debug")) {
+        globalThis.__step = (n = 1, dt = 1 / 60) => {
+            for (let i = 0; i < n; i++) {
+                frame(dt);
+            }
+
+            return frame_index;
+        };
+
+        globalThis.__ready = true;
+
+        return;
+    }
+
+    globalThis.__ready = true;
+
+    create_frame_loop(dt => frame(Math.min(dt, 0.05)));
+}
+
+function show_message(text) {
+    const node = element("message");
+
+    if (node !== null) {
+        node.textContent = text;
+    }
+}
+
+main().catch(e => {
+    console.error(e);
+    show_message("The trails playground failed to start — see the console.\n\n" + e.message);
+});

package/src/shade/playground/water_surface/main.js

@@ -62,9 +62,9 @@ async function main() {
     sun_pose.setRotation(rotation.x, rotation.y, rotation.z, rotation.w); sun_pose.updateMatrix();
     new Entity().add(sun).add(sun_pose).build(dataset);
 
-    // the weather: a steady wind the air relaxes to over two seconds, and a gust on top of it
+    // the weather: a steady wind the air relaxes to over two seconds, and turbulence on top of it
     const weather = new GlobalFluidEffector();
-    weather.drag = 0.5; weather.gust_period = 4;
+    weather.drag = 0.5;
     const effectors = new FluidEffectorsComponent(); effectors.addEffector(weather);
     new Entity().add(effectors).build(dataset);
     // the fluid's domain sits on the stop's body, so the wind 10 m above it is the fluid's, not the far field's alone
@@ -86,7 +86,10 @@ async function main() {
     function configure() {
         const heading = number("direction") * Math.PI / 180;
         weather.wind = [number("wind") * Math.cos(heading), 0, number("wind") * Math.sin(heading)];
-        weather.gust = number("gust");
+        // the gust slider is the turbulence's rms; its strongest eddies go by every 4 s
+        const speed = number("wind");
+        weather.turbulence_intensity = speed > 0 ? number("gust") / speed : 0;
+        weather.turbulence_length = speed > 0 ? speed * 4 / 4.05 : weather.turbulence_length;
         describe_wind();
     }
     const far = new Float64Array(3);

package/src/shade/renderer/animation/GPUAnimationManager.js

@@ -1660,7 +1660,7 @@ export class GPUAnimationManager {
 
                 driving.set(target, clips);
 
-                if (!this.#foliage_rigs_driving.has(target)) {
+                if (!this.#foliage_rigs_driving.has(target)) {
                     gpu_authority_declare(dataset, target);
                     /*
                      The first clip to drive a joint takes its offset, and with it the joint's world
@@ -2893,7 +2893,7 @@ export class GPUAnimationManager {
                 this.#scene_context.wind.bind(bindings);
                 const switches = ShaderSwitchSet.EMPTY.with(
                     WIND_FIELD_UNIFORM,
-                    this.#scene_context.wind.cascade_count === 0
+                    this.#scene_context.wind.is_uniform
                 );
                 shader_foliage_wind_apply.variant(switches).dispatch({
                     encoder: ctx.encoder,

package/src/shade/renderer/animation/animation_curve_write_keys.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Write a curve's keys into `out` at float index `at`, laid out as `ANIMATION_CURVE_KEYFRAME_STRUCT`, the
+ * form `chunk_animation_curve_evaluate_keys` reads them in.
+ *
+ * @param {Float32Array} out
+ * @param {number} at float index
+ * @param {import("../../../engine/animation/curve/AnimationCurve.js").AnimationCurve} curve
+ * @returns {number} the float index after the curve's keys
+ */
+export function animation_curve_write_keys(out: Float32Array, at: number, curve: import("../../../engine/animation/curve/AnimationCurve.js").AnimationCurve): number;
+/**
+ * Floats of one keyframe in an `ANIMATION_CURVE_KEYFRAME_STRUCT` array: time, value, in tangent, out
+ * tangent.
+ *
+ * @type {number}
+ */
+export const ANIMATION_CURVE_KEYFRAME_FLOATS: number;
+//# sourceMappingURL=animation_curve_write_keys.d.ts.map

package/src/shade/renderer/animation/animation_curve_write_keys.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"animation_curve_write_keys.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/animation/animation_curve_write_keys.js"],"names":[],"mappings":"AAQA;;;;;;;;GAQG;AACH,gDALW,YAAY,MACZ,MAAM,SACN,OAAO,mDAAmD,EAAE,cAAc,GACxE,MAAM,CAkBlB;AAjCD;;;;;GAKG;AACH,8CAFU,MAAM,CAEiC"}

package/src/shade/renderer/animation/animation_curve_write_keys.js

@@ -0,0 +1,34 @@
+/**
+ * Floats of one keyframe in an `ANIMATION_CURVE_KEYFRAME_STRUCT` array: time, value, in tangent, out
+ * tangent.
+ *
+ * @type {number}
+ */
+export const ANIMATION_CURVE_KEYFRAME_FLOATS = 4;
+
+/**
+ * Write a curve's keys into `out` at float index `at`, laid out as `ANIMATION_CURVE_KEYFRAME_STRUCT`, the
+ * form `chunk_animation_curve_evaluate_keys` reads them in.
+ *
+ * @param {Float32Array} out
+ * @param {number} at float index
+ * @param {import("../../../engine/animation/curve/AnimationCurve.js").AnimationCurve} curve
+ * @returns {number} the float index after the curve's keys
+ */
+export function animation_curve_write_keys(out, at, curve) {
+    const keys = curve.keys;
+    const count = keys.length;
+
+    for (let i = 0; i < count; i++) {
+        const key = keys[i];
+
+        out[at] = key.time;
+        out[at + 1] = key.value;
+        out[at + 2] = key.inTangent;
+        out[at + 3] = key.outTangent;
+
+        at += ANIMATION_CURVE_KEYFRAME_FLOATS;
+    }
+
+    return at;
+}

package/src/shade/renderer/animation/skinning/GPUMeshSkinningContext.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUMeshSkinningContext.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/animation/skinning/GPUMeshSkinningContext.js"],"names":[],"mappings":"AAmFA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH;IAgNI;;;;;;;OAOG;IACH,sEAPW;QACV,UAAgB,EAAE,kBAAkB,CAAC;QACrC,iBAAuB,EAAE,mBAAmB,CAAC;QAC7C,aAAmB,EAAE,eAAe,CAAC;QACrC,MAAY,YAAY;KACrB,EAcH;IAED;;;;;;OAMG;IACH,iCAEC;IAED;;;;;;;OAOG;IACH,yCAEC;IAED;;;;;;OAMG;IACH,2BAEC;IAED;;;;;OAKG;IACH,4BAEC;IAED;;;;;;;OAOG;IACH,wCAEC;IAED;;;;;;;;;;;;OAYG;IACH,qBAJW,MAAM,YACN,eAAe,GACb,mBAAmB,CAqB/B;IAED;;;;;OAKG;IACH,iBAHW,MAAM,GACJ,mBAAmB,GAAC,SAAS,CAMzC;IAED;;;;;;;;;;OAUG;IACH,aAHW,MAAM,WACN,MAAM,QAwBhB;IAED;;;;;;;OAOG;IACH,oBAHW,MAAM,GACJ,MAAM,GAAC,SAAS,CAI5B;IAED;;;;;;;;;;OAUG;IACH,eAFW,MAAM,QAYhB;IAED;;;;;;;;;;;;;OAaG;IACH,4BAFW,MAAM,QAehB;IA4FD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6BG;IACH,sBAFW,MAAM,QAqBhB;IAuBD;;;;;;;;;;;;;;;;;OAiBG;IACH,gBAJW,sBAAsB,GACpB,OAAO,CA+NnB;IAmXD;;;;;;;OAOG;IACH,gBA+BC;;CACJ;qCAzyCY,OAAO,2CAA2C,EAAE,sBAAsB;iCAC1E,OAAO,sCAAsC,EAAE,kBAAkB;8BACjE,OAAO,gCAAgC,EAAE,eAAe;8BACxD,OAAO,mCAAmC,EAAE,eAAe;kCAC3D,OAAO,uCAAuC,EAAE,mBAAmB;kCACnE,OAAO,2BAA2B,EAAE,mBAAmB"}
+{"version":3,"file":"GPUMeshSkinningContext.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/animation/skinning/GPUMeshSkinningContext.js"],"names":[],"mappings":"AAmFA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH;IAgNI;;;;;;;OAOG;IACH,sEAPW;QACV,UAAgB,EAAE,kBAAkB,CAAC;QACrC,iBAAuB,EAAE,mBAAmB,CAAC;QAC7C,aAAmB,EAAE,eAAe,CAAC;QACrC,MAAY,YAAY;KACrB,EAcH;IAED;;;;;;OAMG;IACH,iCAEC;IAED;;;;;;;OAOG;IACH,yCAEC;IAED;;;;;;OAMG;IACH,2BAEC;IAED;;;;;OAKG;IACH,4BAEC;IAED;;;;;;;OAOG;IACH,wCAEC;IAED;;;;;;;;;;;;OAYG;IACH,qBAJW,MAAM,YACN,eAAe,GACb,mBAAmB,CAqB/B;IAED;;;;;OAKG;IACH,iBAHW,MAAM,GACJ,mBAAmB,GAAC,SAAS,CAMzC;IAED;;;;;;;;;;OAUG;IACH,aAHW,MAAM,WACN,MAAM,QAwBhB;IAED;;;;;;;OAOG;IACH,oBAHW,MAAM,GACJ,MAAM,GAAC,SAAS,CAI5B;IAED;;;;;;;;;;OAUG;IACH,eAFW,MAAM,QAYhB;IAED;;;;;;;;;;;;;OAaG;IACH,4BAFW,MAAM,QAehB;IA4FD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6BG;IACH,sBAFW,MAAM,QAqBhB;IAuBD;;;;;;;;;;;;;;;;;OAiBG;IACH,gBAJW,sBAAsB,GACpB,OAAO,CA8NnB;IAmXD;;;;;;;OAOG;IACH,gBA+BC;;CACJ;qCAxyCY,OAAO,2CAA2C,EAAE,sBAAsB;iCAC1E,OAAO,sCAAsC,EAAE,kBAAkB;8BACjE,OAAO,gCAAgC,EAAE,eAAe;8BACxD,OAAO,mCAAmC,EAAE,eAAe;kCAC3D,OAAO,uCAAuC,EAAE,mBAAmB;kCACnE,OAAO,2BAA2B,EAAE,mBAAmB"}

package/src/shade/renderer/animation/skinning/GPUMeshSkinningContext.js

@@ -108,8 +108,8 @@ const MESHLET_STRIDE_BYTES = MESHLET_METADATA_STRUCT.aligned_size;
  * manager. Resolution happens at upload time via
  * `animation_manager.get_skin_matrix_offset(skin_id)`.
  */
-export class GPUMeshSkinningContext {
-
+export class GPUMeshSkinningContext {
+
     /** @type {GPUDevice} */
     #device;
 
@@ -931,10 +931,9 @@ export class GPUMeshSkinningContext {
         // longer in: rays miss where the mesh now is and hit where it no longer is.
         //
         // Topology is untouched. Refitting a tree whose triangles moved but whose shape did not is
-        // a fraction of the full build's sort-and-emit — which is why a clone gets a copy of the
-        // source's nodes rather than a build of its own. And it is one batch for every clone at
-        // once, not a dispatch per clone: the command count is the same for one skinned mesh as
-        // for three hundred, and each tree's climb overlaps the next's instead of waiting on it.
+        // a fraction of a build — which is why a clone gets a copy of the source's nodes rather
+        // than a build of its own. And it is one batch for every clone at once, not a dispatch per
+        // clone: the command count is the same for one skinned mesh as for three hundred.
         this.#record_blas_refits(cmd_ctx);
 
         // every bound mesh's clone was deformed this frame, so every bound row's bounds moved
@@ -948,8 +947,8 @@ export class GPUMeshSkinningContext {
      * are resident, and where, the batch asks the BLAS manager — and only when the manager says the
      * answer may have moved.
      *
-     * Recorded here and nowhere else, on purpose: the batch binds the manager's arena buffers as
-     * they are at this moment, and those are replaced when an arena grows in the geometry update,
+     * Recorded here and nowhere else, on purpose: the batch binds the manager's arena buffer as
+     * it is at this moment, and that is replaced when the arena grows in the geometry update,
      * which runs before this frame's command context exists. See {@link GPUBLASRefitBatch}.
      *
      * @param {ShadeGPUCommandContext} cmd_ctx

package/src/shade/renderer/deferred/tonemap/ColorGrade.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ColorGrade.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/deferred/tonemap/ColorGrade.js"],"names":[],"mappings":"AAOA;;;;;;;;;;;;;;;GAeG;AACH,8CA2BG;AAEH;;;GAGG;AACH,wCAFU,MAAM,CAE4B;AAE5C;;;GAGG;AACH,qCAFU,MAAM,CAEwB;AAExC;;;GAGG;AACH;IACI;;;;OAIG;IACH,qBAFU,OAAO,CAEoB;IAErC;;;;OAIG;IACH,mBAFU,OAAO,CAEkB;IAEnC;;;;OAIG;IACH,gBAFU,OAAO,CAEe;IAEhC;;;OAGG;IACH,eAFU,OAAO,CAEc;IAE/B;;;;OAIG;IACH,iBAFU,OAAO,CAEgB;CACpC;AAwED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH;IACI;;;OAGG;IACH,mBAFU,MAAM,CAEsC;IAEtD;;;OAGG;IACH,YAFU,MAAM,CAEwB;IAExC;;;;OAIG;IACH,iBAFU,cAAc,CAEM;IAE9B;;;OAGG;IACH,kBAFU,cAAc,CAEO;IAE/B;;;OAGG;IACH,mBAFU,cAAc,CAEQ;IAEhC;;;OAGG;IACH,qBAFU,cAAc,CAEU;IAElC;;;OAGG;IACH,aAFU,MAAM,CAEG;IAEnB;;;OAGG;IACH,gBAFU,MAAM,CAEK;IAErB;;;OAGG;IACH,gBAFU,MAAM,CAEG;IAEnB;;;;OAIG;IACH,oBAFU,cAAc,CAES;IAEjC;;;;OAIG;IACH,yBAFU,cAAc,CAEc;IAEtC;;;;OAIG;IACH,wBAFU,cAAc,CAEa;IAErC;;;;;OAKG;IACH,0BAFU,cAAc,CAEe;IAEvC;;;;;OAKG;IACH,8BAFU,cAAc,CAEmB;IAE3C;;;;;OAKG;IACH,gCAFU,cAAc,CAEqB;IAE7C;;;;;OAKG;IACH,+BAFU,cAAc,CAEoB;IAE5C;;;;OAIG;IACH,wBAFU,cAAc,CAEa;IAErC;;;;OAIG;IACH,0BAFU,cAAc,CAEe;IAEvC;;;;OAIG;IACH,yBAFU,cAAc,CAEc;IAEtC;;;;OAIG;IACH,wBAFU,cAAc,CAEa;IAarC;;;;;;;OAOG;IACH,QAFa,YAAY,CAgFxB;;CACJ;6BAtb4B,mCAAmC;wBAHxC,kCAAkC;+BAC3B,sDAAsD"}
+{"version":3,"file":"ColorGrade.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/deferred/tonemap/ColorGrade.js"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;;;GAeG;AACH,8CA2BG;AAEH;;;GAGG;AACH,wCAFU,MAAM,CAE4B;AAE5C;;;GAGG;AACH,qCAFU,MAAM,CAEsD;AAEtE;;;GAGG;AACH;IACI;;;;OAIG;IACH,qBAFU,OAAO,CAEoB;IAErC;;;;OAIG;IACH,mBAFU,OAAO,CAEkB;IAEnC;;;;OAIG;IACH,gBAFU,OAAO,CAEe;IAEhC;;;OAGG;IACH,eAFU,OAAO,CAEc;IAE/B;;;;OAIG;IACH,iBAFU,OAAO,CAEgB;CACpC;AAgDD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH;IACI;;;OAGG;IACH,mBAFU,MAAM,CAEsC;IAEtD;;;OAGG;IACH,YAFU,MAAM,CAEwB;IAExC;;;;OAIG;IACH,iBAFU,cAAc,CAEM;IAE9B;;;OAGG;IACH,kBAFU,cAAc,CAEO;IAE/B;;;OAGG;IACH,mBAFU,cAAc,CAEQ;IAEhC;;;OAGG;IACH,qBAFU,cAAc,CAEU;IAElC;;;OAGG;IACH,aAFU,MAAM,CAEG;IAEnB;;;OAGG;IACH,gBAFU,MAAM,CAEK;IAErB;;;OAGG;IACH,gBAFU,MAAM,CAEG;IAEnB;;;;OAIG;IACH,oBAFU,cAAc,CAES;IAEjC;;;;OAIG;IACH,yBAFU,cAAc,CAEc;IAEtC;;;;OAIG;IACH,wBAFU,cAAc,CAEa;IAErC;;;;;OAKG;IACH,0BAFU,cAAc,CAEe;IAEvC;;;;;OAKG;IACH,8BAFU,cAAc,CAEmB;IAE3C;;;;;OAKG;IACH,gCAFU,cAAc,CAEqB;IAE7C;;;;;OAKG;IACH,+BAFU,cAAc,CAEoB;IAE5C;;;;OAIG;IACH,wBAFU,cAAc,CAEa;IAErC;;;;OAIG;IACH,0BAFU,cAAc,CAEe;IAEvC;;;;OAIG;IACH,yBAFU,cAAc,CAEc;IAEtC;;;;OAIG;IACH,wBAFU,cAAc,CAEa;IAarC;;;;;;;OAOG;IACH,QAFa,YAAY,CAgFxB;;CACJ;6BA9Z4B,mCAAmC;wBAJxC,kCAAkC;+BAC3B,sDAAsD"}

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

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

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

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

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

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

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

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

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

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

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

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

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

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