@woosh/meep-engine 2.49.8 → 2.50.0

package/src/engine/graphics/texture/sampler/loadSampler2D.js

@@ -14,7 +14,9 @@ import { GameAssetType } from "../../../asset/GameAssetType.js";
 export default function loadSampler2D(url, assetManager) {
     return new Promise(function (resolve, reject) {
         assetManager.get({
-            path: url, type: GameAssetType.Image, callback: (asset) => {
+            path: url,
+            type: GameAssetType.Image,
+            callback: (asset) => {
                 const imageData = asset.create();
 
                 const width = imageData.width;
@@ -32,7 +34,8 @@ export default function loadSampler2D(url, assetManager) {
                 }
                 const sampler2D = new Sampler2D(buffer, 1, width, height);
                 resolve(sampler2D);
-            }, failure: reject
+            },
+            failure: reject
         });
     });
 };

package/src/engine/graphics/texture/sampler/resize/sampler2d_downsample_mipmap.js

@@ -44,12 +44,15 @@ export function sampler2d_downsample_mipmap(source, destination) {
     const m0_sx = (current_mip.width + 1) / (current_mip.width);
     const m0_sy = (current_mip.height + 1) / (current_mip.height);
 
+    const destination_v_scale = dest_height > 1 ? 1 / (dest_height - 1) : 0;
+    const destination_u_scale = dest_width > 1 ? 1 / (dest_width - 1) : 0;
+
     for (let y = 0; y < dest_height; y++) {
-        const v = y / (dest_height - 1);
+        const v = y * destination_v_scale;
 
         for (let x = 0; x < dest_width; x++) {
 
-            const u = x / (dest_width - 1);
+            const u = x * destination_u_scale;
 
             for (let i = 0; i < itemSize; i++) {
 
@@ -58,7 +61,9 @@ export function sampler2d_downsample_mipmap(source, destination) {
 
                 const c_out = lerp(c0, c1, mip_mix);
 
-                destination.data[(y * dest_width + x) * itemSize + i] = c_out;
+                const destination_address = (y * dest_width + x) * itemSize + i;
+
+                destination.data[destination_address] = c_out;
             }
         }
     }

package/src/engine/graphics/texture/sampler/resize/sampler2d_downsample_mipmap.spec.js

@@ -0,0 +1,13 @@
+import { Sampler2D } from "../Sampler2D.js";
+import { sampler2d_downsample_mipmap } from "./sampler2d_downsample_mipmap.js";
+
+test("downsample solid fill from 2x2 to 1x1", () => {
+    const input = Sampler2D.uint8(1, 2, 2);
+
+    input.data.fill(7);
+
+    const result = Sampler2D.uint8(1, 1, 1);
+    sampler2d_downsample_mipmap(input, result);
+
+    expect(result.readChannel(0, 0, 0)).toBeCloseTo(7)
+});

package/src/engine/graphics/texture/sampler/sampler2d_channel_compute_min_indices.js

@@ -0,0 +1,58 @@
+import { assert } from "../../../../core/assert.js";
+
+/**
+ *
+ * @param {number[]|Float32Array|Uint8Array|Uint32Array} result
+ * @param {number} result_offset
+ * @param {Sampler2D} sampler
+ * @param {number} [channel]
+ * @return {number}
+ */
+export function sampler2d_channel_compute_min_indices(
+    result, result_offset,
+    sampler, channel = 0
+) {
+    assert.defined(sampler, 'sampler');
+    assert.isNonNegativeInteger(result_offset, 'result_offset');
+
+    const itemSize = sampler.itemSize;
+
+    assert.isNumber(channel, "channel");
+    assert.isNonNegativeInteger(channel, 'channel');
+    assert.ok(channel >= 0, `channel must be >= 0, was ${channel}`);
+    assert.ok(channel < itemSize, `channel must be less than itemSize(=${itemSize}), was ${channel}`);
+
+    assert.isArrayLike(result, "result");
+
+    const data = this.data;
+
+    const l = data.length;
+
+    if (l === 0) {
+        //no data
+        return 0;
+    }
+
+    let bestValue = data[channel];
+
+    let result_count = 0;
+
+    for (let i = channel + itemSize; i < l; i += itemSize) {
+        const value = data[i];
+
+        if (bestValue > value) {
+            bestValue = value;
+            //drop result
+            result_count = 1;
+
+            result[result_offset] = i;
+        } else if (value === bestValue) {
+            result[result_offset + result_count] = i;
+
+            result_count++;
+        }
+
+    }
+
+    return result_count;
+}

package/src/engine/graphics/trail/TemporalPath.js

@@ -59,33 +59,6 @@ TemporalPath.prototype.update = function (timeDelta) {
     this.updateSequence();
 };
 
-
-/**
- *
- * @param {number} t value between 0..1, falls between points p1 and p2
- * @param {number[]} p0
- * @param {number[]} p1
- * @param {number[]} p2
- * @param {number[]} p3
- * @param {number[]} result
- */
-function catmullRomSample(t, p0, p1, p2, p3, result) {
-
-    for (let j = 0; j < 4; j++) {
-        const v0 = p0[j];
-        const v1 = p1[j];
-        const v2 = p2[j];
-        const v3 = p3[j];
-
-        const t2 = t * t;
-        const t3 = t2 * t;
-
-        const qT = 0.5 * (2 * v1 + (v2 - v0) * t + (2 * v0 - 5 * v1 + 4 * v2 - v3) * t2 + (3 * v1 - v0 - 3 * v2 + v3) * t3);
-
-        result[j] = qT;
-    }
-}
-
 /**
  * @returns {number}
  */
@@ -133,15 +106,6 @@ TemporalPath.prototype.computeLength = function () {
     return result;
 };
 
-/**
- *
- * @param {number} sampleCount
- * @param {Float32Array} result
- */
-TemporalPath.prototype.sampleSmoothPath = function (sampleCount, result) {
-
-};
-
 /**
  *
  * @param {number} x

package/src/engine/intelligence/behavior/composite/ParallelBehavior.spec.js

@@ -21,7 +21,7 @@ test("1 succeeding child", () => {
 
     p.initialize();
 
-    expect(p.tick()).toBe(BehaviorStatus.Succeeded);
+    expect(p.tick(1)).toBe(BehaviorStatus.Succeeded);
 
     p.finalize();
 
@@ -43,8 +43,8 @@ test("1 succeeding child, 1 tick delay", () => {
 
     p.initialize();
 
-    expect(p.tick()).toBe(BehaviorStatus.Running);
-    expect(p.tick()).toBe(BehaviorStatus.Succeeded);
+    expect(p.tick(1)).toBe(BehaviorStatus.Running);
+    expect(p.tick(1)).toBe(BehaviorStatus.Succeeded);
 
     p.finalize();
 
@@ -66,7 +66,7 @@ test("1 failing child", () => {
 
     p.initialize();
 
-    expect(p.tick()).toBe(BehaviorStatus.Failed);
+    expect(p.tick(1)).toBe(BehaviorStatus.Failed);
 
     p.finalize();
 
@@ -88,8 +88,8 @@ test("1 failing child, 1 tick delay", () => {
 
     p.initialize();
 
-    expect(p.tick()).toBe(BehaviorStatus.Running);
-    expect(p.tick()).toBe(BehaviorStatus.Failed);
+    expect(p.tick(1)).toBe(BehaviorStatus.Running);
+    expect(p.tick(1)).toBe(BehaviorStatus.Failed);
 
     p.finalize();
 
@@ -111,7 +111,7 @@ test("policy success-One, failure-One. Succeeding", () => {
 
     p.initialize();
 
-    expect(p.tick()).toBe(BehaviorStatus.Succeeded);
+    expect(p.tick(1)).toBe(BehaviorStatus.Succeeded);
 });
 
 test("policy success-All, failure-One. Succeeding", () => {
@@ -127,8 +127,8 @@ test("policy success-All, failure-One. Succeeding", () => {
 
     p.initialize();
 
-    expect(p.tick()).toBe(BehaviorStatus.Running);
-    expect(p.tick()).toBe(BehaviorStatus.Succeeded);
+    expect(p.tick(1)).toBe(BehaviorStatus.Running);
+    expect(p.tick(1)).toBe(BehaviorStatus.Succeeded);
 });
 
 test("policy success-One, failure-One. Failing", () => {
@@ -144,7 +144,7 @@ test("policy success-One, failure-One. Failing", () => {
 
     p.initialize();
 
-    expect(p.tick()).toBe(BehaviorStatus.Failed);
+    expect(p.tick(1)).toBe(BehaviorStatus.Failed);
 });
 
 test("policy success-One, failure-All. Failing", () => {
@@ -160,6 +160,6 @@ test("policy success-One, failure-All. Failing", () => {
 
     p.initialize();
 
-    expect(p.tick()).toBe(BehaviorStatus.Running);
-    expect(p.tick()).toBe(BehaviorStatus.Failed);
+    expect(p.tick(1)).toBe(BehaviorStatus.Running);
+    expect(p.tick(1)).toBe(BehaviorStatus.Failed);
 });

package/src/engine/intelligence/behavior/composite/SequenceBehavior.spec.js

@@ -0,0 +1,17 @@
+import { SequenceBehavior } from "./SequenceBehavior.js";
+import { SucceedingBehavior } from "../primitive/SucceedingBehavior.js";
+import { BehaviorStatus } from "../BehaviorStatus.js";
+
+test("constructor does not throw", () => {
+    expect(() => new SequenceBehavior()).not.toThrow();
+});
+
+test("succeed in 1 tick with 1 succeeding child", () => {
+
+    const b = SequenceBehavior.from([new SucceedingBehavior()]);
+
+    b.initialize();
+
+    expect(b.tick(1)).toEqual(BehaviorStatus.Succeeded);
+
+});

package/src/engine/intelligence/behavior/primitive/SucceedingBehavior.js

@@ -36,6 +36,8 @@ export class SucceedingBehavior extends Behavior {
             return BehaviorStatus.Running;
         }
     }
+
+    static INSTANCE = new SucceedingBehavior();
 }
 
 SucceedingBehavior.typeName = "SucceedingBehavior";

package/src/engine/knowledge/database/StaticKnowledgeDataTable.d.ts

@@ -1,3 +1,9 @@
-export class StaticKnowledgeDataTable {
+export class StaticKnowledgeDataTable<T> {
+    reset(): void
 
+    size(): number
+
+    get(id: string): T | null
+
+    add(item: T): boolean
 }

package/src/engine/knowledge/database/StaticKnowledgeDataTable.spec.js

@@ -3,3 +3,24 @@ import { StaticKnowledgeDataTable } from "./StaticKnowledgeDataTable.js";
 test("constructor does not throw", () => {
     expect(() => new StaticKnowledgeDataTable()).not.toThrow();
 });
+
+test("resetting empty works as expected", () => {
+    const table = new StaticKnowledgeDataTable();
+
+    table.reset();
+
+    expect(table.size()).toEqual(0);
+});
+
+test("getter", () => {
+
+    const table = new StaticKnowledgeDataTable();
+
+    expect(table.get("x")).toEqual(null);
+
+    const item = { id: "x" };
+
+    table.add(item);
+
+    expect(table.get('x')).toBe(item);
+});

package/src/engine/knowledge/database/StaticKnowledgeDataTableDescriptor.d.ts

@@ -1,7 +1,7 @@
 import {StaticKnowledgeDataTable} from "./StaticKnowledgeDataTable";
 
-export class StaticKnowledgeDataTableDescriptor {
-    public table: StaticKnowledgeDataTable
+export class StaticKnowledgeDataTableDescriptor<T> {
+    public table: StaticKnowledgeDataTable<T>
     public id: string
     public source: string
 }

package/src/engine/logging/ConsoleLoggerBackend.js

@@ -3,6 +3,10 @@ import { LogLevel } from "./LogLevel.js";
 
 let instance;
 
+/**
+ * Directs output into system console
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/console
+ */
 export class ConsoleLoggerBackend extends LoggerBackend {
     log(level, message) {
         switch (level) {

package/src/engine/logging/VoidLoggerBackend.js

@@ -0,0 +1,12 @@
+import { LoggerBackend } from "./LoggerBackend.js";
+
+/**
+ * Non-logging backend, used for testing or when log collection is unwanted
+ */
+export class VoidLoggerBackend extends LoggerBackend {
+    log(level, message) {
+        // do nothing
+    }
+
+    static INSTANCE = new VoidLoggerBackend()
+}

package/src/engine/navigation/ecs/components/computeCatmullRomSpline.js

@@ -1,6 +1,6 @@
 import { assert } from "../../../../core/assert.js";
 import { clamp } from "../../../../core/math/clamp.js";
-import { array_copy } from "../../../../core/collection/array/copyArray.js";
+import { array_copy } from "../../../../core/collection/array/array_copy.js";
 import { computeNonuniformCatmullRomSplineSample } from "./computeNonuniformCatmullRomSplineSample.js";
 
 /**

package/src/engine/navigation/ecs/components/computeCatmullRomSplineUniformDistance.js

@@ -1,5 +1,5 @@
 import { clamp } from "../../../../core/math/clamp.js";
-import { array_copy } from "../../../../core/collection/array/copyArray.js";
+import { array_copy } from "../../../../core/collection/array/array_copy.js";
 import { computeNonuniformCatmullRomSplineSample } from "./computeNonuniformCatmullRomSplineSample.js";
 import { assert } from "../../../../core/assert.js";
 

package/src/engine/physics/cannon/CannonJSPhysicsSystem.js

@@ -5,7 +5,7 @@ import { System } from '../../engine/ecs/System';
 import Transform from '../../engine/ecs/components/Transform';
 import PhysicalBody from '../../engine/ecs/components/PhysicalBody';
 import Vector3 from '../../core/geom/Vector3';
-import Cannon from './cannon.min.js';
+import Cannon from './cannon.min.js'; //TODO replace with package import
 
 
 class CannonPhysicsSystem extends System {

package/src/engine/save/GameStateLoader.js

@@ -26,7 +26,7 @@ class GameStateLoader extends EnginePlugin {
     save(name, resolve, reject, progress) {
         const engine = this.engine;
 
-        const currentScene = engine.sceneManager.currentScene;
+        const currentScene = engine.sceneManager.current_scene;
 
 
         /**

package/src/engine/scene/Scene.d.ts

@@ -1,5 +1,7 @@
 import {EntityComponentDataset} from "../ecs/EntityComponentDataset";
 
 export default class Scene {
+    constructor(name?: string)
+
     public dataset: EntityComponentDataset
 }

package/src/engine/scene/Scene.js

@@ -11,10 +11,10 @@ import { promiseTask } from "../../core/process/task/util/promiseTask.js";
 class Scene {
     /**
      *
-     * @param {string} name
+     * @param {string} [name]
      * @constructor
      */
-    constructor(name) {
+    constructor(name = "Unnamed") {
         /**
          *
          * @type {string}

package/src/engine/scene/Scene.spec.js

@@ -0,0 +1,20 @@
+import Scene from "./Scene.js";
+import { EntityComponentDataset } from "../ecs/EntityComponentDataset.js";
+
+test("constructor should not throw", () => {
+    expect(() => new Scene()).not.toThrow();
+});
+
+test("new scene has it's own dataset", () => {
+    const scene = new Scene();
+
+    expect(scene.dataset).not.toBeNull();
+    expect(scene.dataset).toBeDefined();
+    expect(scene.dataset).toBeInstanceOf(EntityComponentDataset);
+});
+
+test("name properly through constructor", () => {
+    const scene = new Scene("x");
+
+    expect(scene.name).toBe("x");
+});

package/src/engine/scene/SceneManager.d.ts

@@ -1,6 +1,10 @@
 import Scene from "./Scene";
+import {EntityManager} from "../ecs/EntityManager";
 
 export default class SceneManager {
+    readonly current_scene:Scene|null
+    readonly entity_manager: EntityManager
+
     create(name: string): Scene
 
     add(scene: Scene): void

package/src/engine/scene/SceneManager.js

@@ -7,6 +7,34 @@ import List from "../../core/collection/list/List.js";
 
 
 class SceneManager {
+    /**
+     *
+     * @type {Scene|null}
+     */
+    #current_scene = null
+
+    /**
+     *
+     * @return {Scene|null}
+     */
+    get current_scene() {
+        return this.#current_scene;
+    }
+
+    /**
+     *
+     * @type {EntityManager|null}
+     */
+    #entity_manager = null;
+
+    /**
+     *
+     * @return {EntityManager|null}
+     */
+    get entity_manager(){
+        return this.#entity_manager;
+    }
+
     /**
      *
      * @param {EntityManager} entityManager
@@ -14,20 +42,17 @@ class SceneManager {
      * @constructor
      */
     constructor(entityManager, clock) {
-        /**
-         *
-         * @type {Scene|null}
-         */
-        this.currentScene = null;
+
         /**
          * @type {List<Scene>}
          */
         this.scenes = new List();
+
         /**
          *
          * @type {EntityManager}
          */
-        this.entityManager = entityManager;
+        this.#entity_manager = entityManager;
 
         /**
          *
@@ -113,10 +138,10 @@ class SceneManager {
         const scene = this.scenes.get(sceneIndex);
 
 
-        if (this.currentScene === scene) {
+        if (this.#current_scene === scene) {
             this.deactivateCurrentScene();
 
-            this.currentScene = null;
+            this.#current_scene = null;
         }
 
         this.scenes.remove(sceneIndex);
@@ -130,11 +155,11 @@ class SceneManager {
      */
     clear() {
 
-        if (this.currentScene !== null) {
-            this.currentScene.active.set(false);
-            this.entityManager.detachDataSet();
+        if (this.#current_scene !== null) {
+            this.#current_scene.active.set(false);
+            this.#entity_manager.detachDataSet();
 
-            this.currentScene = null;
+            this.#current_scene = null;
         }
 
         return this;
@@ -146,9 +171,7 @@ class SceneManager {
      * @returns {boolean}
      */
     exists(name) {
-        return this.scenes.some(function (scene) {
-            return scene.name === name;
-        });
+        return this.getByName(name) !== undefined;
     }
 
     /**
@@ -170,8 +193,8 @@ class SceneManager {
 
         scene.active.set(false);
 
-        if (this.entityManager.dataset === scene.dataset) {
-            this.entityManager.detachDataSet();
+        if (this.#entity_manager.dataset === scene.dataset) {
+            this.#entity_manager.detachDataSet();
         }
 
         //remove speed modifiers
@@ -200,7 +223,7 @@ class SceneManager {
             console.error(`Exception in pre-activation routine of scene '${scene.id}'`, e);
         }
 
-        const em = this.entityManager;
+        const em = this.#entity_manager;
 
         em.attachDataSet(scene.dataset);
 
@@ -218,7 +241,7 @@ class SceneManager {
             console.error(`Exception in post-activation routine of scene '${scene.id}'`, e);
         }
 
-        this.currentScene = scene;
+        this.#current_scene = scene;
     }
 
     /**
@@ -226,7 +249,7 @@ class SceneManager {
      */
     deactivateCurrentScene() {
 
-        const currentScene = this.currentScene;
+        const currentScene = this.#current_scene;
 
         if (currentScene !== null) {
             this.deactivateScene(currentScene);
@@ -261,12 +284,12 @@ class SceneManager {
             throw new Error(`Scene named '${name}' doesn't exist, valid options are: [${this.scenes.map(s => s.name).join(', ')}]`);
         }
 
-        if (this.currentScene === scene) {
+        if (this.#current_scene === scene) {
             //already at that scene
             return;
         }
 
-        const em = this.entityManager;
+        const em = this.#entity_manager;
 
         // Ensure that all system components are registered
         scene.dataset.registerManyComponentTypes(em.getComponentTypeMap());
@@ -281,7 +304,7 @@ class SceneManager {
      */
     stackPush(id) {
         //take current scene and put it onto the stack
-        this.stack.push(this.currentScene.name);
+        this.stack.push(this.#current_scene.name);
 
         this.set(id);
     }