@woosh/meep-engine 2.33.26 → 2.33.30

package/core/binary/ValidatingBitSetWrapper.js

@@ -0,0 +1,81 @@
+//
+
+/**
+ * Debug tool to verify correct behavior of a BitSet
+ */
+export class ValidatingBitSetWrapper {
+    /**
+     *
+     * @param {BitSet} source
+     */
+    constructor(source) {
+        this.__source = source;
+    }
+
+    preventShrink() {
+        this.__source.preventShrink();
+    }
+
+    setShrinkFactor(x) {
+        this.__source.setShrinkFactor(x);
+    }
+
+    setCapacity(x) {
+        this.__source.setCapacity(x);
+    }
+
+    size() {
+        return this.__source.size();
+    }
+
+    capacity() {
+        return this.__source.capacity();
+    }
+
+    previousSetBit(i) {
+        const bit = this.__source.previousSetBit(i);
+
+        if (bit !== -1 && (this.__source.get(bit) !== true || bit > i)) {
+            debugger;
+        }
+
+        return bit;
+    }
+
+    nextSetBit(i) {
+        const bit = this.__source.nextSetBit(i);
+
+        if (bit !== -1 && (this.__source.get(bit) !== true || bit < i)) {
+            debugger;
+        }
+
+        return bit;
+    }
+
+    nextClearBit(i) {
+        const bit = this.__source.nextClearBit(i);
+
+        if (bit !== -1 && (this.__source.get(bit) !== false || bit < i)) {
+            debugger;
+        }
+
+        return bit;
+    }
+
+    set(x, y) {
+        this.__source.set(x, y);
+    }
+
+    clear(i) {
+        this.__source.clear(i);
+    }
+
+    get(i) {
+        return this.__source.get(i);
+    }
+
+
+    reset() {
+        this.__source.reset();
+    }
+}

package/core/bvh2/aabb3/AABB3.js

@@ -761,16 +761,9 @@ AABB3.prototype.computePlaneSide = function computePlaneSide(plane) {
     const normal = plane.normal;
 
     return computeAABB3PlaneSide(
-        normal.x,
-        normal.y,
-        normal.z,
-        plane.constant,
-        this.x0,
-        this.y0,
-        this.z0,
-        this.x1,
-        this.y1,
-        this.z1
+        normal.x, normal.y, normal.z, plane.constant,
+        this.x0, this.y0, this.z0,
+        this.x1, this.y1, this.z1
     );
 };
 

package/core/cache/Cache.d.ts

@@ -4,13 +4,15 @@ export class Cache<K, V> {
                     keyWeigher,
                     valueWeigher,
                     keyHashFunction,
-                    keyEqualityFunction
+                    keyEqualityFunction,
+                    capacity
                 }?: {
         maxWeight?: number,
         keyWeigher?: (key: K) => number,
         valueWeigher?: (value: V) => number,
         keyHashFunction?: (key: K) => number,
-        keyEqualityFunction?: (a: K, b: K) => boolean
+        keyEqualityFunction?: (a: K, b: K) => boolean,
+        capacity?: number
     })
 
     size(): number

package/core/cache/Cache.js

