@woosh/meep-engine 2.33.23 → 2.33.27

package/engine/animation/curve/AnimationCurve.js

@@ -0,0 +1,72 @@
+import { inverseLerp } from "../../../core/math/inverseLerp.js";
+
+/**
+ *
+ * @param {number} t
+ * @param {Keyframe} keyframe0
+ * @param {Keyframe} keyframe1
+ * @return {number}
+ */
+function evaluate(t, keyframe0, keyframe1) {
+
+    const dt = keyframe1.time - keyframe0.time;
+
+    const m0 = keyframe0.outTangent * dt;
+    const m1 = keyframe1.inTangent * dt;
+
+    const t2 = t * t;
+    const t3 = t2 * t;
+
+    const a = 2 * t3 - 3 * t2 + 1;
+    const b = t3 - 2 * t2 + t;
+    const c = t3 - t2;
+    const d = -2 * t3 + 3 * t2;
+
+    return a * keyframe0.value + b * m0 + c * m1 + d * keyframe1.value;
+}
+
+/**
+ * Modelled on unity's AnimationCurve
+ * @see https://github.com/nothke/ThreadableCurve/blob/master/ThreadableCurve.cs
+ */
+export class AnimationCurve {
+    constructor() {
+        /**
+         *
+         * @type {Keyframe[]}
+         */
+        this.keys = [];
+    }
+
+    evaluate(t) {
+        const keys = this.keys;
+        const key_count = keys.length;
+        if (key_count === 0) {
+            return 0;
+        }
+
+        if (key_count === 1) {
+            return keys[0].value;
+        }
+
+        if (t < keys[0].time) {
+            // before start
+            return keys[0].value;
+        }
+
+        for (let i = 1; i < key_count; i++) {
+            const f1 = keys[i];
+
+            if (t < f1.time) {
+                const f0 = keys[i - 1];
+                const kt = inverseLerp(f0.time, f1.time, t);
+
+                return evaluate(kt, f0, f1);
+            }
+        }
+
+        // past end
+        return keys[key_count - 1].value;
+    }
+
+}

package/engine/animation/curve/Keyframe.js

@@ -0,0 +1,27 @@
+export class Keyframe {
+    constructor() {
+        /**
+         *
+         * @type {number}
+         */
+        this.value = 0;
+
+        /**
+         *
+         * @type {number}
+         */
+        this.time = 0;
+
+        /**
+         *
+         * @type {number}
+         */
+        this.inTangent = 0;
+
+        /**
+         *
+         * @type {number}
+         */
+        this.outTangent = 0;
+    }
+}

package/engine/animation/keyed2/AnimationTrack.js

@@ -19,18 +19,43 @@ function AnimationTrack(properties) {
      */
     this.propertyCount = properties.length;
 
+    /**
+     *
+     * @type {number[]}
+     */
     this.keyValues = [];
+
+    /**
+     *
+     * @type {number[]}
+     */
     this.keyTimes = [];
 
     this.timeStart = Number.POSITIVE_INFINITY;
     this.timeEnd = Number.NEGATIVE_INFINITY;
 
+    /**
+     * Indices of keys from which transition takes place
+     * @type {number[]}
+     */
     this.transitionKeys = [];
+
+    /**
+     * Transition function associated with a key
+     * @type {function[]}
+     */
     this.transitionFunctions = [];
 }
 
