@woosh/meep-engine 2.100.0 → 2.100.1

package/src/core/color/Color.js

@@ -1,5 +1,6 @@
 import { assert } from "../assert.js";
 import { float2uint8 } from "../binary/float2uint8.js";
+import { uint82float } from "../binary/uint82float.js";
 import Signal from "../events/signal/Signal.js";
 import { clamp01 } from "../math/clamp01.js";
 import { lerp } from "../math/lerp.js";
@@ -14,14 +15,15 @@ import { linear_to_sRGB } from "./sRGB/linear_to_sRGB.js";
 import { sRGB_to_linear } from "./sRGB/sRGB_to_linear.js";
 
 /**
+ * @extends {Array.<number>}
  * @class
  */
 export class Color {
     /**
      *
-     * @param {number} r value from 0 to 1
-     * @param {number} g value from 0 to 1
-     * @param {number} b value from 0 to 1
+     * @param {number} [r] Red from 0 to 1
+     * @param {number} [g] Green from 0 to 1
+     * @param {number} [b] Blue from 0 to 1
      * @param {number} [a] value from 0 to 1 Alpha channel (transparency)
      */
     constructor(r = 0, g = 0, b = 0, a = 1) {
@@ -141,6 +143,20 @@ export class Color {
         this.set(r, g, b, this.a);
     }
 
+    /**
+     *
+     * @param {number} r
+     * @param {number} g
+     * @param {number} b
+     */
+    setRGBUint8(r, g, b) {
+        this.setRGB(
+            uint82float(r),
+            uint82float(g),
+            uint82float(b),
+        )
+    }
+
     /**
      * set alpha
      * @param {number} a
@@ -167,11 +183,28 @@ export class Color {
         assert.notNaN(b, 'b');
         assert.notNaN(a, 'a');
 
+        assert.isFiniteNumber(r, 'r');
+        assert.isFiniteNumber(g, 'g');
+        assert.isFiniteNumber(b, 'b');
+        assert.isFiniteNumber(a, 'a');
+
+        // remember old values
         const _r = this.r;
         const _g = this.g;
         const _b = this.b;
         const _a = this.a;
 
+        if (
+            _r === r
+            && _g === g
+            && _b === b
+            && _a === a
+        ) {
+            // no change
+            return;
+        }
+
+        // set new values
         this.r = r;
         this.g = g;
         this.b = b;
@@ -414,7 +447,7 @@ export class Color {
         const g = (value >> 8) & 0xFF;
         const b = (value) & 0xFF;
 
-        this.setRGB(r / 255, g / 255, b / 255);
+        this.setRGBUint8(r, g, b);
     }
 
     /**
@@ -479,8 +512,7 @@ export class Color {
     }
 
     fromJSON({ r, g, b, a = 1 }) {
-        this.setRGB(r, g, b);
-        this.a = a;
+        this.set(r, g, b, a);
     }
 
     toJSON() {
@@ -534,8 +566,7 @@ export class Color {
         const b = buffer.readFloat32();
         const a = buffer.readFloat32();
 
-        this.setRGB(r, g, b);
-        this.a = a;
+        this.set(r, g, b, a);
     }
 
     /**

package/src/engine/animation/async/prototypeAsyncAnimation.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=prototypeAsyncAnimation.d.ts.map

package/src/engine/animation/async/prototypeAsyncAnimation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prototypeAsyncAnimation.d.ts","sourceRoot":"","sources":["../../../../../src/engine/animation/async/prototypeAsyncAnimation.js"],"names":[],"mappings":""}

package/src/engine/animation/async/prototypeAsyncAnimation.js

@@ -0,0 +1,344 @@
+import { GUI } from "dat.gui";
+import { MeshBasicMaterial, MeshStandardMaterial, OctahedronBufferGeometry } from "three";
+import { BinaryDataType } from "../../../core/binary/type/BinaryDataType.js";
+import { RowFirstTable } from "../../../core/collection/table/RowFirstTable.js";
+import { RowFirstTableSpec } from "../../../core/collection/table/RowFirstTableSpec.js";
+import { Color } from "../../../core/color/Color.js";
+import { inverseLerp } from "../../../core/math/inverseLerp.js";
+import { lerp } from "../../../core/math/lerp.js";
+import { max2 } from "../../../core/math/max2.js";
+import { min2 } from "../../../core/math/min2.js";
+import { randomFloatBetween } from "../../../core/math/random/randomFloatBetween.js";
+import { seededRandom } from "../../../core/math/random/seededRandom.js";
+import Clock from "../../Clock.js";
+import Entity from "../../ecs/Entity.js";
+import { Transform } from "../../ecs/transform/Transform.js";
+import { EngineHarness } from "../../EngineHarness.js";
+import { ShadedGeometry } from "../../graphics/ecs/mesh-v2/ShadedGeometry.js";
+import { ShadedGeometrySystem } from "../../graphics/ecs/mesh-v2/ShadedGeometrySystem.js";
+import Trail2D from "../../graphics/ecs/trail2d/Trail2D.js";
+import Trail2DSystem from "../../graphics/ecs/trail2d/Trail2DSystem.js";
+import {
+    RGBA_LUT_HEATMAP_IR
+} from "../../graphics/particles/particular/engine/parameter/sample/RGBA_LUT_HEATMAP_IR.js";
+import { SequenceBehavior } from "../../intelligence/behavior/composite/SequenceBehavior.js";
+import { RepeatBehavior } from "../../intelligence/behavior/decorator/RepeatBehavior.js";
+import { BehaviorComponent } from "../../intelligence/behavior/ecs/BehaviorComponent.js";
+import { BehaviorSystem } from "../../intelligence/behavior/ecs/BehaviorSystem.js";
+import { ActionBehavior } from "../../intelligence/behavior/primitive/ActionBehavior.js";
+import { RandomDelayBehavior } from "../../intelligence/behavior/util/RandomDelayBehavior.js";
+
+const harness = new EngineHarness();
+
+/**
+ *
+ * @param {RowFirstTable} table
+ * @param {number} time
+ * @return {number}
+ */
+function findSampleIndex(table, time) {
+    let minIndex = 0;
+    let maxIndex = table.length - 1;
+
+    while (minIndex <= maxIndex) {
+
+        const pivotIndex = (minIndex + maxIndex) >> 1;
+
+        const cmp = time - table.readCellValue(pivotIndex, 0);
+
+        if (cmp > 0) {
+            minIndex = pivotIndex + 1;
+        } else if (cmp < 0) {
+            maxIndex = pivotIndex - 1;
+        } else {
+            //set low boundary for next step based on assumption that upper bound is higher than lower bound
+            return pivotIndex;
+        }
+    }
+
+    return min2(minIndex, maxIndex);
+}
+
+/**
+ *
+ * @param {EntityComponentDataset} ecd
+ * @param {RowFirstTable} table
+ * @param {number} [count]
+ */
+function makeGhostMarkers({
+                              ecd,
+                              table,
+                              count = 5
+                          }) {
+
+
+    const g = new OctahedronBufferGeometry(1, 3);
+
+    /**
+     *
+     * @type {Entity[]}
+     */
+    const entities = [];
+
+    for (let i = 0; i < count; i++) {
+
+        const color = new Color();
+
+        const sample = [];
+
+        RGBA_LUT_HEATMAP_IR.sample(i / (count - 1), sample);
+
+        color.setRGBUint8(...sample);
+
+        const transform = new Transform();
+
+        const entity = new Entity();
+
+        entities.push(entity);
+
+        entity
+            .add(transform)
+            .add(ShadedGeometry.from(g, new MeshBasicMaterial({
+                wireframe: true,
+                color: color.toUint()
+            })))
+            .build(ecd);
+    }
+
+    return {
+        set time(time) {
+
+            const ref_index = findSampleIndex(table, time);
+
+            const start_index = max2(0, ref_index - Math.floor(count / 2));
+            const limit_index = min2(table.length - 1, ref_index + Math.ceil(count / 2));
+
+            for (let i = 0; i < count; i++) {
+
+                const entity = entities[i];
+
+                const sample_index = ref_index - Math.floor(count / 2) + i;
+
+                const out_of_bound_marker = sample_index < start_index || sample_index > limit_index;
+
+                if (out_of_bound_marker) {
+                    if (entity.isBuilt) {
+                        entity.destroy();
+                    }
+                } else {
+                    if (!entity.isBuilt) {
+                        entity.build(ecd);
+                    }
+                }
+
+                if (out_of_bound_marker) {
+                    continue;
+                }
+
+                const transform = entity.getComponentSafe(Transform);
+
+                transform.position.set(
+                    table.readCellValue(sample_index, 1),
+                    table.readCellValue(sample_index, 2),
+                    table.readCellValue(sample_index, 3)
+                );
+
+            }
+        }
+    };
+}
+
+/**
+ *
+ * @param {Engine} engine
+ * @return {Promise<void>}
+ */
+async function main(engine) {
+    await EngineHarness.buildBasics({
+        engine
+    });
+
+    const table = new RowFirstTable(
+        RowFirstTableSpec.get([
+            BinaryDataType.Float64, // time
+            BinaryDataType.Float32, // x
+            BinaryDataType.Float32, //y
+            BinaryDataType.Float32 //z
+        ])
+    );
+
+    const random = seededRandom(42);
+
+    table.addRow([
+        0, 0, 1, 0
+    ]);
+
+    const sample = [];
+
+    const sim_clock = new Clock();
+    sim_clock.start();
+
+    function addSample() {
+
+        const time_delta = sim_clock.getDelta();
+
+        // get last row
+        const row_count = table.length;
+
+        table.getRow(row_count - 1, sample);
+
+        const speed = 7;
+
+        const displacement = speed * time_delta;
+
+        const direction = randomFloatBetween(random, -Math.PI, Math.PI);
+
+        const displacement_x = displacement * Math.cos(direction);
+        const displacement_y = displacement * Math.sin(direction);
+
+        const new_x = sample[1] + displacement_x;
+        const new_z = sample[3] + displacement_y;
+
+        table.addRow([
+            sample[0] + time_delta,
+            new_x,
+            1,
+            new_z,
+
+        ]);
+    }
+
+
+    const ecd = engine.entityManager.dataset;
+
+    // simulate data arriving from the network
+    const sample_delay = RandomDelayBehavior.from(0.5, 1);
+    new Entity()
+        .add(BehaviorComponent.fromOne(RepeatBehavior.from(
+            SequenceBehavior.from([
+                sample_delay,
+                new ActionBehavior(addSample)
+            ])
+        )))
+        .build(ecd);
+
+    const sim_parameters = {
+        playing: true,
+        play_time: -1,
+        get latest_data_time() {
+            return table.readCellValue(table.length - 1, 0);
+        },
+        get behind_latest() {
+            return table.readCellValue(table.length - 1, 0) - this.play_time;
+        },
+        set behind_latest(v) {
+
+            const current_delay = table.readCellValue(table.length - 1, 0) - this.play_time;
+
+            const delta = v - current_delay;
+
+            this.play_time += delta;
+        }
+    };
+
+
+    // simulate agent moving through space
+    const subject = new Entity();
+
+    subject
+        .add(Transform.fromJSON({
+            position: 0
+        }))
+        .add(Trail2D.fromJSON({
+            textureURL: "data/textures/trail/Circle_04.png",
+            width: 0.2
+        }))
+        .add(ShadedGeometry.from(new OctahedronBufferGeometry(1, 5), new MeshStandardMaterial()))
+        .add(BehaviorComponent.fromOne(RepeatBehavior.from(
+            new ActionBehavior((delta) => {
+                if (sim_parameters.playing) {
+                    sim_parameters.play_time += delta;
+                }
+
+
+                // seek to the right sample
+                const sample_index = max2(0, findSampleIndex(table, sim_parameters.play_time));
+                const next_sample_index = min2(table.length - 1, sample_index + 1);
+
+                const prev = table.readCellValue(sample_index, 0);
+                const next = table.readCellValue(next_sample_index, 0);
+
+                const normalized_offset = inverseLerp(prev, next, sim_parameters.play_time);
+
+                const transform = subject.getComponentSafe(Transform);
+
+                const x0 = table.readCellValue(sample_index, 1);
+                const x1 = table.readCellValue(next_sample_index, 1);
+
+                const y0 = table.readCellValue(sample_index, 2);
+                const y1 = table.readCellValue(next_sample_index, 2);
+
+                const z0 = table.readCellValue(sample_index, 3);
+                const z1 = table.readCellValue(next_sample_index, 3);
+
+                transform.position.set(
+                    lerp(x0, x1, normalized_offset),
+                    lerp(y0, y1, normalized_offset),
+                    lerp(z0, z1, normalized_offset),
+                );
+            })
+        )))
+        .build(ecd);
+
+    const markers = makeGhostMarkers({
+        ecd, table, count: 5
+    });
+
+    engine.ticker.onTick.add(() => markers.time = sim_parameters.play_time);
+
+    const gui = new GUI();
+
+    const gui_samples = gui.addFolder("samples");
+    gui_samples.add(sample_delay.limits, 'min').name("min_delay").step(0.01)
+    gui_samples.add(sample_delay.limits, 'max').name("max_delay").step(0.01)
+
+    for (const k in sim_parameters) {
+
+        const control = gui.add(sim_parameters, k);
+
+        if (typeof sim_parameters[k] === "number") {
+            control.step(0.01);
+        }
+
+        let last_value = sim_parameters[k];
+
+        engine.ticker.onTick.add(() => {
+            let should_update = true;
+
+            const current_value = sim_parameters[k];
+            if (last_value === current_value) {
+                should_update = false;
+            } else {
+                last_value = current_value;
+            }
+
+
+            if (should_update) {
+                control.updateDisplay();
+            }
+        })
+    }
+
+    gui.open();
+
+}
+
+harness.initialize({
+    configuration(config, engine) {
+        config.addManySystems(
+            new BehaviorSystem(engine),
+            new ShadedGeometrySystem(engine),
+            new Trail2DSystem(engine)
+        )
+    }
+}).then(main);

package/src/engine/asset/AssetManager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"AssetManager.d.ts","sourceRoot":"","sources":["../../../../src/engine/asset/AssetManager.js"],"names":[],"mappings":"AAiDA;;;;GAIG;AACH;IAgII;;;;;OAKG;IACH,oCAJW,GAAG,EAYb;IA7ID;;;;OAIG;IACH,eAEG;IAEH;;;OAGG;IACH,aAFU,YAAY,gBAAgB,EAAE,YAAY,CAAC,CAER;IAe7C;;;;;;OAMG;IACH,kBAFU,MAAM,CAEY;IAyB5B;;;;OAIG;IACH,iBAAc;IAEd;;;OAGG;IACH,mBAFU,iBAAiB,CAEiB;IAwE5C,gBAQC;IAED;;;;OAIG;IACH,qBAHW,MAAM,GACL,QAAQ,IAAI,CAAC,CAexB;IAED;;;;;OAKG;IACH,oCAFa,OAAO,CAOnB;IAED;;OAEG;IACH,cAEC;IAED,8BAEC;IAED;;;;;;OAMG;IACH,4DAJW,iBAAiB,GAEf,cAAc,CAY1B;IAED;;;;;;;;;OASG;IACH,qFAsCC;IAED;;;;;OAKG;IACH,aAJW,MAAM,QACN,MAAM,sBAehB;IAsQD;;;;;OAKG;IACH,sBA2BC;IAGD;;;;OAIG;IACH,uBAHW,MAAM,GACL,OAAO,CAIlB;IAED;;;;OAIG;IACH,sBAHW,MAAM,GACJ,wBAAY,SAAS,CAMjC;IAaD;;;;OAIG;IACH,+BAHW,MAAM,4CAqBhB;IAED;;;;OAIG;IACH,iCAHW,MAAM,+CAyBhB;IAED;;;;;OAKG;IACH,0BAJW,MAAM,iEAwChB;IAED;;;OAGG;IACH,uBAFW,MAAM,iBAkBhB;IAED;;;;;;OAMG;IACH,yCAFa,aAAS,IAAI,CAYzB;IAED;;;;;OAKG;IACH,eAJW,MAAM,QACN,MAAM,GACJ,OAAO,CAMnB;IAED;;;;OAIG;IACH,2BAHW,MAAM,GACL,mBAAiB,CAa5B;IAED;;;;OAIG;IACH,oBAHW,MAAM,GACL,gBAAgB,GAAC,SAAS,CAQrC;IAED;;;;;OAKG;IACH,mBAJW,MAAM,QACN,MAAM,QACN,MAAM,QAUhB;IAGL;;;OAGG;IACH,yBAFU,OAAO,CAEoB;;CANpC;4BAv1B2B,0CAA0C;iCAOrC,uBAAuB;6BAM3B,mBAAmB;kCAFd,6BAA6B;kCAD7B,wBAAwB;4BAE9B,0BAA0B"}
+{"version":3,"file":"AssetManager.d.ts","sourceRoot":"","sources":["../../../../src/engine/asset/AssetManager.js"],"names":[],"mappings":"AAiDA;;;;GAIG;AACH;IAgII;;;;;OAKG;IACH,oCAJW,GAAG,EAYb;IA7ID;;;;OAIG;IACH,eAEG;IAEH;;;OAGG;IACH,aAFU,YAAY,gBAAgB,EAAE,YAAY,CAAC,CAER;IAe7C;;;;;;OAMG;IACH,kBAFU,MAAM,CAEY;IAyB5B;;;;OAIG;IACH,iBAAc;IAEd;;;OAGG;IACH,mBAFU,iBAAiB,CAEiB;IAwE5C,gBAQC;IAED;;;;OAIG;IACH,qBAHW,MAAM,GACL,QAAQ,IAAI,CAAC,CAexB;IAED;;;;;OAKG;IACH,oCAFa,OAAO,CAOnB;IAED;;OAEG;IACH,cAEC;IAED,8BAEC;IAED;;;;;;OAMG;IACH,4DAJW,iBAAiB,GAEf,cAAc,CAY1B;IAED;;;;;;;;;OASG;IACH,qFAsCC;IAED;;;;;OAKG;IACH,aAJW,MAAM,QACN,MAAM,sBAehB;IAsQD;;;;;OAKG;IACH,sBA2BC;IAGD;;;;OAIG;IACH,uBAHW,MAAM,GACL,OAAO,CAIlB;IAED;;;;OAIG;IACH,sBAHW,MAAM,GACJ,wBAAY,SAAS,CAMjC;IAaD;;;;OAIG;IACH,+BAHW,MAAM,4CAqBhB;IAED;;;;OAIG;IACH,iCAHW,MAAM,+CAyBhB;IAED;;;;;;OAMG;IACH,6BAJW,MAAM,kCAEJ,QAAQ,OAAO,CAAC,CAU5B;IAED;;;;;OAKG;IACH,0BAJW,MAAM,iEAwChB;IAED;;;OAGG;IACH,uBAFW,MAAM,iBAkBhB;IAED;;;;;;OAMG;IACH,yCAFa,aAAS,IAAI,CAYzB;IAED;;;;;OAKG;IACH,eAJW,MAAM,QACN,MAAM,GACJ,OAAO,CAMnB;IAED;;;;OAIG;IACH,2BAHW,MAAM,GACL,mBAAiB,CAa5B;IAED;;;;OAIG;IACH,oBAHW,MAAM,GACL,gBAAgB,GAAC,SAAS,CAQrC;IAED;;;;;OAKG;IACH,mBAJW,MAAM,QACN,MAAM,QACN,MAAM,QAUhB;IAGL;;;OAGG;IACH,yBAFU,OAAO,CAEoB;;CANpC;4BAx2B2B,0CAA0C;iCAOrC,uBAAuB;6BAM3B,mBAAmB;kCAFd,6BAA6B;kCAD7B,wBAAwB;4BAE9B,0BAA0B"}

package/src/engine/asset/AssetManager.js

@@ -720,6 +720,23 @@ export class AssetManager {
         return true;
     }
 
+    /**
+     * Will register loader only if none exists for this type
+     * @template T
+     * @param {string} type
+     * @param {AssetLoader<T>} loader
+     * @returns {Promise<boolean>} true if registered , false otherwise
+     */
+    async tryRegisterLoader(type, loader) {
+        if (this.hasLoaderForType(type)) {
+            return false;
+        }
+
+        await this.registerLoader(type, loader);
+
+        return true;
+    }
+
     /**
      * @template T
      * @param {string} type

package/src/engine/ecs/Entity.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Entity.d.ts","sourceRoot":"","sources":["../../../../src/engine/ecs/Entity.js"],"names":[],"mappings":";AAeA;;;GAGG;AACH;IAmYI;;;;;OAKG;IACH,+BAJW,MAAM,oCAEJ,MAAM,CAelB;IApZD;;;OAGG;IACH,IAFU,MAAM,CAER;IAER;;;;OAIG;IACH,YAFU,MAAM,CAEA;IAEhB;;;;OAIG;IACH,2BAAgB;IAQhB;;;OAGG;IACH,gCAAe;IAEf;;;OAGG;IACH,OAFU,WAAW,GAAC,MAAM,CAEN;IAEtB;;;OAGG;IACH,gBAAgB;IAEhB;;OAEG;IACH;;MAEE;IAUF;;;OAGG;IACH,eAFW,MAAM,GAAC,WAAW,QAI5B;IAED;;;;OAIG;IACH,cAHW,MAAM,GAAC,WAAW,GAChB,OAAO,CAMnB;IAED;;;OAGG;IACH,gBAFW,MAAM,GAAC,WAAW,QAI5B;IAED;;;OAGG;IACH,uBAEC;IAED;;OAEG;IACH,4BAQC;IAED;;;OAGG;IACH,oBAEC;IAED;;;;OAIG;IACH,8BAFa,MAAM,CAiBlB;IAED;;;;OAIG;IACH,+BAFa,OAAO,CAInB;IAED;;;;OAIG;IACH,0CAYC;IAED;;;;OAIG;IACH,qCAQC;IAED;;;;OAIG;IACH,kCAFa,MAAE,IAAI,CA0BlB;IAED;;;;OAIG;IACH,qBAHW,MAAM,qBAShB;IAED;;;OAGG;IACH,wBAFW,MAAM,gBAiBhB;IAED;;;;;;OAMG;IACH,4BALW,MAAM,sCAGJ,MAAM,CAalB;IAED;;;;;;OAMG;IACH,+BALW,MAAM,sCAGJ,MAAM,CAyBlB;IAED;;;OAGG;IACH,WAFa,OAAO,CAwBnB;IAED;;;;OAIG;IACH,+CAqDC;IAwBL;;;;OAIG;IACH,mBAFU,OAAO,CAEQ;;CAPxB;4BAva2B,kBAAkB;mBAF3B,oCAAoC"}
+{"version":3,"file":"Entity.d.ts","sourceRoot":"","sources":["../../../../src/engine/ecs/Entity.js"],"names":[],"mappings":";AAeA;;;GAGG;AACH;IAoYI;;;;;OAKG;IACH,+BAJW,MAAM,oCAEJ,MAAM,CAelB;IArZD;;;OAGG;IACH,IAFU,MAAM,CAER;IAER;;;;OAIG;IACH,YAFU,MAAM,CAEA;IAEhB;;;;OAIG;IACH,2BAAgB;IAQhB;;;OAGG;IACH,gCAAe;IAEf;;;OAGG;IACH,OAFU,WAAW,GAAC,MAAM,CAEN;IAEtB;;;OAGG;IACH,gBAAgB;IAEhB;;OAEG;IACH;;MAEE;IAUF;;;OAGG;IACH,eAFW,MAAM,GAAC,WAAW,QAI5B;IAED;;;;OAIG;IACH,cAHW,MAAM,GAAC,WAAW,GAChB,OAAO,CAMnB;IAED;;;OAGG;IACH,gBAFW,MAAM,GAAC,WAAW,QAI5B;IAED;;;OAGG;IACH,uBAEC;IAED;;OAEG;IACH,4BAQC;IAED;;;OAGG;IACH,oBAEC;IAED;;;;OAIG;IACH,8BAFa,MAAM,CAiBlB;IAED;;;;OAIG;IACH,+BAFa,OAAO,CAInB;IAED;;;;OAIG;IACH,0CAYC;IAED;;;;;OAKG;IACH,8CAQC;IAED;;;;OAIG;IACH,kCAFa,MAAE,IAAI,CA0BlB;IAED;;;;OAIG;IACH,qBAHW,MAAM,qBAShB;IAED;;;OAGG;IACH,wBAFW,MAAM,gBAiBhB;IAED;;;;;;OAMG;IACH,4BALW,MAAM,sCAGJ,MAAM,CAalB;IAED;;;;;;OAMG;IACH,+BALW,MAAM,sCAGJ,MAAM,CAyBlB;IAED;;;OAGG;IACH,WAFa,OAAO,CAwBnB;IAED;;;;OAIG;IACH,+CAqDC;IAwBL;;;;OAIG;IACH,mBAFU,OAAO,CAEQ;;CAPxB;4BAxa2B,kBAAkB;mBAF3B,oCAAoC"}

package/src/engine/ecs/Entity.js

@@ -186,6 +186,7 @@ class Entity {
 
     /**
      * Similar to {@link #getComponent}, instead of returning null - throws an exception
+     * @template T
      * @param {Class<T>} klass
      * @returns {T}
      */

package/src/engine/ecs/terrain/ecs/TerrainSystem.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TerrainSystem.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/ecs/terrain/ecs/TerrainSystem.js"],"names":[],"mappings":";AA8BA;IA4MI;;;;;OAKG;IACH,kEAHW,OAAO,uBAwCjB;IA9ND;;;;;OAKG;IACH,kEAeC;IA7CD,iCAAyB;IAEzB,mBAAe;IACf,mBAAe;IAEf;;;;OAIG;IACH,qBAAiB;IAEjB;;;OAGG;IACH,aAFU,cAAY,IAAI,CAEP;IAEnB;;;OAGG;IACH,KAFU,GAAG,CAEG;IAoBZ,yBAAwB;IAExB,2BAAgC;IAGpC,kDAMC;IAED,mFA0DC;IAED,2EAIC;IAED;;;;OAIG;IACH,gBAHW,OAAO,qBAqBjB;IAED;;;;OAIG;IACH,kBAHW,OAAO,qBAKjB;IAED,6BAaC;IAED;;;;;OAKG;IACH,gCAwBC;CA+CJ;uBA3QsB,iBAAiB;oBAEpB,cAAc;oBAZd,mCAAmC"}
+{"version":3,"file":"TerrainSystem.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/ecs/terrain/ecs/TerrainSystem.js"],"names":[],"mappings":";AA+BA;IA2MI;;;;;OAKG;IACH,kEAHW,OAAO,uBAwCjB;IA7ND;;;;;OAKG;IACH,kEAeC;IA7CD,iCAAyB;IAEzB,mBAAe;IACf,mBAAe;IAEf;;;;OAIG;IACH,qBAAiB;IAEjB;;;OAGG;IACH,aAFU,cAAY,IAAI,CAEP;IAEnB;;;OAGG;IACH,KAFU,GAAG,CAEG;IAoBZ,yBAAwB;IAExB,2BAAgC;IAGpC,kDAMC;IAED,mFAyDC;IAED,2EAIC;IAED;;;;OAIG;IACH,gBAHW,OAAO,qBAqBjB;IAED;;;;OAIG;IACH,kBAHW,OAAO,qBAKjB;IAED,6BAaC;IAED;;;;;OAKG;IACH,gCAwBC;CA+CJ;uBA1QsB,iBAAiB;oBAEpB,cAAc;oBAbd,mCAAmC"}

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

