@woosh/meep-engine 2.49.7 → 2.49.9

package/editor/enableEditor.js

@@ -61,14 +61,7 @@ export function enableEditor(engine, initialization = noop) {
     }
 
     //bind key for toggling editor
-    engine.inputEngine.mapKey(144, {
-        on: function () {
-            toggleEditor();
-        },
-        off: function () {
-
-        }
-    });
+    engine.devices.keyboard.keys.num_lock.down.add(toggleEditor);
 
     console.warn('Editor mode enabled, use NumLock key to toggle editor mode');
 

package/package.json

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

package/samples/terrain/editor.js

@@ -1,7 +1,6 @@
 import { EngineHarness } from "../../src/engine/EngineHarness.js";
 import EmptyView from "../../src/view/elements/EmptyView.js";
 import { EngineConfiguration } from "../../src/engine/EngineConfiguration.js";
-import { buildCubeURLs } from "../../src/engine/graphics/texture/cubemap/buildCubeURLs.js";
 import { ArrayBufferLoader } from "../../src/engine/asset/loaders/ArrayBufferLoader.js";
 import { TerrainFlags } from "../../src/engine/ecs/terrain/ecs/TerrainFlags.js";
 import Signal from "../../src/core/events/signal/Signal.js";
@@ -22,6 +21,7 @@ import { copy_Sampler2D_channel_data } from "../../src/engine/graphics/texture/s
 import { TextureAssetLoader } from "../../src/engine/asset/loaders/texture/TextureAssetLoader.js";
 import { CanvasView } from "../../src/view/elements/CanvasView.js";
 import convertSampler2D2Canvas from "../../src/engine/graphics/texture/sampler/Sampler2D2Canvas.js";
+import { load_and_set_cubemap_v0 } from "../../src/engine/graphics/load_and_set_cubemap_v0.js";
 
 const engineHarness = new EngineHarness();
 