-AnimationTrack.prototype.initialize = function () {
-    const keysTyped = new Float64Array(this.keyValues.length);
+AnimationTrack.prototype.optimize = function () {
+    const key_value_count = this.keyValues.length;
+    const key_count = this.keyTimes.length;
+
+    // use a common buffer to get better cache locality
+    const buffer = new ArrayBuffer(key_count * 4 + key_value_count * 8);
+
+    const keyTimesTyped = new Float32Array(buffer, 0, key_count);
+    const keysTyped = new Float64Array(buffer, key_count * 4, key_value_count);
 
     //transfer original keys into typed array
     keysTyped.set(this.keyValues, 0);
@@ -38,7 +63,6 @@ AnimationTrack.prototype.initialize = function () {
     //overwrite the original array
     this.keyValues = keysTyped;
 
-    const keyTimesTyped = new Float32Array(this.keyTimes.length);
     keyTimesTyped.set(this.keyTimes, 0);
 
     this.keyTimes = keyTimesTyped;

package/engine/asset/Asset.js

@@ -4,9 +4,9 @@
  * @param {string} type
  * @constructor
  */
-import { computeHashIntegerArray } from "../../core/math/MathUtils.js";
 import { assert } from "../../core/assert.js";
 import { computeStringHash } from "../../core/primitives/strings/computeStringHash.js";
+import { computeHashIntegerArray } from "../../core/collection/array/computeHashIntegerArray.js";
 
 export class AssetDescription {
     /**

package/engine/asset/loaders/GLTFAssetLoader.d.ts

@@ -2,5 +2,5 @@ import {AssetLoader} from "./AssetLoader";
 import {Object3D} from "three";
 
 export class GLTFAssetLoader extends AssetLoader<Object3D> {
-
+    setDracoDecoderPath(path: string): void
 }

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
@@ -127,6 +159,8 @@ export class GLTFAssetLoader extends AssetLoader {
 
         this.__dracoLoader = new DRACOLoader();
         this.__dracoLoader.setWorkerLimit(1);
+
+        // set default path
         this.__dracoLoader.setDecoderPath(buildDracoDecoderPath());
 
         const loader = new GLTFLoader();
@@ -152,10 +186,31 @@ 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
         });
     }
 
+    /**
+     *
+     * @param {string} p
+     */
+    setDracoDecoderPath(p) {
+        this.__dracoLoader.setDecoderPath(p);
+    }
+
     /**
      *
      * @param {boolean} v
@@ -224,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;
+
 
         /**
          *
@@ -243,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();
 
         /**
@@ -28,6 +29,12 @@ export class ImageRGBADataAsset extends Asset {
          */
         this.height = height;
 
+        /**
+         * Number of channels
+         * @type {number}
+         */
+        this.itemSize = itemSize;
+
         this.byteSize = data.length;
     }
 
@@ -35,7 +42,8 @@ export class ImageRGBADataAsset extends Asset {
         return {
             data: this.data,
             width: this.width,
-            height: this.height
+            height: this.height,
+            itemSize: this.itemSize
         };
     }
 }

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
         };
     }
 }

package/engine/asset/loaders/image/png/PNG.js