@@ -8,6 +8,7 @@ import { noop } from "../../../../core/function/noop.js";
 import { read_three_planes_to_array } from "../../../../core/geom/3d/frustum/read_three_planes_to_array.js";
 import { MATRIX_4_IDENTITY } from "../../../../core/geom/3d/mat4/MATRIX_4_IDENTITY.js";
 import { ImageRGBADataLoader } from "../../../asset/loaders/image/ImageRGBADataLoader.js";
+import { TextureAssetLoader } from "../../../asset/loaders/texture/TextureAssetLoader.js";
 import { CameraSystem } from '../../../graphics/ecs/camera/CameraSystem.js';
 import { System } from '../../System.js';
 import { Transform } from "../../transform/Transform.js";
@@ -137,9 +138,8 @@ class TerrainSystem extends System {
 
         const am = this.assetManager;
 
-        if (!am.hasLoaderForType('image')) {
-            await am.registerLoader('image', new ImageRGBADataLoader());
-        }
+        await am.tryRegisterLoader('image', new ImageRGBADataLoader());
+        await am.tryRegisterLoader('texture', new TextureAssetLoader());
 
         readyCallback();
     }

package/src/engine/input/ecs/systems/InputControllerSystem.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"InputControllerSystem.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/input/ecs/systems/InputControllerSystem.js"],"names":[],"mappings":";AA0LA;;GAEG;AACH;IACI,0BA+BC;IA7BG,gCAAsC;IAEtC,yCAAqC;IAErC,aAAsB;IA2B1B,0EAIC;IAFG,YAAiB;IAIrB;;;;OAIG;IACH,gBAHW,eAAe,qBAOzB;IAED;;;;OAIG;IACH,kBAHW,eAAe,qBASzB;CACJ;uBAtPsB,wBAAwB;0BAErB,yCAAyC;4BADvC,kCAAkC"}
+{"version":3,"file":"InputControllerSystem.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/input/ecs/systems/InputControllerSystem.js"],"names":[],"mappings":";AAsLA;;GAEG;AACH;IACI,0BA+BC;IA7BG,gCAAsC;IAEtC,yCAAqC;IAErC,aAAsB;IA2B1B,0EAIC;IAFG,YAAiB;IAIrB;;;;OAIG;IACH,gBAHW,eAAe,qBAOzB;IAED;;;;OAIG;IACH,kBAHW,eAAe,qBASzB;CACJ;uBAhPsB,wBAAwB;0BADrB,yCAAyC;4BAEvC,kCAAkC"}

