@woosh/meep-engine 3.13.1 → 3.14.1

package/src/engine/graphics3/HighlightSystem.d.ts

@@ -1,82 +1,19 @@
 /**
- * Outlines highlighted entities under Shade.
+ * @deprecated Renamed to {@link SGMeshHighlightSystem} and moved back beside the component it reads.
+ * The name said "highlight" where the tuple says `[Highlight, SGMesh]`, and one of the two systems
+ * that outline things is not the highlight system.
  *
- * **An outline is a neighbourhood test on the visibility buffer**, which already says which mesh
- * every pixel came from. The renderer this replaces drew each highlighted object a second time into
- * an id target of its own, dilated the mask across two ping-ponged render targets, blurred it, and
- * decoded ids back to colours — five render targets and a duplicated scene graph, for a picture this
- * gets from a texture the frame was already writing.
+ * **The class behind this name no longer owns the outline pass**, so a constructor call does not
+ * survive the rename: it is now `new SGMeshHighlightSystem(outline, meshes)` against a
+ * {@link HighlightOutlineSystem}, which is registered alongside it and does the drawing for every
+ * kind of highlighted thing. That is a change no alias can absorb — this one keeps `instanceof` and
+ * `EntityManager.getSystem` answering for callers still holding the old name.
  *
- * **Highlights no longer show through what stands in front of them (D27).** The old id pass cleared
- * the depth buffer, so a unit behind a building was outlined in full; the visibility buffer knows
- * only what was rasterized, so it is outlined where it can be seen and nowhere else. That is the
- * accepted cost of not drawing the scene twice.
- *
- * The table is rebuilt every frame, and that is the cheaper arrangement rather than a concession:
- * the game's highlights animate their colour and alpha continuously (0.2 s in, 0.7 s out), so
- * nothing would be saved by watching for changes — and a `Color`'s change signal does not fire for
- * alpha-only edits, which is exactly what this animation is.
- */
-export class HighlightSystem extends System<any> {
-    /**
-     * @param {GraphicsEngine} graphics
-     * @param {MeshSystem} meshes
-     */
-    constructor(graphics: GraphicsEngine, meshes: MeshSystem);
-    dependencies: (typeof SGMesh | typeof Highlight)[];
-    /**
-     * How wide the outline is drawn, in pixels.
-     *
-     * @type {number}
-     */
-    thickness: number;
-    /**
-     * What is highlighted. Read-only — highlights follow their entities.
-     *
-     * @returns {Array}
-     */
-    get highlights(): any[];
-    /**
-     * @returns {Uint32Array} the table the last update packed
-     */
-    get table(): Uint32Array;
-    /**
-     * @returns {number} rows of {@link table} in use
-     */
-    get table_size(): number;
-    startup(entityManager: any): Promise<void>;
-    shutdown(entityManager: any): Promise<void>;
-    /**
-     * @param {Highlight} highlight
-     * @param {SGMesh} mesh
-     * @param {number} entity
-     */
-    link(highlight: Highlight, mesh: SGMesh, entity: number): void;
-    /**
-     * @param {Highlight} highlight
-     * @param {SGMesh} mesh
-     * @param {number} entity
-     */
-    unlink(highlight: Highlight, mesh: SGMesh, entity: number): void;
-    /**
-     * @param {FrameContext} frame
-     */
-    record(frame: FrameContext): void;
-    #private;
-}
-/**
- * The outline is drawn into the scene, so the fog of war conceals it along with what it outlines.
+ * Kept as a re-export rather than removed: this is a library, and an import path is as much a
+ * published interface as a class name.
  */
-export class HighlightExtension extends RenderExtension {
-    /**
-     * @param {HighlightSystem} system
-     */
-    constructor(system: HighlightSystem);
-    record(frame: any): void;
-    #private;
-}
-import { System } from "../ecs/System.js";
-import { SGMesh } from "../graphics/ecs/mesh-v2/aggregate/SGMesh.js";
-import Highlight from "../graphics/ecs/highlight/Highlight.js";
-import { RenderExtension } from "../../shade/renderer/extension/RenderExtension.js";
+export const HighlightSystem: typeof SGMeshHighlightSystem;
+export { HighlightExtension };
+import { SGMeshHighlightSystem } from "../graphics/ecs/mesh-v2/aggregate/SGMeshHighlightSystem.js";
+import { HighlightExtension } from "./HighlightOutlineSystem.js";
 //# sourceMappingURL=HighlightSystem.d.ts.map

