@woosh/meep-engine 2.47.34 → 2.47.36

package/src/engine/animation/TransitionFunctions.js

@@ -1,4 +1,4 @@
-import { makeCubicCurve } from "../../core/math/makeCubicCurve.js";
+import { makeCubicCurve } from "../../core/math/spline/makeCubicCurve.js";
 
 /**
  *

package/src/engine/animation/curve/AnimationCurve.js

@@ -1,5 +1,7 @@
 import { inverseLerp } from "../../../core/math/inverseLerp.js";
 import { lerp } from "../../../core/math/lerp.js";
+import { invokeObjectToJSON } from "../../../core/model/object/invokeObjectToJSON.js";
+import { Keyframe } from "./Keyframe.js";
 
 /**
  *
@@ -39,10 +41,72 @@ export class AnimationCurve {
         this.keys = [];
     }
 
+    /**
+     *
+     * @param {Keyframe} key
+     */
+    add(key) {
+        // TODO figure out the right place to insert the key
+        this.keys.push(key);
+    }
+
+    /**
+     *
+     * @param {Keyframe} key
+     * @returns {boolean}
+     */
+    remove(key) {
+        const i = this.keys.indexOf(key);
+
+        if (i === -1) {
+            return false;
+        }
+
+        this.keys.splice(i, 1);
+
+        return true;
+    }
+
+    /**
+     * Remove all keys
+     */
+    clear() {
+        this.keys.splice(0, this.keys.length);
+    }
+
+    /**
+     *
+     * @param {Keyframe[]} keys
+     * @returns {AnimationCurve}
+     */
+    static from(keys) {
+        const curve = new AnimationCurve();
+
+        const key_count = keys.length;
+
+        for (let i = 0; i < key_count; i++) {
+            curve.add(keys[i]);
+        }
+
+        for (let i = 0; i < key_count; i++) {
+            curve.smoothTangents(i, 1);
+        }
+
+        return curve;
+    }
+
+    /**
+     * Number of keys
+     * @returns {number}
+     */
+    get length() {
+        return this.keys.length;
+    }
+
 
     /**
      *
-     * @param {number} t
+     * @param {number} t time in seconds
      * @return {number}
      */
     evaluate(t) {
@@ -108,4 +172,32 @@ export class AnimationCurve {
         }
 
     }
+
+    smoothAllTangents(){
+        const n = this.length;
+        for (let i = 0; i < n; i++) {
+            this.smoothTangents(i,0);
+        }
+    }
+
+    toJSON() {
+        return {
+            keys: this.keys.map(invokeObjectToJSON)
+        };
+    }
+
+    fromJSON({ keys }) {
+        this.clear();
+
+        for (let i = 0; i < keys.length; i++) {
+
+            const keyframe = new Keyframe();
+
+            keyframe.fromJSON(keys[i]);
+
+            this.add(keyframe);
+
+        }
+
+    }
 }

package/src/engine/animation/curve/Keyframe.js

@@ -43,4 +43,24 @@ export class Keyframe {
 
         return r;
     }
+
+    toJSON() {
+        return {
+            value: this.value,
+            time: this.time,
+            inTangent: this.inTangent,
+            outTangent: this.outTangent
+        }
+    };
+
+    fromJSON({
+                 value, time, inTangent, outTangent
+             }) {
+
+        this.value = value;
+        this.time = time;
+        this.inTangent = inTangent;
+        this.outTangent = outTangent;
+    }
+
 }

package/src/engine/animation/curve/compression/prototypeCurveCompression.js

@@ -134,7 +134,9 @@ async function main(engine) {
         return curve;
     }
 
-    const curve = sample_curve_2();
+    const curve = sample_curve_4();
+
+    curve.smoothAllTangents();
 
     const ecd = engine.entityManager.dataset;
 

package/src/engine/ecs/components/MeshCollider.js

@@ -3,6 +3,11 @@
  */
 
 
+/**
+ * @deprecated
+ * @param options
+ * @constructor
+ */
 function MeshCollider(options) {
     this.tags = options.tags.slice();
 }

package/src/engine/ecs/components/MonsterAI.js

@@ -3,6 +3,11 @@
  */
 
 
+/**
+ * @deprecated
+ * @param options
+ * @constructor
+ */
 function MonsterAI(options) {
     this.chaseDistance = options.chaseDistance || 0;
 }

