@woosh/meep-engine 2.43.37 → 2.43.39

package/core/bvh2/aabb3/AABB3.js

@@ -39,6 +39,69 @@ export class AABB3 {
         this.setBounds(x0, y0, z0, x1, y1, z1);
     }
 
+    * [Symbol.iterator]() {
+
+        yield this.x0;
+        yield this.y0;
+        yield this.z0;
+
+        yield this.x1;
+        yield this.y1;
+        yield this.z1;
+
+    }
+
+    get 0() {
+        return this.x0;
+    }
+
+
+    get 1() {
+        return this.y0;
+    }
+
+    get 2() {
+        return this.z0;
+    }
+
+
+    get 3() {
+        return this.x1;
+    }
+
+
+    get 4() {
+        return this.y1;
+    }
+
+    get 5() {
+        return this.z1;
+    }
+
+    set 0(v) {
+        this.x0 = v;
+    }
+
+    set 1(v) {
+        this.y0 = v;
+    }
+
+    set 2(v) {
+        this.z0 = v;
+    }
+
+    set 3(v) {
+        this.x1 = v;
+    }
+
+    set 4(v) {
+        this.y1 = v;
+    }
+
+    set 5(v) {
+        this.z1 = v;
+    }
+
     /**
      *
      * @param {number} x
@@ -816,17 +879,17 @@ export class AABB3 {
     }
 
     /**
-     *
-     * @param {number} v
+     * Expands the box in all directions by the given amount
+     * @param {number} extra
      */