package/src/engine/graphics3/HighlightSystem.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"HighlightSystem.d.ts","sourceRoot":"","sources":["../../../../src/engine/graphics3/HighlightSystem.js"],"names":[],"mappings":"AAUA;;;;;;;;;;;;;;;;;;GAkBG;AACH;IA6EI;;;OAGG;IACH,0DAQC;IAxFD,mDAAmC;IA8CnC;;;;OAIG;IACH,WAFU,MAAM,CAEwB;IAExC;;;;OAIG;IACH,wBAEC;IAED;;OAEG;IACH,yBAEC;IAED;;OAEG;IACH,yBAEC;IAgBD,2CAIC;IAED,4CAYC;IAED;;;;OAIG;IACH,gBAJW,SAAS,QACT,MAAM,UACN,MAAM,QAOhB;IAED;;;;OAIG;IACH,kBAJW,SAAS,QACT,MAAM,UACN,MAAM,QAgBhB;IAmBD;;OAEG;IACH,kCAmBC;;CACJ;AAED;;GAEG;AACH;IAUI;;OAEG;IACH,oBAFW,eAAe,EAMzB;IAED,yBAEC;;CACJ;uBA7OsB,kBAAkB;uBAElB,6CAA6C;sBAD9C,wCAAwC;gCAF9B,mDAAmD"}
+{"version":3,"file":"HighlightSystem.d.ts","sourceRoot":"","sources":["../../../../src/engine/graphics3/HighlightSystem.js"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;GAaG;AACH,2DAAqD;;sCAjB9C,4DAA4D;mCAChC,6BAA6B"}

package/src/engine/graphics3/HighlightSystem.js

@@ -1,241 +1,27 @@
-import { assert } from "../../core/assert.js";
-import { FramePhase } from "../../shade/renderer/extension/FramePhase.js";
-import { RenderExtension } from "../../shade/renderer/extension/RenderExtension.js";
-import { System } from "../ecs/System.js";
-import Highlight from "../graphics/ecs/highlight/Highlight.js";
-import { SGMesh } from "../graphics/ecs/mesh-v2/aggregate/SGMesh.js";
-import { GPUHighlightRenderer } from "./highlight/GPUHighlightRenderer.js";
-import { HIGHLIGHT_OUTLINE_THICKNESS } from "./highlight/HIGHLIGHT_OUTLINE.js";
-import { pack_highlight_table } from "./highlight/pack_highlight_table.js";
+import {
+    SGMeshHighlightSystem
+} from "../graphics/ecs/mesh-v2/aggregate/SGMeshHighlightSystem.js";
+import { HighlightExtension } from "./HighlightOutlineSystem.js";
 
 /**
- * Outlines highlighted entities under Shade.
+ * @deprecated Renamed to {@link SGMeshHighlightSystem} and moved back beside the component it reads.
+ * The name said "highlight" where the tuple says `[Highlight, SGMesh]`, and one of the two systems
+ * that outline things is not the highlight system.
  *
- * **An outline is a neighbourhood test on the visibility buffer**, which already says which mesh
- * every pixel came from. The renderer this replaces drew each highlighted object a second time into
- * an id target of its own, dilated the mask across two ping-ponged render targets, blurred it, and
- * decoded ids back to colours — five render targets and a duplicated scene graph, for a picture this
- * gets from a texture the frame was already writing.
+ * **The class behind this name no longer owns the outline pass**, so a constructor call does not
+ * survive the rename: it is now `new SGMeshHighlightSystem(outline, meshes)` against a
+ * {@link HighlightOutlineSystem}, which is registered alongside it and does the drawing for every
+ * kind of highlighted thing. That is a change no alias can absorb — this one keeps `instanceof` and
+ * `EntityManager.getSystem` answering for callers still holding the old name.
  *
- * **Highlights no longer show through what stands in front of them (D27).** The old id pass cleared
- * the depth buffer, so a unit behind a building was outlined in full; the visibility buffer knows
- * only what was rasterized, so it is outlined where it can be seen and nowhere else. That is the
- * accepted cost of not drawing the scene twice.
- *
- * The table is rebuilt every frame, and that is the cheaper arrangement rather than a concession:
- * the game's highlights animate their colour and alpha continuously (0.2 s in, 0.7 s out), so
- * nothing would be saved by watching for changes — and a `Color`'s change signal does not fire for
- * alpha-only edits, which is exactly what this animation is.
+ * Kept as a re-export rather than removed: this is a library, and an import path is as much a
+ * published interface as a class name.
  */
-export class HighlightSystem extends System {
-    dependencies = [Highlight, SGMesh];
-
-    /**
-     * @type {GraphicsEngine}
-     */
-    #graphics;
-
-    /**
-     * @type {MeshSystem}
-     */
-    #meshes;
-
-    /**
-     * @type {GPUHighlightRenderer}
-     */
-    #renderer = new GPUHighlightRenderer();
-
-    /**
-     * Highlighted entities, in link order.
-     *
-     * @type {Array<{entity: number, highlight: Highlight}>}
-     */
-    #entries = [];
-
-    /**
-     * @type {Map<number, object>}
-     */
-    #by_entity = new Map();
-
-    /**
-     * One packed rgba8 colour per mesh row, indexed by the row the visibility buffer writes.
-     *
-     * @type {Uint32Array}
-     */
-    #table = new Uint32Array(0);
-
-    /**
-     * @type {number}
-     */
-    #table_size = 0;
-
-    /**
-     * @type {RenderExtension|null}
-     */
-    #extension = null;
-
-    /**
-     * How wide the outline is drawn, in pixels.
-     *
-     * @type {number}
-     */
-    thickness = HIGHLIGHT_OUTLINE_THICKNESS;
-
-    /**
-     * What is highlighted. Read-only — highlights follow their entities.
-     *
-     * @returns {Array}
-     */
-    get highlights() {
-        return this.#entries;
-    }
-
-    /**
-     * @returns {Uint32Array} the table the last update packed
-     */
-    get table() {
-        return this.#table;
-    }
-
-    /**
-     * @returns {number} rows of {@link table} in use
-     */
-    get table_size() {
-        return this.#table_size;
-    }
-
-    /**
-     * @param {GraphicsEngine} graphics
-     * @param {MeshSystem} meshes
-     */
-    constructor(graphics, meshes) {
-        super();
-
-        assert.defined(graphics, 'graphics');
-        assert.defined(meshes, 'meshes');
-
-        this.#graphics = graphics;
-        this.#meshes = meshes;
-    }
-
-    async startup(entityManager) {
-        this.entityManager = entityManager;
-
-        this.#extension = this.#graphics.add_extension(new HighlightExtension(this));
-    }
-
-    async shutdown(entityManager) {
-        if (this.#extension !== null) {
-            this.#graphics.remove_extension(this.#extension);
-
-            this.#extension = null;
-        }
-
-        this.#renderer.destroy();
-
-        this.#entries.length = 0;
-        this.#by_entity.clear();
-        this.#table_size = 0;
-    }
-
-    /**
-     * @param {Highlight} highlight
-     * @param {SGMesh} mesh
-     * @param {number} entity
-     */
-    link(highlight, mesh, entity) {
-        const entry = { entity, highlight };
-
-        this.#entries.push(entry);
-        this.#by_entity.set(entity, entry);
-    }
-
-    /**
-     * @param {Highlight} highlight
-     * @param {SGMesh} mesh
-     * @param {number} entity
-     */
-    unlink(highlight, mesh, entity) {
-        const entry = this.#by_entity.get(entity);
-
-        if (entry === undefined) {
-            return;
-        }
-
-        const index = this.#entries.indexOf(entry);
-
-        if (index !== -1) {
-            this.#entries.splice(index, 1);
-        }
-
-        this.#by_entity.delete(entity);
-    }
-
-    /**
-     * Pack this frame's table. See {@link pack_highlight_table} for why it is every frame.
-     *
-     * @param {GPUSceneContext} scene
-     */
-    #pack(scene) {
-        const packed = pack_highlight_table({
-            entries: this.#entries,
-            meshes: this.#meshes,
-            scene,
-            table: this.#table
-        });
-
-        this.#table = packed.table;
-        this.#table_size = packed.size;
-    }
-
-    /**
-     * @param {FrameContext} frame
-     */
-    record(frame) {
-        if (this.#entries.length === 0) {
-            // nothing highlighted, so the frame keeps the colour it had and pays nothing
-            return;
-        }
-
-        this.#pack(frame.view.scene);
-
-        if (this.#table_size === 0) {
-            // highlighted entities whose models are not in the scene yet
-            return;
-        }
-
-        this.#renderer.graph_draw({
-            frame,
-            table: this.#table,
-            table_size: this.#table_size,
-            thickness: this.thickness
-        });
-    }
-}
+export const HighlightSystem = SGMeshHighlightSystem;
 
 /**
- * The outline is drawn into the scene, so the fog of war conceals it along with what it outlines.
+ * Re-exported because this is where it was published from, and because it is the ordering token
+ * `FogOfWarExtension` and anything else sequencing against the outline names. It lives in
+ * {@link HighlightOutlineSystem}'s file now, with the pass it registers.
  */
