@woosh/meep-engine 2.53.0 → 2.54.0

package/package.json

@@ -5,7 +5,7 @@
   "description": "Fully featured ECS game engine written in JavaScript",
   "type": "module",
   "author": "Alexander Goldring",
-  "version": "2.53.0",
+  "version": "2.54.0",
   "main": "build/meep.module.js",
   "module": "build/meep.module.js",
   "exports": {

package/src/engine/EngineConfiguration.js

@@ -2,31 +2,30 @@ import { assert } from "../core/assert.js";
 import { computeSystemName } from "./ecs/System.js";
 
 export class EngineConfiguration {
-    constructor() {
-        /**
-         * @private
-         * @type {System[]}
-         */
-        this.systems = [];
-
-        /**
-         * @private
-         * @type {Class<EnginePlugin>[]}
-         */
-        this.plugins = [];
-
-        /**
-         * @private
-         * @type {StaticKnowledgeDataTableDescriptor[]}
-         */
-        this.knowledge = [];
-
-        /**
-         *
-         * @type {Map<string,AssetLoader<any>>}
-         */
-        this.loaders = new Map();
-    }
+
+    /**
+     * @private
+     * @type {System[]}
+     */
+    systems = [];
+
+    /**
+     * @private
+     * @type {Class<EnginePlugin>[]}
+     */
+    plugins = [];
+
+    /**
+     * @private
+     * @type {StaticKnowledgeDataTableDescriptor[]}
+     */
+    knowledge = [];
+
+    /**
+     *
+     * @type {Map<string,AssetLoader<any>>}
+     */
+    loaders = new Map();
 
     /**
      *

package/src/engine/ecs/EntityBlueprint.js

@@ -3,7 +3,7 @@ import EntityBuilder from "./EntityBuilder.js";
 /**
  *
  * @param {Object} template
- * @param {Object} seed
+ * @param {Object} [seed]
  */
 function populateJsonTemplate(template, seed) {
     if (seed === undefined) {
@@ -41,9 +41,7 @@ function populateJsonTemplate(template, seed) {
                 for (const propertyName in template) {
                     const templateValue = template[propertyName];
 
-                    const seededValue = populateJsonTemplate(templateValue, seed);
-
-                    result[propertyName] = seededValue;
+                    result[propertyName] = populateJsonTemplate(templateValue, seed);
                 }
 
                 return result;

package/src/engine/ecs/EntityComponentDataset.spec.js

@@ -442,6 +442,30 @@ test('getComponent with 1 entity and 1 component', () => {
     expect(visitor_1).not.toHaveBeenCalled();
 });
 
+test("getComponent on unregistered component class", () => {
+
+    const ecd = new EntityComponentDataset();
+
+    const entity = ecd.createEntity();
+
+    expect(ecd.getComponent(entity, DummyComponentA)).toBe(undefined);
+});
+
+test("getComponentSafe", () => {
+
+    const ecd = new EntityComponentDataset();
+    ecd.registerComponentType(DummyComponentA);
+
+    const entity = ecd.createEntity();
+
+    expect(() => ecd.getComponentSafe(entity, DummyComponentA)).toThrow();
+
+    const component = new DummyComponentA();
+
+    ecd.addComponentToEntity(entity, component);
+
+    expect(ecd.getComponentSafe(entity, DummyComponentA)).toBe(component);
+});
 
 test('isComponentTypeRegistered', () => {
     const ecd = new EntityComponentDataset();
@@ -594,6 +618,59 @@ test('entityHasComponents', () => {
     expect(ecd.entityHasComponents(a)).toBe(true);
 });
 
+test("getAnyComponent", () => {
+
+    const ecd = new EntityComponentDataset();
+
+    ecd.registerManyComponentTypes([
+        DummyComponentA,
+        DummyComponentB
+    ]);
+
+    const a = ecd.createEntity();
+
+    expect(ecd.getAnyComponent(DummyComponentA)).toEqual({
+        entity: -1,
+        component: null
+    });
+
+    const component_a = new DummyComponentA();
+    ecd.addComponentToEntity(a, component_a);
+    ecd.addComponentToEntity(a, new DummyComponentB());
+
+    expect(ecd.getAnyComponent(DummyComponentA)).toEqual({
+        entity: a,
+        component: component_a
+    });
+
+});
+
+test("hasComponent", () => {
+
+
+    const ecd = new EntityComponentDataset();
+
+    ecd.registerManyComponentTypes([
+        DummyComponentA,
+        DummyComponentB
+    ]);
+
+    const a = ecd.createEntity();
+
+    expect(ecd.hasComponent(a, DummyComponentA)).toBe(false);
+    expect(ecd.hasComponent(a, DummyComponentB)).toBe(false);
+
+    ecd.addComponentToEntity(a, new DummyComponentA());
+
+    expect(ecd.hasComponent(a, DummyComponentA)).toBe(true);
+    expect(ecd.hasComponent(a, DummyComponentB)).toBe(false);
+
+    ecd.addComponentToEntity(a, new DummyComponentB());
+
+    expect(ecd.hasComponent(a, DummyComponentA)).toBe(true);
+    expect(ecd.hasComponent(a, DummyComponentB)).toBe(true);
+});
+
 describe('event management', () => {
 
     test("shouldn't be able to add event listener to non-existent entity", () => {

package/src/engine/ecs/terrain/overlay/TerrainOverlay.spec.js

@@ -0,0 +1,6 @@
+import { TerrainOverlay } from "./TerrainOverlay.js";
+import Vector2 from "../../../../core/geom/Vector2.js";
+
+test("constructor does not throw", () => {
+    new TerrainOverlay(new Vector2(1, 1))
+});

package/src/engine/ecs/terrain/tiles/TerrainTile.js

@@ -33,98 +33,101 @@ import { passThrough } from "../../../../core/function/Functions.js";
  * terrain tile is a part of a 2d array
  */
 class TerrainTile {
-    constructor() {
-        this.gridPosition = new Vector2();
-        this.scale = new Vector2(1, 1);
-        this.size = new Vector2();
-        this.position = new Vector2();
-        this.resolution = new ObservedInteger(1);
+    gridPosition = new Vector2();
+    scale = new Vector2(1, 1);
+    size = new Vector2();
+    position = new Vector2();
+    resolution = new ObservedInteger(1);
 
-        /**
-         *
-         * @type {Material}
-         */
-        this.material = null;
-        this.mesh = ThreeFactory.createMesh();
+    /**
+     *
+     * @type {Material}
+     */
+    material = null;
+    mesh = ThreeFactory.createMesh();
 
-        this.mesh.name = "TerrainTile";
 
-        /**
-         * Terrain mesh is static, it never changes its transform. Updates are wasteful.
-         * @type {boolean}
-         */
-        this.mesh.matrixWorldNeedsUpdate = false;
+    /**
+     *
+     * @type {THREE.BufferGeometry}
+     */
+    geometry = null;
 
-        /**
-         *
-         * @type {THREE.BufferGeometry}
-         */
-        this.geometry = null;
+    /**
+     *
+     * @type {boolean}
+     */
+    enableBVH = true;
 
-        /**
-         *
-         * @type {boolean}
-         */
-        this.enableBVH = true;
+    /**
+     *
+     * @type {LeafNode}
+     */
+    boundingBox = new LeafNode(this);
 
-        /**
-         *
-         * @type {LeafNode}
-         */
-        this.boundingBox = new LeafNode(this);
+    /**
+     *
+     * @type {BinaryNode}
+     */
+    bvh = null;
 
-        /**
-         *
-         * @type {BinaryNode}
-         */
-        this.bvh = null;
+    /**
+     *
+     * @type {boolean}
+     */
+    isBuilt = false;
+    /**
+     *
+     * @type {boolean}
+     */
+    isBuildInProgress = false;
+    referenceCount = 0;
 
-        /**
-         *
-         * @type {boolean}
-         */
-        this.isBuilt = false;
-        /**
-         *
-         * @type {boolean}
-         */
-        this.isBuildInProgress = false;
-        this.referenceCount = 0;
+    /**
+     *
+     * @type {Signal<TerrainTile>}
+     */
+    onBuilt = new Signal();
+    onDestroyed = new Signal();
 
-        /**
-         *
-         * @type {Signal<TerrainTile>}
-         */
-        this.onBuilt = new Signal();
-        this.onDestroyed = new Signal();
+    /**
+     * Encodes whether stitching has been performed on per-neighbour basis
+     * @private
+     * @type {{bottomLeft: boolean, top: boolean, left: boolean, bottom: boolean, bottomRight: boolean, topLeft: boolean, topRight: boolean, right: boolean}}
+     */
+    stitching = {
+        top: false,
+        bottom: false,
+        left: false,
+        right: false,
 
-        /**
-         * Encodes whether stitching has been performed on per-neighbour basis
-         * @private
-         * @type {{bottomLeft: boolean, top: boolean, left: boolean, bottom: boolean, bottomRight: boolean, topLeft: boolean, topRight: boolean, right: boolean}}
-         */
-        this.stitching = {
-            top: false,
-            bottom: false,
-            left: false,
-            right: false,
+        topLeft: false,
+        topRight: false,
+
+        bottomLeft: false,
+        bottomRight: false
+    };
 
-            topLeft: false,
-            topRight: false,
+    /**
+     * Initial estimate of height bounds for this tile
+     * Untransformed by transform matrix
+     * @type {NumericInterval}
+     * @private
+     */
+    __initial_height_range = new NumericInterval(Number.NEGATIVE_INFINITY, Number.POSITIVE_INFINITY);
 
-            bottomLeft: false,
-            bottomRight: false
-        };
+    raycaster = new BVHGeometryRaycaster();
+
+    constructor() {
+
+        this.mesh.name = "TerrainTile";
 
         /**
-         * Initial estimate of height bounds for this tile
-         * Untransformed by transform matrix
-         * @type {NumericInterval}
-         * @private
+         * Terrain mesh is static, it never changes its transform. Updates are wasteful.
+         * @type {boolean}
          */
-        this.__initial_height_range = new NumericInterval(Number.NEGATIVE_INFINITY, Number.POSITIVE_INFINITY);
+        this.mesh.matrixWorldNeedsUpdate = false;
 
-        this.raycaster = new BVHGeometryRaycaster();
         //Binary BVH form doesn't have distinct leaf objects and stores face indices directly, this requires a special face index extractor that treats leaves as indices directly.
         this.raycaster.extractFaceIndexFromLeaf = passThrough;
     }

package/src/engine/ecs/terrain/tiles/TerrainTile.spec.js

@@ -0,0 +1,25 @@
+import TerrainTile from "./TerrainTile.js";
+import { MATRIX_4_IDENTITY } from "../../../../core/geom/3d/matrix/MATRIX_4_IDENTITY.js";
+
+test("constructor does not throw", () => {
+    new TerrainTile();
+});
+
+test("get/set transform", () => {
+
+    const tile = new TerrainTile();
+    tile.setInitialHeightBounds(1, 7);
+
+    tile.transform = MATRIX_4_IDENTITY;
+
+    expect(Array.from(tile.transform)).toEqual(Array.from(MATRIX_4_IDENTITY));
+
+});
+
+test("using 'dispose' method on newly created tile", () => {
+
+    const tile = new TerrainTile();
+
+    expect(() => tile.dispose()).not.toThrow();
+    
+});

package/src/engine/platform/EnginePlatform.js

@@ -1,8 +1,4 @@
 export class EnginePlatform {
-    constructor() {
-    }
-
-
     /**
      * @returns {Storage}
      */

package/src/engine/InputEngine.js

@@ -1,94 +0,0 @@
-/**
- * User: Alex Goldring
- * Date: 22/6/2014
- * Time: 20:15
- */
-import { KeyCodes } from './input/devices/KeyCodes.js';
-import { assert } from "../core/assert.js";
-
-/**
- * @deprecated use PointerDevice and KeyboardDevice respectively
- * @param pointerContext
- * @param keyContext
- * @constructor
- */
-const InputEngine = function (pointerContext, keyContext) {
-    assert.defined(pointerContext, 'pointerContext');
-    assert.defined(keyContext, 'keyContext');
-
-    console.warn('deprecated, use PointerDevice and KeyboardDevice instead');
-
-    const keyMap = [];
-    const mouseMap = {};
-
-    function obtainBindingByCode(code) {
-        let binding;
-        if (typeof (code) === "number") {
-            if (keyMap[code] === void 0) {
-                keyMap[code] = {};
-            }
-            binding = keyMap[code];
-        } else {
-            if (mouseMap[code] === void 0) {
-                mouseMap[code] = {};
-            }
-            binding = mouseMap[code];
-        }
-        return binding;
-    }
-
-    this.mapKey = function (keyCode, config) {
-        const binding = obtainBindingByCode(keyCode);
-        if (config.on) {
-            binding.on = config.on;
-        }
-        if (config.off) {
-            binding.off = config.off;
-        }
-    };
-    this.mapKeyBoolean = function (keyName, context, property) {
-        const keyCode = KeyCodes[keyName];
-        const binding = obtainBindingByCode(keyCode);
-        binding.on = function () {
-            context[property] = true;
-        };
-        binding.off = function () {
-            context[property] = false;
-        };
-        return this;
-    };
-    const keyDownHandler = function (event) {
-        const keyCode = event.keyCode;
-        //console.log("down", keyCode);
-        const binding = keyMap[keyCode];
-        if (binding && binding.on) {
-            binding.on(event);
-        }
-    };
-    const keyUpHandler = function (event) {
-        const keyCode = event.keyCode;
-        const binding = keyMap[keyCode];
-        if (binding && binding.off) {
-            binding.off(event);
-        }
-    };
-    const mouseUpHandler = function (event) {
-        const mouse1 = mouseMap.mouse1;
-        if (mouse1) {
-            mouse1.off(event);
-        }
-    };
-    const mouseDownHandler = function (event) {
-        const mouse1 = mouseMap.mouse1;
-        if (mouse1) {
-            mouse1.on(event);
-        }
-    };
-    keyContext.addEventListener("keydown", keyDownHandler);
-    keyContext.addEventListener("keyup", keyUpHandler);
-    pointerContext.addEventListener("mousedown", mouseDownHandler);
-    pointerContext.addEventListener("mouseup", mouseUpHandler);
-    //
-
-};
-export default InputEngine;

package/src/engine/PointerLock.js

@@ -1,60 +0,0 @@
-/**
- * Created by Alex on 27/02/14.
- */
-
-
-
-function getPointerLockElement() {
-    const pointerLockElement = document.pointerLockElement ||
-        document.mozPointerLockElement ||
-        document.webkitPointerLockElement;
-    return pointerLockElement;
-}
-
-function PointerLock(element) {
-    this.element = element;
-    element.requestPointerLock = element.requestPointerLock ||
-        element.mozRequestPointerLock ||
-        element.webkitRequestPointerLock;
-    element.exitPointerLock = element.exitPointerLock ||
-        element.mozExitPointerLock ||
-        element.webkitExitPointerLock;
-    this.pointerLockError = (function (evt) {
-        console.error("failed to lock pointer", evt);
-    }).bind(this);
-    this.pointerLockChange = (function (evt) {
-        if (this.isBound()) {
-            this.emit("locked");
-        } else {
-            this.unlock();
-        }
-    }).bind(this);
-}
-
-PointerLock.prototype = new EventEmitter();
-PointerLock.prototype.isBound = function () {
-    return this.element === getPointerLockElement();
-};
-PointerLock.prototype.lock = function () {
-    if (this.isBound()) {
-        return;
-    }
-    document.addEventListener('pointerlockerror', this.pointerLockError, false);
-    document.addEventListener('mozpointerlockerror', this.pointerLockError, false);
-    document.addEventListener('webkitpointerlockerror', this.pointerLockError, false);
-
-    document.addEventListener('pointerlockchange', this.pointerLockChange, false);
-    document.addEventListener('mozpointerlockchange', this.pointerLockChange, false);
-    document.addEventListener('webkitpointerlockchange', this.pointerLockChange, false);
-    this.element.requestPointerLock();
-};
-PointerLock.prototype.unlock = function () {
-    document.removeEventListener('pointerlockchange', this.pointerLockChange, false);
-    document.removeEventListener('mozpointerlockchange', this.pointerLockChange, false);
-    document.removeEventListener('webkitpointerlockchange', this.pointerLockChange, false);
-    if (this.isBound()) {
-        this.element.exitPointerLock();
-    }
-    this.emit("unlocked");
-};
-export default PointerLock;

package/src/engine/ecs/terrain/ecs/layers/loadLegacyTerrainLayers.js

@@ -1,99 +0,0 @@
-import { max2 } from "../../../../../core/math/max2.js";
-import { TerrainLayer } from "./TerrainLayer.js";
-import { Sampler2D } from "../../../../graphics/texture/sampler/Sampler2D.js";
-
-/**
- *
- * @param {{repeat:Vector2,textures:{diffuse:string[]}}} description
- * @param {TerrainLayers} layers
- * @param {AssetManager} am
- * @param {Vector2} size
- * @param {number} gridScale
- * @returns {Promise}
- */
-export function loadLegacyTerrainLayers(description, layers, am, size, gridScale) {
-
-    /**
-     *
-     * @type {string[]}
-     */
-    const textures = description.textures.diffuse;
-
-    /**
-     *
-     * @param {string} url
-     * @param {number} layerIndex
-     * @return {Promise<Asset>}
-     */
-    function loadLayer(url, layerIndex) {
-
-        /**
-         *
-         * @type {TerrainLayer}
-         */
-        const layer = layers.layers.get(layerIndex);
-
-        layer.textureDiffuseURL = url;
-
-        return layer.loadTextureData(am);
-    }
-
-    const layerCount = textures.length;
-
-    for (let i = 0; i < layerCount; i++) {
-
-        const layer = new TerrainLayer();
-
-
-        const nX = gridScale * (size.x / size.y);
-        const nY = gridScale;
-
-        layer.size.set(nX / description.repeat.x, nY / description.repeat.y);
-
-        layer.diffuse = Sampler2D.uint8(3, layers.resolution.x, layers.resolution.y);
-
-        layers.addLayer(layer);
-    }
-
-    layers.buildTexture();
-
-    const promises = [];
-
-    for (let i = 0; i < layerCount; i++) {
-        const url = textures[i];
-
-        const promise = loadLayer(url, i);
-
-        promises.push(promise);
-    }
-
-    function updateResolution() {
-
-        let size_x = 0;
-        let size_y = 0;
-
-        for (let i = 0; i < layerCount; i++) {
-            const layer = layers.get(i);
-
-            size_x = max2(layer.diffuse.width, size_x);
-            size_y = max2(layer.diffuse.height, size_y);
-        }
-
-        layers.resolution.set(size_x, size_y);
-
-        layers.buildTexture();
-    }
-
-    function writeLayers() {
-
-        layers.writeAllLayersDataIntoTexture();
-    }
-
-
-    return Promise.all(promises)
-        .then(() => {
-            updateResolution();
-
-            writeLayers();
-        });
-}

package/src/engine/ecs/terrain/ecs/splat/loadLegacyTerrainSplats.js

@@ -1,73 +0,0 @@
-import { GameAssetType } from "../../../../asset/GameAssetType.js";
-import { max2 } from "../../../../../core/math/max2.js";
-import { Sampler2D } from "../../../../graphics/texture/sampler/Sampler2D.js";
-
-/**
- *
- * @param {{textures:{splat:string[]}}} description
- * @param {SplatMapping} mapping
- * @param {AssetManager} am
- * @returns {Promise}
- */
-export function loadLegacyTerrainSplats(description, mapping, am) {
-
-
-    const textures = description.textures.splat;
-
-    const n = textures.length;
-
-    /**
-     *
-     * @param {string} url
-     * @param {number} index
-     * @return {Promise<Asset>}
-     */
-    function loadSplat(url, index) {
-
-        return am.promise(url, GameAssetType.Image)
-            .then(asset => {
-
-                const image = asset.create();
-
-                // FIXME texture array in three.js doesn't work when texture size is less than 4x4
-                const width = max2(image.width, 4);
-                const height = max2(image.height, 4);
-
-                //create a sampler
-                const source = new Sampler2D(image.data, 4, image.width, image.height);
-
-                mapping.resize(width, height, 4);
-
-                mapping.writeLayerFromSampler(source, index, 0);
-
-            });
-    }
-
-    const weightPromises = [];
-
-    for (let i = 0; i < n; i++) {
-        const url = textures[i];
-
-        const promise = loadSplat(url, i);
-
-        weightPromises.push(promise);
-    }
-
-    return Promise.all(weightPromises)
-        .then(() => {
-            const materialData = mapping.materialData;
-
-            const n = materialData.length;
-
-            for (let i = 0; i < n; i += 4) {
-                materialData[i] = 0;
-                materialData[i + 1] = 1;
-                materialData[i + 2] = 2;
-                materialData[i + 3] = 3;
-            }
-
-            mapping.materialTexture.needsUpdate = true;
-            mapping.weightTexture.needsUpdate = true;
-
-        });
-}