package/src/engine/ecs/fow/shader/FogOfWarRenderer.js

@@ -2,7 +2,7 @@ import { buildScreenSpaceFogOfWarShader } from "./screenSpaceFogOfWarShader.js";
 import { assert } from "../../../../core/assert.js";
 import { Mesh, OrthographicCamera, Scene } from "three";
 import { FULL_SCREEN_TRIANGLE_GEOMETRY } from "../../../graphics/geometry/FULL_SCREEN_TRIANGLE_GEOMETRY.js";
-import { isValueBetweenInclusive } from "../../../../core/math/isValueBetweenInclusive.js";
+import { isValueBetweenInclusive } from "../../../../core/math/interval/isValueBetweenInclusive.js";
 
 /**
  *

package/src/engine/ecs/guid/GUID.js

@@ -0,0 +1,257 @@
+import { seededRandom } from "../../../core/math/random/seededRandom.js";
+import { randomUint8 } from "../../../core/math/random/randomUint8.js";
+import { is_typed_array_equals } from "../../../core/collection/array/typed/is_typed_array_equals.js";
+import { dec2hex } from "../../../core/binary/dec2hex.js";
+import { array_copy } from "../../../core/collection/array/copyArray.js";
+
+// Previous uuid creation time
+let _lastMSecs = 0;
+let _lastNSecs = 0;
+
+const random = seededRandom(Date.now());
+
+/**
+ *
+ * @param {Uint8Array} result
+ * @param {number} result_offset
+ * @param {function():number} random
+ * @param {number} count
+ */
+function randomBytes(result, result_offset, random, count) {
+    for (let i = 0; i < count; i++) {
+
+        result[result_offset + i] = randomUint8(random);
+
+    }
+}
+
+// node and clockseq need to be initialized to random values.
+let _nodeId = new Uint8Array(6);
+
+// Per 4.5, create and 48-bit node id, (47 random bits + multicast bit = 1)
+randomBytes(_nodeId, 0, random, 6);
+_nodeId[0] |= 0x01;
+
+// Per 4.2.2, randomize (14 bit) clockseq
+let _clockseq = ((randomUint8(random) << 8) | randomUint8(random)) & 0x3fff;
+
+/**
+ * Globally unique identifier
+ */
+export class GUID {
+    #data = new Uint8Array(16);
+
+    constructor() {
+        this.v1();
+    }
+
+    /**
+     *
+     * @param {number[]|Uint8Array|ArrayLike<number>} bytes
+     */
+    set data(bytes) {
+        array_copy(bytes, 0, this.#data, 0, 16);
+    }
+
+    /**
+     *
+     * @returns {Uint8Array}
+     */
+    get data() {
+        return this.#data;
+    }
+
+    /**
+     * Generate Variant 1 UUID
+     * @see https://github.com/uuidjs/uuid/blob/8f028c4ea42ce41a9a9dc5fa634abe525b2e2066/src/v1.js#L17
+     */
+    v1() {
+
+        const b = this.#data;
+
+        let clockseq = _clockseq;
+
+        // UUID timestamps are 100 nano-second units since the Gregorian epoch,
+        // (1582-10-15 00:00).  JSNumbers aren't precise enough for this, so
+        // time is handled internally as 'msecs' (integer milliseconds) and 'nsecs'
+        // (100-nanoseconds offset from msecs) since unix epoch, 1970-01-01 00:00.
+        let msecs = Date.now();
+
+        // Per 4.2.1.2, use count of uuid's generated during the current clock
+        // cycle to simulate higher resolution clock
+        let nsecs = _lastNSecs + 1;
+
+        // Time since last uuid creation (in msecs)
+        const dt = msecs - _lastMSecs + (nsecs - _lastNSecs) / 10000;
+
+        // Per 4.2.1.2, Bump clockseq on clock regression
+        if (dt < 0) {
+            clockseq = (clockseq + 1) & 0x3fff;
+        }
+
+        // Reset nsecs if clock regresses (new clockseq) or we've moved onto a new
+        // time interval
+        if ((dt < 0 || msecs > _lastMSecs)) {
+            nsecs = 0;
+        }
+
+        // Per 4.2.1.2 Throw error if too many uuids are requested
+        if (nsecs >= 10000) {
+            throw new Error("uuid.v1(): Can't create more than 10M uuids/sec");
+        }
+
+        _lastMSecs = msecs;
+        _lastNSecs = nsecs;
+        _clockseq = clockseq;
+
+        // Per 4.1.4 - Convert from unix epoch to Gregorian epoch
+        msecs += 12219292800000;
+
+        let i = 0
+        // `time_low`
+        const tl = ((msecs & 0xfffffff) * 10000 + nsecs) % 0x100000000;
+        b[i++] = (tl >>> 24) & 0xff;
+        b[i++] = (tl >>> 16) & 0xff;
+        b[i++] = (tl >>> 8) & 0xff;
+        b[i++] = tl & 0xff;
+
+        // `time_mid`
+        const tmh = ((msecs / 0x100000000) * 10000) & 0xfffffff;
+        b[i++] = (tmh >>> 8) & 0xff;
+        b[i++] = tmh & 0xff;
+
+        // `time_high_and_version`
+        b[i++] = ((tmh >>> 24) & 0xf) | 0x10; // include version
+        b[i++] = (tmh >>> 16) & 0xff;
+
+        // `clock_seq_hi_and_reserved` (Per 4.2.2 - include variant)
+        b[i++] = (clockseq >>> 8) | 0x80;
+
+        // `clock_seq_low`
+        b[i++] = clockseq & 0xff;
+
+        // `node`
+        for (let n = 0; n < 6; ++n) {
+            b[i + n] = _nodeId[n];
+        }
+    }
+
+    /***
+     * String in UUID format
+     * @see https://github.com/uuidjs/uuid/blob/8f028c4ea42ce41a9a9dc5fa634abe525b2e2066/src/parse.js#L3
+     * @param {string} string
+     */
+    parse(string) {
+        let v;
+        const arr = this.#data;
+
+        // Parse ########-....-....-....-............
+        arr[0] = (v = parseInt(string.slice(0, 8), 16)) >>> 24;
+        arr[1] = (v >>> 16) & 0xff;
+        arr[2] = (v >>> 8) & 0xff;
+        arr[3] = v & 0xff;
+
+        // Parse ........-####-....-....-............
+        arr[4] = (v = parseInt(string.slice(9, 13), 16)) >>> 8;
+        arr[5] = v & 0xff;
+
+        // Parse ........-....-####-....-............
+        arr[6] = (v = parseInt(string.slice(14, 18), 16)) >>> 8;
+        arr[7] = v & 0xff;
+
+        // Parse ........-....-....-####-............
+        arr[8] = (v = parseInt(string.slice(19, 23), 16)) >>> 8;
+        arr[9] = v & 0xff;
+
+        // Parse ........-....-....-....-############
+        // (Use "/" to avoid 32-bit truncation when bit-shifting high-order bytes)
+        arr[10] = ((v = parseInt(string.slice(24, 36), 16)) / 0x10000000000) & 0xff;
+        arr[11] = (v / 0x100000000) & 0xff;
+        arr[12] = (v >>> 24) & 0xff;
+        arr[13] = (v >>> 16) & 0xff;
+        arr[14] = (v >>> 8) & 0xff;
+        arr[15] = v & 0xff;
+    }
+
+    /**
+     * @see https://github.com/uuidjs/uuid/blob/8f028c4ea42ce41a9a9dc5fa634abe525b2e2066/src/stringify.js#L16
+     * @returns {string}
+     */
+    toString() {
+        const bytes = this.#data;
+
+        return (
+            dec2hex(bytes[0]) +
+            dec2hex(bytes[1]) +
+            dec2hex(bytes[2]) +
+            dec2hex(bytes[3]) +
+            '-' +
+            dec2hex(bytes[4]) +
+            dec2hex(bytes[5]) +
+            '-' +
+            dec2hex(bytes[6]) +
+            dec2hex(bytes[7]) +
+            '-' +
+            dec2hex(bytes[8]) +
+            dec2hex(bytes[9]) +
+            '-' +
+            dec2hex(bytes[10]) +
+            dec2hex(bytes[11]) +
+            dec2hex(bytes[12]) +
+            dec2hex(bytes[13]) +
+            dec2hex(bytes[14]) +
+            dec2hex(bytes[15])
+        );
+    }
+
+    /**
+     *
+     * @param {GUID} other
+     */
+    copy(other) {
+        this.#data.set(other.#data);
+    }
+
+    /**
+     *
+     * @param {GUID} other
+     * @returns {boolean}
+     */
+    equals(other) {
+        return is_typed_array_equals(this.#data, other.#data);
+    }
+
+    /**
+     * @returns {number}
+     */
+    hash() {
+        const data = this.#data;
+
+        // use some non-metadata bytes as a hash
+        return data[0]
+            | data[1] << 8
+            | data[2] << 16
+            | data[3] << 24
+            ;
+    }
+
+    toJSON() {
+        return this.toString();
+    }
+
+    fromJSON(v) {
+        this.parse(v);
+    }
+}
+
+/**
+ * @readonly
+ * @type {string}
+ */
+GUID.typeName = "GUID";
+
+/**
+ * @readonly
+ * @type {boolean}
+ */
+GUID.prototype.isGUID = true;

package/src/engine/ecs/guid/GUID.spec.js

@@ -0,0 +1,41 @@
+import { GUID } from "./GUID.js";
+
+test("uniqueness out of 2", () => {
+    const a = new GUID();
+    const b = new GUID();
+
+    expect(a.equals(b)).toBe(false);
+});
+
+
+test("equality", () => {
+    const a = new GUID();
+    const b = new GUID();
+
+    a.parse("a88bb73a-c89f-11ed-afa1-0242ac120002");
+    b.parse("a88bb73a-c89f-11ed-afa1-0242ac120002");
+
+    expect(a.equals(b)).toBe(true);
+
+    b.parse("bb75b300-c89f-11ed-afa1-0242ac120002");
+
+    expect(a.equals(b)).toBe(false);
+});
+
+test("hash stability", () => {
+    const guid = new GUID();
+
+    expect(guid.hash()).toBe(guid.hash());
+});
+
+
+test("to/from JSON consistency", () => {
+    const a = new GUID();
+    a.parse("bb75b300-c89f-11ed-afa1-0242ac120002");
+
+    const b = new GUID();
+
+    b.fromJSON(a.toJSON());
+
+    expect(b.equals(a)).toBe(true)
+});

package/src/engine/ecs/guid/GUIDSerializationAdapter.js

@@ -0,0 +1,25 @@
+import { BinaryClassSerializationAdapter } from "../storage/binary/BinaryClassSerializationAdapter.js";
+import { GUID } from "./GUID.js";
+
+export class GUIDSerializationAdapter extends BinaryClassSerializationAdapter {
+    klass = GUID
+    version = 0
+
+    /**
+     *
+     * @param buffer
+     * @param {GUID} value
+     */
+    serialize(buffer, value) {
+        buffer.writeUint8Array(value.data, 0, 16);
+    }
+
+    /**
+     *
+     * @param buffer
+     * @param {GUID} value
+     */
+    deserialize(buffer, value) {
+        buffer.readUint8Array(value.data, 0, 16);
+    }
+}

package/src/engine/ecs/storage/binary/BinaryClassSerializationAdapter.js

@@ -1,17 +1,16 @@
 export class BinaryClassSerializationAdapter {
-    constructor() {
-        /**
-         * @protected
-         * @type {Class}
-         */
-        this.klass = null;
 
-        /**
-         * @protected
-         * @type {number}
-         */
-        this.version = 0;
-    }
+    /**
+     * @protected
+     * @type {Class}
+     */
+    klass = null;
+
+    /**
+     * @protected
+     * @type {number}
+     */
+    version = 0;
 
     /**
      * @template T

package/src/engine/ecs/terrain/util/loadVisibleTerrainTiles.js

@@ -5,14 +5,21 @@ import { assert } from "../../../../core/assert.js";
 import TerrainSystem from "../ecs/TerrainSystem.js";
 import Task from "../../../../core/process/task/Task.js";
 import { TaskSignal } from "../../../../core/process/task/TaskSignal.js";
+import { max2 } from "../../../../core/math/max2.js";
+import { clamp01 } from "../../../../core/math/clamp01.js";
 
 /**
  *
  * @param {EntityManager} em
  * @param {EntityComponentDataset} ecd
+ * @param {number} [timeout] in seconds
  * @returns {Task}
  */
-export function loadVisibleTerrainTiles(em, ecd) {
+export function loadVisibleTerrainTiles({
+                                            em,
+                                            ecd,
+                                            timeout = 10
+                                        }) {
 
     let totalTiles = 0;
     let loadedTiles = 0;
@@ -22,7 +29,14 @@ export function loadVisibleTerrainTiles(em, ecd) {
 
     let failureFlag = false;
 
+    const timeout_milliseconds = timeout * 1000;
+
+    let start_time = 0;
+
     function init() {
+
+        start_time = Date.now();
+
         const attemptId = attempt;
 
         //force update by camera controller, to ensure correct focus is set
@@ -82,6 +96,11 @@ export function loadVisibleTerrainTiles(em, ecd) {
         initializer: init,
 
         cycleFunction() {
+            if (Date.now() > start_time + timeout_milliseconds) {
+                // timed out
+                return TaskSignal.EndFailure;
+            }
+
             if (failureFlag) {
                 return TaskSignal.EndFailure;
             }
@@ -94,17 +113,12 @@ export function loadVisibleTerrainTiles(em, ecd) {
         },
 
         computeProgress() {
-            if (totalTiles === 0) {
-                return 0;
-            }
 
-            const f = loadedTiles / totalTiles;
+            const loaded_fraction = totalTiles === 0 ? 0 : loadedTiles / totalTiles;
 
-            if (f >= 1) {
-                return 1;
-            }
+            const timeout_fraction = (Date.now() - start_time) / timeout_milliseconds;
 
-            return f;
+            return clamp01(max2(loaded_fraction, timeout_fraction));
         }
     });
 

package/src/engine/graphics/camera/CameraShake.js

@@ -6,7 +6,7 @@ import { Behavior } from "../../intelligence/behavior/Behavior.js";
 import { BehaviorStatus } from "../../intelligence/behavior/BehaviorStatus.js";
 import Quaternion from "../../../core/geom/Quaternion.js";
 import { clamp01 } from "../../../core/math/clamp01.js";
-import { makeCubicCurve } from "../../../core/math/makeCubicCurve.js";
+import { makeCubicCurve } from "../../../core/math/spline/makeCubicCurve.js";
 
 export class CameraShakeTraumaBehavior extends Behavior {
 

package/src/engine/graphics/ecs/camera/CameraClippingPlaneComputer.js

@@ -1,6 +1,6 @@
 import { Frustum as ThreeFrustum } from "three";
 import { v3_dot } from "../../../../core/geom/v3_dot.js";
-import { isValueBetweenInclusive } from "../../../../core/math/isValueBetweenInclusive.js";
+import { isValueBetweenInclusive } from "../../../../core/math/interval/isValueBetweenInclusive.js";
 import { frustum_from_camera } from "./frustum_from_camera.js";
 import { is_valid_distance_value } from "./is_valid_distance_value.js";
 

package/src/engine/graphics/ecs/decal/v2/Decal.js

@@ -1,5 +1,6 @@
 import { Color } from "../../../../../core/color/Color.js";
 import { computeStringHash } from "../../../../../core/primitives/strings/computeStringHash.js";
+import { assert } from "../../../../../core/assert.js";
 
 export class Decal {
     constructor() {
@@ -54,8 +55,13 @@ export class Decal {
     fromJSON({
                  uri,
                  priority = 0,
-                 color
+                 color = '#FFFFFF'
              }) {
+
+        assert.isString(uri, 'uri');
+        assert.isNumber(priority, 'priority');
+        assert.notNaN(priority, 'priority');
+
         this.uri = uri;
         this.priority = priority;
 
@@ -65,11 +71,7 @@ export class Decal {
             this.__cached_uri = null;
         }
 
-        if (color !== undefined) {
-            this.color.parse(color);
-        } else {
-            this.color.set(1, 1, 1, 1);
-        }
+        this.color.parse(color);
     }
 
     hash() {

package/src/engine/graphics/ecs/decal/v2/FPDecalSystem.d.ts

@@ -14,4 +14,7 @@ export class FPDecalSystem extends System<Decal, Transform> {
         filter_function?: (entity: number, mesh: Decal) => boolean,
         filter_function_context?: any
     ): { entity: number, component: Decal, contact: SurfacePoint3 }[]
+
+
+    queryOverlapFrustum(result: number[], result_offset: number, planes: number[]): number
 }