-export class HighlightExtension extends RenderExtension {
-    name = "highlight";
-
-    phase = FramePhase.AfterTransparency;
-
-    /**
-     * @type {HighlightSystem}
-     */
-    #system;
-
-    /**
-     * @param {HighlightSystem} system
-     */
-    constructor(system) {
-        super();
-
-        this.#system = system;
-    }
-
-    record(frame) {
-        this.#system.record(frame);
-    }
-}
+export { HighlightExtension };

package/src/engine/graphics3/HighlightSystem3.d.ts

@@ -1,10 +1,13 @@
 /**
- * @deprecated Renamed to {@link HighlightSystem}. The trailing `3` marked the 2.x → 3.x renderer transition;
- * the 2.x name it disambiguated against is gone, so the suffix no longer distinguishes anything.
+ * @deprecated Renamed to {@link SGMeshHighlightSystem}. The trailing `3` marked the 2.x → 3.x renderer
+ * transition; the 2.x name it disambiguated against is gone, so the suffix no longer distinguishes
+ * anything. It pointed at `HighlightSystem` for one release, which is itself now a deprecated alias
+ * of the same class — this chains straight through rather than through that, so there is one hop
+ * from either old name.
  *
  * Kept as a re-export rather than removed: this is a library, and an import path is as much a
  * published interface as a class name.
  */
