@woosh/meep-engine 2.138.13 → 2.138.16

package/src/engine/asset/loaders/image/png/filter/png_filter_unFilterAverage.js

@@ -0,0 +1,59 @@
+/**
+ * The `Average` filter uses the average of the two neighboring pixels (left
+ * and above) to predict the value of a pixel.
+ *
+ * `Average(x) = Raw(x) + floor((Raw(x-bpp)+Prior(x))/2)`
+ *
+ * @param {Uint8Array} scanline raw data
+ * @param {number} scanline_offset
+ * @param {Uint8Array} pixels processed output
+ * @param {number} bpp bytes-per-pixel
+ * @param {number} offset
+ * @param {number} output_offset_previous pass a negative value when there is no previous scanline
+ * @param {number} length
+ *
+ * @see https://www.w3.org/TR/PNG-Filters.html
+ */
+export function png_filter_unFilterAverage(
+    scanline,
+    scanline_offset,
+    pixels,
+    bpp,
+    offset,
+    output_offset_previous,
+    length
+) {
+    let i = 0, byte, prev, prior;
+
+    if (output_offset_previous < 0) {
+
+        // Prior(x) == 0 && Raw(x - bpp) == 0
+        for (; i < bpp; i++) {
+            pixels[offset + i] = scanline[i + scanline_offset];
+        }
+
+        // Prior(x) == 0 && Raw(x - bpp) != 0 (right shift, prevent doubles)
+        for (; i < length; i++) {
+            const of_i = offset + i;
+            pixels[of_i] = (scanline[i + scanline_offset] + (pixels[of_i - bpp] >> 1)) & 0xFF;
+        }
+
+    } else {
+
+        // Prior(x) != 0 && Raw(x - bpp) == 0
+        for (; i < bpp; i++) {
+            pixels[offset + i] = (scanline[i + scanline_offset] + (pixels[output_offset_previous + i] >> 1)) & 0xFF;
+        }
+
+        // Prior(x) != 0 && Raw(x - bpp) != 0
+        for (; i < length; i++) {
+            byte = scanline[i + scanline_offset];
+
+            prev = pixels[offset + i - bpp];
+            prior = pixels[output_offset_previous + i];
+
+            pixels[offset + i] = (byte + (prev + prior >> 1)) & 0xFF;
+        }
+
+    }
+}

package/src/engine/asset/loaders/image/png/filter/png_filter_unFilterNone.d.ts

@@ -0,0 +1,17 @@
+/**
+ * With the None filter, the scanline is transmitted unmodified; it is only necessary to insert a filter type byte before the data.
+ *
+ * For depths < 8 the scanline byte is unpacked into individual samples; for depths 8 and 16 the bytes are copied straight through
+ * (16-bit samples are stored as two big-endian bytes per channel — the filter layer still operates byte-wise).
+ *
+ * @param {Uint8Array} data
+ * @param {number} scanline_address
+ * @param {Uint8Array} output
+ * @param {number} output_offset
+ * @param {number} length number of bytes (depth >= 8) or samples (depth < 8) to produce
+ * @param {number} bit_depth one of 1, 2, 4, 8, 16
+ *
+ * @see https://www.w3.org/TR/PNG-Filters.html
+ */
+export function png_filter_unFilterNone(data: Uint8Array, scanline_address: number, output: Uint8Array, output_offset: number, length: number, bit_depth: number): void;
+//# sourceMappingURL=png_filter_unFilterNone.d.ts.map

package/src/engine/asset/loaders/image/png/filter/png_filter_unFilterNone.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"png_filter_unFilterNone.d.ts","sourceRoot":"","sources":["../../../../../../../../src/engine/asset/loaders/image/png/filter/png_filter_unFilterNone.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,8CATW,UAAU,oBACV,MAAM,UACN,UAAU,iBACV,MAAM,UACN,MAAM,aACN,MAAM,QA2ChB"}