@@ -5,12 +5,23 @@ export function PNG() {
     // initialize all members to keep the same hidden class
     this.width = 0;
     this.height = 0;
+
+    /**
+     * Number of bits per channel?
+     * @type {number}
+     */
     this.bitDepth = 0;
+
     this.colorType = 0;
     this.compressionMethod = 0;
     this.filterMethod = 0;
     this.interlaceMethod = 0;
 
+    /**
+     * Number of channels in the image
+     * @example RGB = 3, RGBA = 4, etc.
+     * @type {number}
+     */
     this.colors = 0;
     this.alpha = false;
     this.pixelBits = 0;
@@ -23,6 +34,10 @@ export function PNG() {
      */
     this.pixels = null;
 
+    /**
+     * Transparency palette
+     * @type {Uint8Array|null}
+     */
     this.trns = null;
 
 }
@@ -138,6 +153,10 @@ PNG.prototype.setInterlaceMethod = function (interlaceMethod) {
     this.interlaceMethod = interlaceMethod;
 };
 
+/**
+ *
+ * @param {Uint8Array} trns
+ */
 PNG.prototype.setTRNS = function (trns) {
     this.trns = trns;
 };
@@ -161,7 +180,9 @@ PNG.prototype.getPalette = function () {
  * result is an array: [red, green, blue, alpha]
  */
 PNG.prototype.getPixel = function (result, result_offset, x, y) {
-    if (!this.pixels) {
+    var pixels = this.pixels;
+
+    if (!pixels) {
         throw new Error("pixel data is empty");
     }
 
@@ -170,7 +191,6 @@ PNG.prototype.getPixel = function (result, result_offset, x, y) {
     }
 
     var i = this.colors * this.bitDepth / 8 * (y * this.width + x);
-    var pixels = this.pixels;
 
     let r, g, b, a;
 
@@ -189,14 +209,17 @@ PNG.prototype.getPixel = function (result, result_offset, x, y) {
             break;
         case 3:
             a = 255;
-            if (this.trns != null && this.trns[pixels[i]] != null) {
+
+            if (this.trns != null) {
                 a = this.trns[pixels[i]];
             }
+
             const offset = pixels[i] * 3;
 
-            r = this.palette[offset];
-            g = this.palette[offset + 1];
-            b = this.palette[offset + 2];
+            const palette = this.palette;
+            r = palette[offset];
+            g = palette[offset + 1];
+            b = palette[offset + 2];
 
             break;
         case 4:
@@ -293,3 +316,87 @@ PNG.prototype.getRGBA8Array = function () {
 
     return data;
 };
+
+PNG.prototype.getUint8Data_case3 = function () {
+    const w = this.width;
+    const h = this.height;
+
+    const pixel_count = w * h;
+
+    let itemSize;
+
+    const transparency_lookup = this.trns;
+    if (transparency_lookup !== null) {
+        // has transparency
+        itemSize = 4;
+    } else {
+        itemSize = 3;
+    }
+
+    const result_data = new Uint8Array(pixel_count * itemSize);
+
+    const pixels = this.pixels;
+    const palette = this.palette;
+
+    const d = this.colors * this.bitDepth / 8;
+
+    for (let i = 0; i < pixel_count; i++) {
+        const destination_address = i * itemSize;
+
+        const lookup_value = pixels[i * d];
+
+        result_data[destination_address] = palette[lookup_value];
+        result_data[destination_address + 1] = palette[lookup_value + 1];
+        result_data[destination_address + 2] = palette[lookup_value + 2];
+    }
+
+    //transparency
+    if (transparency_lookup !== null) {
+        for (let i = 0; i < pixel_count; i++) {
+            result_data[i * 4 + 3] = transparency_lookup[pixels[i * d]];
+        }
+    }
+
+    return {
+        data: result_data,
+        itemSize: itemSize
+    }
+}
+
+/**
+ * @returns {{itemSize:number, data:Uint8Array}}
+ */
+PNG.prototype.getUint8Data = function () {
+    let data;
+    let itemSize = 0; // note, can take this from this.colors
+
+    switch (this.colorType) {
+        case 0:
+            data = this.pixels;
+            itemSize = 1;
+            break;
+        case 2:
+            data = this.pixels;
+            itemSize = 3;
+            break;
+        case 3:
+            // palette
+            return this.getUint8Data_case3();
+        case 4:
+            // grayscale with alpha
+            data = this.pixels;
+            itemSize = 2;
+            break;
+        case 6:
+            data = this.pixels;
+            itemSize = 4;
+            break;
+        default:
+            throw new Error('Unsupported color type');
+    }
+
+    return {
+        data,
+        itemSize
+    };
+};

package/engine/asset/loaders/image/png/PNGReader.js

@@ -91,6 +91,10 @@ PNGReader.prototype.decodeChunk = function () {
 
     const type = buffer.readASCIICharacters(4);
 
+    /**
+     *
+     * @type {Uint8Array}
+     */
     var chunk = this.readBytes(length);
 
     // checksum
@@ -161,6 +165,7 @@ PNGReader.prototype.decodeIDAT = function (chunk) {
 
 /**
  * https://www.w3.org/TR/PNG/#11tRNS
+ * @param {Uint8Array} chunk
  */
 PNGReader.prototype.decodeTRNS = function (chunk) {
     this.png.setTRNS(chunk);

package/engine/asset/loaders/material/bitmap2sampler_gl.js

@@ -1,5 +1,5 @@
 /**
- *
+ * Transfer bitmap contents to Sampler2D, effectively moving data to CPU, making it readable
  * @param {WebGL2RenderingContext} gl
  * @param {Sampler2D} sampler
  * @param {ImageBitmap} bitmap

package/engine/asset/loaders/material/computeImageBitmapEquality.js

@@ -40,7 +40,7 @@ function obtainSampler(bitmap, ctx) {
 }
 
 /**
- *
+ * Ref holding webgl context, being weak-ref, allows context to be removed when not in use
  * @type {WeakRef<WebGL2RenderingContext>|null}
  */
 let ctx_ref = null;
@@ -97,8 +97,13 @@ export function sampler_from_bitmap(bitmap) {
  * @returns {boolean}
  */
 export function computeImageBitmapEquality(a, b) {
+    if (a === b) {
+        // strict equality check, special case
+        return true;
+    }
 
     if (a.width !== b.width || a.height !== b.height) {
+        // check dimensions
         return false;
     }
 

package/engine/asset/loaders/material/computeMaterialHash.js

@@ -1,7 +1,9 @@
-import { computeHashArray, computeHashFloat, computeHashIntegerArray } from "../../../../core/math/MathUtils.js";
 import { planeHash } from "./planeHash.js";
 import { computeTextureHash } from "./computeTextureHash.js";
 import { computeStringHash } from "../../../../core/primitives/strings/computeStringHash.js";
+import { computeHashArray } from "../../../../core/collection/array/computeHashArray.js";
+import { computeHashIntegerArray } from "../../../../core/collection/array/computeHashIntegerArray.js";
+import { computeHashFloat } from "../../../../core/math/hash/computeHashFloat.js";
 
 /**
  *