-export const HighlightSystem3: typeof HighlightSystem;
-import { HighlightSystem } from "./HighlightSystem.js";
+export const HighlightSystem3: typeof SGMeshHighlightSystem;
+import { SGMeshHighlightSystem } from "../graphics/ecs/mesh-v2/aggregate/SGMeshHighlightSystem.js";
 //# sourceMappingURL=HighlightSystem3.d.ts.map

package/src/engine/graphics3/HighlightSystem3.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"HighlightSystem3.d.ts","sourceRoot":"","sources":["../../../../src/engine/graphics3/HighlightSystem3.js"],"names":[],"mappings":"AAEA;;;;;;GAMG;AACH,sDAAgD;gCAThB,sBAAsB"}
+{"version":3,"file":"HighlightSystem3.d.ts","sourceRoot":"","sources":["../../../../src/engine/graphics3/HighlightSystem3.js"],"names":[],"mappings":"AAIA;;;;;;;;;GASG;AACH,4DAAsD;sCAZ/C,4DAA4D"}

package/src/engine/graphics3/HighlightSystem3.js

@@ -1,10 +1,15 @@
-import { HighlightSystem } from "./HighlightSystem.js";
-
-/**
- * @deprecated Renamed to {@link HighlightSystem}. The trailing `3` marked the 2.x → 3.x renderer transition;
- * the 2.x name it disambiguated against is gone, so the suffix no longer distinguishes anything.
- *
- * Kept as a re-export rather than removed: this is a library, and an import path is as much a
- * published interface as a class name.
- */
-export const HighlightSystem3 = HighlightSystem;
+import {
+    SGMeshHighlightSystem
+} from "../graphics/ecs/mesh-v2/aggregate/SGMeshHighlightSystem.js";
+
+/**
+ * @deprecated Renamed to {@link SGMeshHighlightSystem}. The trailing `3` marked the 2.x → 3.x renderer
+ * transition; the 2.x name it disambiguated against is gone, so the suffix no longer distinguishes
+ * anything. It pointed at `HighlightSystem` for one release, which is itself now a deprecated alias
+ * of the same class — this chains straight through rather than through that, so there is one hop
+ * from either old name.
+ *
+ * Kept as a re-export rather than removed: this is a library, and an import path is as much a
+ * published interface as a class name.
+ */
+export const HighlightSystem3 = SGMeshHighlightSystem;

package/src/engine/graphics3/highlight/pack_highlight_table.d.ts