package/src/engine/asset/loaders/image/png/filter/png_filter_unFilterNone.js

@@ -0,0 +1,55 @@
+/**
+ * With the None filter, the scanline is transmitted unmodified; it is only necessary to insert a filter type byte before the data.
+ *
+ * For depths < 8 the scanline byte is unpacked into individual samples; for depths 8 and 16 the bytes are copied straight through
+ * (16-bit samples are stored as two big-endian bytes per channel — the filter layer still operates byte-wise).
+ *
+ * @param {Uint8Array} data
+ * @param {number} scanline_address
+ * @param {Uint8Array} output
+ * @param {number} output_offset
+ * @param {number} length number of bytes (depth >= 8) or samples (depth < 8) to produce
+ * @param {number} bit_depth one of 1, 2, 4, 8, 16
+ *
+ * @see https://www.w3.org/TR/PNG-Filters.html
+ */
+export function png_filter_unFilterNone(
+    data,
+    scanline_address,
+    output,
+    output_offset,
+    length,
+    bit_depth
+) {
+    if (bit_depth === 1) {
+        for (let x = 0; x < length; x++) {
+            const q = x >>> 4;
+            const datum = data[q + scanline_address];
+            const shift = ((x) & 0x7);
+            const out_value = (datum >>> shift) & 0x1;
+            output[output_offset + x] = out_value;
+        }
+    } else if (bit_depth === 2) {
+        for (let x = 0; x < length; x++) {
+            const q = x >>> 2;
+            const datum = data[q + scanline_address];
+            const shift = ((~x) & 0x3) << 1;
+            const out_value = (datum >>> shift) & 0x3;
+            output[output_offset + x] = out_value;
+        }
+    } else if (bit_depth === 4) {
+        for (let x = 0; x < length; x++) {
+            const q = x >>> 1;
+            const datum = data[q + scanline_address];
+            const shift = ((~x) & 0x1) << 2;
+            const out_value = (datum >>> shift) & 0xF;
+            output[output_offset + x] = out_value;
+        }
+    } else if (bit_depth === 8 || bit_depth === 16) {
+        for (let x = 0; x < length; x++) {
+            output[output_offset + x] = data[x + scanline_address];
+        }
+    } else {
+        throw new Error(`unsupported bit depth ${bit_depth}`);
+    }
+}

package/src/engine/asset/loaders/image/png/filter/png_filter_unFilterPaeth.d.ts

@@ -0,0 +1,17 @@
+/**
+ * The `Paeth` filter computes a simple linear function of the three neighboring pixels (left, above, upper left), then chooses as predictor the neighboring pixel closest to the computed value.
+ *
+ * This technique is due to Alan W. Paeth.
+ *
+ * @param {Uint8Array} scanline raw data
+ * @param {number} scanline_offset
+ * @param {Uint8Array} pixels processed output
+ * @param {number} bpp bytes-per-pixel
+ * @param {number} offset
+ * @param {number} output_offset_previous pass a negative value when there is no previous scanline
+ * @param {number} length
+ *
+ * @see https://www.w3.org/TR/PNG-Filters.html
+ */
+export function png_filter_unFilterPaeth(scanline: Uint8Array, scanline_offset: number, pixels: Uint8Array, bpp: number, offset: number, output_offset_previous: number, length: number): void;
+//# sourceMappingURL=png_filter_unFilterPaeth.d.ts.map

package/src/engine/asset/loaders/image/png/filter/png_filter_unFilterPaeth.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"png_filter_unFilterPaeth.d.ts","sourceRoot":"","sources":["../../../../../../../../src/engine/asset/loaders/image/png/filter/png_filter_unFilterPaeth.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,mDAVW,UAAU,mBACV,MAAM,UACN,UAAU,OACV,MAAM,UACN,MAAM,0BACN,MAAM,UACN,MAAM,QA8DhB"}

package/src/engine/asset/loaders/image/png/filter/png_filter_unFilterPaeth.js