-    grow(v) {
-        this.x0 -= v;
-        this.y0 -= v;
-        this.z0 -= v;
+    grow(extra) {
+        this.x0 -= extra;
+        this.y0 -= extra;
+        this.z0 -= extra;
 
-        this.x1 += v;
-        this.y1 += v;
-        this.z1 += v;
+        this.x1 += extra;
+        this.y1 += extra;
+        this.z1 += extra;
     }
 
     /**
@@ -847,82 +910,6 @@ export class AABB3 {
 }
 
 
-/**
- *
- * @param {BinaryBuffer} buffer
- * @param {AABB3} box
- * @param {number} x0
- * @param {number} y0
- * @param {number} z0
- * @param {number} x1
- * @param {number} y1
- * @param {number} z1
- */
-export function serializeAABB3Encoded_v0(buffer, box, x0, y0, z0, x1, y1, z1) {
-    let header = 0;
-
-    if (box.x0 === x0) {
-        header |= 1;
-    }
-
-    if (box.x1 === x1) {
-        header |= 2;
-    }
-
-    if (box.y0 === y0) {
-        header |= 4;
-    }
-
-    if (box.y1 === y1) {
-        header |= 8;
-    }
-
-    if (box.z0 === z0) {
-        header |= 16;
-    }
-
-    if (box.z1 === z1) {
-        header |= 32;
-    }
-
-    buffer.writeUint8(header);
-
-    //compute value ranges
-    const xD = x1 - x0;
-    const yD = y1 - y0;
-    const zD = z1 - z0;
-
-    if ((header & 1) === 0) {
-        const _x0 = (((box.x0 - x0) / xD) * 65535) | 0;
-        buffer.writeUint16(_x0);
-    }
-
-    if ((header & 2) === 0) {
-        const _x1 = (((box.x1 - x0) / xD) * 65535) | 0;
-        buffer.writeUint16(_x1);
-    }
-
-    if ((header & 4) === 0) {
-        const _y0 = (((box.y0 - y0) / yD) * 65535) | 0;
-        buffer.writeUint16(_y0);
-    }
-
-    if ((header & 8) === 0) {
-        const _y1 = (((box.y1 - y0) / yD) * 65535) | 0;
-        buffer.writeUint16(_y1);
-    }
-
-    if ((header & 16) === 0) {
-        const _z0 = (((box.z0 - z0) / zD) * 65535) | 0;
-        buffer.writeUint16(_z0);
-    }
-
-    if ((header & 32) === 0) {
-        const _z1 = (((box.z1 - z0) / zD) * 65535) | 0;
-        buffer.writeUint16(_z1);
-    }
-}
-
 /**
  * @readonly
  * @type {boolean}

package/core/bvh2/aabb3/serializeAABB3Encoded_v0.js

@@ -0,0 +1,75 @@
+/**
+ *
+ * @param {BinaryBuffer} buffer
+ * @param {AABB3} box
+ * @param {number} x0
+ * @param {number} y0
+ * @param {number} z0
+ * @param {number} x1
+ * @param {number} y1
+ * @param {number} z1
+ */
+export function serializeAABB3Encoded_v0(buffer, box, x0, y0, z0, x1, y1, z1) {
+    let header = 0;
+
+    if (box.x0 === x0) {
+        header |= 1;
+    }
+
+    if (box.x1 === x1) {
+        header |= 2;
+    }
+
+    if (box.y0 === y0) {
+        header |= 4;
+    }
+
+    if (box.y1 === y1) {
+        header |= 8;
+    }
+
+    if (box.z0 === z0) {
+        header |= 16;
+    }
+
+    if (box.z1 === z1) {
+        header |= 32;
+    }
+
+    buffer.writeUint8(header);
+
+    //compute value ranges
+    const xD = x1 - x0;
+    const yD = y1 - y0;
+    const zD = z1 - z0;
+
+    if ((header & 1) === 0) {
+        const _x0 = (((box.x0 - x0) / xD) * 65535) | 0;
+        buffer.writeUint16(_x0);
+    }
+
+    if ((header & 2) === 0) {
+        const _x1 = (((box.x1 - x0) / xD) * 65535) | 0;
+        buffer.writeUint16(_x1);
+    }
+
+    if ((header & 4) === 0) {
+        const _y0 = (((box.y0 - y0) / yD) * 65535) | 0;
+        buffer.writeUint16(_y0);
+    }
+
+    if ((header & 8) === 0) {
+        const _y1 = (((box.y1 - y0) / yD) * 65535) | 0;
+        buffer.writeUint16(_y1);
+    }
+
+    if ((header & 16) === 0) {
+        const _z0 = (((box.z0 - z0) / zD) * 65535) | 0;
+        buffer.writeUint16(_z0);
+    }
+
+    if ((header & 32) === 0) {
+        const _z1 = (((box.z1 - z0) / zD) * 65535) | 0;
+        buffer.writeUint16(_z1);
+    }
+}

package/core/bvh2/serialization/serializeBinaryNodeToBinaryBuffer.js

@@ -1,5 +1,5 @@
-import { serializeAABB3Encoded_v0 } from "../aabb3/AABB3.js";
 import { serializeAABB3 } from "../aabb3/serializeAABB3.js";
+import { serializeAABB3Encoded_v0 } from "../aabb3/serializeAABB3Encoded_v0.js";
 
 /**
  *

package/core/collection/HashMap.js

@@ -177,7 +177,7 @@ export class HashMap {
         // mix the input hash to minimize potential impact of poor hash function spread
         const mixed_hash = (hash >>> 16) ^ hash;
 
-        // ensure index is non-negative
+        // force index to unsigned integer
         const index = mixed_hash >>> 0;
 
         return index % this.__bucket_count;
@@ -194,7 +194,9 @@ export class HashMap {
 
         assert.isFiniteNumber(bucket_index, 'hash');
 
-        let bucket = this.records[bucket_index];
+        const records = this.records;
+
+        let bucket = records[bucket_index];
 
         if (bucket === undefined) {
 
@@ -202,7 +204,7 @@ export class HashMap {
 
             bucket = [];
 
-            this.records[bucket_index] = bucket;
+            records[bucket_index] = bucket;
 
         } else {
 
@@ -218,7 +220,11 @@ export class HashMap {
 
                 if (entryKey === key || this.keyEqualityFunction(entryKey, key)) {
 
+                    // found record with matching key, replace the value
+
                     entry.value = value;
+
+                    // done, return
                     return;
 
                 }
@@ -237,7 +243,7 @@ export class HashMap {
         const load = new_size / this.__bucket_count;
 
         if (load > this.__load_factor) {
-            // increase table size
+            // current load is too high, increase table size
             this.setBucketCount(this.__bucket_count * 2);
         }
     }
@@ -276,7 +282,9 @@ export class HashMap {
     }
 
     /**
+     * If key exists in the map - returns stored value, if it doesn't - invokes `compute` function and stores produced value in the map; then returns that value
      *
+     * Inspired by Java's implementation
      * @param {K} key
      * @param {function(K):V} compute
      * @param {*} [compute_context]
@@ -402,14 +410,14 @@ export class HashMap {
      */
     rebuild() {
 
-        let h, i, l;
+        let string_bucket_index, i, l;
 
         const records = this.records;
 
-        for (h in records) {
-            const stored_bucket_index = parseInt(h);
+        for (string_bucket_index in records) {
+            const stored_bucket_index = parseInt(string_bucket_index);
 
-            if (!records.hasOwnProperty(h)) {
+            if (!records.hasOwnProperty(string_bucket_index)) {
                 continue;
             }
 

package/core/geom/3d/aabb/aabb3_matrix4_project.js

@@ -1,3 +1,5 @@
+import { assert } from "../../../assert.js";
+
 /**
  * NOTE: Based on Transforming Axis-Aligned Bounding Boxes by Jim Arvo from "Graphics Gems", Academic Press, 1990
  * NOTE: {@link result} and {@link aabb} must be different objects
@@ -6,6 +8,8 @@
  * @param {number[]} matrix 4x4 matrix
  */
 export function aabb3_matrix4_project(result, aabb, matrix) {
+    assert.notEqual(result, aabb, 'input and output must not be the same for algorithm to work correctly');
+
     // extract translation from matrix
     result[0] = result[3] = matrix[12];
     result[1] = result[4] = matrix[13];

package/core/geom/3d/sphere/harmonics/sh3_basis_at.js

@@ -0,0 +1,30 @@
+/**
+ * evaluate the basis functions
+ * shBasis is an Array[ 9 ]
+ *
+ * @param {number} x
+ * @param {number} y
+ * @param {number} z
+ * @param {number[]|ArrayLike<number>|Float32Array|Float64Array} shBasis
+ */
+export function sh3_basis_at(x, y, z, shBasis) {
+
+    // normal is assumed to be unit length
+
+
+    // band 0
+    shBasis[0] = 0.282095;
+
+    // band 1
+    shBasis[1] = 0.488603 * y;
+    shBasis[2] = 0.488603 * z;
+    shBasis[3] = 0.488603 * x;
+
+    // band 2
+    shBasis[4] = 1.092548 * x * y;
+    shBasis[5] = 1.092548 * y * z;
+    shBasis[6] = 0.315392 * (3 * z * z - 1);
+    shBasis[7] = 1.092548 * x * z;
+    shBasis[8] = 0.546274 * (x * x - y * y);
+
+}

package/core/geom/3d/sphere/harmonics/sh3_sample_by_direction.js

@@ -27,21 +27,22 @@ export function sh3_sample_by_direction(
     let channel_value;
 
     for (let i = 0; i < dimension_count; i++) {
+        const offset = harmonics_offset + dimension_count * i;
 
         // band 0
-        channel_value = harmonics[harmonics_offset + i] * 0.282095;
+        channel_value = harmonics[offset] * 0.282095;
 
         // band 1
-        channel_value += harmonics[harmonics_offset + dimension_count + i] * 0.488603 * y;
-        channel_value += harmonics[harmonics_offset + dimension_count * 2 + i] * 0.488603 * z;
-        channel_value += harmonics[harmonics_offset + dimension_count * 3 + i] * 0.488603 * x;
+        channel_value += harmonics[offset + 1] * 0.488603 * y;
+        channel_value += harmonics[offset + 2] * 0.488603 * z;
+        channel_value += harmonics[offset + 3] * 0.488603 * x;
 
         // band 2
-        channel_value += harmonics[harmonics_offset + dimension_count * 4 + i] * 1.092548 * (x * y);
-        channel_value += harmonics[harmonics_offset + dimension_count * 5 + i] * 1.092548 * (y * z);
-        channel_value += harmonics[harmonics_offset + dimension_count * 6 + i] * 0.315392 * (3.0 * z * z - 1.0);
-        channel_value += harmonics[harmonics_offset + dimension_count * 7 + i] * 1.092548 * (x * z);
-        channel_value += harmonics[harmonics_offset + dimension_count * 8 + i] * 0.546274 * (x * x - y * y);
+        channel_value += harmonics[offset + 4] * 1.092548 * (x * y);
+        channel_value += harmonics[offset + 5] * 1.092548 * (y * z);
+        channel_value += harmonics[offset + 6] * 0.315392 * (3.0 * z * z - 1.0);
+        channel_value += harmonics[offset + 7] * 1.092548 * (x * z);
+        channel_value += harmonics[offset + 8] * 0.546274 * (x * x - y * y);
 
         // write out
         result[result_offset + i] = channel_value;

package/core/geom/Quaternion.d.ts

@@ -13,6 +13,11 @@ export default class Quaternion {
     public z: number
     public w: number
 
+    0: number
+    1: number
+    2: number
+    3: number
+
     readonly onChanged: Signal<number, number, number, number, number, number, number, number>;
 
     set(x: number, y: number, z: number, w: number): void
@@ -61,9 +66,9 @@ export default class Quaternion {
 
     fromJSON(j: any): void
 
-    readFromArray(array: ArrayLike<number>, offset: number): void
+    readFromArray(array: ArrayLike<number>, offset?: number): void
 
-    writeToArray(array: ArrayLike<number>, offset: number): void
+    writeToArray(array: ArrayLike<number>, offset?: number): void
 
     asArray(): number[]
 }

package/core/geom/Quaternion.js

@@ -154,6 +154,22 @@ class Quaternion {
         return this.w;
     }
 
+    set 0(v) {
+        this.x = v;
+    }
+
+    set 1(v) {
+        this.y = v;
+    }
+
+    set 2(v) {
+        this.z = v;
+    }
+
+    set 3(v) {
+        this.w = v;
+    }
+
     /**
      *
      * @param {number} fx forward vector
@@ -1655,7 +1671,7 @@ class Quaternion {
      * @param {number[]} array
      * @param {number} offset
      */
-    readFromArray(array, offset) {
+    readFromArray(array, offset=0) {
         this.set(
             array[offset],
             array[offset + 1],
@@ -1669,7 +1685,7 @@ class Quaternion {
      * @param {number[]} array
      * @param {number} offset
      */
-    writeToArray(array, offset) {
+    writeToArray(array, offset=0) {
         array[offset] = this.x;
         array[offset + 1] = this.y;
         array[offset + 2] = this.z;

package/core/geom/Vector1.d.ts

@@ -1,7 +1,17 @@
+import Signal from "../events/signal/Signal";
+
 export default class Vector1 {
     x: number
 
-    set(v: number)
+    0: number
+
+    readonly onChanged: Signal<number,number>
+
+    constructor()
+
+    constructor(x: number)
+
+    set(v: number) : void
 
     getValue(): number
 
@@ -13,5 +23,13 @@ export default class Vector1 {
 
     process(callback: (x) => any): void
 
+    toJSON(): any
+
+    fromJSON(j: any): void
+
+    readFromArray(array: ArrayLike<number>, offset?: number): void
+
+    writeToArray(array: ArrayLike<number>, offset?: number): void
+
     asArray(): number[]
 }

package/core/geom/Vector1.js

@@ -223,7 +223,7 @@ class Vector1 extends Number {
      * @param {number[]} array
      * @param {number} offset
      */
-    readFromArray(array, offset) {
+    readFromArray(array, offset=0) {
         this.set(array[offset]);
     }
 
@@ -232,7 +232,7 @@ class Vector1 extends Number {
      * @param {number[]} array
      * @param {number} offset
      */
-    writeToArray(array, offset) {
+    writeToArray(array, offset=0) {
         array[offset] = this.x;
     }
 
@@ -268,6 +268,14 @@ class Vector1 extends Number {
         return a.x - b.x;
     }
 
+    get 0() {
+        return this.x;
+    }
+
+    set 0(v) {
+        this.x = v;
+    }
+
     * [Symbol.iterator]() {
 
         yield this.x;

package/core/geom/Vector2.d.ts

@@ -4,6 +4,9 @@ export default class Vector2 {
     x: number
     y: number
 
+    0: number
+    1: number
+
     public readonly onChanged: Signal<number, number, number, number>
 
     constructor(x: number, y: number)
@@ -36,5 +39,9 @@ export default class Vector2 {
 
     isZero(): boolean
 
+    readFromArray(array: ArrayLike<number>, offset?: number): void
+
+    writeToArray(array: ArrayLike<number>, offset?: number): void
+
     asArray():number[]
 }

package/core/geom/Vector2.js

@@ -46,7 +46,7 @@ class Vector2 {
      * @param {number[]} array
      * @param {number} offset
      */
-    readFromArray(array, offset) {
+    readFromArray(array, offset = 0) {
         this.set(
             array[offset],
             array[offset + 1]
@@ -58,15 +58,15 @@ class Vector2 {
      * @param {number[]} array
      * @param {number} offset
      */
-    writeToArray(array, offset) {
+    writeToArray(array, offset = 0) {
         array[offset] = this.x;
         array[offset + 1] = this.y;
     }
 
-    asArray(){
+    asArray() {
         const r = [];
 
-        this.writeToArray(r,0);
+        this.writeToArray(r, 0);
 
         return r;
     }
@@ -588,6 +588,23 @@ class Vector2 {
         return this.x === other.x && this.y === other.y;
     }
 
+    get 0() {
+        return this.x;
+    }
+
+    get 1() {
+        return this.y;
+    }
+
+    set 0(v) {
+        this.x = v;
+    }
+
+    set 1(v) {
+        this.y = v;
+    }
+
+
     * [Symbol.iterator]() {
 
         yield this.x;

package/core/geom/Vector3.d.ts

@@ -47,7 +47,7 @@ export default class Vector3 implements Vector3Like {
 
     ceil(): void
 
-    multiplyVectors(a:Vector3Like,b:Vector3Like):void
+    multiplyVectors(a: Vector3Like, b: Vector3Like): void
 
     _multiply(x: number, y: number, z: number): void
 
@@ -91,11 +91,11 @@ export default class Vector3 implements Vector3Like {
 
     toJSON(): any
 
-    fromJSON(json: { x?: number, y?: number, z?: number })
+    fromJSON(json: { x?: number, y?: number, z?: number } | number): void
 
-    readFromArray(array: number[] | ArrayLike<number>, offset: number): void
+    readFromArray(array: number[] | ArrayLike<number>, offset?: number): void
 
-    writeToArray(array: number[] | ArrayLike<number>, offset: number): void
+    writeToArray(array: number[] | ArrayLike<number>, offset?: number): void
 
     asArray(): number[]
 

package/core/geom/Vector3.js

@@ -38,7 +38,7 @@ class Vector3 {
      * @param {number[]} array
      * @param {number} offset
      */
-    readFromArray(array, offset) {
+    readFromArray(array, offset=0) {
         this.set(
             array[offset],
             array[offset + 1],
@@ -51,7 +51,7 @@ class Vector3 {
      * @param {number[]} array
      * @param {number} offset
      */
-    writeToArray(array, offset) {
+    writeToArray(array, offset=0) {
         array[offset] = this.x;
         array[offset + 1] = this.y;
         array[offset + 2] = this.z;
@@ -806,7 +806,7 @@ class Vector3 {
     }
 
     toString() {
-        return `[x:${this.x},y:${this.y},z:${this.z}]`;
+        return `[x:${this.x}, y:${this.y}, z:${this.z}]`;
     }
 
     /**
@@ -952,6 +952,31 @@ class Vector3 {
         return hash;
     }
 
+
+    get 0() {
+        return this.x;
+    }
+
+    get 1() {
+        return this.y;
+    }
+
+    get 2() {
+        return this.z;
+    }
+
+    set 0(v) {
+        this.x = v;
+    }
+
+    set 1(v) {
+        this.y = v;
+    }
+
+    set 2(v) {
+        this.z = v;
+    }
+
     * [Symbol.iterator]() {
 
         yield this.x;

package/core/geom/Vector4.d.ts

@@ -15,6 +15,11 @@ export default class Vector4 {
     z: number
     w: number
 
+    0: number
+    1: number
+    2: number
+    3: number
+
     public readonly onChanged: Signal<number, number, number, number, number, number, number, number>;
 
     constructor()
@@ -25,9 +30,9 @@ export default class Vector4 {
 
     copy(other: Vector4Like): void
 
-    readFromArray(array:ArrayLike<number>, offset:number):void
+    readFromArray(array:ArrayLike<number>, offset?:number):void
 
-    writeToArray(array:ArrayLike<number>, offset:number):void
+    writeToArray(array:ArrayLike<number>, offset?:number):void
 
     asArray(): number[]
 

package/core/geom/Vector4.js

@@ -105,11 +105,11 @@ class Vector4 {
      * @constructor
      * @class
      */
-    constructor(x, y, z, w) {
-        this.x = (typeof x === "number") ? x : 0;
-        this.y = (typeof x === "number") ? y : 0;
-        this.z = (typeof z === "number") ? z : 0;
-        this.w = (typeof w === "number") ? w : 1;
+    constructor(x = 0, y = 0, z = 0, w = 0) {
+        this.x = x;
+        this.y = y;
+        this.z = z;
+        this.w = w;
 
         this.onChanged = new Signal();
     }
@@ -135,7 +135,7 @@ class Vector4 {
      * @param {number[]} array
      * @param {number} offset
      */
-    readFromArray(array, offset) {
+    readFromArray(array, offset = 0) {
         this.set(
             array[offset],
             array[offset + 1],
@@ -149,7 +149,7 @@ class Vector4 {
      * @param {number[]} array
      * @param {number} offset
      */
-    writeToArray(array, offset) {
+    writeToArray(array, offset = 0) {
         array[offset] = this.x;
         array[offset + 1] = this.y;
         array[offset + 2] = this.z;

package/core/math/hash/computeObjectHash.js

@@ -18,37 +18,37 @@ export function computeObjectHash(value, depth = 3) {
 
     let hash = 0;
 
-    for (let p in value) {
+    const pType = typeof value;
+
+    if (pType === "string") {
+        hash = computeStringHash(value);
+    } else if (pType === "number") {
+        hash = computeHashFloat(value);
+    } else if (pType === "boolean") {
+        hash = value ? 1 : 0;
+    } else if (pType === "object") {
+
+        if (depth <= 0) {
+            hash = 3;
+        } else {
+
+            for (let p in value) {
 
-        hash = ((hash << 5) - hash) + computeStringHash(p);
+                const pNameHash = computeStringHash(p);
 
-        const pValue = value[p];
+                const pValue = value[p];
 
-        const pType = typeof pValue;
+                const pHash = pNameHash ^ computeObjectHash(pValue, depth - 1);
 
-        let pHash;
-        if (pType === "string") {
-            pHash = computeStringHash(pValue);
-        } else if (pType === "number") {
-            pHash = computeHashFloat(pValue);
-        } else if (pType === "boolean") {
-            pHash = pValue ? 1 : 0;
-        } else if (pType === "object") {
+                hash = ((hash << 5) - hash) + pHash;
 
-            if (depth <= 0) {
-                pHash = 3;
-            } else {
-                pHash = computeObjectHash(pValue, depth - 1);
+                hash |= 0; // Convert to 32bit integer
             }
 
-        } else {
-            pHash = 0;
         }
 
-        hash = ((hash << 5) - hash) + pHash;
-
-        hash |= 0; // Convert to 32bit integer
     }
 
+
     return hash;
 }

package/core/math/hash/computeObjectHash.spec.js

@@ -0,0 +1,42 @@
+import { computeObjectHash } from "./computeObjectHash.js";
+
+/**
+ *
+ * @param {number} hash
+ */
+function validateHash(hash){
+    expect(typeof hash).toBe('number');
+    expect(hash).not.toBeNaN();
+    expect(Number.isFinite(hash)).toBe(true);
+    expect(Number.isInteger(hash)).toBe(true);
+}
+
+test('primitives produce valid hash',()=>{
+    validateHash( computeObjectHash(undefined));
+    validateHash( computeObjectHash(null));
+    validateHash( computeObjectHash(0));
+    validateHash( computeObjectHash(1));
+    validateHash( computeObjectHash(""));
+    validateHash( computeObjectHash("hello"));
+    validateHash( computeObjectHash(false));
+    validateHash( computeObjectHash(true));
+    validateHash( computeObjectHash({}));
+});
+
+test('nested object hash is stable',()=>{
+    const test_object = {
+        a:{
+            b:7
+        },
+        c: "hello"
+    };
+
+    expect(computeObjectHash(test_object)).toEqual(computeObjectHash(test_object));
+
+    expect(computeObjectHash(test_object)).not.toEqual(computeObjectHash({
+        a:{
+            b:5
+        },
+        c: "hello"
+    }));
+});

package/engine/Engine.d.ts

@@ -18,7 +18,7 @@ export interface IEngineInitializationOptions {
 export default class Engine {
     constructor(platform: EnginePlatform, options?: IEngineInitializationOptions);
 
-    public get viewStack(): View
+    readonly viewStack: View
 
     public readonly entityManager: EntityManager
     public readonly sceneManager: SceneManager

package/engine/ecs/transform/Transform.js

@@ -28,33 +28,35 @@ export class Transform {
     constructor() {
 
         /**
-         *
+         * World-space position
          * @type {Vector3}
          * @readonly
          */
         this.position = new Vector3(0, 0, 0);
 
         /**
-         *
+         * World-space rotation
          * @type {Quaternion}
          * @readonly
          */
         this.rotation = new Quaternion(0, 0, 0, 1);
 
         /**
-         *
+         * World-space scale
          * @type {Vector3}
          * @readonly
          */
         this.scale = new Vector3(1, 1, 1);
 
         /**
+         * World-space transform matrix, position, rotation and scale must match, but shear can be different
          * @readonly
          * @type {Float32Array}
          */
         this.matrix = allocate_transform_m4();
 
         /**
+         * Various bit flags, see {@link TransformFlags}
          * @protected
          * @type {number}
          */
@@ -136,7 +138,6 @@ export class Transform {
         return (this.flags & flag) === flag;
     }
 
-
     updateMatrix() {
         compose_matrix4_array(this.matrix, this.position, this.rotation, this.scale);
     }
@@ -275,7 +276,7 @@ export class Transform {
     }
 
     /**
-     *
+     * @deprecated use `fromMatrix4` directly instead
      * @param {THREE.Matrix4} matrix
      */
     fromThreeMatrix4(matrix) {
@@ -283,7 +284,7 @@ export class Transform {
     }
 
     /**
-     *
+     * @deprecated use `toMatrix4` directly instead
      * @param {Matrix4} matrix
      */
     toThreeMatrix(matrix) {
@@ -314,6 +315,12 @@ export class Transform {
         compose_matrix4_array(result, this.position, this.rotation, this.scale);
     }
 
+    /**
+     * reset transform, resulting transform is an identity matrix
+     *      - position: [0,0,0]
+     *      - rotation: [0,0,0,1]
+     *      - scale:    [1,1,1]
+     */
     makeIdentity() {
         this.position.copy(Vector3.zero);
         this.rotation.copy(Quaternion.identity);
@@ -335,11 +342,16 @@ Transform.prototype.isTransform = true;
 
 
 /**
+ * @deprecated use {@link Quaternion.rotateTowards} instead
  * @param {Quaternion} sourceQuaternion
  * @param {Vector3} targetVector
  * @param {Number} limit
  */
-Transform.adjustRotation = function (sourceQuaternion, targetVector, limit) {
-    sourceQuaternion.lookRotation(targetVector, Vector3.up);
+Transform.adjustRotation = function (sourceQuaternion, targetVector, limit = Infinity) {
+    const q = new Quaternion();
+
+    q.lookRotation(targetVector);
+
+    sourceQuaternion.rotateTowards(q, limit);
 };
 

package/engine/graphics/ecs/mesh-v2/ShadedGeometry.js

@@ -50,7 +50,7 @@ export class ShadedGeometry {
         this.material = null;
 
         /**
-         *
+         * Optional extra material used for shadowmaps
          * @type {THREE.Material|null}
          */
         this.depth_material = null;
@@ -84,7 +84,7 @@ export class ShadedGeometry {
         this.__entity = -1;
 
         /**
-         *
+         * Transient, cached for convenience. Associated transform component from the same entity
          * @type {Transform|null}
          * @private
          */

package/engine/graphics/ecs/mesh-v2/render/adapters/InstancedRendererAdapter.js

@@ -20,7 +20,10 @@ export class InstancedRendererAdapter extends AbstractRenderAdapter {
          */
         this.__instanced_meshes = new HashMap({
             keyHashFunction(sg) {
-                return sg.geometry.id ^ sg.material.id ^ sg.mode;
+                return sg.geometry.id
+                    ^ sg.material.id
+                    ^ sg.mode
+                    ;
             },
             keyEqualityFunction(a, b) {
                 return a.material.id === b.material.id

package/engine/graphics/sh3/LightProbeVolume.js

@@ -29,40 +29,10 @@ import { build_three_object } from "../ecs/mesh-v2/build_three_object.js";
 import { ShadedGeometryFlags } from "../ecs/mesh-v2/ShadedGeometryFlags.js";
 import { v3_length_sqr } from "../../../core/geom/v3_length_sqr.js";
 import { sh3_dering_optimize_positive } from "../../../core/geom/3d/sphere/harmonics/sh3_dering_optimize_positive.js";
+import { sh3_basis_at } from "../../../core/geom/3d/sphere/harmonics/sh3_basis_at.js";
 
 const TEMP_CONTACT = new SurfacePoint3();
 
-/**
- * evaluate the basis functions
- * shBasis is an Array[ 9 ]
- *
- * @param {number} x
- * @param {number} y
- * @param {number} z
- * @param {number[]|ArrayLike<number>|Float32Array|Float64Array} shBasis
- */
-function getBasisAt(x, y, z, shBasis) {
-
-    // normal is assumed to be unit length
-
-
-    // band 0
-    shBasis[0] = 0.282095;
-
-    // band 1
-    shBasis[1] = 0.488603 * y;
-    shBasis[2] = 0.488603 * z;
-    shBasis[3] = 0.488603 * x;
-
-    // band 2
-    shBasis[4] = 1.092548 * x * y;
-    shBasis[5] = 1.092548 * y * z;
-    shBasis[6] = 0.315392 * (3 * z * z - 1);
-    shBasis[7] = 1.092548 * x * z;
-    shBasis[8] = 0.546274 * (x * x - y * y);
-
-}
-
 /**
  *
  * @param {Uint8Array} data
@@ -160,7 +130,7 @@ function fromCubeRenderTarget(data, renderer, cubeRenderTarget) {
             normal_z /= length;
 
             // evaluate SH basis functions in direction dir
-            getBasisAt(normal_x, normal_y, normal_z, sh_basis);
+            sh3_basis_at(normal_x, normal_y, normal_z, sh_basis);
 
             // pixel color, already in linear space so no sRGB->Linear conversion necessary
 
@@ -266,7 +236,7 @@ class CubeRenderer {
             //
             //     object3D.material.color.copy(source_material.color);
             // } else {
-                object3D.material = source_material.clone();
+            object3D.material = source_material.clone();
             // }
 
             applyTransformToThreeObject(object3D, t);

package/engine/intelligence/behavior/Behavior.js

@@ -2,50 +2,17 @@ import { BehaviorStatus } from "./BehaviorStatus.js";
 
 /**
  * Base class of behavior tree implementation
+ * @template CTX
  */
 export class Behavior {
     constructor() {
         /**
          * Any internal state used by the behavior
-         * @type {*}
+         * @type {CTX|null}
          */
         this.context = null;
     }
 
-    /**
-     * @deprecated
-     * @private
-     * @returns {BehaviorStatus}
-     */
-    get __status() {
-        throw new Error('Deprecated');
-    }
-
-    /**
-     * @deprecated
-     * @param {BehaviorStatus} v
-     * @private
-     */
-    set __status(v) {
-        throw new Error('Deprecated');
-    }
-
-    /**
-     * @deprecated
-     * @returns {BehaviorStatus}
-     */
-    getStatus() {
-        throw new Error('Deprecated');
-    }
-
-    /**
-     * @deprecated
-     * @param {BehaviorStatus} s
-     */
-    setStatus(s) {
-        throw new Error('Deprecated');
-    }
-
     /**
      * Main update function
      * @param {number} timeDelta time step in seconds

package/engine/plugin/EnginePlugin.js

@@ -11,6 +11,12 @@ export class EnginePlugin extends BaseProcess {
          * @private
          */
         this.__dependencies = [];
+
+        /**
+         *
+         * @type {Engine|null}
+         */
+        this.engine = null;
     }
 
     attach() {

package/engine/ui/bindings/{DomElementManager.js → DomElementProcessorManager.js}

@@ -1,13 +1,12 @@
 import { DomElementBinding } from "./DomElementBinding.js";
+import { EnginePlugin } from "../../plugin/EnginePlugin.js";
+import { array_remove_first } from "../../../core/collection/array/array_remove_first.js";
 
-export class DomElementManager {
+export class DomElementProcessorManager extends EnginePlugin {
     constructor() {
-        /**
-         *
-         * @type {Engine|null}
-         * @private
-         */
-        this.__engine = null;
+        super();
+
+        this.id = "dom-element-processor-manager";
 
         /**
          *
@@ -59,6 +58,23 @@ export class DomElementManager {
         this.__descriptors.push(descriptor);
     }
 
+    /**
+     *
+     * @param {DomElementBindingDescription} descriptor
+     * @return {boolean}
+     */
+    deregister(descriptor) {
+        if (array_remove_first(this.__descriptors, descriptor)) {
+            // element removed
+
+            // TODO cleanup whatever effects have been applied to elements matching the descriptor
+            return true;
+        } else {
+            // not found
+            return false;
+        }
+    }
+
     /**
      *
      * @param {sequence<MutationRecord>} mutations_list
@@ -215,17 +231,7 @@ export class DomElementManager {
      * @return {Engine|null}
      */
     getEngine() {
-        return this.__engine;
-    }
-
-    /**
-     *
-     * @param {Engine} engine
-     */
-    initialize(engine) {
-
-        this.__engine = engine;
-
+        return this.engine;
     }
 
     /**
@@ -258,6 +264,25 @@ export class DomElementManager {
 
     }
 
+    async startup() {
+        const view = this.getEngine().viewStack;
+
+        this.link(view.el);
+
+        return super.startup();
+    }
+
+    async shutdown() {
+
+        this.unlink();
+
+        return super.shutdown();
+    }
+
+    /**
+     *
+     * @param {Element} root
+     */
     link(root) {
 
         this.__root = root;

package/package.json

@@ -5,7 +5,7 @@
   "productName": "Meep",
   "description": "production-ready JavaScript game engine based on Entity Component System Architecture",
   "author": "Alexander Goldring",
-  "version": "2.43.37",
+  "version": "2.43.39",
   "dependencies": {
     "gl-matrix": "3.4.3",
     "fast-levenshtein": "2.0.6",