@woosh/meep-engine 2.39.43 → 2.40.1

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

@@ -7,7 +7,14 @@ import { PNG } from './PNG.js';
 import { BinaryBuffer } from "../../../../../core/binary/BinaryBuffer.js";
 import { isArrayEqualStrict } from "../../../../../core/collection/array/isArrayEqualStrict.js";
 import { PNG_HEADER_BYTES } from "./PNG_HEADER_BYTES.js";
+import { crc } from "./crc.js";
 
+/**
+ *
+ * @param {Uint8Array} buffer
+ * @param {number} offset
+ * @return {number}
+ */
 function readUInt32(buffer, offset) {
     return (buffer[offset] << 24) +
         (buffer[offset + 1] << 16) +
@@ -16,6 +23,12 @@ function readUInt32(buffer, offset) {
 }
 
 
+/**
+ *
+ * @param {Uint8Array} buffer
+ * @param {number} offset
+ * @return {number}
+ */
 function readUInt8(buffer, offset) {
     return buffer[offset];
 }
@@ -37,8 +50,19 @@ export function PNGReader(bytes) {
 
     this.buffer = new BinaryBuffer();
     this.buffer.fromArrayBuffer(bytes);
+
+    /**
+     * Whether CRC should be performed or not
+     * @type {boolean}
+     */
+    this.crc_enabled = false;
 }
 
+/**
+ *
+ * @param {number} length
+ * @return {Uint8Array}
+ */
 PNGReader.prototype.readBytes = function (length) {
     const result = new Uint8Array(length);
 
@@ -91,16 +115,31 @@ PNGReader.prototype.decodeChunk = function () {
         throw new Error('Bad chunk length ' + (0xFFFFFFFF & length));
     }
 
+
+    const chunk_address = buffer.position;
+
     const type = buffer.readASCIICharacters(4);
 
     /**
      *
      * @type {Uint8Array}
      */
-    var chunk = this.readBytes(length);
+    const chunk = this.readBytes(length);
 
     // checksum
-    var crc = buffer.readUint32();
+    const crc_expected = buffer.readUint32();
+
+    if (this.crc_enabled) {
+
+        // NOTE: CRC includes the "type" tag, not just the chunk bytes
+        const crc_actual = crc(buffer.raw_bytes, chunk_address, length + 4);
+
+        if (crc_actual !== crc_expected) {
+            console.warn(`CRC (Cyclic Redundancy Check) error at block '${type}' at address ${chunk_address}`);
+        }
+
+    }
+
 
     switch (type) {
         case 'IHDR':
@@ -118,12 +157,53 @@ PNGReader.prototype.decodeChunk = function () {
         case 'IEND':
             this.decodeIEND(chunk);
             break;
+        default:
+            //console.log(`Unsupported block ${type}`);
+            break;
     }
 
     return type;
 
 };
 
+/**
+ * https://www.w3.org/TR/PNG/#11tEXt
+ * @param {Uint8Array} chunk
+ */
+PNGReader.prototype.decodetEXt = function (chunk) {
+    const buff = BinaryBuffer.fromArrayBuffer(chunk.buffer);
+    const keyword = buff.readASCIICharacters(Number.POSITIVE_INFINITY, true);
+
+    const value = buff.readASCIICharacters(keyword.length - 1, false);
+
+    this.png.text[keyword] = value;
+}
+/**
+ * NOTE: untested
+ * https://www.w3.org/TR/PNG/#11iEXt
+ * @param {Uint8Array} chunk
+ */
+PNGReader.prototype.decodeiEXt = function (chunk) {
+    const buff = BinaryBuffer.fromArrayBuffer(chunk.buffer);
+
+    const keyword = buff.readASCIICharacters(Number.POSITIVE_INFINITY, true);
+
+    const compression_flag = buff.readUint8();
+    const compression_method = buff.readUint8();
+    const language_tag = buff.readASCIICharacters(Number.POSITIVE_INFINITY, true);
+    const translated_keyword = buff.readUTF8String();
+
+    const separator = buff.readUint8();
+
+    if (separator !== 0) {
+        throw new Error('Expected Null Separator after Translated keyword');
+    }
+
+    const text = buff.readUTF8String();
+
+    this.png.text[keyword] = text;
+}
+
 /**
  * http://www.w3.org/TR/2003/REC-PNG-20031110/#11IHDR
  * http://www.libpng.org/pub/png/spec/1.2/png-1.2-pdg.html#C.IHDR

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

@@ -0,0 +1,66 @@
+/*
+ * Ported from C source at https://www.w3.org/TR/PNG-CRCAppendix.html
+ * See also ISO 3309 [ISO-3309] or ITU-T V.42 [ITU-V42] for a formal specification
+ */
+
+/**
+ *
+ * @type {Uint32Array}
+ */
+const crc_table = new Uint32Array(256);
+
+// Precompute checksum table
+for (let n = 0; n < 256; n++) {
+    let c = n;
+    for (let k = 0; k < 8; k++) {
+        if (c & 1) {
+            c = 0xedb88320 ^ (c >>> 1);
+        } else {
+            c = c >>> 1;
+        }
+    }
+    crc_table[n] = c;
+}
+
+const INITIAL = 0xffffffff;
+
+/**
+ * Update a running CRC with the bytes buf[0..len-1]--the CRC
+ * should be initialized to all 1's, and the transmitted value
+ * is the 1's complement of the final running CRC (see the
+ * crc() routine below)).
+ * @param {number} crc
+ * @param {Uint8Array} buf
+ * @param {number} offset
+ * @param {number} len
+ * @return {number}
+ */
+function update_crc(
+    crc,
+    buf,
+    offset,
+    len,
+) {
+    let c = crc;
+
+    const end = offset + len;
+
+    for (let n = offset; n < end; n++) {
+        const lookup_index = (c ^ buf[n]) & 0xff;
+
+        c = crc_table[lookup_index] ^ (c >>> 8);
+    }
+
+    return c;
+}
+
+/**
+ * Returns CRC of the bytes buf[0..len-1]
+ * @param {Uint8Array} buf byte buffer
+ * @param {number} offset
+ * @param {number} len how many bytes to include in checksum calculation
+ * @return {number}
+ */
+export function crc(buf, offset, len) {
+    return (update_crc(INITIAL, buf, offset, len) ^ INITIAL) >>> 0;
+}

package/engine/ecs/speaker/VoiceSystem.js

@@ -429,7 +429,7 @@ export class VoiceSystem extends AbstractContextSystem {
                         const bb = ecd.getComponent(entity, Blackboard);
 
                         if (bb !== undefined) {
-                            bb.acquireNumber(`voice.line_spoken.${line_id}.count`).increment();
+                            bb.incrementNumber(`voice.line_spoken.${line_id}.count`);
                         }
 
                     }

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

@@ -37,6 +37,8 @@ import { buildLightTexture } from "./BuildLightTexture.js";
 import { promiseSamplerHeight } from "./PromiseSamplerHeight.js";
 import { loadLegacyTerrainSplats } from "./splat/loadLegacyTerrainSplats.js";
 import { WHITE_PIXEL_DATA_URL } from "../../../graphics/WHITE_PIXEL_DATA_URL.js";
+import { mat4 } from "gl-matrix";
+import { SurfacePoint3 } from "../../../../core/geom/3d/SurfacePoint3.js";
 
 let idCounter = 0;
 
@@ -157,6 +159,13 @@ class Terrain {
          */
         this.frustumCulled = true;
 
+        /**
+         * 4x4 transform matrix
+         * @private
+         * @type {Float32Array}
+         */
+        this.__transform_matrix = mat4.create();
+
 
         /**
          *
@@ -176,6 +185,11 @@ class Terrain {
          */
         this.__buildWorker = makeTerrainWorkerProxy();
 
+        /**
+         *
+         * @type {TerrainTileManager}
+         * @private
+         */
         this.__tiles = new TerrainTileManager({
             material: this.material,
             buildWorker: this.__buildWorker
@@ -393,26 +407,17 @@ class Terrain {
      * @param {function} errorCallback
      */
     sampleHeight(x, y, callback, missCallback, errorCallback) {
-        assert.typeOf(callback, 'function', 'callback');
-        assert.typeOf(missCallback, 'function', 'missCallback');
-        assert.typeOf(errorCallback, 'function', 'errorCallback');
+        assert.isFunction(callback, 'callback');
+        assert.isFunction(missCallback, 'missCallback');
+        assert.isFunction(errorCallback, 'errorCallback');
 
-        let processed = false;
+        const hit = new SurfacePoint3();
 
-        /**
-         *
-         * @param {Vector3} hit
-         * @param face
-         * @param geometry
-         */
-        function processHit(hit, face, geometry) {
-            if (!processed) {
-                processed = true;
-                callback(hit.y);
-            }
+        if (this.raycastVerticalFirstSync(hit, x, y)) {
+            callback(hit.position.y);
+        } else {
+            missCallback();
         }
-
-        this.raycastVertical(x, y, processHit, missCallback, errorCallback);
     }
 
     /**
@@ -426,27 +431,27 @@ class Terrain {
      * @param {number} directionZ
      * @returns {boolean}
      */
-    raycastFirstSync(result, originX, originY, originZ, directionX, directionY, directionZ) {
-        if (this.__tiles === undefined) {
-            return false;
-        }
-
+    raycastFirstSync(
+        result,
+        originX, originY, originZ,
+        directionX, directionY, directionZ
+    ) {
         return this.__tiles.raycastFirstSync(result, originX, originY, originZ, directionX, directionY, directionZ);
     }
 
     /**
-     *
+     * @deprecated
      * @param {Vector3} origin
      * @param {Vector3} direction
      * @param {function(hit:Vector3, normal:Vector3, geometry:BufferGeometry)} callback
      * @param {function} missCallback
      */
     raycast(origin, direction, callback, missCallback) {
-        this.__tiles.raycast(origin, direction, callback, missCallback);
+        throw new Error('Deprecated, use raycastFirstSync instead');
     }
 
     /**
-     *
+     * @deprecated
      * @param {number} x
      * @param {number} y
      * @param {function} callback
@@ -454,11 +459,7 @@ class Terrain {
      * @param {function} errorCallback
      */
     raycastVertical(x, y, callback, missCallback, errorCallback) {
-        assert.typeOf(callback, 'function', 'callback');
-        assert.typeOf(missCallback, 'function', 'missCallback');
-        assert.typeOf(errorCallback, 'function', 'errorCallback');
-
-        this.__tiles.raycastVertical(x, y, callback, missCallback);
+        throw new Error('Deprecated, use raycastVerticalFirstSync instead');
     }
 
     /**
@@ -469,12 +470,7 @@ class Terrain {
      * @return {boolean}
      */
     raycastVerticalFirstSync(contact, x, y) {
-        if (this.__tiles === undefined) {
-            //tiles don't exist
-            return false;
-        }
-
-        return this.__tiles.raycastVerticalFirstSync(contact, x, y);
+           return this.__tiles.raycastVerticalFirstSync(contact, x, y);
     }
 
     /**
@@ -649,6 +645,24 @@ class Terrain {
         m.uniformsNeedUpdate = true;
     }
 
+    /**
+     *
+     * @param {mat4|Float32Array|number[]} m4
+     */
+    set transform(m4) {
+        mat4.copy(this.__transform_matrix, m4);
+
+        this.__tiles.transform = m4;
+    }
+
+    /**
+     *
+     * @return {Float32Array}
+     */
+    get transform() {
+        return this.__transform_matrix;
+    }
+
     /**
      *
      * @param {TerrainLayer} layer
@@ -846,6 +860,14 @@ class Terrain {
         this.setFlag(TerrainFlags.Built);
     }
 
+    /**
+     * Note: For advanced users only. You can seriously mess up how things look and function with respect to terrain here
+     * @return {TerrainTileManager}
+     */
+    get tiles() {
+        return this.__tiles;
+    }
+
     /**
      *
      * @returns {Texture|null}

package/engine/ecs/terrain/ecs/TerrainSystem.js

@@ -5,6 +5,8 @@ import { assert } from "../../../../core/assert.js";
 import { noop } from "../../../../core/function/Functions.js";
 import { TerrainFlags } from "./TerrainFlags.js";
 import { ImageRGBADataLoader } from "../../../asset/loaders/image/ImageRGBADataLoader.js";
+import { Transform } from "../../transform/Transform.js";
+import { MATRIX_4_IDENTITY } from "../../../../core/geom/3d/matrix/MATRIX_4_IDENTITY.js";
 
 /**
  *
@@ -157,9 +159,12 @@ class TerrainSystem extends System {
         this.__time_delta = timeDelta;
 
 
-        if (dataset !== null) {
-            dataset.traverseComponents(Terrain, this.__visitTerrainComponent, this);
+        if (dataset === null) {
+            return;
         }
+
+
+        dataset.traverseComponents(Terrain, this.__visitTerrainComponent, this);
     }
 
     /**
@@ -171,13 +176,26 @@ class TerrainSystem extends System {
     __visitTerrainComponent(terrain, entity) {
         const em = this.entityManager;
 
-        const dataset = em.dataset;
+        const ecd = em.dataset;
+
+        /**
+         *
+         * @type {Transform|undefined}
+         */
+        const transform = ecd.getComponent(entity, Transform);
+
+        if (transform !== undefined) {
+            // terrain has a transform
+            terrain.transform = transform.matrix;
+        }else{
+            terrain.transform = MATRIX_4_IDENTITY;
+        }
 
         terrain.update(this.__time_delta);
 
         //do frustum culling
         if (terrain.frustumCulled) {
-            TerrainSystem.traverseVisibleTiles(dataset, terrain, ensureTileBuilt);
+            TerrainSystem.traverseVisibleTiles(ecd, terrain, ensureTileBuilt);
         }
     }