@woosh/meep-engine 2.39.5 → 2.39.9

package/generation/markers/actions/MarkerNodeActionImaginary.js

@@ -0,0 +1,86 @@
+import { MarkerNodeAction } from "./MarkerNodeAction.js";
+import { MarkerNodeConsumerBuffer } from "../emitter/MarkerNodeConsumerBuffer.js";
+import Vector3 from "../../../core/geom/Vector3.js";
+import { assert } from "../../../core/assert.js";
+
+/**
+ * Spawns imaginary markers that are not added to the grid, and executes further actions on these
+ * Useful when desired additional markers are not present in the grid
+ */
+export class MarkerNodeActionImaginary extends MarkerNodeAction {
+    /**
+     * @type {MarkerNodeEmitter}
+     */
+    emitter;
+
+    /**
+     * @type {MarkerNodeAction}
+     */
+    action;
+
+    /**
+     * Pre-multiplies emitted marker transform by the transform of the consumed node
+     * @type {boolean}
+     * @private
+     */
+    propagate_scale = true;
+
+    _buffer = new MarkerNodeConsumerBuffer();
+
+    /**
+     *
+     * @param {MarkerNodeEmitter} emitter
+     * @param {MarkerNodeAction} action
+     * @param {boolean} [propagate_scale]
+     * @returns {MarkerNodeActionImaginary}
+     */
+    static from({
+                    emitter,
+                    action,
+                    propagate_scale = true
+                }) {
+
+        assert.defined(emitter, 'emitter');
+        assert.equal(emitter.isMarkerNodeEmitter, true, 'emitter.isMarkerNodeEmitter !== true');
+
+        assert.defined(action, 'emitter');
+        assert.equal(action.isMarkerNodeAction, true, 'action.isMarkerNodeAction !== true');
+
+        assert.isBoolean(propagate_scale, 'propagate_scale');
+
+        const r = new MarkerNodeActionImaginary();
+
+        r.emitter = emitter;
+        r.action = action;
+        r.propagate_scale = propagate_scale;
+
+        return r;
+    }
+
+    execute(grid, ecd, node) {
+        this._buffer.reset();
+
+        const rotation = node.transform.rotation.computeTwistAngle(Vector3.down);
+
+        this.emitter.execute(grid, node.position.x, node.position.y, rotation, this._buffer);
+
+        const n = this._buffer.size();
+
+        for (let i = 0; i < n; i++) {
+            const imaginary_node = this._buffer.get(i);
+
+            if (this.propagate_scale) {
+                imaginary_node.transform.scale.multiply(node.transform.scale);
+
+                imaginary_node.size *= node.size;
+            }
+
+            this.action.execute(grid, ecd, imaginary_node);
+        }
+    }
+
+    initialize(grid, ecd, seed) {
+        this.emitter.initialize(grid, seed);
+        this.action.initialize(grid, ecd, seed);
+    }
+}

package/generation/markers/actions/terrain/MarkerNodeActionPaintTerrain.js

