@woosh/meep-engine 2.49.9 → 2.50.0

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);
     }

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

@@ -0,0 +1,107 @@
+import SceneManager from "./SceneManager.js";
+import { EntityManager } from "../ecs/EntityManager.js";
+import Clock from "../Clock.js";
+
+
+function makeSM() {
+    const em = new EntityManager();
+    const clock = new Clock();
+
+    return {
+        manager: new SceneManager(em, clock),
+        entityManager: em
+    };
+}
+
+test("constructor", () => {
+
+    const { manager } = makeSM();
+
+    expect(manager.current_scene).toBeNull();
+});
+
+test("create method", () => {
+
+    const { manager } = makeSM();
+
+    const scene_x = manager.create('x');
+
+    expect(scene_x).toBeDefined();
+    expect(scene_x).not.toBeNull();
+
+    expect(() => manager.create('x')).toThrow();
+
+    const scene_y = manager.create('y');
+
+    expect(scene_y).toBeDefined();
+    expect(scene_y).not.toBeNull();
+
+});
+
+test("getByName", () => {
+    const { manager } = makeSM();
+
+    expect(manager.getByName('x')).toBeUndefined();
+
+    const scene_x = manager.create('x');
+
+    expect(manager.getByName('x')).toBe(scene_x);
+
+    const scene_y = manager.create('y');
+
+    expect(manager.getByName('x')).toBe(scene_x);
+    expect(manager.getByName('y')).toBe(scene_y);
+});
+
+test("remove", () => {
+
+    const { manager } = makeSM();
+
+    expect(manager.remove('x')).toBe(false);
+
+    manager.create('x');
+
+    expect(manager.remove('x')).toBe(true);
+    expect(manager.remove('x')).toBe(false);
+
+});
+
+test("exists", () => {
+
+    const { manager } = makeSM();
+
+    expect(manager.exists('x')).toBe(false);
+
+    manager.create('x');
+
+    expect(manager.exists('x')).toBe(true);
+});
+
+test("set active scene", () => {
+    const { manager, entityManager } = makeSM();
+
+    const scene = manager.create('x');
+
+    manager.set('x');
+
+    expect(manager.current_scene).toBe(scene);
+    expect(entityManager.dataset).toBe(scene.dataset);
+});
+
+test("stack push/pop", () => {
+
+    const { manager } = makeSM();
+
+    const scene_x = manager.create('x');
+    const scene_y = manager.create('y');
+
+    manager.set('x');
+
+    manager.stackPush('y');
+
+    expect(manager.current_scene).toBe(scene_y);
+
+    manager.stackPop();
+
+    expect(manager.current_scene).toBe(scene_x);
+});

package/src/engine/sound/material/detector/terrain/TerrainSoundMaterialSurfaceDetector.js

@@ -5,7 +5,7 @@ import { SilentSoundMaterial } from "../../concrete/SilentSoundMaterial.js";
 import { SingleSoundMaterial } from "../../concrete/SingleSoundMaterial.js";
 import { deserializeSoundMaterialFromJSON } from "../../concrete/json/deserializeSoundMaterialFromJSON.js";
 import { assert } from "../../../../../core/assert.js";
-import { normalizeArrayVector } from "../../../../../core/math/normalizeArrayVector.js";
+import { vector_nd_normalize } from "../../../../../core/math/vector_nd_normalize.js";
 
 const v2_temp = new Vector2();
 
@@ -112,7 +112,7 @@ export class TerrainSoundMaterialSurfaceDetector extends SoundMaterialSurfaceDet
 
         }
 
-        normalizeArrayVector(this.__composite.weights, this.__composite.weights, layer_count);
+        vector_nd_normalize(this.__composite.weights, this.__composite.weights, layer_count);
 
         const additions = this.__composite.computeInteractionSounds(result, 0, interaction);
 

package/src/engine/ui/GUIEngine.js

