@woosh/meep-engine 2.39.44 → 2.40.0

package/core/binary/BinaryBuffer.js

@@ -85,6 +85,14 @@ export class BinaryBuffer {
         this.__growFactor = 1.1;
     }
 
+    /**
+     * Access raw underlying bytes attached to the buffer
+     * @return {Uint8Array}
+     */
+    get raw_bytes() {
+        return this.__data_uint8;
+    }
+
     /**
      * @param {ArrayBuffer} arrayBuffer
      */

package/core/bvh2/aabb3/AABB3.js

@@ -551,139 +551,6 @@ export class AABB3 {
         return aabb3_intersects_line_segment(this.x0, this.y0, this.z0, this.x1, this.y1, this.z1, startX, startY, startZ, endX, endY, endZ);
     }
 
-    /**
-     * @source http://stackoverflow.com/questions/3106666/intersection-of-line-segment-with-axis-aligned-box-in-c-sharp
-     * @param {number} startX
-     * @param {number} startY
-     * @param {number} startZ
-     * @param {number} endX
-     * @param {number} endY
-     * @param {number} endZ
-     * @returns {boolean}
-     */
-    intersectSegment2(startX, startY, startZ, endX, endY, endZ) {
-        //var beginToEnd = segmentEnd - segmentBegin;
-        const deltaX = endX - startX,
-            deltaY = endY - startY,
-            deltaZ = endZ - startZ;
-        //var minToMax = new Vector3D(boxSize.X, boxSize.Y, boxSize.Z);
-
-        //var min = boxCenter - minToMax / 2;
-        //var max = boxCenter + minToMax / 2;
-        //var beginToMin = min - segmentBegin;
-        //var beginToMax = max - segmentBegin;
-        //var tNear = double.MinValue;
-        let tNear = Number.NEGATIVE_INFINITY;
-        //var tFar = double.MaxValue;
-        let tFar = Number.POSITIVE_INFINITY;
-        let t1, t2, tMin, tMax;
-        //var intersections = new List<Point3D>();
-        //var intersections = [];
-        let beginToMin = this.x0 - startX;
-        let beginToMax = this.x1 - startX;
-        if (deltaX === 0) {//parallel
-            if (beginToMin > 0 || beginToMax < 0) {
-                return false; //segment is not between planes
-            }
-        } else {
-            t1 = beginToMin / deltaX;
-            t2 = beginToMax / deltaX;
-            tMin = Math.min(t1, t2);
-            tMax = Math.max(t1, t2);
-            if (tMin > tNear) {
-                tNear = tMin;
-            }
-            if (tMax < tFar) {
-                tFar = tMax;
-            }
-            if (tNear > tFar || tFar < 0) {
-                return false;
-            }
-        }
-        beginToMin = this.y0 - startY;
-        beginToMax = this.y1 - startY;
-        if (deltaY === 0) {//parallel
-            if (beginToMin > 0 || beginToMax < 0) {
-                return false; //segment is not between planes
-            }
-        } else {
-            t1 = beginToMin / deltaY;
-            t2 = beginToMax / deltaY;
-            tMin = Math.min(t1, t2);
-            tMax = Math.max(t1, t2);
-            if (tMin > tNear) {
-                tNear = tMin;
-            }
-            if (tMax < tFar) {
-                tFar = tMax;
-            }
-            if (tNear > tFar || tFar < 0) {
-                return false;
-            }
-        }
-        beginToMin = this.z0 - startZ;
-        beginToMax = this.z1 - startZ;
-        if (deltaZ === 0) {//parallel
-            if (beginToMin > 0 || beginToMax < 0) {
-                return false; //segment is not between planes
-            }
-        } else {
-            t1 = beginToMin / deltaZ;
-            t2 = beginToMax / deltaZ;
-            tMin = Math.min(t1, t2);
-            tMax = Math.max(t1, t2);
-            if (tMin > tNear) {
-                tNear = tMin;
-            }
-            if (tMax < tFar) {
-                tFar = tMax;
-            }
-            if (tNear > tFar || tFar < 0) {
-                return false;
-            }
-        }
-        //
-        if (tNear >= 0 && tNear <= 1) {
-            //intersections.push({
-            //    x: startX + deltaX * tNear,
-            //    y: startY + deltaY * tNear,
-            //    z: startZ + deltaZ * tNear
-            //});
-            return true;
-        }
-        if (tFar >= 0 && tFar <= 1) {
-            //intersections.push({
-            //    x: startX + deltaX * tFar,
-            //    y: startY + deltaY * tFar,
-            //    z: startZ + deltaZ * tFar
-            //});
-            return true;
-        }
-        return false;
-        //foreach (Axis axis in Enum.GetValues(typeof(Axis)))
-        //{
-        //    if (beginToEnd.GetCoordinate(axis) == 0) // parallel
-        //    {
-        //        if (beginToMin.GetCoordinate(axis) > 0 || beginToMax.GetCoordinate(axis) < 0)
-        //            return intersections; // segment is not between planes
-        //    }
-        //    else
-        //    {
-        //        var t1 = beginToMin.GetCoordinate(axis) / beginToEnd.GetCoordinate(axis);
-        //        var t2 = beginToMax.GetCoordinate(axis) / beginToEnd.GetCoordinate(axis);
-        //        var tMin = Math.Min(t1, t2);
-        //        var tMax = Math.Max(t1, t2);
-        //        if (tMin > tNear) tNear = tMin;
-        //        if (tMax < tFar) tFar = tMax;
-        //        if (tNear > tFar || tFar < 0) return intersections;
-        //
-        //    }
-        //}
-        //if (tNear >= 0 && tNear <= 1) intersections.Add(segmentBegin + beginToEnd * tNear);
-        //if (tFar >= 0 && tFar <= 1) intersections.Add(segmentBegin + beginToEnd * tFar);
-        //return intersections;
-    }
-
     /**
      *
      * @param {THREE.Box} box

package/core/bvh2/aabb3/aabb3_intersects_line_segment.js

@@ -1,7 +1,7 @@
 import { fabsf } from "../../math/fabsf.js";
 
 /**
- *
+ *  http://stackoverflow.com/questions/3106666/intersection-of-line-segment-with-axis-aligned-box-in-c-sharp
  * @param {number} x0
  * @param {number} y0
  * @param {number} z0

package/core/geom/3d/matrix/MATRIX_4_IDENTITY.js

@@ -0,0 +1,9 @@
+/**
+ *
+ * @type {number[]|mat4}
+ */
+export const MATRIX_4_IDENTITY = Object.freeze([1, 0, 0, 0,
+    0, 1, 0, 0,
+    0, 0, 1, 0,
+    0, 0, 0, 1
+]);

