@woosh/meep-engine 2.33.26 → 2.33.27

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/computeTextureEquality.js

@@ -1,4 +1,5 @@
 import { computeImageBitmapEquality } from "./computeImageBitmapEquality.js";
+import { isArrayEqualStrict } from "../../../../core/collection/array/isArrayEqualStrict.js";
 
 //
 
@@ -50,20 +51,10 @@ export function computeTextureEquality(a, b) {
         const aMipmaps = a.mipmaps;
         const bMipmaps = b.mipmaps;
 
-        const n = aMipmaps.length;
-
-        if (n !== bMipmaps.length) {
+        if (!textureMipChainEqual(aMipmaps, bMipmaps)) {
             return false;
         }
 
-        for (let i = 0; i < n; i++) {
-            const aMipmap = aMipmaps[i];
-            const bMipmap = bMipmaps[i];
-
-            if (!textureMipmapEqual(aMipmap, bMipmap)) {
-                return false;
-            }
-        }
     }
 
     //TODO implement support for other texture types
@@ -119,47 +110,52 @@ export function textureImagesEqual(a, b) {
             const bMipmaps = bi.mipmaps;
 
             //TODO should we ignore mipmaps if they are absent?
-            if (aMipmaps === undefined) {
-                if (bMipmaps === undefined) {
-                    continue;
-                } else {
-                    return false;
-                }
-            } else if (bMipmaps === undefined) {
+            if (!textureMipChainEqual(aMipmaps, bMipmaps)) {
                 return false;
             }
+        }
+
+    }
 
-            for (let j = 0; j < aMipmaps.length; j++) {
-                const aMipmap = aMipmaps[j];
-                const bMipmap = bMipmaps[j];
+    // assume equivalent
+    return true;
+}
+
+/**
+ *
+ * @param {[]} a
+ * @param {[]} b
+ * @returns {boolean}
+ */
+function textureMipChainEqual(a, b) {
+    if (a === undefined) {
+        if (b === undefined) {
+            return true;
+        } else {
+            return false;
+        }
+    } else if (b === undefined) {
+        return false;
+    }
 
-                /**
-                 * @type {Uint8Array}
-                 */
-                const aData = aMipmap.data;
+    const a_length = a.length;
 
-                /**
-                 * @type {Uint8Array}
-                 */
-                const bData = bMipmap.data;
+    if (a_length !== b.length) {
+        // different mip chain length
+        return false;
+    }
 
-                const dataLength = aData.length;
-                if (dataLength !== bData.length) {
-                    return false;
-                }
+    for (let j = a_length - 1; j >= 0; j--) { //traverse chain top to bottom, starting from smallest mip for faster rejection
 
+        const aMipmap = a[j];
+        const bMipmap = b[j];
 
-                for (let k = 0; k < dataLength; k++) {
-                    if (aData[k] !== bData[k]) {
-                        return false;
-                    }
-                }
-            }
+        if (!textureMipmapEqual(aMipmap, bMipmap)) {
+            return false;
         }
 
     }
 
-    // assume equivalent
     return true;
 }
 
@@ -182,16 +178,11 @@ function textureMipmapEqual(a, b) {
     const aData = a.data;
     const bData = b.data;
 
-    const n = aData.length;
-    if (bData.length !== n) {
-        return false;
-    }
 
-    for (let i = 0; i < n; i++) {
-        if (aData[i] !== bData[i]) {
-            return false;
-        }
+    if (aData === bData) {
+        // special case
+        return true;
     }
 
-    return true;
+    return isArrayEqualStrict(aData, bData);
 }

package/engine/ecs/EntityComponentDataset.js

@@ -1212,7 +1212,7 @@ export class EntityComponentDataset {
 
         if (!ENV_PRODUCTION) {
             assert.isNumber(componentTypeIndex, "componentTypeIndex");
-            assert.typeOf(visitor, "function", "visitor");
+            assert.isFunction(visitor, "visitor");
         }