@woosh/meep-engine 2.33.57 → 2.33.61

package/core/bvh2/aabb3/AABB3.js

@@ -832,11 +832,14 @@ AABB3.prototype.intersectSpace = function (clippingPlanes) {
 AABB3.prototype.intersectFrustumDegree = function (frustum) {
     const planes = frustum.planes;
 
+    let i = 0;
     let result = 2;
-    for (let i = 0; i < 6; i++) {
+    for (i = 0; i < 6; i++) {
 
         const plane = planes[i];
+
         const planeSide = this.computePlaneSide(plane);
+
         if (planeSide < 0) {
             return 0;
         } else if (planeSide === 0) {

package/core/bvh2/traversal/traverseBinaryNodeUsingVisitor.js

@@ -22,19 +22,19 @@ export function traverseBinaryNodeUsingVisitor(node, visitor) {
 
             if (traverseDeeper !== false) {
 
-                if (n.right !== null) {
+                if (n.left !== null) {
 
-                    // has a RIGHT child
+                    // has a LEFT child
 
-                    stack[stackPointer++] = n.right;
+                    stack[stackPointer++] = n.left;
 
                 }
 
-                if (n.left !== null) {
+                if (n.right !== null) {
 
-                    // has a LEFT child
+                    // has a RIGHT child
 
-                    stack[stackPointer++] = n.left;
+                    stack[stackPointer++] = n.right;
 
                 }
 

package/core/cache/Cache.js

@@ -7,6 +7,7 @@ import { CacheElement } from "./CacheElement.js";
 /**
  *
  * @template Key, Value
+ * @extends Map<Key,Value>
  */
 export class Cache {
     /**
@@ -430,3 +431,9 @@ export class Cache {
         this.weight = 0;
     }
 }
+
+/**
+ * Shortcut for "map" compliance
+ * @type {Cache.put}
+ */
+Cache.prototype.set = Cache.prototype.put;

package/core/collection/array/fastArrayEquals.js

@@ -0,0 +1,17 @@
+import { isArrayEqualStrict } from "./isArrayEqualStrict.js";
+import { is_typed_array_equals } from "./typed/is_typed_array_equals.js";
+
+/**
+ *
+ * @param {number[]|Uint8Array} a
+ * @param {number[]|Uint8Array} b
+ */
+export function fastArrayEquals(a, b) {
+    if (Array.isArray(a) || Array.isArray(b)) {
+        // not typed array
+        return isArrayEqualStrict(a, b);
+    }
+
+    // typed array, can do better
+    return is_typed_array_equals(a, b);
+}

package/core/collection/array/typed/is_typed_array_equals.js

@@ -0,0 +1,58 @@
+//
+import { isArrayEqualStrict } from "../isArrayEqualStrict.js";
+
+/**
+ *
+ * @param {Uint8Array} a
+ * @param {Uint8Array} b
+ * @returns {boolean}
+ */
+export function is_typed_array_equals(a, b) {
+    const a_length = a.length;
+    const b_length = b.length;
+
+    if (a_length !== b_length) {
+        return false;
+    }
+
+    if (a_length < 128) {
+        // small array, do direct compare
+        return isArrayEqualStrict(a, b);
+    }
+
+    const byte_length = a.byteLength;
+
+    if (byte_length !== b.byteLength) {
+        return false;
+    }
+
+    const bytes_per_element = a.constructor.BYTES_PER_ELEMENT;
+
+    if (bytes_per_element !== b.constructor.BYTES_PER_ELEMENT) {
+        // incompatible constructors
+        return false;
+    }
+
+    const a_buffer = a.buffer;
+    const b_buffer = b.buffer;
+
+    // check if buffers are the same
+    if (a_buffer === b_buffer && a.byteOffset === b.byteOffset) {
+        // using the same buffer and pointing to the same range within it
+        return true;
+    }
+
+    let a_proxy = a;
+    let b_proxy = b;
+
+    if (bytes_per_element < 4 && byte_length % 4 === 0) {
+        // 4 byte alignment, can use uint32
+        a_proxy = new Uint32Array(a_buffer, a.byteOffset, byte_length / 4);
+        b_proxy = new Uint32Array(b_buffer, b.byteOffset, byte_length / 4);
+    } else if (bytes_per_element < 2 && byte_length % 2 === 0) {
+        a_proxy = new Uint16Array(a_buffer, a.byteOffset, byte_length / 2);
+        b_proxy = new Uint16Array(b_buffer, b.byteOffset, byte_length / 2);
+    }
+
+    return isArrayEqualStrict(a_proxy, b_proxy);
+}

package/core/collection/map/AbstractAsyncMap.js

@@ -0,0 +1,30 @@
+//
+
+
+/**
+ * @template Key,Value
+ */
+export class AbstractAsyncMap {
+    constructor() {
+
+    }
+
+    /**
+     *
+     * @param {Key} key
+     * @return {Promise<Value|undefined>}
+     */
+    async get(key) {
+        throw new Error('Not Implemented');
+    }
+
+    /**
+     *
+     * @param {Key} key
+     * @param {Value} value
+     * @return {Promise<void>}
+     */
+    async set(key, value) {
+        throw new Error('Not Implemented');
+    }
+}

package/core/collection/map/AsyncMapWrapper.js

@@ -0,0 +1,16 @@
+import { AbstractAsyncMap } from "./AbstractAsyncMap.js";
+
+export class AsyncMapWrapper extends AbstractAsyncMap {
+    constructor(source) {
+        super();
+        this._source = source;
+    }
+
+    async get(key) {
+        return this._source.get(key);
+    }
+
+    async set(key, value) {
+        this._source.set(key, value);
+    }
+}

package/core/collection/map/AsyncRemoteHashMap.js

@@ -0,0 +1,358 @@
+import { assert } from "../../assert.js";
+import { BinaryBuffer } from "../../binary/BinaryBuffer.js";
+import { AbstractAsyncMap } from "./AbstractAsyncMap.js";
+
+/**
+ * @template Key,Value
+ */
+export class AsyncRemoteHashMap extends AbstractAsyncMap {
+
+    /**
+     *
+     * @param keyHashFunction
+     * @param keyEqualityFunction
+     * @param {BinaryClassSerializationAdapter} keySerializationAdapter
+     * @param {BinaryClassSerializationAdapter} valueSerializationAdapter
+     * @param storageKeyPrefix
+     * @param {Storage} storage
+     */
+    constructor({
+                    keyHashFunction,
+                    keyEqualityFunction,
+                    keySerializationAdapter,
+                    valueSerializationAdapter,
+                    storageKeyPrefix,
+                    storage
+                }) {
+        super();
+
+        assert.isString(storageKeyPrefix, 'storageKeyPrefix');
+
+        this._keyHashFunction = keyHashFunction;
+        this._keyEqualityFunction = keyEqualityFunction;
+        this._keySerializationAdapter = keySerializationAdapter;
+        this._valueSerializationAdapter = valueSerializationAdapter;
+        this._storageKeyPrefix = storageKeyPrefix;
+        this._storage = storage;
+
+        /**
+         *
+         * @type {Map<number,Promise>}
+         * @private
+         */
+        this._bucket_locks = new Map();
+    }
+
+    /**
+     *
+     * @param {Storage} storage
+     */
+    attach_storage(storage) {
+        this._storage = storage;
+    }
+
+    detach_storage() {
+        this._storage = null;
+    }
+
+    async __get_bucket_lock(hash) {
+        let source_lock = this._bucket_locks.get(hash);
+        if (source_lock === undefined) {
+            source_lock = Promise.resolve();
+        }
+
+        let is_resolved = false;
+        const lock_object = {
+            release() {
+                is_resolved = true;
+            }
+        };
+
+        const release_promise = new Promise((resolve, reject) => {
+            lock_object.release = resolve;
+
+            if (is_resolved) {
+                resolve();
+            }
+        });
+
+        const new_lock = source_lock.then(() => release_promise);
+
+        this._bucket_locks.set(hash, new_lock);
+
+        await source_lock;
+
+        return lock_object;
+    }
+
+    /**
+     * @param {number} hash
+     * @return {Promise<ArrayBuffer|undefined>}
+     * @private
+     */
+    __get_bucket_binary(hash) {
+        return this._storage.promiseLoadBinary(this.__compute_bucket_storage_key(hash)).catch(() => {
+            return undefined;
+        });
+    }
+
+    __compute_bucket_storage_key(hash) {
+        return `${this._storageKeyPrefix}/${hash}`;
+    }
+
+    /**
+     *
+     * @param {number} hash
+     * @param {ArrayBuffer} bucket
+     * @return {Promise}
+     * @private
+     */
+    __set_bucket_binary(hash, bucket) {
+        return this._storage.promiseStoreBinary(this.__compute_bucket_storage_key(hash), bucket);
+    }
+
+    /**
+     *
+     * @param {Key} key
+     * @param {Value|undefined} value
+     * @param {ArrayBuffer} buffer
+     * @return {ArrayBuffer}
+     * @private
+     */
+    __set_value_by_key_in_bucket(key, value, buffer) {
+        const source = new BinaryBuffer();
+        source.fromArrayBuffer(buffer);
+
+        const record_count = buffer.byteLength >= 2 ? source.readUint16() : 0;
+
+        let new_record_count = record_count;
+
+        // first attempt to find the key
+        const existing_value_address = this.__get_value_offset_from_bucket_by_key(key, buffer);
+
+        if (existing_value_address === -1) {
+            new_record_count++;
+        }
+
+        const destination = new BinaryBuffer();
+        destination.writeUint16(new_record_count);
+
+        let destination_data_offset = 2 + 16 * new_record_count;
+        let write_cursor = 0;
+        // copy old record over
+        for (let i = 0; i < record_count; i++) {
+            source.position = 2 + i * 16;
+
+            const key_position = source.readUint32();
+            const key_length = source.readUint32();
+            const value_position = source.readUint32();
+            const value_length = source.readUint32();
+
+            if (existing_value_address !== -1 && value_position === existing_value_address) {
+                // skip
+                continue;
+            }
+
+            // write key + value
+            destination.position = 2 + write_cursor * 16;
+
+            // write header section
+            destination.writeUint32(destination_data_offset);
+            destination.writeUint32(key_length);
+            destination.writeUint32(destination_data_offset + key_length);
+            destination.writeUint32(value_length);
+
+            destination.position = destination_data_offset;
+            source.position = key_position;
+            BinaryBuffer.copyBytes(source, destination, key_length);
+
+            destination_data_offset += key_length;
+
+            destination.position = destination_data_offset;
+            source.position = value_position;
+            BinaryBuffer.copyBytes(source, destination, value_length);
+
+            destination_data_offset += value_length;
+
+            write_cursor++;
+        }
+
+        const inserted_key_address = destination_data_offset;
+        const inserted_key_length = this.__encode_object(destination, inserted_key_address, key, this._keySerializationAdapter);
+
+        destination_data_offset += inserted_key_length;
+        const inserted_value_address = destination_data_offset;
+        const inserted_value_length = this.__encode_object(destination, inserted_value_address, value, this._valueSerializationAdapter);
+
+
+        // write section for the new value
+        destination.position = 2 + 16 * write_cursor;
+        destination.writeUint32(inserted_key_address);
+        destination.writeUint32(inserted_key_length);
+        destination.writeUint32(inserted_value_address);
+        destination.writeUint32(inserted_value_length);
+
+        // restore position
+        destination.position = inserted_value_address + inserted_value_length;
+
+        destination.trim();
+
+        return destination.data;
+    }
+
+    /**
+     *
+     * @param {Key} key
+     * @param {ArrayBuffer} buffer
+     * @return {number} -1 if not found, otherwise address within the buffer where the value can be read
+     * @private
+     */
+    __get_value_offset_from_bucket_by_key(key, buffer) {
+        const binary = new BinaryBuffer();
+        binary.fromArrayBuffer(buffer);
+
+        if (binary.length < 2) {
+            return -1;
+        }
+
+        const record_count = binary.readUint16();
+
+        if (record_count === 0) {
+            return -1;
+        }
+
+        const key_offsets = new Uint32Array(record_count);
+        const value_offsets = new Uint32Array(record_count);
+
+        // read record offsets
+        for (let i = 0; i < record_count; i++) {
+            const key_offset = binary.readUint32();
+            const key_length = binary.readUint32();
+
+            const value_offset = binary.readUint32();
+            const value_length = binary.readUint32();
+
+            key_offsets[i] = key_offset;
+            value_offsets[i] = value_offset;
+        }
+
+        // read key
+        for (let i = 0; i < record_count; i++) {
+            const key_address = key_offsets[i];
+
+            const stored_key = this.__decode_object(binary, key_address, this._keySerializationAdapter);
+
+            if (this._keyEqualityFunction(stored_key, key)) {
+                return value_offsets[i]
+            }
+        }
+
+        return -1;
+    }
+
+    /**
+     *
+     * @param {BinaryBuffer} buffer
+     * @param {number} address
+     * @param {BinaryClassSerializationAdapter} adapter
+     * @return {Value}
+     * @private
+     */
+    __decode_object(buffer, address, adapter) {
+
+        buffer.position = address;
+
+        const ValueKlass = adapter.getClass();
+
+        const value = new ValueKlass();
+
+        adapter.deserialize(buffer, value);
+
+        return value;
+    }
+
+    /**
+     * @template T
+     * @param {BinaryBuffer} buffer
+     * @param {number} address
+     * @param {T} value
+     * @param {BinaryClassSerializationAdapter} adapter
+     * @returns {number} bytes written
+     * @private
+     */
+    __encode_object(buffer, address, value, adapter) {
+        buffer.position = address;
+
+        adapter.serialize(buffer, value);
+
+        const bytes_written = buffer.position - address;
+
+        return bytes_written;
+    }
+
+    /**
+     *
+     * @param {BinaryBuffer} buffer
+     * @param {number} address
+     * @return {Value}
+     * @private
+     */
+    __decode_value(buffer, address) {
+        return this.__decode_object(buffer, address, this._valueSerializationAdapter);
+    }
+
+    /**
+     *
+     * @param {Key} key
+     * @return {Promise<Value|undefined>}
+     */
+    async get(key) {
+        // hash the key to identify bucket to load
+        const key_hash = this._keyHashFunction(key);
+
+        const lock = await this.__get_bucket_lock(key_hash);
+
+        const bucket_buffer = await this.__get_bucket_binary(key_hash);
+
+        lock.release();
+
+        if (bucket_buffer === undefined) {
+            return;
+        }
+
+        const value_address = this.__get_value_offset_from_bucket_by_key(key, bucket_buffer);
+
+        if (value_address === -1) {
+            return;
+        }
+
+        const binary = new BinaryBuffer();
+        binary.fromArrayBuffer(bucket_buffer);
+
+        return this.__decode_value(binary, value_address);
+    }
+
+    /**
+     *
+     * @param {Key} key
+     * @param {Value} value
+     * @return {Promise<void>}
+     */
+    async set(key, value) {
+        const key_hash = this._keyHashFunction(key);
+
+        const lock = await this.__get_bucket_lock(key_hash);
+
+        let bucket_buffer = await this.__get_bucket_binary(key_hash);
+
+        if (bucket_buffer === undefined) {
+            bucket_buffer = new ArrayBuffer(0);
+        }
+
+        const updated_buffer = this.__set_value_by_key_in_bucket(key, value, bucket_buffer);
+
+        await this.__set_bucket_binary(key_hash, updated_buffer);
+
+        lock.release();
+    }
+}

package/core/collection/map/CachedAsyncMap.js

@@ -0,0 +1,34 @@
+import { AbstractAsyncMap } from "./AbstractAsyncMap.js";
+
+export class CachedAsyncMap extends AbstractAsyncMap {
+    /**
+     *
+     * @param {AbstractAsyncMap} volatile
+     * @param {AbstractAsyncMap} persisted
+     */
+    constructor(volatile, persisted) {
+        super();
+
+        this.__volatile = volatile;
+        this.__persisted = persisted;
+    }
+
+    async get(key) {
+        const volatile_value = await this.__volatile.get(key);
+
+        if (volatile_value !== undefined && volatile_value !== null) {
+            return volatile_value;
+        }
+
+        return await this.__persisted.get(key);
+    }
+
+    async set(key, value) {
+        const lock = this.__volatile.set(key, value);
+
+        // don't wait for completion on persisted
+        this.__persisted.set(key, value);
+
+        await lock;
+    }
+}

package/core/geom/3d/SurfacePoint3.js

@@ -1,5 +1,6 @@
 import Quaternion from "../Quaternion.js";
 import Vector3 from "../Vector3.js";
+import { v3_length } from "../v3_length.js";
 
 const q = new Quaternion();
 
@@ -14,14 +15,52 @@ export class SurfacePoint3 {
 
     /**
      *
-     * @param {THREE.Matrix4} matrix4
+     * @param {number[]|mat4|Float32Array} m4
      */
-    applyMatrix4_three(matrix4) {
-        this.position.applyMatrix4_three(matrix4);
+    applyMatrix4(m4) {
+        // transform position
+        const p = this.position;
+
+        const p_x = p.x;
+        const p_y = p.y;
+        const p_z = p.z;
+
+        const result_p_x = m4[0] * p_x + m4[4] * p_y + m4[8] * p_z + m4[12];
+        const result_p_y = m4[1] * p_x + m4[5] * p_y + m4[9] * p_z + m4[13];
+        const result_p_z = m4[2] * p_x + m4[6] * p_y + m4[10] * p_z + m4[14];
+
+        this.position.set(
+            result_p_x,
+            result_p_y,
+            result_p_z
+        );
+
+        // transform normal
+        const n = this.normal;
+
+        const n_x = n.x;
+        const n_y = n.y;
+        const n_z = n.z;
+
+        const result_n_x = m4[0] * n_x + m4[4] * n_y + m4[8] * n_z;
+        const result_n_y = m4[1] * n_x + m4[5] * n_y + m4[9] * n_z;
+        const result_n_z = m4[2] * n_x + m4[6] * n_y + m4[10] * n_z;
 
-        q.setFromRotationMatrix(matrix4);
+        const normal_multiplier = 1 / v3_length(result_n_x, result_n_y, result_n_z);
 
-        this.normal.applyQuaternion(q);
+        this.normal.set(
+            result_n_x * normal_multiplier,
+            result_n_y * normal_multiplier,
+            result_n_z * normal_multiplier,
+        );
+    }
+
+    /**
+     *
+     * @param {THREE.Matrix4} matrix4
+     */
+    applyMatrix4_three(matrix4) {
+        this.applyMatrix4(matrix4.elements);
     }
 
     /**

package/core/geom/Vector2.d.ts

@@ -30,6 +30,8 @@ export default class Vector2 {
 
     copy(other: Vector2): void
 
+    clone(): Vector2
+
     distanceTo(other: Vector2): number
 
     isZero(): boolean

package/core/geom/Vector4.js

@@ -313,10 +313,10 @@ class Vector4 {
         const qw = q.w;
 
         // calculate quat * vec
-        let ix = qw * x + qy * z - qz * y;
-        let iy = qw * y + qz * x - qx * z;
-        let iz = qw * z + qx * y - qy * x;
-        let iw = -qx * x - qy * y - qz * z;
+        const ix = qw * x + qy * z - qz * y;
+        const iy = qw * y + qz * x - qx * z;
+        const iz = qw * z + qx * y - qy * x;
+        const iw = -qx * x - qy * y - qz * z;
 
         // calculate result * inverse quat
         const _x = ix * qw + iw * -qx + iy * -qz - iz * -qy;
@@ -425,7 +425,7 @@ class Vector4 {
         this.set(x, y, z, w);
     }
 
-    *[ Symbol.iterator ]() {
+    * [Symbol.iterator]() {
 
         yield this.x;
         yield this.y;