@woosh/meep-engine 3.18.0 → 3.20.0

package/src/core/geom/3d/shape/HeightMapShape3D.js

@@ -2,6 +2,8 @@ import { hash_mix3 } from "../../../math/hash/hash_mix3.js";
 import { hash_mix2 } from "../../../math/hash/hash_mix2.js";
 import { assert } from "../../../assert.js";
 import { clamp } from "../../../math/clamp.js";
+import { optional_equality } from "../../../model/object/optional_equality.js";
+import { optional_hash } from "../../../model/object/optional_hash.js";
 import { v3_length } from "../../vec3/v3_length.js";
 import { Vector3 } from "../../Vector3.js";
 import { AbstractShape3D } from "./AbstractShape3D.js";
@@ -442,20 +444,13 @@ export class HeightMapShape3D extends AbstractShape3D {
         if (!this.size.equals(other.size)) return false;
         if (this.tessellation !== other.tessellation) return false;
 
-        // strict identity is enough for sampler equality in the common case;
-        // fall through to value equality so two shapes built from independent
-        // but identical sampler instances still compare equal
-        if (this.sampler === other.sampler) return true;
-
-        if (this.sampler === null || other.sampler === null) return false;
-
-        return this.sampler.equals(other.sampler);
+        return optional_equality(this.sampler, other.sampler);
     }
 
     hash() {
         const a = this.orientation.hash();
         const b = this.size.hash();
-        const c = this.sampler !== null ? this.sampler.hash() : 0;
+        const c = optional_hash(this.sampler);
 
         return hash_mix2(hash_mix3(a, b, c), this.tessellation);
     }

package/src/core/model/node-graph/visual/layout/layout_assign_coordinates.js

@@ -347,11 +347,13 @@ function align(graph, layer_count, order, rank, layer_start, neighbours, marked,
  * Push the blocks of one pass as far towards the top as the boxes below them allow, and read off a
  * coordinate for every box.
  *
- * Blocks are placed by longest path through the constraints between neighbours in a column, which
- * is what makes the arrangement as tight as the ordering permits. Blocks that turn out not to
- * constrain each other at all form separate classes, and a class is then shifted up until it meets
- * whatever is above it — without that, a block hanging off the bottom of the drawing pins every
- * class that follows it down there too.
+ * First place blocks relative to the sink of their class, then solve the separation constraints
+ * between classes. A class above another must carry that neighbour's final shift: treating a
+ * relative shift as absolute can move the lower class into the upper one. These constraints form
+ * a DAG, so a topological pass propagates every shift before the classes depending on it are placed.
+ * Both stages take linear time and preserve the port offsets within each block.
+ *
+ * @see https://arxiv.org/abs/2008.01252 — Brandes, Walter, Zink, correction to shift accumulation
  *
  * @param {LayoutBoxGraph} graph
  * @param {Int32Array} order
@@ -428,13 +430,7 @@ function compact(graph, order, rank, layer_start, block, options) {
                     if (place[u] + need > place[v]) {
                         place[v] = place[u] + need;
                     }
-                } else {
-                    const slack = place[v] - place[u] - need;
-
-                    if (slack < shift[sink[u]]) {
-                        shift[sink[u]] = slack;
-                    }
-                }
+                }
             }
 
             w = next[w];