@@ -0,0 +1,74 @@
+/**
+ * The `Paeth` filter computes a simple linear function of the three neighboring pixels (left, above, upper left), then chooses as predictor the neighboring pixel closest to the computed value.
+ *
+ * This technique is due to Alan W. Paeth.
+ *
+ * @param {Uint8Array} scanline raw data
+ * @param {number} scanline_offset
+ * @param {Uint8Array} pixels processed output
+ * @param {number} bpp bytes-per-pixel
+ * @param {number} offset
+ * @param {number} output_offset_previous pass a negative value when there is no previous scanline
+ * @param {number} length
+ *
+ * @see https://www.w3.org/TR/PNG-Filters.html
+ */
+export function png_filter_unFilterPaeth(
+    scanline,
+    scanline_offset,
+    pixels,
+    bpp,
+    offset,
+    output_offset_previous,
+    length
+) {
+    let i = 0, raw, a, b, c, p, pa, pb, pc, pr;
+
+    if (output_offset_previous < 0) {
+
+        // Prior(x) == 0 && Raw(x - bpp) == 0
+        for (; i < bpp; i++) {
+            pixels[offset + i] = scanline[i + scanline_offset];
+        }
+
+        // Prior(x) == 0 && Raw(x - bpp) != 0
+        // paethPredictor(x, 0, 0) is always x
+        for (; i < length; i++) {
+            pixels[offset + i] = (scanline[i + scanline_offset] + pixels[offset + i - bpp]) & 0xFF;
+        }
+
+    } else {
+
+        // Prior(x) != 0 && Raw(x - bpp) == 0
+        // paethPredictor(x, 0, 0) is always x
+        for (; i < bpp; i++) {
+            pixels[offset + i] = (scanline[i + scanline_offset] + pixels[output_offset_previous + i]) & 0xFF;
+        }
+
+        // Prior(x) != 0 && Raw(x - bpp) != 0
+        for (; i < length; i++) {
+            raw = scanline[i + scanline_offset];
+
+            c = pixels[output_offset_previous + i - bpp];
+            b = pixels[output_offset_previous + i];
+            a = pixels[offset + i - bpp];
+
+            p = a + b - c;
+
+            pa = Math.abs(p - a);
+            pb = Math.abs(p - b);
+            pc = Math.abs(p - c);
+
+            if (pa <= pb && pa <= pc) {
+                pr = a;
+            } else if (pb <= pc) {
+                pr = b;
+            } else {
+                pr = c;
+            }
+
+            pixels[offset + i] = (raw + pr) & 0xFF;
+        }
+
+    }
+}

package/src/engine/asset/loaders/image/png/filter/png_filter_unFilterSub.d.ts

@@ -0,0 +1,15 @@
+/**
+ * The `Sub` filter transmits the difference between each byte and the value
+ * of the corresponding byte of the prior pixel.
+ * `Sub(x) = Raw(x) + Raw(x - bpp)`
+ *
+ * @param {Uint8Array} scanline raw data
+ * @param {number} scanline_offset
+ * @param {Uint8Array} pixels processed output
+ * @param {number} bpp bytes-per-pixel
+ * @param {number} offset
+ * @param {number} length
+ * @see https://www.w3.org/TR/PNG-Filters.html
+ */
+export function png_filter_unFilterSub(scanline: Uint8Array, scanline_offset: number, pixels: Uint8Array, bpp: number, offset: number, length: number): void;
+//# sourceMappingURL=png_filter_unFilterSub.d.ts.map

package/src/engine/asset/loaders/image/png/filter/png_filter_unFilterSub.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"png_filter_unFilterSub.d.ts","sourceRoot":"","sources":["../../../../../../../../src/engine/asset/loaders/image/png/filter/png_filter_unFilterSub.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,iDARW,UAAU,mBACV,MAAM,UACN,UAAU,OACV,MAAM,UACN,MAAM,UACN,MAAM,QAuBhB"}