@@ -0,0 +1,265 @@
+import { MarkerNodeAction } from "../MarkerNodeAction.js";
+import { CellFilterLiteralFloat } from "../../../filtering/numeric/CellFilterLiteralFloat.js";
+import LinearModifier from "../../../../core/model/stat/LinearModifier.js";
+import Terrain from "../../../../engine/ecs/terrain/ecs/Terrain.js";
+import { seededRandom } from "../../../../core/math/random/seededRandom.js";
+import { v2_distance } from "../../../../core/geom/Vector2.js";
+import TransitionFunctions from "../../../../engine/animation/TransitionFunctions.js";
+import { inverseLerp } from "../../../../core/math/inverseLerp.js";
+import { clamp01 } from "../../../../core/math/clamp01.js";
+import { clamp } from "../../../../core/math/clamp.js";
+import { assert } from "../../../../core/assert.js";
+import { TerrainLayer } from "../../../../engine/ecs/terrain/ecs/layers/TerrainLayer.js";
+import { max2 } from "../../../../core/math/max2.js";
+
+export class MarkerNodeActionPaintTerrain extends MarkerNodeAction {
+    /**
+     *
+     * @CellFilter
+     */
+    weight = CellFilterLiteralFloat.ONE;
+
+    /**
+     * What to paint
+     * @type {TerrainLayerDescription}
+     */
+    layer = null;
+
+    /**
+     * Actual layer index, will be taken from the terrain upon initialization
+     * @type {number}
+     * @private
+     */
+    _layer_index = -1;
+
+    /**
+     *
+     * @type {SplatMapping}
+     * @private
+     */
+    _splat_map = null;
+
+    /**
+     *
+     * @type {Terrain}
+     * @private
+     */
+    _terrain = null;
+
+    /**
+     * How far does the area extend from the marker's shape, has both % and constant component
+     * Can grow or shrink the area
+     * @type {LinearModifier}
+     */
+    dilation = LinearModifier.CONSTANT_ZERO;
+
+    /**
+     * Function to apply smoothing to the area that falls into "edge"
+     * @type {function(number): number}
+     */
+    weight_edge_easing_function = TransitionFunctions.EaseInOut;
+
+    /**
+     * How wide is the edge, computed from the effective region including padding, must produce a non-negative number
+     * @type {LinearModifier}
+     */
+    weight_edge_easing = LinearModifier.CONSTANT_ZERO;
+
+    /**
+     *
+     * @type {function():number}
+     * @private
+     */
+    _random;
+
+    /**
+     *
+     * @param {LinearModifier} dilation
+     * @param {function(number):number} border_blending
+     * @param {LinearModifier} border
+     * @param {CellFilter} weight
+     * @param {TerrainLayerDescription} layer
+     * @returns {MarkerNodeActionPaintTerrain}
+     */
+    static from({
+                    dilation = LinearModifier.CONSTANT_ZERO,
+                    border_blending = TransitionFunctions.EaseInOut,
+                    border = LinearModifier.CONSTANT_ZERO,
+                    weight = CellFilterLiteralFloat.ONE,
+                    layer
+                }) {
+
+        assert.defined(layer, 'layer');
+        assert.notNull(layer, 'layer');
+        assert.equal(layer.isTerrainLayerDescription, true, 'layer.isTerrainLayerDescription !== true');
+
+        const r = new MarkerNodeActionPaintTerrain();
+
+
+        r.dilation = dilation;
+        r.weight_edge_easing = border;
+        r.weight_edge_easing_function = border_blending;
+        r.weight = weight;
+        r.layer = layer;
+
+        return r;
+    }
+
+    /**
+     *
+     * @param {number} x
+     * @param {number} y
+     * @param {MarkerNode} node
+     * @param {GridData} grid
+     * @param {number} radius_outer
+     * @param {number} radius_inner
+     * @returns {number}
+     * @private
+     */
+    _getPointWeight(x, y, node, grid, radius_outer, radius_inner) {
+        // compute distance from node center
+        const distance_from_center = v2_distance(node.position.x, node.position.y, x, y);
+
+        if (distance_from_center > radius_outer) {
+            // too far away
+            return 0;
+        }
+
+        const weight_sampled = this.weight.execute(grid, x, y, 0);
+
+
+        // compute position in the padding region, where 0 is at the outer edge of the padding, and 1 is at the
+        const edge_normalized_position = clamp01(inverseLerp(radius_inner, radius_outer, distance_from_center));
+
+        // apply edge smoothing
+        const edge_weight_bias = this.weight_edge_easing_function(1 - edge_normalized_position);
+
+        return weight_sampled * edge_weight_bias;
+    }
+
+    _getLayerIndex() {
+        if (this._layer_index === -1) {
+            // bind terrain layer
+            const layers = this._terrain.layers;
+            const layer_descriptor = this.layer;
+
+            this._layer_index = layers.findIndexByDiffuseTextureURL(layer_descriptor.diffuse);
+
+
+            if (this._layer_index !== -1) {
+                // check to see if size matches
+                const actual_layer = layers.get(this._layer_index);
+                if (!actual_layer.size.equals(layer_descriptor.size)) {
+                    console.warn(`Actual terrain layer with texture '${layer_descriptor.diffuse}' has size ${actual_layer.size}, instead of desired ${layer_descriptor.size}. Ignoring this difference, layer will still be used`);
+                }
+            } else {
+
+                // layer not found, let's create it
+                this._layer_index = this._terrain.addLayer(TerrainLayer.fromDescription(layer_descriptor));
+            }
+
+        }
+
+        return this._layer_index;
+    }
+
+    execute(grid, ecd, node) {
+        const _splat_layer_index = this._getLayerIndex();
+
+        const splat = this._splat_map;
+
+        const splat_resolution_x = splat.size.x;
+        const splat_resolution_y = splat.size.y;
+
+        // compute scale between grid and splat
+        const splat_scale_x = splat_resolution_x / grid.width;
+        const splat_scale_y = splat_resolution_y / grid.height;
+
+        const splat_to_grid_x = 1 / splat_scale_x;
+        const splat_to_grid_y = 1 / splat_scale_y;
+
+        const radius_outer = node.size * (1 + this.dilation.a) + this.dilation.b;
+
+        const edge_width = node.size * this.weight_edge_easing.a + this.weight_edge_easing.b;
+        const radius_inner = radius_outer - edge_width;
+
+        // we shift to the center of the grid cell
+        const node_p_x = node.position.x + splat_to_grid_x;
+        const node_p_y = node.position.y + splat_to_grid_y;
+
+        // compute affected region in Splat space
+        const x0 = Math.floor((node_p_x - radius_outer) * splat_scale_x + 0.5);
+        const x1 = Math.floor((node_p_x + radius_outer) * splat_scale_x + 0.5);
+        const y0 = Math.ceil((node_p_y - radius_outer) * splat_scale_y + 0.5);
+        const y1 = Math.ceil((node_p_y + radius_outer) * splat_scale_y + 0.5);
+
+        const layer_count = splat.depth;
+
+        const splat_data = splat.weightData;
+
+        // execute blending
+        for (let y = y0; y <= y1; y++) {
+            for (let x = x0; x <= x1; x++) {
+
+                // convert position into grid coordinates
+                const grid_x = (x - 0.5) * splat_to_grid_x - splat_to_grid_x;
+                const grid_y = (y - 0.5) * splat_to_grid_y - splat_to_grid_y;
+
+                const weight = this._getPointWeight(grid_x, grid_y, node, grid, radius_outer, radius_inner);
+
+                if (weight === 0) {
+                    continue;
+                }
+
+                const weight_scaled = weight * 255;
+
+                // paint
+                const weight_reciprocal_multiplier = max2(0, 1 - weight);
+
+                for (let layer_index = 0; layer_index < layer_count; layer_index++) {
+
+                    const layer_address = splat_resolution_x * splat_resolution_y * layer_index;
+                    const texel_address = layer_address + y * splat_resolution_x + x;
+
+                    const source_value = splat_data[texel_address];
+
+                    let destination_value;
+
+                    if (_splat_layer_index === layer_index) {
+                        // the channel that we are stamping
+                        destination_value = source_value + weight_scaled;
+                    } else {
+                        // other layers get erased by proportional amount
+                        destination_value = source_value * weight_reciprocal_multiplier;
+                    }
+
+                    splat_data[texel_address] = clamp(destination_value, 0, 255);
+
+                }
+            }
+        }
+
+        // mark splat map for update
+        splat.weightTexture.needsUpdate = true;
+    }
+
+    initialize(grid, ecd, seed) {
+        // find layer index
+        const terrain = ecd.getAnyComponent(Terrain);
+
+        if (terrain.component === null) {
+            throw new Error('No terrain present');
+        }
+
+        this._terrain = terrain.component;
+
+        // bind splats
+        this._splat_map = terrain.component.splat;
+
+        this._layer_index = -1;
+
+        this._random = seededRandom(seed);
+
+        this.weight.ensureInitialized(grid, seed);
+    }
+}

