@woosh/meep-engine 2.37.18 → 2.38.0

package/generation/markers/prototypeGridCellActionPlaceMarker.js

@@ -0,0 +1,209 @@
+import { EngineHarness } from "../../engine/EngineHarness.js";
+import { GridCellActionPlaceMarker } from "./GridCellActionPlaceMarker.js";
+import { GridData } from "../grid/GridData.js";
+import EntityBuilder from "../../engine/ecs/EntityBuilder.js";
+import Mesh from "../../engine/graphics/ecs/mesh/Mesh.js";
+import { MeshSystem } from "../../engine/graphics/ecs/mesh/MeshSystem.js";
+import { GameAssetType } from "../../engine/asset/GameAssetType.js";
+import { GLTFAssetLoader } from "../../engine/asset/loaders/GLTFAssetLoader.js";
+import {
+    AmbientOcclusionPostProcessEffect
+} from "../../engine/graphics/render/buffer/simple-fx/ao/AmbientOcclusionPostProcessEffect.js";
+import { MarkerNodeEmitterFromAction } from "./emitter/MarkerNodeEmitterFromAction.js";
+import { Transform } from "../../engine/ecs/transform/Transform.js";
+import { MarkerNodeTransformerOffsetPosition } from "./transform/MarkerNodeTransformerOffsetPosition.js";
+import { MarkerNodeConsumerBuffer } from "./emitter/MarkerNodeConsumerBuffer.js";
+import { normalize_angle_rad } from "../../core/geom/normalize_angle_rad.js";
+
+const harness = new EngineHarness();
+
+const corner = MarkerNodeEmitterFromAction.from([
+    GridCellActionPlaceMarker.from({
+        type: 'Construction-Corner-L',
+        size: 0.2,
+        tags: ['wall-segment-damaged'],
+        transform: Transform.fromJSON({
+            scale: 0.1
+        })
+    }),
+    GridCellActionPlaceMarker.from({
+        type: 'Virtual',
+        size: 0.1,
+        transform: Transform.fromJSON({
+            scale: 0.1
+        }),
+        transformers: [
+            MarkerNodeTransformerOffsetPosition.from(-0.2, 0)
+        ]
+    }),
+    GridCellActionPlaceMarker.from({
+        type: 'Virtual',
+        size: 0.1,
+        transform: Transform.fromJSON({
+            scale: 0.1
+        }),
+        transformers: [
+            MarkerNodeTransformerOffsetPosition.from(-0.4, 0)
+        ]
+    }),
+    GridCellActionPlaceMarker.from({
+        type: 'Virtual',
+        size: 0.1,
+        transform: Transform.fromJSON({
+            scale: 0.1
+        }),
+        transformers: [
+            MarkerNodeTransformerOffsetPosition.from(-0.6, 0)
+        ]
+    }),
+    GridCellActionPlaceMarker.from({
+        type: 'Virtual',
+        size: 0.13,
+        transform: Transform.fromJSON({
+            scale: 0.1
+        }),
+        tags: ['wall-segment-end'],
+        transformers: [
+            MarkerNodeTransformerOffsetPosition.from(-0.83, 0)
+        ]
+    }),
+
+    //wall 2
+    GridCellActionPlaceMarker.from({
+        type: 'Virtual',
+        size: 0.1,
+        transform: Transform.fromJSON({
+            scale: 0.1
+        }),
+        transformers: [
+            MarkerNodeTransformerOffsetPosition.from(0, -0.2)
+        ]
+    }),
+    GridCellActionPlaceMarker.from({
+        type: 'Virtual',
+        size: 0.1,
+        transform: Transform.fromJSON({
+            scale: 0.1
+        }),
+        transformers: [
+            MarkerNodeTransformerOffsetPosition.from(0, -0.4)
+        ]
+    }),
+    GridCellActionPlaceMarker.from({
+        type: 'Virtual',
+        size: 0.1,
+        transform: Transform.fromJSON({
+            scale: 0.1
+        }),
+        transformers: [
+            MarkerNodeTransformerOffsetPosition.from(0, -0.6)
+        ]
+    }),
+    GridCellActionPlaceMarker.from({
+        type: 'Virtual',
+        size: 0.13,
+        tags: ['wall-segment-end'],
+        transform: Transform.fromJSON({
+            scale: 0.1
+        }),
+        transformers: [
+            MarkerNodeTransformerOffsetPosition.from(0, -0.83)
+        ]
+    })
+]);
+
+/**
+ *
+ * @param {Engine} engine
+ */
+async function main(engine) {
+    EngineHarness.buildBasics({
+        engine
+    });
+
+    const action = GridCellActionPlaceMarker.from({
+        type: 'X',
+        size: 1
+    });
+
+    const grid = new GridData();
+
+    grid.resize(50, 50);
+
+    corner.initialize(grid, 0);
+
+    const GRID_CENTER_X = 12;
+    const GRID_CENTER_Y = 12;
+
+    const GRID_SIZE = 0;
+    const ANGLE_STEP = Math.PI * 2 / (GRID_SIZE * GRID_SIZE);
+    const GRID_SPACING = 4;
+
+    const buffer = new MarkerNodeConsumerBuffer();
+
+    for (let i = 0; i < GRID_SIZE * GRID_SIZE; i++) {
+        const angle = i * ANGLE_STEP;
+
+        const x = i % GRID_SIZE;
+
+        const y = Math.floor(i / GRID_SIZE);
+
+        const _x = GRID_CENTER_X - (GRID_SPACING * GRID_SIZE) * 0.5 + x * GRID_SPACING;
+        const _y = GRID_CENTER_Y - (GRID_SPACING * GRID_SIZE) * 0.5 + y * GRID_SPACING;
+
+        corner.execute(grid, _x, _y, angle, buffer);
+
+        // const node = action.buildNode(grid, _x, _y, angle);
+
+    }
+
+
+    corner.execute(grid, 12, 12, (Math.PI / 2) * 0, buffer);
+    corner.execute(grid, 14, 12, (Math.PI / 2) * 1, buffer);
+    corner.execute(grid, 16, 12, (Math.PI / 2) * 2, buffer);
+    corner.execute(grid, 18, 12, normalize_angle_rad((Math.PI / 2) * 3), buffer);
+
+
+    function build_node(node, url) {
+
+        new EntityBuilder()
+            .add(node.transform)
+            .add(Mesh.fromJSON({
+
+                url: url
+            }))
+            .build(engine.entityManager.dataset);
+    }
+
+    console.warn(buffer);
+
+    for (let i = 0; i < buffer.size(); i++) {
+        const node = buffer.get(i);
+
+        node.transform.position.set(
+            node.position.x * grid.transform.scale_x + grid.transform.offset_x,
+            node.transform.position.y,
+            node.position.y * grid.transform.scale_y + grid.transform.offset_y
+        );
+
+
+// url: "data/models/arrow-symbols/arrow4/model.gltf"
+
+        build_node(node, 'data/models/arrow-symbols/arrow4/model.gltf');
+
+    }
+}
+
+harness
+    .initialize({
+        configuration(config, engine) {
+            config.addSystem(new MeshSystem(engine));
+            config.addPlugin(AmbientOcclusionPostProcessEffect);
+
+            const gltfAssetLoader = new GLTFAssetLoader();
+
+            config.addLoader(GameAssetType.ModelGLTF, gltfAssetLoader);
+            config.addLoader(GameAssetType.ModelGLTF_JSON, gltfAssetLoader);
+        }
+    })
+    .then(main);

