@woosh/meep-engine 2.74.0 → 2.75.1

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

@@ -1,431 +1,438 @@
-"use strict";
+export class PNG {
 
-export function PNG() {
-
-    // initialize all members to keep the same hidden class
-    this.width = 0;
-    this.height = 0;
+    /**
+     *
+     * @type {number}
+     */
+    width = 0;
+    /**
+     *
+     * @type {number}
+     */
+    height = 0;
 
     /**
      * Number of bits per channel?
      * @type {number}
      */
-    this.bitDepth = 0;
+    bitDepth = 0;
 
-    this.colorType = 0;
-    this.compressionMethod = 0;
-    this.filterMethod = 0;
-    this.interlaceMethod = 0;
+    colorType = 0;
+    compressionMethod = 0;
+    filterMethod = 0;
+    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;
+    colors = 0;
+    alpha = false;
+    pixelBits = 0;
 
-    this.palette = null;
+    palette = null;
 
     /**
      *
      * @type {Uint8Array|null}
      */
-    this.pixels = null;
+    pixels = null;
 
     /**
      * Transparency palette
      * @type {Uint8Array|null}
      */
-    this.trns = null;
+    trns = null;
 
 
     /**
      * Text metadata coming from tEXt chunks
      * @type {Object<string>}
      */
-    this.text = {};
-}
+    text = {};
 
-PNG.prototype.getWidth = function () {
-    return this.width;
-};
 
-PNG.prototype.setWidth = function (width) {
-    this.width = width;
-};
-
-PNG.prototype.getHeight = function () {
-    return this.height;
-};
-
-PNG.prototype.setHeight = function (height) {
-    this.height = height;
-};
+    getWidth() {
+        return this.width;
+    }
 
-PNG.prototype.getBitDepth = function () {
-    return this.bitDepth;
-};
+    setWidth(width) {
+        this.width = width;
+    }
 
-PNG.prototype.setBitDepth = function (bitDepth) {
-    if ([2, 4, 8, 16].indexOf(bitDepth) === -1) {
-        throw new Error("invalid bith depth " + bitDepth);
+    getHeight() {
+        return this.height;
     }
-    this.bitDepth = bitDepth;
-};
-
-PNG.prototype.getColorType = function () {
-    return this.colorType;
-};
-
-PNG.prototype.setColorType = function (colorType) {
-
-    //   Color    Allowed    Interpretation
-    //   Type    Bit Depths
-    //
-    //   0       1,2,4,8,16  Each pixel is a grayscale sample.
-    //
-    //   2       8,16        Each pixel is an R,G,B triple.
-    //
-    //   3       1,2,4,8     Each pixel is a palette index;
-    //                       a PLTE chunk must appear.
-    //
-    //   4       8,16        Each pixel is a grayscale sample,
-    //                       followed by an alpha sample.
-    //
-    //   6       8,16        Each pixel is an R,G,B triple,
-    //                       followed by an alpha sample.
-
-    var colors = 0, alpha = false;
-
-    switch (colorType) {
-        case 0:
-            colors = 1;
-            break;
-        case 2:
-            colors = 3;
-            break;
-        case 3:
-            colors = 1;
-            break;
-        case 4:
-            colors = 2;
-            alpha = true;
-            break;
-        case 6:
-            colors = 4;
-            alpha = true;
-            break;
-        default:
-            throw new Error("invalid color type");
+
+    setHeight(height) {
+        this.height = height;
     }
 
-    this.colors = colors;
-    this.alpha = alpha;
-    this.colorType = colorType;
-};
+    getBitDepth() {
+        return this.bitDepth;
+    }
 
-PNG.prototype.getCompressionMethod = function () {
-    return this.compressionMethod;
-};
+    setBitDepth(bitDepth) {
+        if ([1, 2, 4, 8, 16].indexOf(bitDepth) === -1) {
+            throw new Error("invalid bith depth " + bitDepth);
+        }
+        this.bitDepth = bitDepth;
+    }
 
-PNG.prototype.setCompressionMethod = function (compressionMethod) {
-    if (compressionMethod !== 0) {
-        throw new Error("invalid compression method " + compressionMethod);
+    getColorType() {
+        return this.colorType;
     }
-    this.compressionMethod = compressionMethod;
-};
 
-PNG.prototype.getFilterMethod = function () {
-    return this.filterMethod;
-};
+    setColorType(colorType) {
+
+        //   Color    Allowed    Interpretation
+        //   Type    Bit Depths
+        //
+        //   0       1,2,4,8,16  Each pixel is a grayscale sample.
+        //
+        //   2       8,16        Each pixel is an R,G,B triple.
+        //
+        //   3       1,2,4,8     Each pixel is a palette index;
+        //                       a PLTE chunk must appear.
+        //
+        //   4       8,16        Each pixel is a grayscale sample,
+        //                       followed by an alpha sample.
+        //
+        //   6       8,16        Each pixel is an R,G,B triple,
+        //                       followed by an alpha sample.
+
+        let colors = 0, alpha = false;
+
+        switch (colorType) {
+            case 0:
+                colors = 1;
+                break;
+            case 2:
+                colors = 3;
+                break;
+            case 3:
+                colors = 1;
+                break;
+            case 4:
+                colors = 2;
+                alpha = true;
+                break;
+            case 6:
+                colors = 4;
+                alpha = true;
+                break;
+            default:
+                throw new Error("invalid color type");
+        }
 
-PNG.prototype.setFilterMethod = function (filterMethod) {
-    if (filterMethod !== 0) {
-        throw new Error("invalid filter method " + filterMethod);
+        this.colors = colors;
+        this.alpha = alpha;
+        this.colorType = colorType;
     }
-    this.filterMethod = filterMethod;
-};
 
-PNG.prototype.getInterlaceMethod = function () {
-    return this.interlaceMethod;
-};
-
-PNG.prototype.setInterlaceMethod = function (interlaceMethod) {
-    if (interlaceMethod !== 0 && interlaceMethod !== 1) {
-        throw new Error("invalid interlace method " + interlaceMethod);
+    getCompressionMethod() {
+        return this.compressionMethod;
     }
-    this.interlaceMethod = interlaceMethod;
-};
-
-/**
- *
- * @param {Uint8Array} trns
- */
-PNG.prototype.setTRNS = function (trns) {
-    this.trns = trns;
-};
-
-PNG.prototype.setPalette = function (palette) {
-    if (palette.length % 3 !== 0) {
-        throw new Error("incorrect PLTE chunk length");
+
+    setCompressionMethod(compressionMethod) {
+        if (compressionMethod !== 0) {
+            throw new Error("invalid compression method " + compressionMethod);
+        }
+        this.compressionMethod = compressionMethod;
     }
-    if (palette.length > (Math.pow(2, this.bitDepth) * 3)) {
-        throw new Error("palette has more colors than 2^bitdepth");
+
+    getFilterMethod() {
+        return this.filterMethod;
     }
-    this.palette = palette;
-};
-
-PNG.prototype.getPalette = function () {
-    return this.palette;
-};
-
-/**
- * get the pixel color on a certain location in a normalized way
- * result is an array: [red, green, blue, alpha]
- */
-PNG.prototype.getPixel = function (result, result_offset, x, y) {
-    var pixels = this.pixels;
-
-    if (!pixels) {
-        throw new Error("pixel data is empty");
+
+    setFilterMethod(filterMethod) {
+        if (filterMethod !== 0) {
+            throw new Error("invalid filter method " + filterMethod);
+        }
+        this.filterMethod = filterMethod;
     }
 
-    if (x >= this.width || y >= this.height) {
-        throw new Error("x,y position out of bound");
+    getInterlaceMethod() {
+        return this.interlaceMethod;
     }
 
-    var i = this.colors * this.bitDepth / 8 * (y * this.width + x);
-
-    let r, g, b, a;
-
-    switch (this.colorType) {
-        case 0:
-            r = pixels[i];
-            g = r;
-            b = r;
-            a = 255;
-            break;
-        case 2:
-            r = pixels[i];
-            g = pixels[i + 1];
-            b = pixels[i + 2];
-            a = 255;
-            break;
-        case 3:
-            a = 255;
-
-            if (this.trns != null) {
-                a = this.trns[pixels[i]];
-            }
+    setInterlaceMethod(interlaceMethod) {
+        if (interlaceMethod !== 0 && interlaceMethod !== 1) {
+            throw new Error("invalid interlace method " + interlaceMethod);
+        }
+        this.interlaceMethod = interlaceMethod;
+    }
 
-            const offset = pixels[i] * 3;
-
-            const palette = this.palette;
-            r = palette[offset];
-            g = palette[offset + 1];
-            b = palette[offset + 2];
-
-            break;
-        case 4:
-            r = pixels[i];
-            g = r;
-            b = r;
-            a = pixels[i + 1];
-            break;
-        case 6:
-            r = pixels[i];
-            g = pixels[i + 1];
-            b = pixels[i + 2];
-            a = pixels[i + 3];
-            break;
-        default:
-            throw new Error('Unsupported color type');
+    /**
+     *
+     * @param {Uint8Array} trns
+     */
+    setTRNS(trns) {
+        this.trns = trns;
     }
 
-    result[result_offset + 0] = r;
-    result[result_offset + 1] = g;
-    result[result_offset + 2] = b;
-    result[result_offset + 3] = a;
-};
+    setPalette(palette) {
+        if (palette.length % 3 !== 0) {
+            throw new Error("incorrect PLTE chunk length");
+        }
+        if (palette.length > (Math.pow(2, this.bitDepth) * 3)) {
+            throw new Error("palette has more colors than 2^bitdepth");
+        }
+        this.palette = palette;
+    }
 
-/**
- * Assumes pixels are stored as RGB without A component, will set A to 255
- * @param {Uint8Array} destination
- */
-PNG.prototype.getRGBA8Array_fromRGB = function (destination) {
+    getPalette() {
+        return this.palette;
+    }
 
-    const height = this.height;
-    const width = this.width;
+    /**
+     * get the pixel color on a certain location in a normalized way
+     * result is an array: [red, green, blue, alpha]
+     */
+    getPixel(result, result_offset, x, y) {
+        const pixels = this.pixels;
 
-    const pixel_count = width * height;
+        if (!pixels) {
+            throw new Error("pixel data is empty");
+        }
 
-    const source = this.pixels;
+        if (x >= this.width || y >= this.height) {
+            throw new Error("x,y position out of bound");
+        }
 
-    for (let i = 0; i < pixel_count; i++) {
-        const i3 = i * 3;
-        const i4 = i3 + i;
+        const i = this.colors * this.bitDepth / 8 * (y * this.width + x);
+
+        let r, g, b, a;
+
+        switch (this.colorType) {
+            case 0:
+                r = pixels[i];
+                g = r;
+                b = r;
+                a = 255;
+                break;
+            case 2:
+                r = pixels[i];
+                g = pixels[i + 1];
+                b = pixels[i + 2];
+                a = 255;
+                break;
+            case 3:
+                a = 255;
+
+                if (this.trns != null) {
+                    a = this.trns[pixels[i]];
+                }
+
+                const offset = pixels[i] * 3;
+
+                const palette = this.palette;
+                r = palette[offset];
+                g = palette[offset + 1];
+                b = palette[offset + 2];
+
+                break;
+            case 4:
+                r = pixels[i];
+                g = r;
+                b = r;
+                a = pixels[i + 1];
+                break;
+            case 6:
+                r = pixels[i];
+                g = pixels[i + 1];
+                b = pixels[i + 2];
+                a = pixels[i + 3];
+                break;
+            default:
+                throw new Error('Unsupported color type');
+        }
 
-        destination[i4] = source[i3];
-        destination[i4 + 1] = source[i3 + 1];
-        destination[i4 + 2] = source[i3 + 2];
-        destination[i4 + 3] = 255;
+        result[result_offset + 0] = r;
+        result[result_offset + 1] = g;
+        result[result_offset + 2] = b;
+        result[result_offset + 3] = a;
     }
 
-};
+    /**
+     * Assumes pixels are stored as RGB without A component, will set A to 255
+     * @param {Uint8Array} destination
+     */
+    getRGBA8Array_fromRGB(destination) {
 
-/**
- *
- * @param {Uint8Array} destination
- */
-PNG.prototype.getRGBA8Array_generic = function (destination) {
+        const height = this.height;
+        const width = this.width;
 
-    const height = this.height;
-    const width = this.width;
+        const pixel_count = width * height;
 
-    for (var y = 0; y < height; y++) {
-        const row_index = y * width;
+        const source = this.pixels;
 
-        for (var x = 0; x < width; x++) {
-            const address = (row_index + x) * 4;
+        for (let i = 0; i < pixel_count; i++) {
+            const i3 = i * 3;
+            const i4 = i3 + i;
 
-            this.getPixel(destination, address, x, y);
+            destination[i4] = source[i3];
+            destination[i4 + 1] = source[i3 + 1];
+            destination[i4 + 2] = source[i3 + 2];
+            destination[i4 + 3] = 255;
         }
+
     }
 
-}
+    /**
+     *
+     * @param {Uint8Array} destination
+     */
+    getRGBA8Array_generic(destination) {
 
+        const height = this.height;
+        const width = this.width;
 
-/**
- * get the pixels of the image as a RGBA array of the form [r1, g1, b1, a1, r2, b2, g2, a2, ...]
- * Matches the api of canvas.getImageData
- */
-PNG.prototype.getRGBA8Array = function () {
-    if (this.colorType === 6) {
-        // RGBA color type, return pixels directly
-        return this.pixels;
-    }
+        for (let y = 0; y < height; y++) {
+            const row_index = y * width;
 
-    const height = this.height;
-    const width = this.width;
+            for (let x = 0; x < width; x++) {
+                const address = (row_index + x) * 4;
 
-    var data = new Uint8Array(width * height * 4);
+                this.getPixel(destination, address, x, y);
+            }
+        }
 
-    if (this.colorType === 2) {
-        // RGB color type
-        this.getRGBA8Array_fromRGB(data);
-    } else {
-        // original, slow generic method
-        this.getRGBA8Array_generic(data);
     }
 
-    return data;
-};
+    /**
+     * get the pixels of the image as a RGBA array of the form [r1, g1, b1, a1, r2, b2, g2, a2, ...]
+     * Matches the api of canvas.getImageData
+     */
+    getRGBA8Array() {
+        if (this.colorType === 6) {
+            // RGBA color type, return pixels directly
+            return this.pixels;
+        }
 
-PNG.prototype.getUint8Data_case3 = function () {
-    const w = this.width;
-    const h = this.height;
+        const height = this.height;
+        const width = this.width;
 
-    const pixel_count = w * h;
+        const data = new Uint8Array(width * height * 4);
 
-    let itemSize;
+        if (this.colorType === 2) {
+            // RGB color type
+            this.getRGBA8Array_fromRGB(data);
+        } else {
+            // original, slow generic method
+            this.getRGBA8Array_generic(data);
+        }
 
-    const transparency_lookup = this.trns;
-    if (transparency_lookup !== null) {
-        // has transparency
-        itemSize = 4;
-    } else {
-        itemSize = 3;
+        return data;
     }
 
-    const result_data = new Uint8Array(pixel_count * itemSize);
+    getUint8Data_case3() {
+        const w = this.width;
+        const h = this.height;
+
+        const area = w * h;
+
+        let itemSize;
 
-    const pixels = this.pixels;
-    const palette = this.palette;
+        const transparency_lookup = this.trns;
+        if (transparency_lookup !== null) {
+            // has transparency
+            itemSize = 4;
+        } else {
+            itemSize = 3;
+        }
 
-    const d = this.colors * this.bitDepth / 8;
+        const result_data = new Uint8Array(area * itemSize);
 
-    for (let i = 0; i < pixel_count; i++) {
-        const destination_address = i * itemSize;
+        const pixels = this.pixels;
+        const palette = this.palette;
 
-        const lookup_index = pixels[i * d];
+        const d = this.colors * Math.ceil(this.bitDepth / 8);
 
-        const lookup_value = lookup_index * 3;
+        for (let i = 0; i < area; i++) {
+            const destination_address = i * itemSize;
 
-        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];
-    }
+            const lookup_index = pixels[i * d];
 
-    //transparency
-    if (transparency_lookup !== null) {
-        const transparency_lookup_size = transparency_lookup.length;
+            const lookup_value = lookup_index * 3;
 
-        for (let i = 0; i < pixel_count; i++) {
-            const pixel_index = pixels[i * d];
-
-            const result_address = i * 4 + 3;
-
-            if (pixel_index >= transparency_lookup_size) {
-                /*
-                 when sampling outside of lookup, value defaults to 255
-                 @see "tRNS" chunk in PNG 1.2 spec
-                 */
-                result_data[result_address] = 255;
-            } else {
-                result_data[result_address] = transparency_lookup[pixel_index];
+            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) {
+            const transparency_lookup_size = transparency_lookup.length;
+
+            for (let i = 0; i < area; i++) {
+                const pixel_index = pixels[i * d];
+
+                const result_address = i * 4 + 3;
+
+                if (pixel_index >= transparency_lookup_size) {
+                    /*
+                     when sampling outside of lookup, value defaults to 255
+                     @see "tRNS" chunk in PNG 1.2 spec
+                     */
+                    result_data[result_address] = 255;
+                } else {
+                    result_data[result_address] = transparency_lookup[pixel_index];
+                }
             }
         }
+
+        return {
+            data: result_data,
+            itemSize: itemSize
+        }
     }
 
-    return {
-        data: result_data,
-        itemSize: itemSize
+    /**
+     * @returns {{itemSize:number, data:Uint8Array, bitDepth: number}}
+     */
+    getUint8Data() {
+        let data;
+        let itemSize = 0; // note, can take this from this.colors
+
+        const color_type = this.colorType;
+
+        switch (color_type) {
+            case 0:
+                data = this.pixels;
+                itemSize = 1;
+                break;
+            case 2:
+                data = this.pixels;
+                itemSize = 3;
+                break;
+            case 3:
+                // palette
+                const c3 = this.getUint8Data_case3();
+
+                data = c3.data;
+                itemSize = c3.itemSize;
+
+                break;
+            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
+        };
     }
 }
 
-/**
- * @returns {{itemSize:number, data:Uint8Array, bitDepth: number}}
- */
-PNG.prototype.getUint8Data = function () {
-    let data;
-    let itemSize = 0; // note, can take this from this.colors
-
-    const color_type = this.colorType;
-
-    switch (color_type) {
-        case 0:
-            data = this.pixels;
-            itemSize = 1;
-            break;
-        case 2:
-            data = this.pixels;
-            itemSize = 3;
-            break;
-        case 3:
-            // palette
-            const c3 = this.getUint8Data_case3();
-
-            data = c3.data;
-            itemSize = c3.itemSize;
-
-            break;
-        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
-    };
-};