@@ -16,6 +16,7 @@ export class Cache {
      * @param {function(key:Key, value:Value)} [removeListener] will be notified when element is either explicitly removed or evicted
      * @param {function(Key):number} [keyHashFunction]
      * @param {function(Key, Key):boolean} [keyEqualityFunction]
+     * @param {number} capacity initial capacity for the cache, helps prevent early resizing
      * @constructor
      * @template Key, Value
      */
@@ -25,7 +26,8 @@ export class Cache {
                     valueWeigher = returnOne,
                     removeListener = noop,
                     keyHashFunction = returnZero,
-                    keyEqualityFunction = strictEquals
+                    keyEqualityFunction = strictEquals,
+                    capacity
                 } = {}) {
 
         assert.isNumber(maxWeight, 'maxWeight');
@@ -95,7 +97,8 @@ export class Cache {
          */
         this.data = new HashMap({
             keyHashFunction,
-            keyEqualityFunction
+            keyEqualityFunction,
+            capacity
         });
 
         /**

package/core/collection/HashMap.d.ts

@@ -1,7 +1,14 @@
 export class HashMap<K, V> implements Iterable<[V, K]> {
-    constructor({keyHashFunction, keyEqualityFunction}: {
+    constructor({
+                    keyHashFunction,
+                    keyEqualityFunction,
+                    capacity,
+                    loadFactor
+                }: {
         keyHashFunction: (k: K) => number,
-        keyEqualityFunction: (a: K, b: K) => boolean
+        keyEqualityFunction: (a: K, b: K) => boolean,
+        capacity?: number,
+        loadFactor?: number
     })
 
     constructor()

package/core/collection/HashSet.d.ts

@@ -1,7 +1,12 @@
 export class HashSet<T> {
-    constructor({keyHashFunction, keyEqualityFunction}: {
+    constructor({
+                    keyHashFunction,
+                    keyEqualityFunction,
+                    capacity
+                }: {
         keyHashFunction: (k: T) => number,
-        keyEqualityFunction: (a: T, b: T) => boolean
+        keyEqualityFunction: (a: T, b: T) => boolean,
+        capacity?: number
     })
 
     constructor()

package/core/collection/HashSet.js

@@ -11,7 +11,11 @@ export class HashSet {
     /**
      * @template T
      */
-    constructor({ keyHashFunction = invokeObjectHash, keyEqualityFunction = invokeObjectEquals } = {}) {
+    constructor({
+                    keyHashFunction = invokeObjectHash,
+                    keyEqualityFunction = invokeObjectEquals,
+                    capacity
+                } = {}) {
 
         /**
          * Using HashMap as a backing, this is not the most efficient approach, but it works
@@ -20,7 +24,8 @@ export class HashSet {
          */
         this.__map = new HashMap({
             keyHashFunction,
-            keyEqualityFunction
+            keyEqualityFunction,
+            capacity
         });
     }
 

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

@@ -2,7 +2,7 @@ import { array_copy } from "../copyArray.js";
 
 
 /**
- *
+ * Assumes arrays have the same type
  * @param {TypedArray|Float32Array} source
  * @param {TypedArray|Float32Array} destination
  */

package/core/geom/3d/frustum/array_setFromProjectionMatrix.js

@@ -1,5 +1,3 @@
-import { v3_length } from "../../v3_length.js";
-
 /**
  *
  * @param {number[]} destination
@@ -10,10 +8,12 @@ import { v3_length } from "../../v3_length.js";
  * @param {number} w
  */
 function array_set_plane_normalized(destination, destination_offset, x, y, z, w) {
-    const length = v3_length(x, y, z);
+    // compute vector length
+    const length = Math.hypot(x, y, z);
 
     const inverseNormalLength = 1.0 / length;
 
+    // apply normalization
     destination[destination_offset] = x * inverseNormalLength;
     destination[destination_offset + 1] = y * inverseNormalLength;
     destination[destination_offset + 2] = z * inverseNormalLength;

package/core/model/ObservedBoolean.d.ts

@@ -1,4 +1,6 @@
 export default class ObservedBoolean {
+    constructor(value: boolean)
+
     set(value: boolean): ObservedBoolean
 
     getValue(): boolean

package/core/parser/simple/Token.d.ts

@@ -0,0 +1,13 @@
+export class Token<V = string, T = string> {
+    readonly value: V
+    readonly start: number
+    readonly end: number
+    readonly name: string
+    readonly type: T
+
+    constructor(value: V, start: number, end: number, name: string, type: T)
+
+    equals(other: Token<V, T>): boolean
+
+    hash(): number
+}

package/core/parser/simple/Token.js

@@ -1,31 +1,65 @@
-function Token(value, start, end, name, type) {
-    this.value = value;
-    this.start = start;
-    this.end = end;
-    this.name = name;
-    this.type = type;
-}
+class Token {
+    /**
+     * @template V,T
+     * @param {V} value
+     * @param {number} start
+     * @param {number} end
+     * @param {string} name
+     * @param {T} type
+     */
+    constructor(value, start, end, name, type) {
+        /**
+         * @readonly
+         * @type {V}
+         */
+        this.value = value;
+        /**
+         * Starting position in the input
+         * @readonly
+         * @type {number}
+         */
+        this.start = start;
+        /**
+         * End position in the input
+         * @readonly
+         * @type {number}
+         */
+        this.end = end;
+        /**
+         * @readonly
+         * @type {string}
+         */
+        this.name = name;
+        /**
+         * Token type
+         * @readonly
+         * @type {T}
+         */
+        this.type = type;
+    }
 
-/**
- *
- * @param {Token} other
- * @returns {boolean}
- */
-Token.prototype.equals = function (other) {
-    return this.value === other.value &&
-        this.start === other.start &&
-        this.end === other.end &&
-        this.name === other.name &&
-        this.type === other.type
-        ;
-};
+    /**
+     *
+     * @param {Token} other
+     * @returns {boolean}
+     */
+    equals(other) {
+        return this.value === other.value &&
+            this.start === other.start &&
+            this.end === other.end &&
+            this.name === other.name &&
+            this.type === other.type
+            ;
+    }
 
-/**
- *
- * @return {number}
- */
-Token.prototype.hash = function () {
-    return 0;
-};
+    /**
+     *
+     * @return {number}
+     */
+    hash() {
+        // TODO make an actual hash
+        return 0;
+    }
+}
 
 export default Token;

package/editor/tools/FoliagePaintTool.js

@@ -6,7 +6,7 @@ import { parseHex } from "../../core/color/ColorUtils.js";
 import Vector4 from "../../core/geom/Vector4.js";
 import loadSampler2D from "../../engine/graphics/texture/sampler/loadSampler2D.js";
 import convertSampler2D2Canvas from "../../engine/graphics/texture/sampler/Sampler2D2Canvas.js";
-import { Foliage2 } from "../../engine/ecs/foliage/ecs/Foliage2.js";
+import { InstancedMeshComponent } from "../../engine/ecs/foliage/ecs/InstancedMeshComponent.js";
 
 class FoliagePaintTool extends Tool {
     constructor() {
@@ -100,7 +100,7 @@ class FoliagePaintTool extends Tool {
 
         /**
          *
-         * @param {Foliage2} foliage
+         * @param {InstancedMeshComponent} foliage
          * @param {Number} entity
          */
         function visit(foliage, entity) {
@@ -149,9 +149,9 @@ class FoliagePaintTool extends Tool {
 
             /**
              *
-             * @type {Foliage2}
+             * @type {InstancedMeshComponent}
              */
-            const foliage = entityManger.getComponent(entity, Foliage2);
+            const foliage = entityManger.getComponent(entity, InstancedMeshComponent);
 
 
             if (foliage === null) {

package/engine/asset/loaders/GLTFAssetLoader.js

@@ -24,10 +24,42 @@ import { HashSet } from "../../../core/collection/HashSet.js";
 import { computeGeometryHash } from "./geometry/geometry/computeGeometryHash.js";
 import { computeGeometryEquality } from "./geometry/geometry/computeGeometryEquality.js";
 import { traverseThreeObject } from "../../graphics/ecs/highlight/renderer/traverseThreeObject.js";
+import { computeTextureHash } from "./material/computeTextureHash.js";
+import { computeTextureEquality } from "./material/computeTextureEquality.js";
 
 const animationOptimizer = new AnimationOptimizer();
 const materialCache = StaticMaterialCache.Global;
 
+/**
+ *
+ * @param {THREE.Material} material
+ * @param {HashSet<Texture>} texture_cache
+ */
+function replace_material_textures_from_cache(material, texture_cache) {
+    const attachments = TextureAttachmentsByMaterialType[material.type];
+
+    if (attachments === undefined) {
+        // unsupported material
+        return;
+    }
+
+    const attachment_count = attachments.length;
+
+    for (let i = 0; i < attachment_count; i++) {
+        const attachment = attachments[i];
+
+        const texture = attachment.read(material);
+        if (texture !== undefined && texture !== null) {
+            const cached = texture_cache.ensure(texture);
+
+            if (cached !== texture) {
+                // got an existing cached texture, write that instead
+                attachment.write(material, cached);
+            }
+        }
+    }
+}
+
 /**
  * Transfer any transform on the root down to the children instead
  * @param {Object3D} root
@@ -154,7 +186,20 @@ export class GLTFAssetLoader extends AssetLoader {
          */
         this.__geometry_cache = new HashSet({
             keyHashFunction: computeGeometryHash,
-            keyEqualityFunction: computeGeometryEquality
+            keyEqualityFunction: computeGeometryEquality,
+            capacity: 1024
+        });
+
+
+        /**
+         *
+         * @type {HashSet<Texture>}
+         * @private
+         */
+        this.__texture_cache = new HashSet({
+            keyHashFunction: computeTextureHash,
+            keyEqualityFunction: computeTextureEquality,
+            capacity: 2048
         });
     }
 
@@ -234,9 +279,12 @@ export class GLTFAssetLoader extends AssetLoader {
         }
     }
 
+
     load(path, success, failure, progress) {
         const loader = this.loader;
         const geometry_cache = this.__geometry_cache;
+        const texture_cache = this.__texture_cache;
+
 
         /**
          *
@@ -253,6 +301,9 @@ export class GLTFAssetLoader extends AssetLoader {
             geometry = geometry_cache.ensure(geometry);
             mesh.geometry = geometry;
 
+            // replace textures from cache
+            replace_material_textures_from_cache(mesh.material, texture_cache);
+
             const isSkinned = mesh.isSkinnedMesh === true;
 
 

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

@@ -10,7 +10,7 @@ async function decode_png(png_bytes) {
 
         const png = reader.parse();
 
-        const data = png.getRGBA8Array();
+        const uint_channels = png.getUint8Data();
 
         const width = png.getWidth();
         const height = png.getHeight();
@@ -19,9 +19,10 @@ async function decode_png(png_bytes) {
         // console.profileEnd('decode');
 
         resolve({
-            data,
+            data: uint_channels.data,
             width,
-            height
+            height,
+            itemSize: uint_channels.itemSize
         });
     });
 }

package/engine/asset/loaders/image/ImageRGBADataAsset.js

@@ -6,8 +6,9 @@ export class ImageRGBADataAsset extends Asset {
      * @param {number[]|Uint8Array} data
      * @param {number} width
      * @param {number} height
+     * @param {number} [itemSize]
      */
-    constructor(data, width, height) {
+    constructor(data, width, height, itemSize = 4) {
         super();
 
         /**
@@ -32,7 +33,7 @@ export class ImageRGBADataAsset extends Asset {
          * Number of channels
          * @type {number}
          */
-        this.itemSize = 4;
+        this.itemSize = itemSize;
 
         this.byteSize = data.length;
     }

package/engine/asset/loaders/image/ImageRGBADataLoader.js

@@ -23,7 +23,7 @@ export class ImageRGBADataLoader extends AssetLoader {
     /**
      *
      * @param {string} path
-     * @returns {Promise<{data:ArrayBuffer, width: number, height:number}>}
+     * @returns {Promise<{data:ArrayBuffer, width: number, height:number, itemSize: number}>}
      * @private
      */
     async __decode_via_worker(path) {
@@ -45,7 +45,7 @@ export class ImageRGBADataLoader extends AssetLoader {
 
         const bitmap = await this.__decode_via_worker(path);
 
-        return new ImageRGBADataAsset(new Uint8Array(bitmap.data), bitmap.width, bitmap.height);
+        return new ImageRGBADataAsset(new Uint8Array(bitmap.data), bitmap.width, bitmap.height, bitmap.itemSize);
     }
 
     load(path, success, failure, progress) {
@@ -65,7 +65,7 @@ export class ImageRGBADataLoader extends AssetLoader {
 
                 texture.dispose();
 
-                const f = new ImageRGBADataAsset(sampler2D.data, sampler2D.width, sampler2D.height);
+                const f = new ImageRGBADataAsset(sampler2D.data, sampler2D.width, sampler2D.height, sampler2D.itemSize);
 
                 success(f);
 

package/engine/asset/loaders/image/codec/NativeImageDecoder.js

@@ -45,7 +45,8 @@ export class NativeImageDecoder extends Codec {
         return {
             data: rgba_data,
             width: width,
-            height: height
+            height: height,
+            itemSize: 4
         };
     }
 }