package/src/engine/asset/loaders/image/png/filter/png_filter_unFilterSub.js

@@ -0,0 +1,34 @@
+/**
+ * The `Sub` filter transmits the difference between each byte and the value
+ * of the corresponding byte of the prior pixel.
+ * `Sub(x) = Raw(x) + Raw(x - bpp)`
+ *
+ * @param {Uint8Array} scanline raw data
+ * @param {number} scanline_offset
+ * @param {Uint8Array} pixels processed output
+ * @param {number} bpp bytes-per-pixel
+ * @param {number} offset
+ * @param {number} length
+ * @see https://www.w3.org/TR/PNG-Filters.html
+ */
+export function png_filter_unFilterSub(
+    scanline,
+    scanline_offset,
+    pixels,
+    bpp,
+    offset,
+    length
+) {
+
+    let i = 0;
+
+    for (; i < bpp; i++) {
+        pixels[offset + i] = scanline[i + scanline_offset];
+    }
+
+    for (; i < length; i++) {
+        // Raw(x) + Raw(x - bpp)
+        const of_i = offset + i;
+        pixels[of_i] = (scanline[i + scanline_offset] + pixels[of_i - bpp]) & 0xFF;
+    }
+}

package/src/engine/asset/loaders/image/png/filter/png_filter_unFilterUp.d.ts

@@ -0,0 +1,16 @@
+/**
+ * The `Up` filter is just like the Sub() filter except that the pixel
+ * immediately above the current pixel, rather than just to its left, is used
+ * as the predictor.
+ * `Up(x) = Raw(x) + Prior(x)`
+ *
+ * @param {Uint8Array} scanline raw data
+ * @param {number} scanline_offset
+ * @param {Uint8Array} pixels processed output
+ * @param {number} offset
+ * @param {number} output_offset_previous pass a negative value when there is no previous scanline
+ * @param {number} length
+ * @see https://www.w3.org/TR/PNG-Filters.html
+ */
+export function png_filter_unFilterUp(scanline: Uint8Array, scanline_offset: number, pixels: Uint8Array, offset: number, output_offset_previous: number, length: number): void;
+//# sourceMappingURL=png_filter_unFilterUp.d.ts.map

package/src/engine/asset/loaders/image/png/filter/png_filter_unFilterUp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"png_filter_unFilterUp.d.ts","sourceRoot":"","sources":["../../../../../../../../src/engine/asset/loaders/image/png/filter/png_filter_unFilterUp.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,gDARW,UAAU,mBACV,MAAM,UACN,UAAU,UACV,MAAM,0BACN,MAAM,UACN,MAAM,QAkChB"}

package/src/engine/asset/loaders/image/png/filter/png_filter_unFilterUp.js

@@ -0,0 +1,46 @@
+/**
+ * The `Up` filter is just like the Sub() filter except that the pixel
+ * immediately above the current pixel, rather than just to its left, is used
+ * as the predictor.
+ * `Up(x) = Raw(x) + Prior(x)`
+ *
+ * @param {Uint8Array} scanline raw data
+ * @param {number} scanline_offset
+ * @param {Uint8Array} pixels processed output
+ * @param {number} offset
+ * @param {number} output_offset_previous pass a negative value when there is no previous scanline
+ * @param {number} length
+ * @see https://www.w3.org/TR/PNG-Filters.html
+ */
+export function png_filter_unFilterUp(
+    scanline,
+    scanline_offset,
+    pixels,
+    offset,
+    output_offset_previous,
+    length
+) {
+    let i = 0, byte, prev;
+
+    // Prior(x) is 0 for all x on the first scanline
+    if (output_offset_previous < 0) {
+
+        for (; i < length; i++) {
+            pixels[offset + i] = scanline[i + scanline_offset];
+        }
+
+    } else {
+
+        for (; i < length; i++) {
+
+            // Raw(x)
+            byte = scanline[i + scanline_offset];
+
+            // Prior(x)
+            prev = pixels[output_offset_previous + i];
+
+            pixels[offset + i] = (byte + prev) & 0xFF;
+        }
+
+    }
+}

