@woosh/meep-engine 3.13.0 → 3.14.0

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 "__#360@#refresh_masks"(fluid: FluidComponent): void;
+    static "__#364@#refresh_masks"(fluid: FluidComponent): void;
     /**
      * @param {FluidComponent} fluid
      */
-    static "__#360@#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 "__#360@#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 "__#360@#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>)[];