@woosh/meep-engine 2.43.1 → 2.43.4

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

@@ -1,4 +1,5 @@
 import { Sampler2D } from "./Sampler2D.js";
+import { sampler2d_combine } from "./sampler2d_combine.js";
 
 test("constructor arguments", () => {
     const uint8Array = new Uint8Array(24);
@@ -217,7 +218,7 @@ test('Sampler2.combine ADD', () => {
 
     const ut = new Sampler2D(new Array(8), 2, 2, 2);
 
-    Sampler2D.combine(s0, s1, ut, function (arg0, arg1, res, index) {
+    sampler2d_combine(s0, s1, ut, function (arg0, arg1, res, index) {
         res[0] = arg0[0] + arg1[0];
         res[1] = arg0[1] + arg1[1];
     });

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

@@ -0,0 +1,67 @@
+import { assert } from "../../../../core/assert.js";
+
+
+/**
+ * Execute a binary operation with 2 input samplers and an output
+ * @param {Sampler2D} input0
+ * @param {Sampler2D} input1
+ * @param {Sampler2D} result
+ * @param {function( value0 : number[], value1 : number[], result : number[], index : number) : void} operation
+ */
+export function sampler2d_combine(input0, input1, result, operation) {
+    assert.notEqual(input0, undefined, "input0 is undefined");
+    assert.notEqual(input1, undefined, "input1 is undefined");
+    assert.notEqual(result, undefined, "result is undefined");
+
+    assert.typeOf(operation, "function", "operation");
+
+    assert.equal(input0.width, input1.width, `input0.width(=${input0.width}) is not equal to input1.width(=${input1.width})`);
+    assert.equal(input0.height, input1.height, `input0.height(=${input0.height}) is not equal to input1.height(=${input1.height})`);
+
+    assert.equal(input0.width, result.width, `input width(=${input0.width}) is not equal to result.width(=${result.width})`);
+    assert.equal(input0.height, result.height, `input height(=${input0.height}) is not equal to result.height(=${result.height})`);
+
+    const width = input0.width;
+    const height = input0.height;
+
+    const length = width * height;
+
+    const arg0 = [];
+    const arg1 = [];
+    const res = [];
+
+    const itemSize0 = input0.itemSize;
+    const itemSize1 = input1.itemSize;
+    const itemSizeR = result.itemSize;
+
+    const data0 = input0.data;
+    const data1 = input1.data;
+    const dataR = result.data;
+
+
+    let i, j;
+
+    for (i = 0; i < length; i++) {
+
+        // read input 0
+        for (j = 0; j < itemSize0; j++) {
+            arg0[j] = data0[j + i * itemSize0];
+        }
+
+        // read input 1
+        for (j = 0; j < itemSize0; j++) {
+            arg1[j] = data1[j + i * itemSize1];
+        }
+
+        //perform operation
+        operation(arg0, arg1, res, i);
+
+        //write result
+        for (j = 0; j < itemSizeR; j++) {
+            dataR[j + i * itemSizeR] = res[j];
+        }
+
+    }
+
+    result.version++;
+}

package/engine/intelligence/behavior/ecs/BehaviorSystem.spec.js

@@ -1,7 +1,6 @@
 import { BehaviorSystem } from "./BehaviorSystem.js";
 import { BehaviorComponent } from "./BehaviorComponent.js";
 import { Behavior } from "../Behavior.js";
-import { BehaviorStatus } from "../BehaviorStatus.js";
 import { EntityComponentDataset } from "../../../ecs/EntityComponentDataset.js";
 import { EntityManager } from "../../../ecs/EntityManager.js";
 import { noop } from "../../../../core/function/Functions.js";
@@ -44,7 +43,6 @@ test("unlinking finalizes behavior if it is running", () => {
 
     const behavior = new Behavior();
     behavior.finalize = jest.fn();
-    behavior.setStatus(BehaviorStatus.Running);
 
     s.unlink(BehaviorComponent.fromOne(behavior), 0);
 
@@ -56,7 +54,6 @@ test("update ticks behavior with the time delta", () => {
 
     const behavior = new Behavior();
     behavior.tick = jest.fn();
-    behavior.setStatus(BehaviorStatus.Running);
 
     const behaviorComponent = BehaviorComponent.fromOne(behavior);
 

package/engine/intelligence/blackboard/AbstractBlackboard.d.ts

@@ -1,5 +1,5 @@
 import ObservedBoolean from "../../../core/model/ObservedBoolean";
-import {Vector1} from "../../../core/geom/Vector1";
+import Vector1 from "../../../core/geom/Vector1";
 import ObservedString from "../../../core/model/ObservedString";
 
 export class AbstractBlackboard {

package/engine/network/PriorityFetch.js

@@ -0,0 +1,192 @@
+import FastBinaryHeap from "../../core/collection/heap/FastBinaryHeap.js";
+import { noop } from "../../core/function/Functions.js";
+import { assert } from "../../core/assert.js";
+
+/**
+ * @readonly
+ * @type {{high: number, auto: number, low: number}}
+ */
+const priority_value_map = {
+    "high": 10,
+    "low": -1,
+    "auto": 0
+};
+
+/**
+ *
+ * @param {string|undefined} p
+ * @return {number}
+ */
+function extract_priority_from_resource(p) {
+
+    let v = 0;
+
+    if (typeof p === "string") {
+        v = priority_value_map[p];
+
+        if (v === undefined) {
+            console.warn(`Unsupported request priority value '${p}', defaulting to 'auto'`);
+        }
+
+        v = priority_value_map['auto'];
+    }
+
+    return v;
+
+}
+
+class FetchRequest {
+    /**
+     *
+     * @param {Request|string} resource
+     * @param {{}} options
+     */
+    constructor(resource, options) {
+        let priority = 0;
+
+        this.__resource = resource;
+        this.__options = options;
+
+        if (typeof this.__resource === "object" && typeof this.__resource.priority !== "undefined") {
+            priority = extract_priority_from_resource(this.__resource.priority);
+        }
+
+        this.__priority = priority;
+
+        this.fulfillment = {
+            resolve: null, reject: null
+        };
+
+        this.promise = new Promise((resolve, reject) => {
+            this.fulfillment.resolve = resolve;
+            this.fulfillment.reject = reject;
+        });
+    }
+}
+
+/**
+ *
+ * @param {FetchRequest} request
+ * @returns {number}
+ */
+function get_priority_score(request) {
+    return -request.__priority;
+}
+
+/**
+ * @readonly
+ * @type {number}
+ */
+const DEFAULT_CONCURRENCY = Infinity;
+
+/**
+ * Wraps {@link fetch} api and adds concurrency management to it by queueing requests,
+ * as well as prioritization in that queue
+ */
+export class PriorityFetch {
+    constructor({
+                    adapter = noop,
+                    concurrency = DEFAULT_CONCURRENCY
+                }) {
+        /**
+         *
+         * @type {number}
+         * @private
+         */
+        this.__concurrency = concurrency;
+
+        /**
+         *
+         * @type {BinaryHeap<FetchRequest>}
+         * @private
+         */
+        this.__queue = new FastBinaryHeap(get_priority_score);
+
+        /**
+         *
+         * @type {Set<FetchRequest>}
+         * @private
+         */
+        this.__pending_set = new Set();
+
+        /**
+         *
+         * @type {null}
+         * @private
+         */
+        this.__adapter = adapter;
+    }
+
+    /**
+     *
+     * @param {function} v
+     */
+    set adapter(v) {
+        this.__adapter = v;
+    }
+
+    /**
+     *
+     * @param {number} v
+     */
+    set concurrency(v) {
+        assert.isNumber(v, 'v');
+        assert.notNaN(v, 'v');
+        assert.greaterThan(v, 0, 'concurrency must be greater than 0');
+
+        this.__concurrency = v;
+    }
+
+    /**
+     *
+     * @return {number}
+     */
+    get concurrency() {
+        return this.__concurrency;
+    }
+
+    /**
+     *
+     * @param {FetchRequest} req
+     * @private
+     */
+    __dispatch(req) {
+        const promise = this.__adapter(req.__resource, req.__options);
+
+        promise.finally(() => {
+            this.__pending_set.delete(req);
+
+            this.__prod();
+        });
+
+        promise
+            .then(
+                (v) => {
+                    req.fulfillment.resolve(v);
+                },
+                (reason) => {
+                    req.fulfillment.reject(reason);
+                }
+            );
+    }
+
+    __prod() {
+        if (this.__pending_set.size < this.__concurrency && !this.__queue.isEmpty()) {
+            const req = this.__queue.pop();
+
+            this.__dispatch(req);
+        }
+    }
+
+    fetch(resource, options) {
+        const req = new FetchRequest(resource, options);
+
+        if (this.__pending_set.size < this.__concurrency) {
+            this.__dispatch(req);
+        } else {
+            this.__queue.push(req);
+        }
+
+        return req.promise;
+    }
+}

package/engine/simulation/DormandPrince.js

@@ -166,7 +166,7 @@ function computeStepSize(fxy, x, y, suggestedStepSize, tolerance, maxIterations,
  * @param {number} hmax max step size
  * @param {number} hmin min step size
  * @param {number} max_iteration maximum number of iterations
- * @returns {*[]}
+ * @returns {Array.<number>}
  */
 function odedopri(fxy, x0, y0, x1, tol, hmax, hmin, max_iteration) {
 

package/engine/ui/DraggableAspect.js

@@ -34,7 +34,6 @@ export class DraggableAspect {
         const pointerGlobal = this.pointerGlobal = new PointerDevice(window);
 
         const dragOriginalPosition = new Vector2();
-        const delta = new Vector2();
         const pointer_position_last = new Vector2();
 
         if (stopPropagation) {

package/generation/grid/generation/road/GridTaskGenerateRoads.js

@@ -11,7 +11,6 @@ import { buildPathFromDistanceMap } from "../util/buildPathFromDistanceMap.js";
 import { GridCellActionPlaceTags } from "../../../placement/action/GridCellActionPlaceTags.js";
 import { GridTags } from "../../../GridTags.js";
 import { CellMatcher } from "../../../rules/CellMatcher.js";
-import { groupArrayBy } from "../../../../core/collection/ArrayUtils.js";
 import { collectIteratorValueToArray } from "../../../../core/collection/IteratorUtils.js";
 import { QuadTreeNode } from "../../../../core/geom/2d/quad-tree/QuadTreeNode.js";
 import AABB2 from "../../../../core/geom/AABB2.js";
@@ -24,6 +23,7 @@ import { RoadConnectionNetwork } from "./RoadConnectionNetwork.js";
 import { MirGridLayers } from "../../../example/grid/MirGridLayers.js";
 import { actionTask } from "../../../../core/process/task/util/actionTask.js";
 import { countTask } from "../../../../core/process/task/util/countTask.js";
+import { groupArrayBy } from "../../../../core/collection/array/groupArrayBy.js";
 
 const NODE_TYPE_ROAD_CONNECTOR = 'Road Connector';
 

package/package.json

@@ -5,12 +5,13 @@
   "productName": "Meep",
   "description": "production-ready JavaScript game engine based on Entity Component System Architecture",
   "author": "Alexander Goldring",
-  "version": "2.43.1",
+  "version": "2.43.4",
   "dependencies": {
     "gl-matrix": "3.4.3",
     "fast-levenshtein": "2.0.6",
     "opentype.js": "1.3.3",
     "simplex-noise": "2.4.0",
+    "robust-predicates": "3.0.1",
     "three": "^0.135.0"
   },
   "devDependencies": {

package/samples/terrain/from_image_2.js

@@ -7,7 +7,6 @@ import EntityBuilder from "../../engine/ecs/EntityBuilder.js";
 import Terrain from "../../engine/ecs/terrain/ecs/Terrain.js";
 import { ImageRGBADataLoader } from "../../engine/asset/loaders/image/ImageRGBADataLoader.js";
 import TerrainSystem from "../../engine/ecs/terrain/ecs/TerrainSystem.js";
-import WaterSystem from "../../engine/graphics/ecs/water/WaterSystem.js";
 import Water from "../../engine/graphics/ecs/water/Water.js";
 import {
     AmbientOcclusionPostProcessEffect
@@ -16,73 +15,42 @@ import { TerrainLayer } from "../../engine/ecs/terrain/ecs/layers/TerrainLayer.j
 import Mesh from "../../engine/graphics/ecs/mesh/Mesh.js";
 import { Transform } from "../../engine/ecs/transform/Transform.js";
 import { MeshSystem } from "../../engine/graphics/ecs/mesh/MeshSystem.js";
-import { enableEditor } from "../../editor/enableEditor.js";
-import "../../../../../css/main.scss";
-import '../../../../../css/editor/EntityEditorView.scss';
-import '../../../../../css/editor/EditorView.scss';
-import { initializeEditor } from "../../../model/game/initializeEditor.js";
+import ButtonView from "../../view/elements/button/ButtonView.js";
+import { downloadAsFile } from "../../core/binary/ByteArrayTools.js";
 
 const HEIGHT_RANGE = 64;
 
 const eh = new EngineHarness();
 
-/**
- *
- * @param {Engine} engine
- * @return {EngineConfiguration}
- */
-function makeConfig(engine) {
-    const r = new EngineConfiguration();
-
-    // configure engine here, add systems, loaders etc.
-    r.addLoader(GameAssetType.Texture, new TextureAssetLoader());
-    r.addLoader(GameAssetType.Image, new ImageRGBADataLoader());
-
-
-    r.addSystem(new TerrainSystem(engine.graphics, engine.assetManager));
-    r.addSystem(new WaterSystem(engine.graphics));
-    r.addSystem(new MeshSystem(engine));
-
-    r.addPlugin(AmbientOcclusionPostProcessEffect);
-
-    return r;
-}
 
 /**
  *
- * @param {string} path
- * @param {AssetManager} am
+ * @param {Sampler2D} source
+ * @param {Terrain} terrain
  */
-async function load_sampler(path, am) {
-
-    const asset = await am.promise(path, 'image');
+function scale_terrain_heights(source, terrain) {
+    const source_height_data = source.data;
+    const sampler_pixel_count = source_height_data.length;
+    const terrain_height_data = terrain.samplerHeight.data;
 
-    /**
-     *
-     * @type {Sampler2D}
-     */
-    const sampler = asset.create();
+    let divisor;
+    if (source_height_data instanceof Uint8Array) {
+        divisor = 255;
+    } else if (source_height_data instanceof Uint16Array) {
+        divisor = 65536 - 1;
+    }
 
-    return sampler;
-}
+    for (let i = 0; i < sampler_pixel_count; i++) {
+        const source_v = source_height_data[i];
 
-/**
- *
- * @param {string} path
- * @param {Engine} engine
- * @param {Transform} transform
- */
-async function load_gltf(path, engine, transform) {
-    const em = engine.entityManager;
+        const b0 = source_v & 0xFF;
+        const b1 = (source_v >> 8) & 0xFF;
 
-    const ecd = em.dataset;
+        let rotated_v;
+        rotated_v = b1 | (b0 << 8);
 
-    new EntityBuilder()
-        .add(Mesh.fromJSON({
-            url: path
-        }))
-        .add(transform)
-        .build(ecd);
+        terrain_height_data[i] = (rotated_v / divisor) * HEIGHT_RANGE
+    }
 }
 
 /**
@@ -139,43 +107,22 @@ async function main(engine) {
     await load_splat_layer("moicon/23_Nov_21_Skogplanter/01/splat_stone.png", 2);
 
     terrain.samplerHeight.resize(sampler.width, sampler.height);
-    const source_height_data = sampler.data;
-    const sampler_pixel_count = source_height_data.length;
-    const terrain_height_data = terrain.samplerHeight.data;
-
-    let divisor;
-    if (source_height_data instanceof Uint8Array) {
-        divisor = 255;
-    } else if (source_height_data instanceof Uint16Array) {
-        divisor = 65536 - 1;
-    }
-
-    for (let i = 0; i < sampler_pixel_count; i++) {
-        const source_v = source_height_data[i];
-
-        const b0 = source_v & 0xFF;
-        const b1 = (source_v >> 8) & 0xFF;
-
-        let rotated_v;
-        rotated_v = b1 | (b0 << 8);
-
-        terrain_height_data[i] = (rotated_v / divisor) * HEIGHT_RANGE
-    }
+    scale_terrain_heights(sampler, terrain);
 
     terrain.layers.resolution.set(1024, 1024);
 
     terrain.layers.addLayer(TerrainLayer.from(
-        "data/textures/materials/terrain_township_set/Grass_2.png",
+        "moicon/23_Nov_21_Skogplanter/01/textures/Grass_2.png",
         20,
         20
     ));
     terrain.layers.addLayer(TerrainLayer.from(
-        "data/textures/materials/terrain_township_set/1024/Ground_1_dark.png",
+        "moicon/23_Nov_21_Skogplanter/01/textures/Ground_1_dark.png",
         20,
         20
     ));
     terrain.layers.addLayer(TerrainLayer.from(
-        "data/textures/materials/Sci-Fi Planet/Sand_01.png",
+        "moicon/23_Nov_21_Skogplanter/01/textures/Sand_01.png",
         20,
         20
     ));
@@ -188,7 +135,8 @@ async function main(engine) {
     water.shoreDepthTransition.set(0.1, 0.3);
     water.scattering.set(3);
 
-    new EntityBuilder()
+    const terrain_builder = new EntityBuilder();
+    terrain_builder
         .add(terrain)
         // .add(water)
         .build(ecd);
@@ -204,6 +152,47 @@ async function main(engine) {
     load_gltf("moicon/23_Nov_21_Skogplanter/02/model.gltf", engine, transform);
     // load_gltf("moicon/23_Nov_21_Skogplanter/03/model.gltf", engine, transform);
     // load_gltf("moicon/23_Nov_21_Skogplanter/04/model.gltf", engine, transform);
+
+    engine.gui.view.addChild(new ButtonView({
+        name: 'Download',
+        action() {
+            // we wrap the terrain data into "component json" format that meep editor recognizes to make this compatible with the standalone terrain editor
+            const json_payload = {
+                type: "Terrain",
+                data: terrain.toJSON()
+            };
+
+            downloadAsFile(
+                JSON.stringify(json_payload),
+                'terrain.json'
+            );
+        },
+        css: {
+            bottom: '4px',
+            left: '4px',
+            position: 'absolute',
+            background: 'white',
+            border: '1px solid black',
+            padding: '2px',
+            pointerEvents: 'auto'
+        }
+    }));
+
+    engine.gui.view.addChild(new ButtonView({
+        name: 'Remove',
+        action() {
+           engine.entityManager.dataset.removeEntity(terrain_builder.entity);
+        },
+        css: {
+            bottom: '4px',
+            left: '104px',
+            position: 'absolute',
+            background: 'white',
+            border: '1px solid black',
+            padding: '2px',
+            pointerEvents: 'auto'
+        }
+    }));
 }
 
 /**
@@ -215,11 +204,67 @@ async function init(harness) {
 
     await makeConfig(engine).apply(engine);
 
-    enableEditor(engine,initializeEditor);
-
     await eh.initialize();
 
     main(engine);
 }
 
 init(eh);
+
+/**
+ *
+ * @param {Engine} engine
+ * @return {EngineConfiguration}
+ */
+function makeConfig(engine) {
+    const r = new EngineConfiguration();
+
+    // configure engine here, add systems, loaders etc.
+    r.addLoader(GameAssetType.Texture, new TextureAssetLoader());
+    r.addLoader(GameAssetType.Image, new ImageRGBADataLoader());
+
+
+    r.addSystem(new TerrainSystem(engine.graphics, engine.assetManager));
+    r.addSystem(new MeshSystem(engine));
+
+    r.addPlugin(AmbientOcclusionPostProcessEffect);
+
+    return r;
+}
+
+/**
+ *
+ * @param {string} path
+ * @param {AssetManager} am
+ */
+async function load_sampler(path, am) {
+
+    const asset = await am.promise(path, 'image');
+
+    /**
+     *
+     * @type {Sampler2D}
+     */
+    const sampler = asset.create();
+
+    return sampler;
+}
+
+/**
+ *
+ * @param {string} path
+ * @param {Engine} engine
+ * @param {Transform} transform
+ */
+async function load_gltf(path, engine, transform) {
+    const em = engine.entityManager;
+
+    const ecd = em.dataset;
+
+    new EntityBuilder()
+        .add(Mesh.fromJSON({
+            url: path
+        }))
+        .add(transform)
+        .build(ecd);
+}

package/view/elements/CanvasView.js

@@ -1,6 +1,8 @@
 import View from "../View.js";
 
-
+/**
+ * Wrapper around {@link HTMLCanvasElement}, exposes {@link CanvasRenderingContext2D}
+ */
 export class CanvasView extends View {
     constructor() {
         super();
@@ -8,6 +10,10 @@ export class CanvasView extends View {
         const canvas = document.createElement('canvas');
         this.el = canvas;
 
+        /**
+         *
+         * @type {CanvasRenderingContext2D}
+         */
         this.context2d = canvas.getContext('2d');
 
         this.size.onChanged.add(this.__handleSizeChange, this);

package/view/elements/image/HTMLElementCacheKey.js

@@ -1,8 +1,8 @@
-import { isArrayEqual } from "../../../core/collection/ArrayUtils.js";
 import { KeyValuePair } from "../../../core/collection/KeyValuePair.js";
 import { computeStringHash } from "../../../core/primitives/strings/computeStringHash.js";
 import { computeHashArray } from "../../../core/collection/array/computeHashArray.js";
 import { computeHashIntegerArray } from "../../../core/collection/array/computeHashIntegerArray.js";
+import { isArrayEqual } from "../../../core/collection/array/isArrayEqual.js";
 
 /**
  *