@woosh/meep-engine 2.33.22 → 2.33.26

package/engine/graphics/texture/atlas/AtlasPatch.js

@@ -5,12 +5,15 @@ import AABB2 from "../../../../core/geom/AABB2.js";
 export class AtlasPatch {
     constructor() {
         /**
-         *
+         * Position in the atlas where the raw patch data is found, excludes padding
+         * @readonly
          * @type {Vector2}
          */
         this.position = new Vector2(0, 0);
+
         /**
-         *
+         * Size in pixels of the patch, excludes padding
+         * @readonly
          * @type {Vector2}
          */
         this.size = new Vector2(0, 0);
@@ -34,11 +37,13 @@ export class AtlasPatch {
         this.sampler = null;
 
         /**
+         * @readonly
          * @type {Rectangle}
          */
         this.uv = new Rectangle(0, 0, 0, 0);
 
         /**
+         * Area in the atlas where patch along with the padding is packed into
          * Used for packing inside TextureAtlas. Do not modify manually
          * @readonly
          * @protected

package/engine/graphics/texture/atlas/TextureAtlas.js

@@ -82,8 +82,8 @@ export class TextureAtlas {
      * @returns {boolean}
      */
     contains(patch) {
-        assert.notEqual(patch, null, 'patch is null');
-        assert.notEqual(patch, undefined, 'patch is undefined');
+        assert.notNull(patch, 'patch');
+        assert.defined(patch, 'patch');
         assert.ok(patch.isAtlasPatch, 'patch argument is not an AtlasPatch');
 
         return this.patches.includes(patch);

package/engine/graphics/texture/sampler/HarmonicDiffusionGrid.spec.js

@@ -1,6 +1,6 @@
 import { seededRandom } from "../../../../core/math/random/seededRandom.js";
 import { HarmonicDiffusionGrid } from "./HarmonicDiffusionGrid.js";
-import { randomIntegerBetween} from "../../../../core/math/MathUtils.js";
+import { randomIntegerBetween } from "../../../../core/math/random/randomIntegerBetween.js";
 
 test("constructor doesn't throw", () => {
     new HarmonicDiffusionGrid([], 0, 0);

package/engine/graphics/texture/sampler/SampleTraverser.js

@@ -3,8 +3,8 @@
  */
 import QuadTree from '../../../../core/geom/2d/quad-tree/PointQuadTree.js';
 import AABB2 from '../../../../core/geom/AABB2.js';
-import { makeRangedRandom} from '../../../../core/math/MathUtils.js';
 import { seededRandom } from "../../../../core/math/random/seededRandom.js";
+import { makeRangedRandom } from "../../../../core/math/random/makeRangedRandom.js";
 
 
 const Point2 = function (x, y) {

package/engine/graphics/texture/sampler/Sampler2D.js

@@ -493,7 +493,7 @@ Sampler2D.prototype.get = function (x, y, result) {
 
     const t = [];
 
-    this.sampleBilinear(x, y, t);
+    this.sampleBilinear(x, y, t, 0);
 
     if (result !== undefined) {
         result.readFromArray(t, 0);
@@ -655,14 +655,15 @@ Sampler2D.prototype.sampleChannelBicubic = function (x, y, channel) {
  * @param {number} x
  * @param {number} y
  * @param {number[]} result
+ * @param {number} result_offset
  */
-Sampler2D.prototype.sampleBilinear = function (x, y, result) {
+Sampler2D.prototype.sampleBilinear = function (x, y, result, result_offset) {
 
     const itemSize = this.itemSize;
 
     for (let i = 0; i < itemSize; i++) {
         //TODO this can be optimized greatly
-        result[i] = this.sampleChannelBilinear(x, y, i);
+        result[i + result_offset] = this.sampleChannelBilinear(x, y, i);
 
     }
 };
@@ -809,7 +810,7 @@ Sampler2D.prototype.sample = function (u, v, result) {
 
     const temp = [];
 
-    this.sampleBilinear(u * (this.width - 1), v * (this.height - 1), temp);
+    this.sampleBilinear(u * (this.width - 1), v * (this.height - 1), temp, 0);
 
     result.readFromArray(temp);
 
@@ -888,7 +889,7 @@ Sampler2D.prototype.makeArrayFiller = function (scale, offset) {
     }
 
     function fillDD2(index, array, x, y) {
-        sampler.sampleBilinear(x, y, v4);
+        sampler.sampleBilinear(x, y, v4, 0);
         const val = (v4[0] + offset) * scale | 0;
         array.fill(val, index, index + 3);
         array[index + 3] = (v4[1] + offset) * scale | 0;
@@ -896,7 +897,7 @@ Sampler2D.prototype.makeArrayFiller = function (scale, offset) {
 
     function fillDD3(index, array, x, y) {
 
-        sampler.sampleBilinear(x, y, v4);
+        sampler.sampleBilinear(x, y, v4, 0);
 
         array[index] = (v4[0] + offset) * scale | 0;
         array[index + 1] = (v4[1] + offset) * scale | 0;
@@ -905,7 +906,7 @@ Sampler2D.prototype.makeArrayFiller = function (scale, offset) {
     }
 
     function fillDD4(index, array, x, y) {
-        sampler.sampleBilinear(x, y, v4);
+        sampler.sampleBilinear(x, y, v4, 0);
         array[index] = (v4[0] + offset) * scale | 0;
         array[index + 1] = (v4[1] + offset) * scale | 0;
         array[index + 2] = (v4[2] + offset) * scale | 0;

package/engine/graphics/texture/sampler/distanceField.spec.js

@@ -1,7 +1,7 @@
 import { seededRandom } from "../../../../core/math/random/seededRandom.js";
 import { Sampler2D } from "./Sampler2D.js";
 import { computeUnsignedDistanceField } from "./distanceField.js";
-import { randomIntegerBetween} from "../../../../core/math/MathUtils.js";
+import { randomIntegerBetween } from "../../../../core/math/random/randomIntegerBetween.js";
 
 describe('computeUnsignedDistanceField', () => {
     test('empty', () => {

package/engine/graphics/texture/sampler/scaleSampler2D.js

@@ -7,6 +7,7 @@ import { assert } from "../../../../core/assert.js";
  */
 export function scaleSampler2D(source, target) {
     const targetItemSize = target.itemSize;
+
     assert.equal(source.itemSize, targetItemSize, 'both source and target must have the same number of channels');
 
     const targetWidth = target.width;
@@ -18,32 +19,28 @@ export function scaleSampler2D(source, target) {
     const target_data = target.data;
 
     if (sourceWidth === targetWidth && sourceHeight === targetHeight) {
-        // exact size match
+        // exact size match, nothing to do
         target_data.set(source.data);
         return;
     }
 
-    const sample = [];
-
     const targetRowSize = targetItemSize * targetWidth;
 
+    const source_scale_x = sourceWidth / targetWidth;
+    const source_scale_y = sourceHeight / targetHeight;
+
     for (let y = 0; y < targetHeight; y++) {
 
-        const v = y / targetHeight;
 
+        const sample_y = y * source_scale_y;
         const target_row_address = y * targetRowSize;
 
         for (let x = 0; x < targetWidth; x++) {
 
-            const u = x / targetWidth;
-
-            source.sampleBilinear(u * sourceWidth, v * sourceHeight, sample);
 
             const target_offset = target_row_address + x * targetItemSize;
 
-            for (let i = 0; i < targetItemSize; i++) {
-                target_data[target_offset + i] = sample[i];
-            }
+            source.sampleBilinear(x * source_scale_x, sample_y, target_data, target_offset);
 
         }
     }

package/engine/graphics/trail/x/RibbonMaterialX.js

@@ -106,11 +106,11 @@ export class RibbonMaterialX extends ShaderMaterial {
                 uDiffuse: {
                     type: 't',
                     value: null
-                },
-                defines: {
-                    USE_TEXTURE: false
                 }
             },
+            defines: {
+                USE_TEXTURE: false
+            },
             blending: NormalBlending,
             transparent: true,
             depthWrite: false,

package/engine/graphics/trail/x/RibbonX.js

@@ -36,7 +36,6 @@ export class RibbonX {
          */
         this.__data = new RowFirstTable(ribbon_attributes_spec);
 
-
         /**
          * Index into current geometry segment that is at the END of the ribbon
          * @type {number}
@@ -66,6 +65,10 @@ export class RibbonX {
         this.__count = 0;
     }
 
+    dispose() {
+        this.__geometry.dispose();
+    }
+
     /**
      *
      * @returns {BufferGeometry}
@@ -350,6 +353,11 @@ export class RibbonX {
         this.setPointAttribute_Vector3(index, RIBBON_ATTRIBUTE_ADDRESS_COLOR, r, g, b);
     }
 
+    /**
+     *
+     * @param {number} index
+     * @param {number} value
+     */
     setPointAlpha(index, value) {
         const i2 = index * 2;
 
@@ -359,7 +367,11 @@ export class RibbonX {
         this.__ib_float32.needsUpdate = true;
     }
 
-
+    /**
+     *
+     * @param {number} index
+     * @param {number} value
+     */
     setPointThickness(index, value) {
         const i2 = index * 2;
 
@@ -377,6 +389,9 @@ export class RibbonX {
         assert.greaterThanOrEqual(count, 2, 'number of points in the ribbon must be at least 2 (to produce at least a single quad)');
         assert.isNonNegativeInteger(count, 'count');
 
+        // dispose of existing geometry
+        this.__geometry.dispose();
+
         const point_count = count * 2;
 
         if (this.__data.length > point_count) {

package/engine/graphics/trail/x/RibbonXPlugin.js

@@ -1,15 +1,18 @@
 import { EnginePlugin } from "../../../plugin/EnginePlugin.js";
 import { RibbonMaterialX } from "./RibbonMaterialX.js";
-import { DoubleSide } from "three";
+import { DoubleSide, Vector2 } from "three";
 import { GameAssetType } from "../../../asset/GameAssetType.js";
 import { Cache } from "../../../../core/cache/Cache.js";
 import { invokeObjectEquals } from "../../../../core/model/object/invokeObjectEquals.js";
 import { invokeObjectHash } from "../../../../core/model/object/invokeObjectHash.js";
+import { MaterialManager } from "../../material/manager/MaterialManager.js";
 
 export class RibbonXPlugin extends EnginePlugin {
     initialize(engine) {
         super.initialize(engine);
 
+        this.id = 'ribbon-x-plugin';
+
         /**
          * @private
          * @readonly
@@ -21,6 +24,51 @@ export class RibbonXPlugin extends EnginePlugin {
             keyHashFunction: invokeObjectHash,
             keyEqualityFunction: invokeObjectEquals
         });
+
+        this.__shared_uniforms = {
+            resolution: {
+                value: new Vector2(1, 1)
+            }
+        };
+
+        /**
+         *
+         * @type {MaterialManager}
+         * @private
+         */
+        this.__materials = new MaterialManager();
+    }
+
+    __handle_viewport_size_change() {
+        const s = this.engine.graphics.viewport.size;
+
+        this.__shared_uniforms.resolution.value.set(s.x, s.y);
+    }
+
+    async startup() {
+        this.__handle_viewport_size_change();
+
+        this.engine.graphics.viewport.size.onChanged.add(this.__handle_viewport_size_change, this);
+
+        return super.startup();
+    }
+
+    async shutdown() {
+
+        this.engine.graphics.viewport.size.onChanged.remove(this.__handle_viewport_size_change, this);
+
+        return super.shutdown();
+    }
+
+    /**
+     *
+     * @param {RibbonXMaterialSpec} spec
+     * @return {Reference<Material>}
+     */
+    obtain_material_reference(spec) {
+        const mm = this.obtain_material_x(spec);
+
+        return this.__materials.obtain(mm);
     }
 
     /**
@@ -62,6 +110,8 @@ export class RibbonXPlugin extends EnginePlugin {
             }
         });
 
+        material.uniforms.resolution = this.__shared_uniforms.resolution;
+
         if (spec.diffuse !== null) {
             const am = this.engine.assetManager;
 

package/engine/graphics/util/composeMatrix4.js

@@ -1,13 +1,11 @@
 /**
  *
- * @param {Matrix4} result
+ * @param {number[]|Float32Array|mat4} result
  * @param {Vector3} position
  * @param {Quaternion} rotation
  * @param {Vector3} scale
  */
-export function composeMatrix4(result, position, rotation, scale) {
-    const te = result.elements;
-
+export function compose_matrix4_array(result, position, rotation, scale) {
     const x = rotation.x;
     const y = rotation.y;
     const z = rotation.z;
@@ -33,23 +31,35 @@ export function composeMatrix4(result, position, rotation, scale) {
     const sy = scale.y;
     const sz = scale.z;
 
-    te[0] = (1 - (yy + zz)) * sx;
-    te[1] = (xy + wz) * sx;
-    te[2] = (xz - wy) * sx;
-    te[3] = 0;
-
-    te[4] = (xy - wz) * sy;
-    te[5] = (1 - (xx + zz)) * sy;
-    te[6] = (yz + wx) * sy;
-    te[7] = 0;
-
-    te[8] = (xz + wy) * sz;
-    te[9] = (yz - wx) * sz;
-    te[10] = (1 - (xx + yy)) * sz;
-    te[11] = 0;
-
-    te[12] = position.x;
-    te[13] = position.y;
-    te[14] = position.z;
-    te[15] = 1;
+    result[0] = (1 - (yy + zz)) * sx;
+    result[1] = (xy + wz) * sx;
+    result[2] = (xz - wy) * sx;
+    result[3] = 0;
+
+    result[4] = (xy - wz) * sy;
+    result[5] = (1 - (xx + zz)) * sy;
+    result[6] = (yz + wx) * sy;
+    result[7] = 0;
+
+    result[8] = (xz + wy) * sz;
+    result[9] = (yz - wx) * sz;
+    result[10] = (1 - (xx + yy)) * sz;
+    result[11] = 0;
+
+    result[12] = position.x;
+    result[13] = position.y;
+    result[14] = position.z;
+    result[15] = 1;
+}
+
+/**
+ *
+ * @param {Matrix4} result
+ * @param {Vector3} position
+ * @param {Quaternion} rotation
+ * @param {Vector3} scale
+ */
+export function composeMatrix4(result, position, rotation, scale) {
+    const te = result.elements;
+    compose_matrix4_array(te, position, rotation, scale);
 }

package/engine/graphics/util/decompose_matrix_4_array.js

@@ -0,0 +1,61 @@
+/**
+ *
+ * @param {number[]} m
+ * @param {Vector3} position
+ * @param {Quaternion} rotation
+ * @param {Vector3} scale
+ */
+export function decompose_matrix_4_array(m, position, rotation, scale) {
+    const m11 = m[0];
+    const m12 = m[1];
+    const m13 = m[2];
+
+    const m21 = m[4];
+    const m22 = m[5];
+    const m23 = m[6];
+
+    const m31 = m[8];
+    const m32 = m[9];
+    const m33 = m[10];
+
+    const scale_x = Math.hypot(m11, m12, m13);
+    const scale_y = Math.hypot(m21, m22, m23);
+    const scale_z = Math.hypot(m31, m32, m33);
+
+    // extract rotation
+    const is1 = 1 / scale_x;
+    const is2 = 1 / scale_y;
+    const is3 = 1 / scale_z;
+
+    const sm11 = m11 * is1;
+    const sm12 = m12 * is1;
+    const sm13 = m13 * is1;
+
+    const sm21 = m21 * is2;
+    const sm22 = m22 * is2;
+    const sm23 = m23 * is2;
+
+    const sm31 = m31 * is3;
+    const sm32 = m32 * is3;
+    const sm33 = m33 * is3;
+
+    // write out results
+
+    position.set(
+        m[12],
+        m[13],
+        m[14]
+    );
+
+    scale.set(
+        scale_x,
+        scale_y,
+        scale_z
+    );
+
+    rotation.__setFromRotationMatrix(
+        sm11, sm21, sm31,
+        sm12, sm22, sm32,
+        sm13, sm23, sm33
+    );
+}

package/engine/grid/components/GridObstacle.js

@@ -4,10 +4,11 @@
 
 
 import Vector2 from '../../../core/geom/Vector2.js';
-import { computeHashIntegerArray } from "../../../core/math/MathUtils.js";
 import { assert } from "../../../core/assert.js";
 import { BinaryClassSerializationAdapter } from "../../ecs/storage/binary/BinaryClassSerializationAdapter.js";
 import { computeIntegerArrayHash } from "../../../core/primitives/array/computeIntegerArrayHash.js";
+import { isArrayEqualStrict } from "../../../core/collection/array/isArrayEqualStrict.js";
+import { computeHashIntegerArray } from "../../../core/collection/array/computeHashIntegerArray.js";
 
 class GridObstacle {
     constructor() {
@@ -236,15 +237,7 @@ class GridObstacle {
             return false;
         }
 
-        const dataSize = this.size.x * this.size.y;
-
-        for (let i = 0; i < dataSize; i++) {
-            if (this.data[i] !== other.data[i]) {
-                return false;
-            }
-        }
-
-        return true;
+        return isArrayEqualStrict(this.data, other.data);
     }
 }
 

package/engine/intelligence/behavior/ecs/BehaviorComponent.js

@@ -1,5 +1,7 @@
 import { assert } from "../../../../core/assert.js";
 import { ClockChannelType } from "./ClockChannelType.js";
+import { RepeatBehavior } from "../decorator/RepeatBehavior.js";
+import { ActionBehavior } from "../primitive/ActionBehavior.js";
 
 export const BehaviorComponentFlag = {
     AllowSleep: 1
@@ -25,24 +27,38 @@ export class BehaviorComponent {
          */
         this.flags = 0;
     }
-}
 
-/**
- *
- * @param {Behavior} b
- * @returns {BehaviorComponent}
- */
-BehaviorComponent.fromOne = function (b) {
-    assert.notEqual(b, undefined, 'behavior is undefined');
-    assert.notEqual(b, null, 'behavior is null');
-    assert.equal(b.isBehavior, true, 'b.isBehavior !== true');
 
-    const result = new BehaviorComponent();
+    /**
+     *
+     * @param {function} f
+     * @param {*} [thisArg]
+     * @returns {BehaviorComponent}
+     */
+    static looping_function(f, thisArg) {
+        return BehaviorComponent.fromOne(RepeatBehavior.from(
+            new ActionBehavior(f, thisArg)
+        ));
+    }
 
-    result.list.push(b);
+    /**
+     *
+     * @param {Behavior} b
+     * @returns {BehaviorComponent}
+     */
+    static fromOne(b) {
+        assert.notEqual(b, undefined, 'behavior is undefined');
+        assert.notEqual(b, null, 'behavior is null');
+        assert.equal(b.isBehavior, true, 'b.isBehavior !== true');
 
-    return result;
-};
+        const result = new BehaviorComponent();
+
+        result.list.push(b);
+
+        return result;
+
+    }
+}
 
 /**
  * @readonly

package/engine/intelligence/behavior/selector/WeightedElement.js

@@ -1,7 +1,8 @@
-import { computeHashFloat, computeHashIntegerArray } from "../../../../core/math/MathUtils.js";
 import { assert } from "../../../../core/assert.js";
 import { invokeObjectEquals } from "../../../../core/model/object/invokeObjectEquals.js";
 import { invokeObjectHash } from "../../../../core/model/object/invokeObjectHash.js";
+import { computeHashIntegerArray } from "../../../../core/collection/array/computeHashIntegerArray.js";
+import { computeHashFloat } from "../../../../core/math/hash/computeHashFloat.js";
 
 export class WeightedElement {
 

package/engine/intelligence/optimization/RandomOptimizer.js

@@ -1,5 +1,5 @@
-import { randomFromArray} from "../../../core/math/MathUtils.js";
 import { seededRandom } from "../../../core/math/random/seededRandom.js";
+import { randomFromArray } from "../../../core/math/random/randomFromArray.js";
 
 /**
  * Hill climbing optimizer based on random moves

package/engine/knowledge/database/StaticKnowledgeDataTable.js

@@ -222,7 +222,7 @@ export class StaticKnowledgeDataTable {
             } catch (e) {
 
                 let id;
-                //attempt to extract talent ID
+                //attempt to extract item ID
                 try {
                     id = datum.id;
                 } catch (e) {
@@ -243,6 +243,11 @@ export class StaticKnowledgeDataTable {
                 return;
             }
 
+            if (this.contains(id)) {
+                console.error(`Duplicate id '${id}'`);
+                return;
+            }
+
             this.__json.set(id, datum);
 
             const added = this.add(element);

package/engine/navigation/ecs/components/Path.js

@@ -3,7 +3,6 @@
  */
 
 
-import { line3_computeSegmentPointDistance_sqr } from "../../../../core/geom/LineSegment.js";
 import Vector3 from "../../../../core/geom/Vector3.js";
 
 import { CatmullRomCurve3 } from "three";
@@ -18,6 +17,7 @@ import { min2 } from "../../../../core/math/min2.js";
 import { computeNonuniformCatmullRomSplineSample } from "./computeNonuniformCatmullRomSplineSample.js";
 import { InterpolationType } from "./InterpolationType.js";
 import { v3_distance } from "../../../../core/geom/v3_distance.js";
+import { line3_computeSegmentPointDistance_sqr } from "../../../../core/geom/3d/line/line3_computeSegmentPointDistance_sqr.js";
 
 const v3_a = new Vector3();
 const v3_b = new Vector3();
@@ -270,11 +270,6 @@ class Path {
     copy(other) {
         this.__data.copy(other.__data);
         this.interpolation = other.interpolation;
-
-        // Traversal variables
-        this.markerOffset = other.markerOffset;
-        this.markerIndex = other.markerIndex;
-        this.markerDistanceToNext = other.markerDistanceToNext;
     }
 
     /**

package/engine/navigation/grid/FastBinaryHeap.spec.js

@@ -1,7 +1,7 @@
 import { seededRandom } from "../../../core/math/random/seededRandom.js";
 import BinaryHeap from "./FastBinaryHeap.js";
 import { passThrough, returnZero } from "../../../core/function/Functions.js";
-import { randomIntegerBetween} from "../../../core/math/MathUtils.js";
+import { randomIntegerBetween } from "../../../core/math/random/randomIntegerBetween.js";
 
 test("constructor doesn't throw", () => {
     new BinaryHeap(returnZero);

package/engine/reference/v2/Reference.js

@@ -81,3 +81,9 @@ export class Reference {
         this.__onReleased.send1(this);
     }
 }
+
+/**
+ * @readonly
+ * @type {Readonly<Reference>}
+ */
+Reference.NULL = Object.freeze(new Reference());

package/engine/sound/ecs/emitter/SoundEmitter.js

@@ -10,11 +10,12 @@ import { SoundEmitterFlags } from "./SoundEmitterFlags.js";
 import { SoundAttenuationFunction } from "./SoundAttenuationFunction.js";
 import { attenuateSoundLinear } from "./attenuate/attenuateSoundLinear.js";
 import { attenuateSoundLogarithmic } from "./attenuate/attenuateSoundLogarithmic.js";
-import { computeHashFloat, computeHashIntegerArray } from "../../../../core/math/MathUtils.js";
 import { SoundPanningModelType } from "./SoundPanningModelType.js";
 import { attenuateSoundSmith } from "./attenuate/attenuateSoundSmith.js";
 import { objectKeyByValue } from "../../../../core/model/object/objectKeyByValue.js";
 import { computeStringHash } from "../../../../core/primitives/strings/computeStringHash.js";
+import { computeHashIntegerArray } from "../../../../core/collection/array/computeHashIntegerArray.js";
+import { computeHashFloat } from "../../../../core/math/hash/computeHashFloat.js";
 
 /**
  * Convert decibel to percentage volume

package/engine/sound/ecs/emitter/SoundTrack.js

@@ -1,8 +1,9 @@
 import Signal from "../../../../core/events/signal/Signal.js";
 import { SoundTrackFlags } from "./SoundTrackFlags.js";
-import { computeHashFloat, computeHashIntegerArray } from "../../../../core/math/MathUtils.js";
 import { assert } from "../../../../core/assert.js";
 import { computeStringHash } from "../../../../core/primitives/strings/computeStringHash.js";
+import { computeHashIntegerArray } from "../../../../core/collection/array/computeHashIntegerArray.js";
+import { computeHashFloat } from "../../../../core/math/hash/computeHashFloat.js";
 
 const DEFAULT_FLAGS = SoundTrackFlags.StartWhenReady;