package/generation/markers/transform/MarkerNodeTransformerOffsetPosition.js

@@ -2,8 +2,6 @@ import { MarkerNodeTransformer } from "./MarkerNodeTransformer.js";
 import Vector2 from "../../../core/geom/Vector2.js";
 import Vector3 from "../../../core/geom/Vector3.js";
 
-const v3 = new Vector3();
-
 export class MarkerNodeTransformerOffsetPosition extends MarkerNodeTransformer {
     constructor() {
         super();
@@ -28,10 +26,8 @@ export class MarkerNodeTransformerOffsetPosition extends MarkerNodeTransformer {
     transform(node, grid) {
         const r = node.clone();
 
-        r.transform.rotation.toEulerAnglesYXZ(v3);
-
         //rotate offset
-        const rotation = -v3.z;
+        const rotation = r.transform.rotation.computeTwistAngle(Vector3.down);
 
         const sin = Math.sin(rotation);
         const cos = Math.cos(rotation);

package/generation/markers/transform/MarkerNodeTransformerYRotateByFilterGradient.spec.js

@@ -1,7 +1,7 @@
 import { MarkerNodeTransformerYRotateByFilterGradient } from "./MarkerNodeTransformerYRotateByFilterGradient.js";
 import { GridData } from "../../grid/GridData.js";
 import { GridDataLayer } from "../../grid/layers/GridDataLayer.js";
-import { CellFilterReadGridLayer } from "../../filtering/numeric/CellFilterReadGridLayer.js";
+import { CellFilterSampleLayerLinear } from "../../filtering/numeric/sampling/CellFilterSampleLayerLinear.js";
 import { MarkerNode } from "../MarkerNode.js";
 import Vector3 from "../../../core/geom/Vector3.js";
 import { RAD_TO_DEG } from "../../../core/math/RAD_TO_DEG.js";
@@ -40,7 +40,7 @@ function prepareSample(data) {
     const grid = makeGrid(data);
 
     const transformer = MarkerNodeTransformerYRotateByFilterGradient.from(
-        CellFilterReadGridLayer.from('x')
+        CellFilterSampleLayerLinear.from('x')
     );
 
     transformer.initialize(grid, 0);

package/generation/placement/GridCellPlacementRule.js

@@ -1,6 +1,7 @@
 import { assert } from "../../core/assert.js";
 import Vector2 from "../../core/geom/Vector2.js";
 import { CellFilterLiteralFloat } from "../filtering/numeric/CellFilterLiteralFloat.js";
+import { GridCellActionSequence } from "./action/util/GridCellActionSequence.js";
 
 export class GridCellPlacementRule {
     constructor() {
@@ -25,9 +26,9 @@ export class GridCellPlacementRule {
 
         /**
          *
-         * @type {GridCellAction[]}
+         * @type {GridCellAction}
          */
-        this.actions = [];
+        this.action = null;
 
         /**
          *
@@ -39,28 +40,44 @@ export class GridCellPlacementRule {
     /**
      *
      * @param {CellMatcher} matcher
-     * @param {GridCellAction[]} actions
+     * @param {GridCellAction[]} [actions]
+     * @param {GridCellAction} action
      * @param {number|CellFilter} [probability]
      * @param {Vector2} [offset]
+     * @param {boolean} [allowRotation]
      * @returns {GridCellPlacementRule}
      */
-    static from({ matcher, actions, probability = CellFilterLiteralFloat.from(1), offset = Vector2.zero }) {
+    static from({
+                    matcher,
+                    actions,
+                    action = GridCellActionSequence.from(actions),
+                    probability = CellFilterLiteralFloat.from(1),
+                    offset = Vector2.zero,
+                    allowRotation = true
+                }) {
 
         assert.defined(matcher);
-        assert.defined(actions);
-
-        assert.isArray(actions);
+        assert.defined(action);
 
         const r = new GridCellPlacementRule();
 
         r.pattern = matcher;
-        r.actions = actions;
+
+        r.action = action;
+
+        if (actions !== undefined) {
+            console.warn(`"actions" parameter is deprecated. Use a sequence instead`);
+            assert.isArray(actions, 'actions');
+        }
 
         assert.equal(probability.isCellFilter, true, 'probability.isCellFilter !== true');
+
         r.probability = probability;
 
         r.positionOffset.copy(offset);
 
+        r.allowRotation = allowRotation;
+
         return r;
     }
 
@@ -70,14 +87,8 @@ export class GridCellPlacementRule {
      * @param {number} seed
      */
     initialize(grid, seed) {
-        const actions = this.actions;
-        const n = actions.length;
 
-        for (let i = 0; i < n; i++) {
-            const action = actions[i];
-
-            action.initialize(grid, seed);
-        }
+        this.action.initialize(grid, seed);
 
         this.pattern.initialize(grid, seed);
 
@@ -94,23 +105,18 @@ export class GridCellPlacementRule {
      * @param {number} rotation in Radians
      */
     execute(grid, x, y, rotation) {
-        const actions = this.actions;
-        const n = actions.length;
-
         const sin = Math.sin(rotation);
         const cos = Math.cos(rotation);
 
-        const local_x = this.positionOffset.x;
-        const local_y = this.positionOffset.y;
+        const offset = this.positionOffset;
+
+        const local_x = offset.x;
+        const local_y = offset.y;
 
         const rotated_local_x = local_x * cos - local_y * sin
         const rotated_local_y = local_x * sin + local_y * cos;
 
-        for (let i = 0; i < n; i++) {
-            const action = actions[i];
-
-            action.execute(grid, x + rotated_local_x, y + rotated_local_y, rotation);
-        }
+        this.action.execute(grid, x + rotated_local_x, y + rotated_local_y, rotation);
 
     }
 }

package/generation/theme/ThemeEngine.js

@@ -573,7 +573,7 @@ export class ThemeEngine {
         const tTerrainGeometry = futureTask(new Future((resolve, reject) => {
 
             terrain.updateWorkerHeights();
-            terrain.tiles.rebuild();
+            terrain.__tiles.rebuild();
 
             terrain.promiseAllTiles().then(resolve, reject);
         }), 'Wait for terrain tiles');

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.37.18",
+  "version": "2.38.0",
   "dependencies": {
     "gl-matrix": "3.4.3",
     "fast-levenshtein": "2.0.6",

package/samples/terrain/from_image.js

@@ -19,14 +19,18 @@ import { TerrainLayerDescription } from "../../generation/theme/TerrainLayerDesc
 import Vector2 from "../../core/geom/Vector2.js";
 import { CellFilterLiteralFloat } from "../../generation/filtering/numeric/CellFilterLiteralFloat.js";
 import { GridDataLayer } from "../../generation/grid/layers/GridDataLayer.js";
-import { CellFilterReadGridLayer } from "../../generation/filtering/numeric/CellFilterReadGridLayer.js";
+import {
+    CellFilterSampleLayerLinear
+} from "../../generation/filtering/numeric/sampling/CellFilterSampleLayerLinear.js";
 import { CellFilterSmoothStep } from "../../generation/filtering/numeric/math/CellFilterSmoothStep.js";
 import { CellFilterOneMinus } from "../../generation/filtering/numeric/math/CellFilterOneMinus.js";
 import { CellFilterMultiply } from "../../generation/filtering/numeric/math/algebra/CellFilterMultiply.js";
 import { CellFilterCurvature } from "../../generation/filtering/numeric/complex/CellFilterCurvature.js";
 import { CellFilterMax2 } from "../../generation/filtering/numeric/math/CellFilterMax2.js";
 import { CellFilterMin2 } from "../../generation/filtering/numeric/math/CellFilterMin2.js";
-import { AmbientOcclusionPostProcessEffect } from "../../engine/graphics/render/buffer/simple-fx/ao/AmbientOcclusionPostProcessEffect.js";
+import {
+    AmbientOcclusionPostProcessEffect
+} 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";
 
@@ -61,7 +65,7 @@ function makeTheme() {
 
     const terrainTheme = new TerrainTheme();
 
-    const height = CellFilterReadGridLayer.from('height');
+    const height = CellFilterSampleLayerLinear.from('height');
     const curvature = CellFilterCurvature.from(height);
 
     const slope = CellFilterAngleToNormal.from(height, Vector3.forward);

package/samples/terrain/main.js

@@ -64,7 +64,7 @@ async function buildRandomTerrainHeights({
     terrain.updateHeightTexture();
     terrain.buildLightMap();
 
-    terrain.tiles.rebuild();
+    terrain.__tiles.rebuild();
 }
 
 /**

package/view/View.js

@@ -26,7 +26,7 @@ function setElementTransform(domElement, position, scale, rotation) {
 
     const m3 = scratch_m3_0;
 
-    compose3x3transform(m3, position.x, position.y, scale.x, scale.y, rotation);
+    compose3x3transform(m3, position.x, position.y, scale.x, scale.y,0,0, rotation);
 
 
     /*
@@ -346,6 +346,16 @@ class View {
         this.on.unlinked.send0();
     }
 
+    /**
+     *
+     * @param {View[]} children
+     */
+    addChildren(children) {
+        for (let i = 0; i < children.length; i++) {
+            this.addChild(children[i]);
+        }
+    }
+
     /**
      *
      * @param {View} child
@@ -725,6 +735,18 @@ class View {
         }
     }
 
+    /**
+     *
+     * @param {Object} hash
+     */
+    attr(hash) {
+        for (let propertyName in hash) {
+            if (hash.hasOwnProperty(propertyName)) {
+                this.el.setAttribute(propertyName, hash[propertyName]);
+            }
+        }
+    }
+
     /**
      *
      * @param {Vector2} size

package/view/common/LabelView.js

@@ -16,7 +16,7 @@ import { frameThrottle } from "../../engine/graphics/FrameThrottle.js";
 import { assert } from "../../core/assert.js";
 import ObservedInteger from "../../core/model/ObservedInteger.js";
 import { noop } from "../../core/function/Functions.js";
-import { isTypedArray } from "../../core/json/JsonUtils.js";
+import { isTypedArray } from "../../core/collection/array/typed/isTypedArray.js";
 
 
 /**

package/view/compose3x3transform.js

@@ -5,16 +5,11 @@
  * @param {number} tY translation Y offset
  * @param {number} sX scale in X axis
  * @param {number} sY scale in Y axis
+ * @param {number} cx center of rotation X
+ * @param {number} cy center of rotation Y
  * @param {number} angle rotation angle
  */
-export function compose3x3transform(result, tX, tY, sX, sY, angle) {
-    /**
-     * Center of rotation
-     * @type {number}
-     */
-    const cx = 0;
-    const cy = 0;
-
+export function compose3x3transform(result, tX, tY, sX, sY, cx, cy, angle) {
     const neg_angle = -angle;
 
     const sin = Math.sin(neg_angle);
@@ -32,3 +27,32 @@ export function compose3x3transform(result, tX, tY, sX, sY, angle) {
     result[7] = 0;
     result[8] = 1;
 }
+
+/**
+ *
+ * @param {number[]|Float32Array} result
+ * @param {number} tX
+ * @param {number} tY
+ */
+export function m3_from_translation(result, tX, tY) {
+    result[0] = 1;
+    result[1] = 0;
+    result[2] = tX;
+
+    result[3] = 0;
+    result[4] = 1;
+    result[5] = tY;
+
+    result[6] = 0;
+    result[7] = 0;
+    result[8] = 1;
+}
+
+/**
+ * @see https://stackoverflow.com/questions/45159314/decompose-2d-transformation-matrix
+ * @param {mat3|number[]|Float32Array} m3
+ * @returns {number}
+ */
+export function m3_extract_rotation(m3) {
+    return Math.atan2(m3[3], m3[0]);
+}

package/view/controller/dat/DatGuiUtils.js

@@ -10,10 +10,10 @@ import Signal from "../../../core/events/signal/Signal.js";
 import ObservedBoolean from "../../../core/model/ObservedBoolean.js";
 import ObservedEnum from "../../../core/model/ObservedEnum.js";
 import ObservedString from "../../../core/model/ObservedString.js";
-import { isTypedArray } from "../../../core/json/JsonUtils.js";
 import { Color } from "../../../core/color/Color.js";
 import View from "../../View.js";
 import ObservedInteger from "../../../core/model/ObservedInteger.js";
+import { isTypedArray } from "../../../core/collection/array/typed/isTypedArray.js";
 
 /**
  *

package/view/elements/DropDownSelectionView.js

@@ -33,7 +33,7 @@ class DropDownSelectionView extends View {
         this.bindSignal(this.model.on.added, this.handleAdded, this);
         this.bindSignal(this.model.on.removed, this.handleRemoved, this);
 
-        if(changeListener !== undefined) {
+        if (changeListener !== undefined) {
 
             elRoot.addEventListener('change', (event) => {
                 const id = event.target.value;
@@ -139,10 +139,18 @@ class DropDownSelectionView extends View {
         return this.getValueById(id);
     }
 
-    link() {
-        super.link();
+    /**
+     *
+     * @param {T} v
+     */
+    setSelectedValue(v) {
+        this.el.selectedIndex = this.model.indexOf(v);
+    }
 
+    link() {
         this.model.forEach(this.handleAdded, this);
+
+        super.link();
     }
 
     unlink() {

package/view/elements/image/ImageView.js

@@ -62,7 +62,9 @@ class ImageView extends View {
          */
         let src;
 
-        if (typeof url === "string") {
+        if (url === null || url === undefined) {
+            src = '';
+        } else if (typeof url === "string") {
             src = url;
         } else if (typeof url === "object" && typeof url.getValue === "function") {
             src = url.getValue();

package/core/model/ObservedReal.js

@@ -1,55 +0,0 @@
-import { assert } from "../assert.js";
-import Signal from "../events/signal/Signal.js";
-
-/**
- *
- * @param {Number} value
- * @constructor
- */
-function ObservedReal(value) {
-    assert.equal(typeof value, "number", `Value must be of type "number", instead was "${typeof value}"`);
-
-    /**
-     *
-     * @type {Number}
-     * @private
-     */
-    this.__value = value;
-
-    this.onChanged = new Signal();
-}
-
-/**
- *
- * @param {Number} value
- * @returns {ObservedReal}
- */
-ObservedReal.prototype.set = function (value) {
-    assert.equal(typeof value, "number", `Value must be of type "number", instead was "${typeof value}"`);
-
-    const oldValue = this.__value;
-    if (oldValue !== value) {
-        this.__value = value;
-        this.onChanged.dispatch(value, oldValue);
-    }
-
-    return this;
-};
-
-/**
- *
- * @returns {Number}
- */
-ObservedReal.prototype.getValue = function () {
-    return this.__value;
-};
-
-ObservedReal.prototype.toJSON = function () {
-    return this.__value;
-};
-
-ObservedReal.prototype.fromJSON = function (obj) {
-    this.set(obj);
-};
-
-export default ObservedReal;

package/engine/graphics/particles/particular/engine/renderers/SoftBillboardParticleRenderer.js

@@ -1,7 +0,0 @@
-import { ParticleRenderer } from "./ParticleRenderer.js";
-
-export class SoftBillboardParticleRenderer extends ParticleRenderer {
-    render(pools) {
-
-    }
-}

package/engine/sound/ecs/emitter/attenuate/attenuateSoundLinear.js

@@ -1,11 +0,0 @@
-import { inverseLerp } from "../../../../../core/math/inverseLerp.js";
-
-export function attenuateSoundLinear(distance, min, max) {
-    if (distance <= min) {
-        return 1;
-    } else if (distance >= max) {
-        return 0;
-    } else {
-        return inverseLerp(max, min, distance);
-    }
-}