@@ -462,7 +462,7 @@ GUIEngine.prototype.getActiveSceneContext = function () {
 
     const sm = engine.sceneManager;
 
-    const scene = sm.currentScene;
+    const scene = sm.current_scene;
 
     if (scene === null) {
         return null;

package/src/generation/grid/generation/util/buildUnsignedDistanceField.js

@@ -1,5 +1,7 @@
-import { computeUnsignedDistanceField } from "../../../../engine/graphics/texture/sampler/distanceField.js";
 import { Sampler2D } from "../../../../engine/graphics/texture/sampler/Sampler2D.js";
+import {
+    computeUnsignedDistanceField
+} from "../../../../engine/graphics/texture/sampler/distance/computeUnsignedDistanceField.js";
 
 /**
  *

package/src/generation/markers/MarkerNode.js

@@ -1,7 +1,7 @@
 import Vector2 from "../../core/geom/Vector2.js";
 import { Transform } from "../../engine/ecs/transform/Transform.js";
-import { copyArray } from "../../core/collection/array/copyArray.js";
 import { circleIntersectsCircle } from "../../core/geom/2d/circle/circleIntersectsCircle.js";
+import { array_copy_entire } from "../../core/collection/array/array_copy_entire.js";
 
 export class MarkerNode {
     constructor() {
@@ -95,7 +95,7 @@ export class MarkerNode {
     copy(other) {
         this.type = other.type;
 
-        copyArray(other.tags, this.tags);
+        array_copy_entire(other.tags, this.tags);
 
         this.position.copy(other.position);
 

package/src/generation/theme/AreaMask.js

@@ -1,6 +1,8 @@
 import { Sampler2D } from "../../engine/graphics/texture/sampler/Sampler2D.js";
 import AABB2 from "../../core/geom/2d/aabb/AABB2.js";
-import { computeUnsignedDistanceField } from "../../engine/graphics/texture/sampler/distanceField.js";
+import {
+    computeUnsignedDistanceField
+} from "../../engine/graphics/texture/sampler/distance/computeUnsignedDistanceField.js";
 
 export class AreaMask {
     constructor() {

package/src/view/elements/progress/RectangularPieProgressView.js

@@ -1,7 +1,9 @@
 import View from "../../View.js";
 import SVG from "../../SVG.js";
-import { line2_line2_intersection } from "../../../core/geom/2d/LineSegment2.js";
 import Vector1 from "../../../core/geom/Vector1.js";
+import {
+    line_segment_compute_line_segment_intersection_array_2d
+} from "../../../core/geom/2d/line/line_segment_compute_line_segment_intersection_array_2d.js";
 
 export class RectangularPieProgressView extends View {
 
@@ -76,31 +78,31 @@ export class RectangularPieProgressView extends View {
 
         if (fraction < .125) {
 
-            line2_line2_intersection(p, 0, 0, size_x, 0, center_x, center_y, line_x, line_y);
+            line_segment_compute_line_segment_intersection_array_2d(p, 0, 0, 0, size_x, 0, center_x, center_y, line_x, line_y);
 
             path = `M ${center_x} 0 L ${center_x} ${center_y} L ${p[0]} ${p[1]} L ${size_x} 0 L ${size_x} ${size_y} L 0 ${size_y} L 0 0 Z`;
 
         } else if (fraction < 0.375) {
 
-            line2_line2_intersection(p, size_x, 0, size_x, size_y, center_x, center_y, line_x, line_y);
+            line_segment_compute_line_segment_intersection_array_2d(p, 0, size_x, 0, size_x, size_y, center_x, center_y, line_x, line_y);
 
             path = `M ${center_x} 0 L ${center_x} ${center_y} L ${p[0]} ${p[1]} L ${size_x} ${size_y} L 0 ${size_y} L 0 0 Z`;
 
         } else if (fraction < 0.625) {
 
-            line2_line2_intersection(p, size_x, size_y, 0, size_y, center_x, center_y, line_x, line_y);
+            line_segment_compute_line_segment_intersection_array_2d(p, 0, size_x, size_y, 0, size_y, center_x, center_y, line_x, line_y);
 
             path = `M ${center_x} 0 L ${center_x} ${center_y} L ${p[0]} ${p[1]} L 0 ${size_y} L 0 0 Z`;
 
         } else if (fraction < 0.875) {
 
-            line2_line2_intersection(p, 0, size_y, 0, 0, center_x, center_y, line_x, line_y);
+            line_segment_compute_line_segment_intersection_array_2d(p, 0, 0, size_y, 0, 0, center_x, center_y, line_x, line_y);
 
             path = `M ${center_x} 0 L ${center_x} ${center_y} L ${p[0]} ${p[1]} L 0 0 Z`;
 
         } else {
 
-            line2_line2_intersection(p, 0, 0, size_x, 0, center_x, center_y, line_x, line_y);
+            line_segment_compute_line_segment_intersection_array_2d(p, 0, 0, 0, size_x, 0, center_x, center_y, line_x, line_y);
 
             path = `M ${center_x} 0 L ${center_x} ${center_y} L ${p[0]} ${p[1]} Z`;
 

package/src/core/geom/2d/LineSegment2.js

@@ -1,175 +0,0 @@
-/**
- * 2-D line Mathematics
- * @author Alex Goldring 2019
- * @copyright Alex Goldring 2019
- */
-
-/**
- *
- * @constructor
- */
-function LineSegment2() {
-
-}
-
-/**
- * @param {Vector2} p0
- * @param {Vector2} p1
- * @param {Vector2} p2
- * @param {Vector2} p3
- * @returns {[number,number]}
- */
-export function computeLine2Intersection(p0, p1, p2, p3) {
-    const p0_x = p0.x;
-    const p0_y = p0.y;
-    const p1_x = p1.x;
-    const p1_y = p1.y;
-    const p2_x = p2.x;
-    const p2_y = p2.y;
-    const p3_x = p3.x;
-    const p3_y = p3.y;
-
-    const result = [];
-
-    if (line2_line2_intersection(result, p0_x, p0_y, p1_x, p1_y, p2_x, p2_y, p3_x, p3_y)) {
-        return result;
-    } else {
-        return null; // No collision
-    }
-
-}
-
-/**
- *
- * @param {number[]} result
- * @param {number} a0_x
- * @param {number} a0_y
- * @param {number} a1_x
- * @param {number} a1_y
- * @param {number} b2_x
- * @param {number} b2_y
- * @param {number} b3_x
- * @param {number} b3_y
- * @return {boolean}
- */
-export function line2_line2_intersection(result, a0_x, a0_y, a1_x, a1_y, b2_x, b2_y, b3_x, b3_y) {
-
-    const s1_x = a1_x - a0_x;
-    const s1_y = a1_y - a0_y;
-    const s2_x = b3_x - b2_x;
-    const s2_y = b3_y - b2_y;
-
-    const dy_02 = a0_y - b2_y;
-    const dx_02 = a0_x - b2_x;
-
-    const denom = -s2_x * s1_y + s1_x * s2_y;
-
-    const s = (-s1_y * dx_02 + s1_x * dy_02) / denom;
-    const t = (s2_x * dy_02 - s2_y * dx_02) / denom;
-
-    if (s >= 0 && s <= 1 && t >= 0 && t <= 1) {
-        // Collision detected
-
-        const intX = a0_x + (t * s1_x);
-        const intY = a0_y + (t * s1_y);
-
-        result[0] = intX;
-        result[1] = intY;
-
-        return true;
-    }
-
-    return false; // No collision
-}
-
-/**
- * Adapted from answer by iMalc from stackoverflow.com "how do you detect where two line segments intersect"
- * @link https://stackoverflow.com/questions/563198/how-do-you-detect-where-two-line-segments-intersect
- * @param {Vector2} a0 start of first segment
- * @param {Vector2} a1 end of first segment
- * @param {Vector2} b0 start of second segment
- * @param {Vector2} b1 end of second segment
- * @param {Vector2} result resulting intersection point will be stored here if intersection exists
- * @returns {boolean} True if segments intersect, False otherwise
- */
-function intersectionPoint(a0, a1, b0, b1, result) {
-    return intersectionPointRaw(a0.x, a0.y, a1.x, a1.y, b0.x, b0.y, b1.x, b1.y, result);
-}
-
-/**
- *
- * @param {number} a0_x
- * @param {number} a0_y
- * @param {number} a1_x
- * @param {number} a1_y
- * @param {number} b0_x
- * @param {number} b0_y
- * @param {number} b1_x
- * @param {number} b1_y
- * @returns {boolean} True if segments intersect, False otherwise
- * @public
- */
-export function line2SegmentsIntersect(a0_x, a0_y, a1_x, a1_y, b0_x, b0_y, b1_x, b1_y) {
-    const s1_x = a1_x - a0_x;
-    const s1_y = a1_y - a0_y;
-    const s2_x = b1_x - b0_x;
-    const s2_y = b1_y - b0_y;
-
-
-    const denom = (-s2_x * s1_y + s1_x * s2_y);
-
-    const dy0_ab = a0_y - b0_y;
-    const dx0_ab = a0_x - b0_x;
-
-    const s = (-s1_y * dx0_ab + s1_x * dy0_ab) / denom;
-    const t = (s2_x * dy0_ab - s2_y * dx0_ab) / denom;
-
-    return s >= 0 && s <= 1 && t >= 0 && t <= 1;
-}
-
-
-/**
- *
- * @param {number} a0_x
- * @param {number} a0_y
- * @param {number} a1_x
- * @param {number} a1_y
- * @param {number} b0_x
- * @param {number} b0_y
- * @param {number} b1_x
- * @param {number} b1_y
- * @param {Vector2} result resulting intersection point will be stored here if intersection exists
- * @returns {boolean} True if segments intersect, False otherwise
- * @public
- */
-function intersectionPointRaw(a0_x, a0_y, a1_x, a1_y, b0_x, b0_y, b1_x, b1_y, result) {
-    const s1_x = a1_x - a0_x;
-    const s1_y = a1_y - a0_y;
-    const s2_x = b1_x - b0_x;
-    const s2_y = b1_y - b0_y;
-
-
-    const denom = (-s2_x * s1_y + s1_x * s2_y);
-
-    const s = (-s1_y * (a0_x - b0_x) + s1_x * (a0_y - b0_y)) / denom;
-    const t = (s2_x * (a0_y - b0_y) - s2_y * (a0_x - b0_x)) / denom;
-
-    if (s >= 0 && s <= 1 && t >= 0 && t <= 1) {
-        // Collision detected
-
-        const i_x = a0_x + (t * s1_x);
-        const i_y = a0_y + (t * s1_y);
-
-        result.set(i_x, i_y);
-
-        return true;
-    }
-
-
-    return false;
-}
-
-LineSegment2.intersectionPoint = intersectionPoint;
-LineSegment2.intersectionPointRaw = intersectionPointRaw;
-
-export default LineSegment2;