package/src/engine/asset/loaders/image/png/inflate.d.ts

@@ -0,0 +1,7 @@
+/**
+ *
+ * @param {Uint8Array} encoded_chunk
+ * @returns {ArrayBuffer}
+ */
+export function inflate(encoded_chunk: Uint8Array): ArrayBuffer;
+//# sourceMappingURL=inflate.d.ts.map

package/src/engine/asset/loaders/image/png/inflate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inflate.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/asset/loaders/image/png/inflate.js"],"names":[],"mappings":"AAEA;;;;GAIG;AACH,uCAHW,UAAU,GACR,WAAW,CAcvB"}

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

@@ -0,0 +1,20 @@
+import zlib from "pako";
+
+/**
+ *
+ * @param {Uint8Array} encoded_chunk
+ * @returns {ArrayBuffer}
+ */
+export function inflate(encoded_chunk) {
+    const inflator = new zlib.Inflate();
+
+
+    inflator.push(encoded_chunk);
+
+    if (inflator.err) {
+        throw new Error(inflator.err);
+    }
+
+
+    return inflator.result.buffer;
+}

package/src/engine/ecs/terrain/ecs/Terrain.js

@@ -40,7 +40,7 @@ let idCounter = 0;
  * NOTE: edges of the terrain will typically result in patches smaller than this, so this is upper bound
  * @type {number}
  */