@@ -450,15 +446,62 @@ function compact(graph, order, rank, layer_start, block, options) {
     const y = new Float64Array(box_count);
 
     for (let box = 0; box < box_count; box++) {
-        const r = root[box];
-
-        y[box] = place[r] + offset[box];
-
-        const carried = shift[sink[r]];
-
-        if (carried < Infinity) {
-            y[box] += carried;
-        }
+        const r = root[box];
+
+        y[box] = place[r] + offset[box];
+    }
+
+    // Record every boundary between classes, directed from the lower class to the upper one.
+    // Use the position of the lower box in `order` as the edge index; its predecessor is `at - 1`.
+    // Parallel boundaries matter: different box heights and ports can make either one tighter.
+    const first_boundary = new Int32Array(box_count).fill(-1);
+    const next_boundary = new Int32Array(box_count);
+    const pending = new Int32Array(box_count);
+
+    for (let layer = 0; layer + 1 < layer_start.length; layer++) {
+        for (let at = layer_start[layer] + 1; at < layer_start[layer + 1]; at++) {
+            const upper = sink[root[order[at - 1]]];
+            const lower = sink[root[order[at]]];
+
+            if (upper !== lower) {
+                next_boundary[at] = first_boundary[lower];
+                first_boundary[lower] = at;
+                pending[upper]++;
+            }
+        }
+    }
+
+    const ready = new Int32Array(box_count);
+    let end = 0;
+
+    for (let box = 0; box < box_count; box++) {
+        if (root[box] === box && sink[box] === box && pending[box] === 0) {
+            shift[box] = 0;
+            ready[end++] = box;
+        }
+    }
+
+    for (let cursor = 0; cursor < end; cursor++) {
+        const lower = ready[cursor];
+
+        for (let at = first_boundary[lower]; at !== -1; at = next_boundary[at]) {
+            const above = order[at - 1];
+            const below = order[at];
+            const upper = sink[root[above]];
+
+            // y[above] + shift[upper] + separation <= y[below] + shift[lower]
+            const limit = shift[lower] + y[below] - y[above] - separation(above, below);
+
+            shift[upper] = Math.min(shift[upper], limit);
+
+            if (--pending[upper] === 0) {
+                ready[end++] = upper;
+            }
+        }
+    }
+
+    for (let box = 0; box < box_count; box++) {
+        y[box] += shift[sink[root[box]]];
     }
 
     return y;
@@ -471,7 +514,9 @@ function compact(graph, order, rank, layer_start, block, options) {
  * top edge, the ones biased towards the bottom by their bottom edge — against whichever of them
  * came out shortest. Only then can they be compared box by box, and each box takes the average of
  * the middle two of its four candidates: an average of all four is pulled about by whichever single
- * pass went furthest astray, and the middle two are the ones the passes agree on.
+ * pass went furthest astray, and the middle two are the ones the passes agree on.
+ * Each candidate must already satisfy every separation constraint. Taking the same order
+ * statistics for both ends of an inequality preserves it; balancing cannot repair an invalid pass.
  *
  * @param {LayoutBoxGraph} graph mutated: `box_y` is written
  * @param {Float64Array[]} candidates

package/src/core/model/object/optional_clone.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @template T
+ * @param {T} obj
+ * @return {T}
+ */
+export function optional_clone<T>(obj: T): T;
+//# sourceMappingURL=optional_clone.d.ts.map

package/src/core/model/object/optional_clone.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"optional_clone.d.ts","sourceRoot":"","sources":["../../../../../src/core/model/object/optional_clone.js"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,6CAcC"}

package/src/core/model/object/optional_equality.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @template {{equals(T):boolean}} T
+ * @param {undefined|null|T} a
+ * @param {undefined|null|T} b
+ * @return {boolean}
+ */
+export function optional_equality<T extends {
+    equals(T: any): boolean;
+}>(a: T, b: T): boolean;
+//# sourceMappingURL=optional_equality.d.ts.map

package/src/core/model/object/optional_equality.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"optional_equality.d.ts","sourceRoot":"","sources":["../../../../../src/core/model/object/optional_equality.js"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH;oBALyB,OAAO;gBAGpB,OAAO,CAsBlB"}

package/src/{shade/descriptor/util → core/model/object}/optional_equality.js

@@ -1,7 +1,7 @@
 /**
  * @template {{equals(T):boolean}} T
- * @param {undefined|T} a
- * @param {undefined|T} b
+ * @param {undefined|null|T} a
+ * @param {undefined|null|T} b
  * @return {boolean}
  */
 export function optional_equality(a, b) {

package/src/core/model/object/optional_hash.d.ts

@@ -0,0 +1,9 @@
+/**
+ * @template {{hash():number}} T
+ * @param {T|null|undefined} thing
+ * @return {number}
+ */
+export function optional_hash<T extends {
+    hash(): number;
+}>(thing: T): number;
+//# sourceMappingURL=optional_hash.d.ts.map

package/src/core/model/object/optional_hash.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"optional_hash.d.ts","sourceRoot":"","sources":["../../../../../src/core/model/object/optional_hash.js"],"names":[],"mappings":"AAEA;;;;GAIG;AACH;YAJsB,MAAM;cAEhB,MAAM,CAYjB"}

package/src/{shade/descriptor/util → core/model/object}/optional_hash.js

@@ -1,12 +1,12 @@
-import { assert } from "../../../core/assert.js";
+import { assert } from "../../assert.js";
 
 /**
  * @template {{hash():number}} T
- * @param {T|undefined} thing
+ * @param {T|null|undefined} thing
  * @return {number}
  */
 export function optional_hash(thing) {
-    if (thing === undefined) {
+    if (thing === undefined || thing === null) {
         return 0;
     }
 

package/src/engine/asset/Asset.d.ts

@@ -37,7 +37,7 @@ export class Asset<T> {
      * @returns {boolean}
      */
     equals(other: Asset<any>): boolean;
-    hash(): any;
+    hash(): number;
     /**
      *
      * @returns {T}

package/src/engine/asset/Asset.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Asset.d.ts","sourceRoot":"","sources":["../../../../src/engine/asset/Asset.js"],"names":[],"mappings":"AAAA;;;GAGG;AACH;IAcI;;;;;OAKG;IACH,4CAHW,MAAM,EAehB;IA/BD;;;;OAIG;IACH,cAFU,uBAAuB,CAEf;IAElB;;;OAGG;IACH,8BAAmB;IASf;;;OAGG;IACH,mBAAsB;IAEtB;;;OAGG;IACH,UAFU,MAAM,CAEQ;IAG5B;;;;OAIG;IACH,2BAFa,OAAO,CAgBnB;IAED,YAEC;IAED;;;OAGG;IACH,UAFa,CAAC,CAIb;CACJ"}
+{"version":3,"file":"Asset.d.ts","sourceRoot":"","sources":["../../../../src/engine/asset/Asset.js"],"names":[],"mappings":"AAEA;;;GAGG;AACH;IAcI;;;;;OAKG;IACH,4CAHW,MAAM,EAehB;IA/BD;;;;OAIG;IACH,cAFU,uBAAuB,CAEf;IAElB;;;OAGG;IACH,8BAAmB;IASf;;;OAGG;IACH,mBAAsB;IAEtB;;;OAGG;IACH,UAFU,MAAM,CAEQ;IAG5B;;;;OAIG;IACH,2BAFa,OAAO,CAgBnB;IAED,eAEC;IAED;;;OAGG;IACH,UAFa,CAAC,CAIb;CACJ"}

package/src/engine/asset/Asset.js

@@ -1,3 +1,5 @@
+import { optional_hash } from "../../core/model/object/optional_hash.js";
+
 /**
  * @template T
  *
@@ -58,7 +60,7 @@ export class Asset {
     }
 
     hash() {
-        return this.description === null ? 0 : this.description.hash();
+        return optional_hash(this.description);
     }
 
     /**

package/src/engine/asset/loaders/image/ImageDecoderWorker.js

@@ -1,32 +1,17 @@
 import { PNGReader } from "../../../../format/image/png/PNGReader.js";
 
-async function decode_png(png_bytes) {
-    return new Promise((resolve, reject) => {
-
-        const reader = new PNGReader(png_bytes);
-
-        // console.time('decode');
-        // console.profile('decode');
-
-        const png = reader.parse();
-
-        const uint_channels = png.getUint8Data();
-
-        const width = png.getWidth();
-        const height = png.getHeight();
-
-        // console.timeEnd('decode');
-        // console.profileEnd('decode');
-
-        resolve({
-            data: uint_channels.data.buffer,
-            width,
-            height,
-            itemSize: uint_channels.itemSize,
-            bitDepth: png.getBitDepth()
-        });
-    });
-}
+async function decode_png(png_bytes) {
+    const png = await new PNGReader(png_bytes).parse();
+    const uint_channels = png.getUint8Data();
+
+    return {
+        data: uint_channels.data.buffer,
+        width: png.getWidth(),
+        height: png.getHeight(),
+        itemSize: uint_channels.itemSize,
+        bitDepth: png.getBitDepth()
+    };
+}
 
 /**
  *

package/src/engine/asset/loaders/image/prototypePNG.js

@@ -16,22 +16,23 @@ const array_loader = new ArrayBufferLoader();
 // const path = 'data/textures/utility/vt/uv_map_reference/5-21-14.png';
 const path = 'data/textures/utility/vt/uv_map_reference/6-39-33.png';
 
-array_loader.load(new AssetRequestScope(), path, (asset) => {
+array_loader.load(new AssetRequestScope(), path, (asset) => {
 
     const array = asset.create();
 
     const reader = new PNGReader(array);
 
-    const png = reader.parse();
+    reader.parse().then(png => {
 
-    console.log(png);
+        console.log(png);
 
-    const uint8Data = png.getUint8Data();
+        const uint8Data = png.getUint8Data();
 
-    const sampler = new Sampler2D(uint8Data.data, uint8Data.itemSize, png.getWidth(), png.getHeight());
+        const sampler = new Sampler2D(uint8Data.data, uint8Data.itemSize, png.getWidth(), png.getHeight());
 
-    const canvas = sampler2D2Canvas(sampler, 1, 0);
+        const canvas = sampler2D2Canvas(sampler, 1, 0);
 
-    document.body.appendChild(canvas);
+        document.body.appendChild(canvas);
+    }).catch(error => console.error('Failed to decode PNG', error));
 
 });

package/src/engine/ecs/gui/hud/HeadsUpDisplaySystem.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"HeadsUpDisplaySystem.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/ecs/gui/hud/HeadsUpDisplaySystem.js"],"names":[],"mappings":";AAsBA;;;;;GAKG;AACH;IASI;;;OAGG;IACH,4CAmBC;IA/BD,wCAAgC;IAGhC,2HAGE;IAaE,yBAA8B;IAM9B;;;;OAIG;IACH,+BAAiD;IAGrD,iCAGC;IAED,gCAIC;IAED;;;;;;;;;OASG;IACH,sCAkJC;IAED,6BAsBC;CACJ;uBAxPsB,iBAAiB;2BAIb,qBAAqB;uBAFzB,kBAAkB;4CAJG,uDAAuD;6BAKtE,iCAAiC"}
+{"version":3,"file":"HeadsUpDisplaySystem.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/ecs/gui/hud/HeadsUpDisplaySystem.js"],"names":[],"mappings":";AAsBA;;;;;GAKG;AACH;IASI;;;OAGG;IACH,4CAmBC;IA/BD,wCAAgC;IAGhC,2HAGE;IAaE,yBAA8B;IAM9B;;;;OAIG;IACH,+BAAiD;IAGrD,iCAGC;IAED,gCAIC;IAED;;;;;;;;;OASG;IACH,sCAiJC;IAED,6BAsBC;CACJ;uBAvPsB,iBAAiB;2BAIb,qBAAqB;uBAFzB,kBAAkB;4CAJG,uDAAuD;6BAKtE,iCAAiC"}

package/src/engine/ecs/gui/hud/HeadsUpDisplaySystem.js

@@ -95,9 +95,10 @@ class HeadsUpDisplaySystem extends System {
             y *= transform.scale_y;
             z *= transform.scale_z;
 
-            const q = transform.rotation;
-
-            v3_quaternion_apply(scratch_rotated_offset, 0, x, y, z, q[0], q[1], q[2], q[3]);
+            v3_quaternion_apply(
+                scratch_rotated_offset, 0, x, y, z,
+                transform.rotation_x, transform.rotation_y, transform.rotation_z, transform.rotation_w
+            );
 
             x = scratch_rotated_offset[0];
             y = scratch_rotated_offset[1];
@@ -105,11 +106,9 @@ class HeadsUpDisplaySystem extends System {
         }
 
         // add transform position to get final world position
-        const position = transform.translation;
-
-        x += position[0];
-        y += position[1];
-        z += position[2];
+        x += transform.translation_x;
+        y += transform.translation_y;
+        z += transform.translation_z;
 
         const worldPositionX = x;
         const worldPositionY = y;
@@ -187,8 +186,8 @@ class HeadsUpDisplaySystem extends System {
             ndcY = 0.5 + dy;
         }
 
-        vp.position[0] = ndcX;
-            position[1] = ndcY;
+        // Notify ViewportPositionSystem so it updates the label's placement and visibility.
+        vp.position.set(ndcX, ndcY);
 
         const visible = (!trackedPositionOutOfBounds || vp.stickToScreenEdge) && this.__visibility_predicate.test(worldPositionX, worldPositionY, worldPositionZ);
 

package/src/engine/ecs/storage/populateEngineSerializationRegistry.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"populateEngineSerializationRegistry.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/storage/populateEngineSerializationRegistry.js"],"names":[],"mappings":"AAmLA;;;;;;;;GAQG;AACH,iGA2GC"}
+{"version":3,"file":"populateEngineSerializationRegistry.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/storage/populateEngineSerializationRegistry.js"],"names":[],"mappings":"AAsLA;;;;;;;;GAQG;AACH,iGA4GC"}

package/src/engine/ecs/storage/populateEngineSerializationRegistry.js

@@ -45,6 +45,9 @@ import {
 } from "../../graphics3/VolumetricLightMapSerializationAdapter.js";
 import { Transform } from "../transform/Transform.js";
 import { Transform64SerializationAdapter } from "../transform/Transform64SerializationAdapter.js";
+import {
+    ParticleEffectSerializationAdapter
+} from "../../graphics/ecs/particles/ParticleEffectSerializationAdapter.js";
 import { TransformSerializationAdapter } from "../transform/TransformSerializationAdapter.js";
 import { TransformSerializationUpgrader_0_1 } from "../transform/TransformSerializationUpgrader_0_1.js";
 import {
@@ -206,6 +209,7 @@ export function populateEngineSerializationRegistry(registry) {
         new PathSerializationAdapter(),
         new TagSerializationAdapter(),
         new ParticleEmitterSerializationAdapter(),
+        new ParticleEffectSerializationAdapter(),
         new SoundEmitterSerializationAdapter(),
         new SoundControllerSerializationAdapter(),
         new SoundListenerSerializationAdapter(),