package/src/engine/input/ecs/systems/InputControllerSystem.js

@@ -3,11 +3,11 @@
  */
 
 
+import { assert } from "../../../../core/assert.js";
 import { resolvePath } from "../../../../core/json/resolvePath.js";
+import ObservedValue from "../../../../core/model/ObservedValue.js";
 import { System } from "../../../ecs/System.js";
 import InputController from "../components/InputController.js";
-import ObservedValue from "../../../../core/model/ObservedValue.js";
-import { assert } from "../../../../core/assert.js";
 
 /**
  *
@@ -122,12 +122,8 @@ function getOrCreateProxy(proxies, path, signal) {
      * @param {InputControllerBinding} binding
      */
     Proxy.prototype.add = function (binding) {
-        if (this.signal.isDispatching()) {
-            // handler is currently running, adding the binding could trigger it immediately. Deferring the registration allows us to avoid this
-            this.deferred.push(binding);
-        } else {
-            this.registerBinding(binding);
-        }
+        //TODO handle case where binding is added mid-dispatch
+        this.registerBinding(binding);
     };
 
     /**

package/src/engine/intelligence/behavior/util/RandomDelayBehavior.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Wait for a certain amount of time
+ */
+export class RandomDelayBehavior extends Behavior<any> {
+    /**
+     *
+     * @param json
+     * @return {RandomDelayBehavior}
+     */
+    static fromJSON(json: any): RandomDelayBehavior;
+    /**
+     *
+     * @return {RandomDelayBehavior}
+     * @param min
+     * @param max
+     */
+    static from(min: any, max: any): RandomDelayBehavior;
+    constructor();
+    /**
+     * Delay value in seconds
+     * @type {number}
+     */
+    value: number;
+    /**
+     *
+     * @type {NumericInterval}
+     */
+    limits: NumericInterval;
+    /**
+     * Time elapsed
+     * @private
+     * @type {number}
+     */
+    private elapsed;
+    random: () => number;
+    fromJSON({ limits, elapsed }: {
+        limits: any;
+        elapsed?: number;
+    }): void;
+    initialize(ctx: any): void;
+    tick(timeDelta: any): BehaviorStatus.Running | BehaviorStatus.Succeeded;
+}
+import { Behavior } from "../Behavior.js";
+import { NumericInterval } from "../../../../core/math/interval/NumericInterval.js";
+import { BehaviorStatus } from "../BehaviorStatus.js";
+//# sourceMappingURL=RandomDelayBehavior.d.ts.map

package/src/engine/intelligence/behavior/util/RandomDelayBehavior.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RandomDelayBehavior.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/intelligence/behavior/util/RandomDelayBehavior.js"],"names":[],"mappings":"AAWA;;GAEG;AACH;IA6BI;;;;OAIG;IACH,4BAFY,mBAAmB,CAM9B;IAED;;;;;OAKG;IACH,iCAJY,mBAAmB,CAU9B;;IAlDD;;;OAGG;IACH,OAFU,MAAM,CAEN;IAEV;;;OAGG;IACH,QAFU,eAAe,CAEU;IAEnC;;;;OAIG;IACH,gBAAY;IAEZ,qBAAiC;IAGjC;;;aAGC;IA2BD,2BAKC;IAED,wEAQC;CACJ;yBAjFwB,gBAAgB;gCAFT,mDAAmD;+BAGpD,sBAAsB"}