@@ -2,9 +2,16 @@
  * Build the lookup the outline shader reads: one packed colour per mesh row, addressed by the row
  * the visibility buffer writes.
  *
- * **The scene decides the indices.** A highlight is attached to an entity, an entity's model is
- * several nodes, and each node that carries geometry has a row — so the walk is entity → nodes →
- * rows, and an entity whose model has not loaded contributes none and needs no special case.
+ * **The scene decides the indices, and each entry decides which of them are its own.** A highlight
+ * is attached to an entity, and what that entity has in the scene depends on what kind of thing it
+ * is — a model is many nodes the mesh system holds, a primitive is the one node its own component
+ * carries. Neither is this function's business: an entry arrives already knowing how to walk to its
+ * nodes, so the walk here is entry → nodes → rows and there is no kind to switch on. An entity
+ * whose model has not loaded walks to nothing and needs no special case.
+ *
+ * **A row holds one colour.** Where two entries reach the same node — a highlighted model and a
+ * separately highlighted primitive inside it — the later entry wins, which is link order. Nothing
+ * blends there, because the outline is drawn from the table and the table has one word per row.
  *
  * Rebuilt every frame, which is the cheaper arrangement and not a concession: the game's highlights
  * animate colour and alpha continuously, so nothing is saved by watching for changes — and a
@@ -12,19 +19,17 @@
  * is.
  *
  * @param {object} args
- * @param {Array<{entity: number, highlight: Highlight}>} args.entries
- * @param {MeshSystem} args.meshes resolves an entity to the nodes it has in the scene
+ * @param {Array<{highlight: Highlight, traverse: function(function(Mesh): void): void}>} args.entries
  * @param {GPUSceneContext} args.scene resolves a node to its row
  * @param {Uint32Array} args.table reused between frames; replaced when it is too small
  * @returns {{table: Uint32Array, size: number}} `size` is one past the highest row written, and is
  * zero when nothing highlighted is in the scene
  */