-const TILE_SIZE = 7;
+const TILE_SIZE = 32;
 
 class Terrain {
     /**

package/src/engine/ecs/terrain/ecs/splat/SplatMapping.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SplatMapping.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/ecs/terrain/ecs/splat/SplatMapping.js"],"names":[],"mappings":"AAaA;;GAEG;AACH;IAEQ;;;OAGG;IACH,MAFU,OAAO,CAEY;IAE7B;;;OAGG;IACH,OAFU,MAAM,CAEF;IAOd;;;OAGG;IACH,eAFU,kBAAkB,CAEiE;IAUjG;;;;;;;MAQC;IAED;;;;;;;aA6BC;IAED;;;;;OAKG;IACH,8BAJW,SAAS,SACT,MAAM,YACN,MAAM,QA0BhB;IAED;;;;;OAKG;IACH,gCAJW,SAAS,SACT,MAAM,YACN,MAAM,QA2BhB;IAED;;;;;;;OAOG;IACH,wBANW,UAAU,gBACV,MAAM,gBACN,MAAM,eACN,MAAM,gBACN,MAAM,QA2ChB;IAED;;;;;;;OAOG;IACH,4BANW,UAAU,WACV,MAAM,WACN,MAAM,SACN,MAAM,UACN,MAAM,QAuChB;IAED;;;;;;OAMG;IACH,gBALW,MAAM,KACN,MAAM,iBACN,MAAM,GACJ,MAAM,CAKlB;IAED;;;;OAIG;IACH,6BAHW,MAAM,GACJ,SAAS,CAcrB;IAED;;OAEG;IACH,iDAEC;IAED;;;OAGG;IACH,mDAEC;IAED;;;OAGG;IACH,iCAEC;IAED;;;;OAIG;IACH,gCAHW,UAAU,QAoDpB;IAED,gBAEC;IAED;;;;OAIG;IACH,yBAHW,MAAM,GACJ,OAAO,CAuCnB;IAED;;;;OAIG;IACH,8BAHW,MAAM,SACN,MAAM,QAqBhB;IAED,uBAiBC;IAED;;;;;;OAMG;IACH,cALW,MAAM,UACN,MAAM,SACN,MAAM,cACN,OAAO,QA6DjB;CACJ;oBAtgBmB,qCAAqC;mCALoC,OAAO;0BAU1E,mDAAmD"}
+{"version":3,"file":"SplatMapping.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/ecs/terrain/ecs/splat/SplatMapping.js"],"names":[],"mappings":"AAaA;;GAEG;AACH;IAEQ;;;OAGG;IACH,MAFU,OAAO,CAEY;IAE7B;;;OAGG;IACH,OAFU,MAAM,CAEF;IAOd;;;OAGG;IACH,eAFU,kBAAkB,CAEiE;IAUjG;;;;;;;MAQC;IAED;;;;;;;aA6BC;IAED;;;;;OAKG;IACH,8BAJW,SAAS,SACT,MAAM,YACN,MAAM,QAiDhB;IAED;;;;;OAKG;IACH,gCAJW,SAAS,SACT,MAAM,YACN,MAAM,QA2BhB;IAED;;;;;;;OAOG;IACH,wBANW,UAAU,gBACV,MAAM,gBACN,MAAM,eACN,MAAM,gBACN,MAAM,QA2ChB;IAED;;;;;;;OAOG;IACH,4BANW,UAAU,WACV,MAAM,WACN,MAAM,SACN,MAAM,UACN,MAAM,QAuChB;IAED;;;;;;OAMG;IACH,gBALW,MAAM,KACN,MAAM,iBACN,MAAM,GACJ,MAAM,CAKlB;IAED;;;;OAIG;IACH,6BAHW,MAAM,GACJ,SAAS,CAcrB;IAED;;OAEG;IACH,iDAEC;IAED;;;OAGG;IACH,mDAEC;IAED;;;OAGG;IACH,iCAEC;IAED;;;;OAIG;IACH,gCAHW,UAAU,QAoDpB;IAED,gBAEC;IAED;;;;OAIG;IACH,yBAHW,MAAM,GACJ,OAAO,CAuCnB;IAED;;;;OAIG;IACH,8BAHW,MAAM,SACN,MAAM,QAqBhB;IAED,uBAiBC;IAED;;;;;;OAMG;IACH,cALW,MAAM,UACN,MAAM,SACN,MAAM,cACN,OAAO,QA6DjB;CACJ;oBA7hBmB,qCAAqC;mCALoC,OAAO;0BAU1E,mDAAmD"}

package/src/engine/ecs/terrain/ecs/splat/SplatMapping.js

@@ -95,27 +95,50 @@ export class SplatMapping {
      * @param {number} channel
      */
     writeLayerFromSampler(source, index, channel = 0) {
-        const weightData = this.weightData;
+        const weight_data = this.weightData;
 
         const width = this.size.x;
         const height = this.size.y;
 
         const dataOffset = index * width * height;
 
-        for (let y = 0; y < height; y++) {
-            const v = (y + 0.5) / height;
 
-            for (let x = 0; x < width; x++) {
+        if (source.width === width && source.height === height) {
 
-                const u = (x + 0.5) / width;
+            // special fast path
+            const pixel_count = width * height;
 
-                const targetIndex = y * width + x;
-                const targetAddress = dataOffset + targetIndex;
+            const source_channel_count = source.itemSize;
+            const source_data = source.data;
+
+            for (let i = 0; i < pixel_count; i++) {
+                weight_data[dataOffset + i] = source_data[i * source_channel_count + channel]
+            }
+
+        } else {
 
-                const value = source.sampleChannelBilinearUV(u, v, channel);
+            for (let y = 0; y < height; y++) {
 
-                weightData[targetAddress] = value;
+                const v = (y + 0.5) / height;
+
+                for (let x = 0; x < width; x++) {
+
+                    const u = (x + 0.5) / width;
+
+                    const targetIndex = y * width + x;
+                    const targetAddress = dataOffset + targetIndex;
+
+                    let value = source.sampleChannelBilinearUV(u, v, channel);
+
+                    if (value > 0 && value < 1) {
+                        // avoid collapse to 0
+                        value = 1;
+                    }
+
+                    weight_data[targetAddress] = value;
+                }
             }
+
         }
 
     }