@@ -338,7 +338,7 @@ async function init(harness) {
 
     await makeConfig(engine).apply(engine);
 
-    await engine.graphics.loadEnvironmentMap(buildCubeURLs('data/textures/cubemaps/hip_miramar/32/', '.png'));
+    await load_and_set_cubemap_v0(engine.graphics, 'data/textures/cubemaps/hip_miramar/32/', '.png');
 
     await harness.initialize();
 

package/src/core/cache/Cache.js

@@ -3,7 +3,7 @@ import { HashMap } from "../collection/HashMap.js";
 import Signal from "../events/signal/Signal.js";
 import { returnOne, returnZero, strictEquals } from "../function/Functions.js";
 import { CacheElement } from "./CacheElement.js";
-import { collectIteratorValueToArray } from "../collection/IteratorUtils.js";
+import { collectIteratorValueToArray } from "../collection/collectIteratorValueToArray.js";
 
 /**
  * Hash-based cache, uses LRU (least-recently-used) eviction policy

package/src/core/collection/HashSet.js

@@ -105,7 +105,7 @@ export class HashSet {
     }
 
     /**
-     *
+     * Get the equivalent value that's already in the set or add the supplied value if it's not present
      * @param {T} value
      * @return {T}
      */

package/src/core/collection/table/RowFirstTableSpec.js

@@ -10,6 +10,7 @@ import { isArrayEqualStrict } from "../array/isArrayEqualStrict.js";
 import { BinaryDataType } from "../../binary/type/BinaryDataType.js";
 import { DataTypeByteSizes } from "../../binary/type/DataTypeByteSizes.js";
 import { assert } from "../../assert.js";
+import { computeHashArray } from "../array/computeHashArray.js";
 
 /**
  * @readonly
@@ -152,123 +153,140 @@ function genCellReader(type, offset, endianType = EndianType.BigEndian) {
     });
 }
 
-/**
- *
- * @param {BinaryDataType[]} types
- * @param {EndianType} [endianType]
- * @constructor
- */
-export function RowFirstTableSpec(types, endianType = EndianType.BigEndian) {
-    assert.isArray(types, 'types');
-
-    const numTypes = types.length;
-
+export class RowFirstTableSpec {
     /**
-     * @readonly
-     * @type {BinaryDataType[]}
+     *
+     * @param {BinaryDataType[]} types
+     * @param {EndianType} [endianType]
+     * @constructor
      */
-    this.types = types;
+    constructor(types, endianType = EndianType.BigEndian) {
+        assert.isArray(types, 'types');
 
-    /**
-     * @readonly
-     * @type {EndianType}
-     */
-    this.endianType = endianType;
+        const numTypes = types.length;
 
-    /**
-     * @readonly
-     * @type {number[]}
-     */
-    this.columnOffsets = new Array(numTypes);
-    let byteOffset = 0;
-    types.forEach((type, index) => {
-        this.columnOffsets[index] = byteOffset;
+        /**
+         * @readonly
+         * @type {BinaryDataType[]}
+         */
+        this.types = types;
 
-        const columnByteSize = DataTypeByteSizes[type];
+        /**
+         * @readonly
+         * @type {EndianType}
+         */
+        this.endianType = endianType;
 
-        byteOffset += columnByteSize;
-    });
+        /**
+         * @readonly
+         * @type {number[]}
+         */
+        this.columnOffsets = new Uint32Array(numTypes);
 
+        let byteOffset = 0;
 
-    /**
-     * @readonly
-     * @type {number}
-     */
-    this.bytesPerRecord = byteOffset;
+        for (let index = 0; index < numTypes; index++) {
+            const type = types[index];
+            this.columnOffsets[index] = byteOffset;
+
+            const columnByteSize = DataTypeByteSizes[type];
+
+            byteOffset += columnByteSize;
+        }
+
+
+        /**
+         * @readonly
+         * @type {number}
+         */
+        this.bytesPerRecord = byteOffset;
+
+        /**
+         * @readonly
+         * @type {function(DataView, number, number[]): void}
+         */
+        this.readRowMethod = genRowReader(types, endianType);
+
+        /**
+         * @readonly
+         * @type {function(DataView, number, number[]): void}
+         */
+        this.writeRowMethod = genRowWriter(types, endianType);
+
+
+        //generate cell readers/writers
+        this.cellWriters = new Array(numTypes);
+        this.cellReaders = new Array(numTypes);
+
+        for (let i = 0; i < numTypes; i++) {
+            this.cellReaders[i] = genCellReader(types[i], this.columnOffsets[i], endianType);
+            this.cellWriters[i] = genCellWriter(types[i], this.columnOffsets[i], endianType);
+        }
+        /**
+         * @readonly
+         * @type {boolean}
+         */
+        this.isRowFirstTableSpec = true;
+    }
 
     /**
-     * @readonly
-     * @type {function(DataView, number, number[]): void}
+     *
+     * @return {number}
      */
-    this.readRowMethod = genRowReader(types, endianType);
+    getColumnCount() {
+        return this.types.length;
+    }
 
     /**
-     * @readonly
-     * @type {function(DataView, number, number[]): void}
+     *
+     * @return {number}
      */
-    this.writeRowMethod = genRowWriter(types, endianType);
+    hash() {
+        let hash = this.endianType === EndianType.BigEndian ? 1 : 0;
 
+        hash += computeHashArray(this.types, computeStringHash);
 
-    //generate cell readers/writers
-    this.cellWriters = new Array(numTypes);
-    this.cellReaders = new Array(numTypes);
-
-    for (let i = 0; i < numTypes; i++) {
-        this.cellReaders[i] = genCellReader(types[i], this.columnOffsets[i], endianType);
-        this.cellWriters[i] = genCellWriter(types[i], this.columnOffsets[i], endianType);
+        return hash;
     }
-}
 
-/**
- *
- * @return {number}
- */
-RowFirstTableSpec.prototype.getColumnCount = function () {
-    return this.types.length;
-}
+    /**
+     *
+     * @param {RowFirstTableSpec} other
+     * @returns {boolean}
+     */
+    equals(other) {
+        if (this.endianType !== other.endianType) {
+            return false;
+        }
 
-/**
- *
- * @param {RowFirstTableSpec} other
- * @returns {boolean}
- */
-RowFirstTableSpec.prototype.equals = function (other) {
-    if (this.endianType !== other.endianType) {
-        return false;
+        return isArrayEqualStrict(this.types, other.types);
     }
 
-    return isArrayEqualStrict(this.types, other.types);
-};
-
-/**
- * @readonly
- * @type {boolean}
- */
-RowFirstTableSpec.prototype.isRowFirstTableSpec = true;
-
+    /**
+     *
+     * @param {BinaryDataType[]} types
+     * @param {EndianType} [endianType]
+     * @returns {RowFirstTableSpec}
+     */
+    static get(types, endianType = EndianType.BigEndian) {
+        //compute hash
+        const hash = types.join('.') + ':' + endianType;
 
-const cache = new Cache({
-    keyHashFunction: computeStringHash
-});
+        const cachedValue = cache.get(hash);
 
-/**
- *
- * @param {BinaryDataType[]} types
- * @param {EndianType} [endianType]
- * @returns {RowFirstTableSpec}
- */
-RowFirstTableSpec.get = function (types, endianType = EndianType.BigEndian) {
-    //compute hash
-    const hash = types.join('.') + ':' + endianType;
+        if (cachedValue !== null) {
+            return cachedValue;
+        }
 
-    const cachedValue = cache.get(hash);
+        const newValue = new RowFirstTableSpec(types);
+        cache.put(hash, newValue);
 
-    if (cachedValue !== null) {
-        return cachedValue;
+        return newValue;
     }
+}
 
-    const newValue = new RowFirstTableSpec(types);
-    cache.put(hash, newValue);
 
-    return newValue;
-};
+const cache = new Cache({
+    keyHashFunction: computeStringHash
+});
+

package/src/core/collection/table/RowFirstTableSpec.spec.js

@@ -0,0 +1,49 @@
+import { RowFirstTableSpec } from "./RowFirstTableSpec.js";
+import { BinaryDataType } from "../../binary/type/BinaryDataType.js";
+import { EndianType } from "../../binary/BinaryBuffer.js";
+
+test("constructor with 1 column does not throw", () => {
+    expect(() => new RowFirstTableSpec([BinaryDataType.Float32])).not.toThrow();
+});
+
+test("hash produced a valid value", () => {
+    const spec = new RowFirstTableSpec([BinaryDataType.Float32]);
+
+    const hash = spec.hash();
+
+    expect(typeof hash).toBe("number");
+    expect(hash).not.toBeNaN();
+    expect(Number.isInteger(hash)).toBe(true);
+});
+
+test("hash is stable", () => {
+
+    const spec = new RowFirstTableSpec([BinaryDataType.Float32]);
+
+    expect(spec.hash()).toEqual(spec.hash());
+
+});
+
+test("hashes of identical specs must match", () => {
+    const a = new RowFirstTableSpec([BinaryDataType.Float32]);
+    const b = new RowFirstTableSpec([BinaryDataType.Float32]);
+
+    expect(a.hash()).toEqual(b.hash());
+});
+
+test("equals", () => {
+    const a = new RowFirstTableSpec([BinaryDataType.Float32, BinaryDataType.Uint8], EndianType.BigEndian);
+    const b = new RowFirstTableSpec([BinaryDataType.Float32, BinaryDataType.Uint8], EndianType.BigEndian);
+
+    const c = new RowFirstTableSpec([BinaryDataType.Uint8, BinaryDataType.Float32], EndianType.BigEndian);
+
+    const d = new RowFirstTableSpec([BinaryDataType.Float32, BinaryDataType.Uint8], EndianType.LittleEndian);
+
+    expect(a.equals(a)).toBe(true);
+    expect(a.equals(b)).toBe(true);
+
+    expect(a.equals(c)).toBe(false);
+    expect(c.equals(a)).toBe(false);
+
+    expect(a.equals(d)).toBe(false);
+});

package/src/core/color/Color.d.ts

@@ -1,12 +1,12 @@
 import Signal from "../events/signal/Signal";
 
 export class Color {
-    constructor(r?: number, g?: number, b?: number,a?:number)
+    constructor(r?: number, g?: number, b?: number, a?: number)
 
     r: number
     g: number
     b: number
-    a:number
+    a: number
 
     readonly onChanged: Signal<number, number, number, number, number, number>
 
@@ -14,6 +14,8 @@ export class Color {
 
     setRGB(r: number, g: number, b: number): void
 
+    setA(a: number): void
+
     setHSL(h: number, s: number, l: number): void
 
     setHCL(h: number, c: number, l: number): void

package/src/core/color/Color.js

@@ -1,11 +1,9 @@
 import { assert } from "../assert.js";
 import Signal from "../events/signal/Signal.js";
-import { parseColor } from "./ColorUtils.js";
+import { parseColor } from "./parseColor.js";
 import { min2 } from "../math/min2.js";
 import { max2 } from "../math/max2.js";
 import { min3 } from "../math/min3.js";
-import { computeHashIntegerArray } from "../collection/array/computeHashIntegerArray.js";
-import { computeHashFloat } from "../primitives/numbers/computeHashFloat.js";
 import { rgb2hsv } from "./rgb2hsv.js";
 import { rgb2uint24 } from "./rgb2uint24.js";
 import { clamp01 } from "../math/clamp01.js";
@@ -156,6 +154,11 @@ export class Color {
         assert.isNumber(b, 'b');
         assert.isNumber(a, 'a');
 
+        assert.notNaN(r, 'r');
+        assert.notNaN(g, 'g');
+        assert.notNaN(b, 'b');
+        assert.notNaN(a, 'a');
+
         const _r = this.r;
         const _g = this.g;
         const _b = this.b;
@@ -462,11 +465,7 @@ export class Color {
      * @returns {number}
      */
     hash() {
-        return computeHashIntegerArray(
-            computeHashFloat(this.r),
-            computeHashFloat(this.g),
-            computeHashFloat(this.b)
-        );
+        return this.toUint();
     }
 
     fromJSON({ r, g, b, a = 1 }) {

package/src/core/color/Color.spec.js

@@ -53,3 +53,96 @@ test("setHSV white", () => {
     expect(c.g).toBeCloseTo(1);
     expect(c.b).toBeCloseTo(1);
 });
+
+test("setA sets alpha nd invokes 'onChanged' signal", () => {
+    const c = new Color();
+
+    const mock = jest.fn();
+
+    c.onChanged.add(mock);
+
+    c.setA(0.7);
+
+    expect(c.a).toBe(0.7);
+    expect(mock).toHaveBeenCalledTimes(1);
+});
+
+test("equals", () => {
+
+    expect(new Color(0, 0, 0, 0).equals(new Color(0, 0, 0, 0)))
+        .toBe(true);
+
+    expect(new Color(0.1, 0.2, 0.3, 0.7).equals(new Color(0.1, 0.2, 0.3, 0.7)))
+        .toBe(true);
+
+    expect(new Color(0, 0, 0, 0).equals(new Color(0, 0, 0, 1)))
+        .toBe(false);
+
+    expect(new Color(0, 0, 0, 0).equals(new Color(0, 0, 1, 0)))
+        .toBe(false);
+
+    expect(new Color(0, 0, 0, 0).equals(new Color(0, 1, 0, 0)))
+        .toBe(false);
+
+    expect(new Color(0, 0, 0, 0).equals(new Color(1, 0, 0, 0)))
+        .toBe(false);
+});
+
+test("hash is stable", () => {
+    expect(new Color(0.1, 0.3, 0.7, 0.11).hash())
+        .toEqual(new Color(0.1, 0.3, 0.7, 0.11).hash());
+
+    const c = new Color(0.1, 0.3, 0.7, 0.11);
+
+    expect(c.hash()).toEqual(c.hash());
+
+    const hash = c.hash();
+
+    expect(typeof hash).toEqual("number");
+    expect(Number.isInteger(hash)).toBe(true);
+});
+
+test("toJSON", () => {
+
+    expect(new Color(0.1, 0.3, 0.7, 0.11).toJSON())
+        .toEqual({
+            r: 0.1,
+            g: 0.3,
+            b: 0.7,
+            a: 0.11
+        });
+
+});
+
+test("fromJSON", () => {
+    const c = new Color();
+
+    c.fromJSON({
+        r: 0.1,
+        g: 0.3,
+        b: 0.7,
+        a: 0.11
+    });
+
+    expect(c.r).toBe(0.1);
+    expect(c.g).toBe(0.3);
+    expect(c.b).toBe(0.7);
+    expect(c.a).toBe(0.11);
+});
+
+test("iterator", () => {
+
+    const color = new Color(0.1, 0.3, 0.7, 0.11);
+
+    const iterator = color[Symbol.iterator]();
+
+    expect(iterator.next().value).toBe(0.1)
+    expect(iterator.next().value).toBe(0.3)
+    expect(iterator.next().value).toBe(0.7)
+    expect(iterator.next().value).toBe(0.11)
+
+    const last = iterator.next();
+
+    expect(last.done).toBe(true)
+    expect(last.value).toBeUndefined()
+});

package/src/core/color/hex2rgb.spec.js

@@ -0,0 +1,10 @@
+import { hex2rgb } from "./hex2rgb.js";
+
+test("rgba support", () => {
+    expect(hex2rgb('#01020304')).toEqual({
+        r: 0x01,
+        g: 0x02,
+        b: 0x03,
+        a: 0x04
+    });
+});

package/src/core/color/rgb2hex.js

@@ -1,7 +1,7 @@
 import { dec2hex } from "../binary/dec2hex.js";
 
 /**
- *
+ * Takes values in 0..255 range
  * @param {number} r
  * @param {number} g
  * @param {number} b

package/src/core/color/rgb2hex.spec.js

@@ -0,0 +1,13 @@
+import { rgb2hex } from "./rgb2hex.js";
+
+test("white", () => {
+    expect(rgb2hex(255, 255, 255)).toBe("ffffff");
+});
+
+test("black", () => {
+    expect(rgb2hex(0, 0, 0)).toBe("000000");
+});
+
+test("unique channel values", () => {
+    expect(rgb2hex(11, 3, 7)).toBe("0b0307");
+});

package/src/core/fsm/simple/SimpleStateMachine.spec.js

@@ -0,0 +1,75 @@
+import { SimpleStateMachine } from "./SimpleStateMachine.js";
+import { SimpleStateMachineDescription } from "./SimpleStateMachineDescription.js";
+
+test("constructor does not throw", () => {
+    const description = new SimpleStateMachineDescription();
+
+    expect(() => new SimpleStateMachine(description)).not.toThrow();
+});
+
+
+test("state entry event handler is fired as expected", () => {
+
+    const description = new SimpleStateMachineDescription();
+
+    const a = description.createState();
+    const b = description.createState();
+
+    description.createEdge(a, b);
+
+    const fsm = new SimpleStateMachine(description);
+
+    fsm.setState(a);
+
+    const entry_callback = jest.fn();
+
+    fsm.addEventHandlerStateEntry(b, entry_callback);
+
+    fsm.setState(b);
+
+    expect(entry_callback).toHaveBeenCalledTimes(1);
+    expect(entry_callback).toHaveBeenCalledWith(b, a);
+});
+
+test("state exit event handler is fired as expected", () => {
+
+    const description = new SimpleStateMachineDescription();
+
+    const a = description.createState();
+    const b = description.createState();
+
+    description.createEdge(a, b);
+
+    const fsm = new SimpleStateMachine(description);
+
+    fsm.setState(a);
+
+    const entry_callback = jest.fn();
+
+    fsm.addEventHandlerStateExit(a, entry_callback);
+
+    fsm.setState(b);
+
+    expect(entry_callback).toHaveBeenCalledTimes(1);
+    expect(entry_callback).toHaveBeenCalledWith(a, b);
+});
+
+test("'advance' moves us to the next state in the chain", () => {
+
+
+    const description = new SimpleStateMachineDescription();
+
+    const a = description.createState();
+    const b = description.createState();
+
+    description.createEdge(a, b);
+
+    const fsm = new SimpleStateMachine(description);
+
+    fsm.setState(a);
+
+    fsm.advance(0);
+
+    expect(fsm.getState()).toBe(b);
+
+});

package/src/core/fsm/simple/SimpleStateMachineDescription.js

@@ -141,7 +141,7 @@ export class SimpleStateMachineDescription {
      *
      * @param {number} start
      * @param {number} goal
-     * @returns {number[]}
+     * @returns {number[]|null}
      */
     findPath(start, goal) {
         assert.ok(this.stateExists(start), `start state ${start} doesn't exist`);

package/src/core/fsm/simple/SimpleStateMachineDescription.spec.js

@@ -69,3 +69,35 @@ test('getIncomingStates', () => {
     expect(smd.getIncomingStates(b)).toEqual([a]);
     expect(smd.getIncomingStates(c)).toEqual([a]);
 });
+
+test('edgeExists', () => {
+
+    const smd = new SimpleStateMachineDescription();
+
+    const a = smd.createState();
+    const b = smd.createState();
+
+    expect(smd.edgeExists(a, b)).toBe(false);
+    expect(smd.edgeExists(b, a)).toBe(false);
+
+    smd.createEdge(a, b);
+
+    expect(smd.edgeExists(a, b)).toEqual(true);
+    expect(smd.edgeExists(b, a)).toEqual(false);
+});
+
+test("findPath sanity check", () => {
+
+    const smd = new SimpleStateMachineDescription();
+
+    const a = smd.createState();
+    const b = smd.createState();
+
+    expect(smd.findPath(a, a)).toEqual([a]);
+
+    expect(smd.findPath(a, b)).toEqual(null);
+
+    smd.createEdge(a, b);
+
+    expect(smd.findPath(a, b)).toEqual([a, b]);
+});