-export function pack_highlight_table({ entries, meshes, scene, table }: {
+export function pack_highlight_table({ entries, scene, table }: {
     entries: Array<{
-        entity: number;
         highlight: Highlight;
+        traverse: (arg0: (arg0: Mesh) => void) => void;
     }>;
-    meshes: MeshSystem;
     scene: GPUSceneContext;
     table: Uint32Array;
 }): {

package/src/engine/graphics3/highlight/pack_highlight_table.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"pack_highlight_table.d.ts","sourceRoot":"","sources":["../../../../../src/engine/graphics3/highlight/pack_highlight_table.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH;IAP+D,OAAO,EAA3D,MAAM;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,SAAS,YAAW;KAAC,CAAC;IAC5B,MAAM;IACD,KAAK;IACT,KAAK,EAAvB,WAAW;;WACD,WAAW;UAAQ,MAAM;EAqD7C"}
+{"version":3,"file":"pack_highlight_table.d.ts","sourceRoot":"","sources":["../../../../../src/engine/graphics3/highlight/pack_highlight_table.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH;IAN+F,OAAO,EAA3F,MAAM;QAAC,SAAS,YAAY;QAAC,QAAQ,yBAA2B,IAAI,KAAG,IAAI,CAAA;KAAC,CAAC;IACvD,KAAK;IACT,KAAK,EAAvB,WAAW;;WACD,WAAW;UAAQ,MAAM;EAqD7C"}

package/src/engine/graphics3/highlight/pack_highlight_table.js

@@ -4,9 +4,16 @@ import { pack_highlight_color } from "./pack_highlight_color.js";
  * Build the lookup the outline shader reads: one packed colour per mesh row, addressed by the row
  * the visibility buffer writes.
  *
- * **The scene decides the indices.** A highlight is attached to an entity, an entity's model is
- * several nodes, and each node that carries geometry has a row — so the walk is entity → nodes →
- * rows, and an entity whose model has not loaded contributes none and needs no special case.
+ * **The scene decides the indices, and each entry decides which of them are its own.** A highlight
+ * is attached to an entity, and what that entity has in the scene depends on what kind of thing it
+ * is — a model is many nodes the mesh system holds, a primitive is the one node its own component
+ * carries. Neither is this function's business: an entry arrives already knowing how to walk to its
+ * nodes, so the walk here is entry → nodes → rows and there is no kind to switch on. An entity
+ * whose model has not loaded walks to nothing and needs no special case.
+ *
+ * **A row holds one colour.** Where two entries reach the same node — a highlighted model and a
+ * separately highlighted primitive inside it — the later entry wins, which is link order. Nothing
+ * blends there, because the outline is drawn from the table and the table has one word per row.
  *
  * Rebuilt every frame, which is the cheaper arrangement and not a concession: the game's highlights
  * animate colour and alpha continuously, so nothing is saved by watching for changes — and a
@@ -14,14 +21,13 @@ import { pack_highlight_color } from "./pack_highlight_color.js";
  * is.
  *
  * @param {object} args
- * @param {Array<{entity: number, highlight: Highlight}>} args.entries
- * @param {MeshSystem} args.meshes resolves an entity to the nodes it has in the scene
+ * @param {Array<{highlight: Highlight, traverse: function(function(Mesh): void): void}>} args.entries
  * @param {GPUSceneContext} args.scene resolves a node to its row
  * @param {Uint32Array} args.table reused between frames; replaced when it is too small
  * @returns {{table: Uint32Array, size: number}} `size` is one past the highest row written, and is
  * zero when nothing highlighted is in the scene
  */
-export function pack_highlight_table({ entries, meshes, scene, table }) {
+export function pack_highlight_table({ entries, scene, table }) {
     let highest = -1;
 
     /*
@@ -31,7 +37,7 @@ export function pack_highlight_table({ entries, meshes, scene, table }) {
      rather than over the scene.
     */
     for (let i = 0; i < entries.length; i++) {
-        meshes.traverse_meshes(entries[i].entity, node => {
+        entries[i].traverse(node => {
             const row = scene.mesh_row_of(node);
 
             if (row > highest) {
@@ -61,7 +67,7 @@ export function pack_highlight_table({ entries, meshes, scene, table }) {
             continue;
         }
 
-        meshes.traverse_meshes(entry.entity, node => {
+        entry.traverse(node => {
             const row = scene.mesh_row_of(node);
 
             if (row >= 0) {

package/src/engine/physics/fluid/ecs/FluidObstacleSystem.d.ts

@@ -64,11 +64,11 @@ export class FluidObstacleSystem extends System<any> {
     /**
      * @param {FluidComponent} fluid
      */
-    static "__#362@#refresh_masks"(fluid: FluidComponent): void;
+    static "__#364@#refresh_masks"(fluid: FluidComponent): void;
     /**
      * @param {FluidComponent} fluid
      */
-    static "__#362@#clear_field"(fluid: FluidComponent): void;
+    static "__#364@#clear_field"(fluid: FluidComponent): void;
     /**
      * Mark every cell of `fluid` whose centre lies within `inflation` of the
      * posed shape as solid. Iteration is clipped to the shape's world AABB
@@ -80,7 +80,7 @@ export class FluidObstacleSystem extends System<any> {
      * @param {number} inflation       world-units SDF threshold
      * @param {Float64Array} point     length-3 scratch
      */
-    static "__#362@#voxelize"(fluid: FluidComponent, posed: PosedShape3D, aabb: Float64Array, inflation: number, point: Float64Array): void;
+    static "__#364@#voxelize"(fluid: FluidComponent, posed: PosedShape3D, aabb: Float64Array, inflation: number, point: Float64Array): void;
     /**
      * Write the obstacle's translation velocity onto every face of every cell
      * it voxelized — the moving-wall boundary condition. Runs AFTER the mask
@@ -100,7 +100,7 @@ export class FluidObstacleSystem extends System<any> {
      * @param {number} wvy
      * @param {number} wvz
      */
-    static "__#362@#stamp_wall_velocity"(fluid: FluidComponent, posed: PosedShape3D, aabb: Float64Array, inflation: number, point: Float64Array, wvx: number, wvy: number, wvz: number): void;
+    static "__#364@#stamp_wall_velocity"(fluid: FluidComponent, posed: PosedShape3D, aabb: Float64Array, inflation: number, point: Float64Array, wvx: number, wvy: number, wvz: number): void;
     constructor();
     dependencies: (typeof FluidObstacle)[];
     components_used: (ResourceAccessSpecification<typeof Transform> | ResourceAccessSpecification<typeof RigidBody> | ResourceAccessSpecification<typeof Collider> | ResourceAccessSpecification<typeof FluidComponent> | ResourceAccessSpecification<typeof FluidObstacle>)[];