package/generation/theme/TerrainLayerDescription.js

@@ -34,6 +34,17 @@ export class TerrainLayerDescription {
             && this.size.equals(other.size);
     }
 
+    toJSON() {
+        return {
+            diffuse: this.diffuse,
+            size: this.size.toJSON()
+        };
+    }
+
+    toString() {
+        return JSON.stringify(this.toJSON());
+    }
+
     static from({
                     diffuse,
                     size

package/generation/theme/ThemeEngine.js

@@ -244,11 +244,7 @@ export class ThemeEngine {
             });
 
             layer_descriptors.forEach(l => {
-                terrain.layers.addLayer(TerrainLayer.from(
-                    l.diffuse,
-                    l.size.x,
-                    l.size.y
-                ));
+                terrain.layers.addLayer(TerrainLayer.fromDescription(l));
             });
 
             terrain.clearFlag(TerrainFlags.Built);
@@ -587,10 +583,13 @@ export class ThemeEngine {
         const tCells = this.applyCellRules(grid, ecd);
 
         tTerrain.addDependency(tInitializeThemes);
+
         tNodes.addDependencies([
             tInitializeThemes,
-            tTerrainGeometry
+            tTerrainGeometry,
+            tTerrain
         ]);
+
         tCells.addDependency(tInitializeThemes);
         tTerrainGeometry.addDependency(tCells);
 

package/package.json

@@ -5,7 +5,7 @@
   "productName": "Meep",
   "description": "production-ready JavaScript game engine based on Entity Component System Architecture",
   "author": "Alexander Goldring",
-  "version": "2.39.5",
+  "version": "2.39.9",
   "dependencies": {
     "gl-matrix": "3.4.3",
     "fast-levenshtein": "2.0.6",

package/samples/terrain/from_image.js

@@ -33,6 +33,7 @@ import {
 } from "../../engine/graphics/render/buffer/simple-fx/ao/AmbientOcclusionPostProcessEffect.js";
 import { CellFilterAngleToNormal } from "../../generation/filtering/numeric/complex/CellFilterAngleToNormal.js";
 import { CellFilterCache } from "../../generation/filtering/numeric/CellFilterCache.js";
+import { TaskLoadingScreen } from "../../view/task/TaskLoadingScreen.js";
 
 const HEIGHT_RANGE = 100;
 
@@ -267,7 +268,7 @@ async function main(engine) {
 
     const task = theme_engine.apply(grid, ecd);
 
-    const promise_load = engine.loadSlowTask(task);
+    const promise_load = TaskLoadingScreen.load(engine, task);
 
     engine.executor.runGroup(task);
 

package/view/common/ListView.js

@@ -8,6 +8,7 @@ import View from "../View.js";
 import { assert } from "../../core/assert.js";
 import { noop, returnTrue } from "../../core/function/Functions.js";
 import { Cache } from "../../core/cache/Cache.js";
+import List from "../../core/collection/list/List.js";
 
 /**
  * @template T
@@ -52,7 +53,7 @@ export class ListView extends View {
     /**
      * List representation
      * @template E
-     * @param {List<E>} model List to be represented
+     * @param {List<E>|E[]} model List to be represented
      * @param {string[]} [classList] collection of CSS classes
      * @param {function(E):View} elementFactory factory function, takes a list element and returns a view
      * @param {function(E, View, number, ListView<E>)} [addHook] hook function to be called when a view is created
@@ -90,6 +91,11 @@ export class ListView extends View {
 
         assert.typeOf(elementFactory, 'function', 'elementFactory');
 
+        if (Array.isArray(model)) {
+            // wrap array as a list
+            model = new List(model);
+        }
+
         /**
          *
          * @type {List<E>}

package/view/elements/windrose/WindRoseDiagram.js

@@ -0,0 +1,13 @@
+import View from "../../View.js";
+
+export class WindRoseDiagram extends View {
+    constructor() {
+        super();
+
+        this.el = document.createElement('div');
+
+        this.addClass('ui-wind-rose-diagram-view');
+
+
+    }
+}

package/view/task/TaskLoadingScreen.js

@@ -0,0 +1,172 @@
+import TaskProgressView from "./TaskProgressView.js";
+import { AssetLoaderStatusView } from "../asset/AssetLoaderStatusView.js";
+import { logger } from "../../engine/logging/GlobalLogger.js";
+import { array_remove_first } from "../../core/collection/array/array_remove_first.js";
+import { assert } from "../../core/assert.js";
+
+/**
+ * @type {TaskLoadingScreen}
+ */
+let _instance;
+
+export class TaskLoadingScreen {
+    _active_promise = Promise.resolve();
+    /**
+     *
+     * @type {number}
+     * @private
+     */
+    _release_delay_seconds = 0.5;
+
+    /**
+     *
+     * @type {number}
+     * @private
+     */
+    _release_delay_handle = -1;
+
+    _pending_cleanup = [];
+    _state_stack = [];
+
+    _clearReleaseTimeout() {
+        if (this._release_delay_handle !== -1) {
+            clearTimeout(this._release_delay_handle);
+            this._release_delay_handle = -1;
+        }
+    }
+
+    /**
+     *
+     * @param {Engine} engine
+     * @param {Task|TaskGroup} task
+     * @returns {Promise<void>}
+     */
+    async load(engine, task) {
+
+        assert.defined(task, 'task');
+        assert.notNull(task, 'task');
+
+        assert.defined(engine, 'engine');
+        assert.notNull(engine, 'engine');
+
+
+        await Promise.allSettled([this._active_promise]);
+
+        this._clearReleaseTimeout();
+
+        const localization = engine.localization;
+
+        const taskProgressView = new TaskProgressView({ task, localization });
+        taskProgressView.el.classList.add('loading-screen');
+
+        //add asset manager loading progress
+        const loaderStatusView = new AssetLoaderStatusView({ assetManager: engine.assetManager, localization });
+        taskProgressView.addChild(loaderStatusView);
+        taskProgressView.link();
+
+        const graphics = engine.graphics;
+
+        const engine_state = {
+            engine_rendering_enabled: engine.renderingEnabled,
+            graphics_auto_draw: graphics.autoDraw
+        };
+
+        this._state_stack.push(engine_state);
+
+        const domParent = document.body;
+
+        domParent.appendChild(taskProgressView.el);
+
+        // suspend rendering
+        engine.renderingEnabled = false;
+        graphics.autoDraw = false;
+
+        const attempt_cleanup = () => {
+            if (this._active_promise !== promise) {
+                return;
+            }
+
+            // clear any pending timeouts if they exist
+            this._clearReleaseTimeout();
+
+            // run all remaining pending cleanup tasks
+            for (let i = 0; i < this._pending_cleanup.length; i++) {
+                const t = this._pending_cleanup[i];
+
+                if (t === cleanup) {
+                    // skip self
+                    continue;
+                }
+
+                try {
+                    t();
+                } catch (e) {
+                    logger.error(e);
+                }
+
+                // just to make sure, try to remove it again
+                array_remove_first(this._pending_cleanup, t);
+
+                // update iterator
+                i--;
+            }
+
+            // this is the last task in the queue
+            this._release_delay_handle = setTimeout(() => {
+                cleanup();
+            }, Math.ceil(this._release_delay_seconds * 1000));
+        }
+
+        const cleanup = () => {
+            array_remove_first(this._pending_cleanup, cleanup);
+
+            domParent.removeChild(taskProgressView.el);
+
+            taskProgressView.unlink();
+
+            // restore state
+            const state = this._state_stack.pop();
+
+            engine.renderingEnabled = state.engine_rendering_enabled;
+            engine.graphics.autoDraw = state.graphics_auto_draw;
+        };
+
+        this._pending_cleanup.push(cleanup);
+
+        const promise = new Promise((resolve, reject) => {
+
+            const p = task.promise();
+
+            p.finally(attempt_cleanup);
+            p.then(resolve, reject);
+
+        });
+
+        this._active_promise = promise;
+
+        return promise;
+    }
+
+    /**
+     *
+     * @param {Engine} engine
+     * @param {Task|TaskGroup} task
+     * @returns {Promise<void>}
+     */
+    static load(engine, task) {
+        return TaskLoadingScreen.instance.load(engine, task);
+    }
+
+    /**
+     *
+     * @returns {TaskLoadingScreen}
+     */
+    static get instance() {
+        if (_instance === undefined) {
+            _instance = new TaskLoadingScreen();
+        }
+
+        return _instance;
+    }
+}
+

package/view/{common → task}/TaskProgressView.js

@@ -5,47 +5,15 @@
 
 import View from '../View.js';
 import SmoothProgressBar from '../elements/progress/SmoothProgressBar.js';
-import LabelView from './LabelView.js';
+import LabelView from '../common/LabelView.js';
 
 import TaskState from '../../core/process/task/TaskState.js';
 
 import dom from '../DOM.js';
 import Clock from "../../engine/Clock.js";
 import Vector1 from "../../core/geom/Vector1.js";
-import { LocalizedLabelView } from "./LocalizedLabelView.js";
-
-function ReimaingTimeEstimator(sampleCount) {
-    this.sampleCount = sampleCount;
-    this.rates = new Float32Array(sampleCount);
-    this.cursor = 0;
-}
-
-ReimaingTimeEstimator.prototype.update = function (timeElapsed, progress) {
-    const index = this.cursor;
-    this.cursor = (this.cursor + 1) % this.sampleCount;
-
-    const rate = progress / timeElapsed;
-
-    this.rates[index] = rate;
-};
-
-ReimaingTimeEstimator.prototype.estimate = function (currentProgress) {
-    let rateSum = 0;
-
-    for (let i = 0; i < this.sampleCount; i++) {
-        rateSum += this.rates[i];
-    }
-
-    const rate = rateSum / this.sampleCount;
-
-    if (rate === 0) {
-        return Infinity;
-    }
-
-    const result = (1 - currentProgress) / rate;
-
-    return result;
-};
+import { LocalizedLabelView } from "../common/LocalizedLabelView.js";
+import { RemainingTimeEstimator } from "../../core/process/task/RemainingTimeEstimator.js";
 
 class TaskProgressView extends View {
     /**
@@ -131,7 +99,7 @@ class TaskProgressView extends View {
         state.on.linked.add(updateState);
         state.bindSignal(task.state.onChanged, updateState);
 
-        const remainingTimeEstimator = new ReimaingTimeEstimator(100);
+        const remainingTimeEstimator = new RemainingTimeEstimator(100);
         const remainingTime = new Vector1(0);
 
         const lRemainingTime = new LabelView(remainingTime, {