package/core/parser/simple/DataType.js

@@ -3,7 +3,7 @@
  * @enum {string}
  * @readonly
  */
-const DataType = {
+export const DataType = {
     String: "string",
     Number: "number",
     Boolean: "boolean",
@@ -12,4 +12,4 @@ const DataType = {
 };
 
 
-export default DataType;
+export default DataType;

package/editor/view/EditorView.js

@@ -28,10 +28,11 @@ import SelectionClearAction from "../actions/concrete/SelectionClearAction.js";
 import EntityCreateAction from "../actions/concrete/EntityCreateAction.js";
 import ComponentAddAction from "../actions/concrete/ComponentAddAction.js";
 import SelectionAddAction from "../actions/concrete/SelectionAddAction.js";
-import { noop, passThrough } from "../../core/function/Functions.js";
+import { passThrough } from "../../core/function/Functions.js";
 import { ProcessState } from "../../core/process/ProcessState.js";
 import { MeshEvents } from "../../engine/graphics/ecs/mesh/MeshEvents.js";
 import { obtainTerrain } from "../../engine/ecs/terrain/util/obtainTerrain.js";
+import { SurfacePoint3 } from "../../core/geom/3d/SurfacePoint3.js";
 
 class ViewManager extends View {
     constructor() {
@@ -204,35 +205,37 @@ function prepareMeshLibrary(editor) {
         const entityCreateAction = new EntityCreateAction();
         actions.do(entityCreateAction);
 
-        terrain.raycast(source, direction, function (hit, normal, geometry) {
-            function handleMeshSetEvent() {
-                const bb = mesh.boundingBox;
+        const sp3 = new SurfacePoint3();
 
-                const c0 = new Vector3(bb.x0, bb.y0, bb.z0);
-                const c1 = new Vector3(bb.x1, bb.y1, bb.z1);
+        const hit_found = terrain.raycastFirstSync(sp3, source.x, source.y, source.z, direction.x, direction.y, direction.z);
 
-                const diagonal = c0.distanceTo(c1);
+        function handleMeshSetEvent() {
+            const bb = mesh.boundingBox;
 
-                const offset = direction.clone().multiplyScalar(diagonal);
+            const c0 = new Vector3(bb.x0, bb.y0, bb.z0);
+            const c1 = new Vector3(bb.x1, bb.y1, bb.z1);
 
-                transform.position.add(offset);
+            const diagonal = c0.distanceTo(c1);
 
-                //remove listener
-                ecd.removeEntityEventListener(entityCreateAction.entity, MeshEvents.DataSet, handleMeshSetEvent);
-            }
+            const offset = direction.clone().multiplyScalar(diagonal);
 
-            if (hit !== null) {
-                //got a terrain ray hit, set world placement position to that point
-                worldPosition.copy(hit);
-            } else {
-                //set position to the source of the ray pick if there's nothing else available
-                worldPosition.copy(source);
+            transform.position.add(offset);
 
+            //remove listener
+            ecd.removeEntityEventListener(entityCreateAction.entity, MeshEvents.DataSet, handleMeshSetEvent);
+        }
 
-                //wait for mesh to load
-                ecd.addEntityEventListener(entityCreateAction.entity, MeshEvents.DataSet, handleMeshSetEvent);
-            }
-        }, noop);
+        if (hit_found) {
+            //got a terrain ray hit, set world placement position to that point
+            worldPosition.copy(sp3.position);
+        } else {
+            //set position to the source of the ray pick if there's nothing else available
+            worldPosition.copy(source);
+
+
+            //wait for mesh to load
+            ecd.addEntityEventListener(entityCreateAction.entity, MeshEvents.DataSet, handleMeshSetEvent);
+        }
 
         transform.position.copy(worldPosition);
 

package/editor/view/ecs/components/common/NumberController.js

@@ -1,6 +1,8 @@
 import View from "../../../../../view/View.js";
 import Vector1 from "../../../../../core/geom/Vector1.js";
 
+const DEFAULT_VALUE = 0;
+
 export class NumberController extends View {
     /**
      *
@@ -32,6 +34,22 @@ export class NumberController extends View {
 
         let lockForward = false;
 
+        /**
+         *
+         * @param {number} num_value
+         * @return {string}
+         */
+        function format_value_string(num_value) {
+
+            let str = String(num_value);
+
+            if (Math.abs(num_value) > 0 && Math.abs(num_value % 1).toString().length > (figures + 2)) {
+                str = num_value.toFixed(figures);
+            }
+
+            return str;
+        }
+
         function data2view() {
 
             if (lockForward) {
@@ -40,26 +58,37 @@ export class NumberController extends View {
 
             const num_value = _value.getValue();
 
-            let str = num_value;
-
-            if (Math.abs(num_value) > 0 && Math.abs(num_value % 1).toString().length > (figures + 2)) {
-                str = num_value.toFixed(figures);
-            }
-
-            el.value = str;
+            el.value = format_value_string(num_value);
 
         }
 
         function view2data() {
             lockForward = true;
 
-            _value.set(parseFloat(el.value));
+            const value = parseFloat(el.value);
+
+            if (Number.isNaN(value)) {
+                _value.set(DEFAULT_VALUE);
+            } else {
+                _value.set(value);
+            }
 
             lockForward = false;
         }
 
+        /**
+         * Input field stops being edited
+         */
+        function handle_blur() {
+            if (Number.isNaN(parseFloat(el.value))) {
+                // input in the field is invalid, replace with the value held in the data container
+                el.value = format_value_string(_value.getValue());
+            }
+        }
+
         _value.process(data2view);
 
         el.addEventListener('input', view2data);
+        el.addEventListener('blur', handle_blur);
     }
 }

package/engine/EngineHarness.js

@@ -9,7 +9,6 @@ import Vector3 from "../core/geom/Vector3.js";
 import Terrain from "./ecs/terrain/ecs/Terrain.js";
 import Vector2 from "../core/geom/Vector2.js";
 import Water from "./graphics/ecs/water/Water.js";
-import { loadGameClassRegistry } from "../../model/game/GameClassRegistry.js";
 import { WebEnginePlatform } from "./platform/WebEnginePlatform.js";
 import Tag from "./ecs/components/Tag.js";
 import { SerializationMetadata } from "./ecs/components/SerializationMetadata.js";
@@ -116,8 +115,6 @@ export class EngineHarness {
 
             await setLocale(engine);
 
-            loadGameClassRegistry(engine.classRegistry);
-
             engine.sceneManager.create("test");
             engine.sceneManager.set("test");
 

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':

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}