@woosh/meep-engine 2.49.8 → 2.50.0

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/filtering/numeric/complex/CellFilterAngleToNormal.js

@@ -3,6 +3,12 @@ import Vector3 from "../../../../core/geom/Vector3.js";
 import { assert } from "../../../../core/assert.js";
 import { v3_angle_between } from "../../../../core/geom/v3_angle_between.js";
 
+/**
+ * Distance from the reference point where support points will be sampled to compute derivative
+ * @type {number}
+ */
+const DERIVATIVE_OFFSET = 1;
+
 /**
  * Builds surface normal of another filter, and then computes the angle to a fixed 3d vector
  */
@@ -27,6 +33,7 @@ export class CellFilterAngleToNormal extends CellFilter {
      *
      * @param {CellFilter} surface
      * @param {Vector3} [reference=Vector3.forward]
+     * @returns {CellFilterAngleToNormal}
      */
     static from(surface, reference = Vector3.forward) {
         assert.equal(surface.isCellFilter, true, 'surface.isCellFilter !== true');
@@ -51,12 +58,12 @@ export class CellFilterAngleToNormal extends CellFilter {
         const filter = this.surface;
 
         //read surrounding points
-        const top = filter.execute(grid, x, y - 1, 0);
+        const top = filter.execute(grid, x, y - DERIVATIVE_OFFSET, 0);
 
-        const left = filter.execute(grid, x - 1, y, 0);
-        const right = filter.execute(grid, x + 1, y, 0);
+        const left = filter.execute(grid, x - DERIVATIVE_OFFSET, y, 0);
+        const right = filter.execute(grid, x + DERIVATIVE_OFFSET, y, 0);
 
-        const bottom = filter.execute(grid, x, y + 1, 0);
+        const bottom = filter.execute(grid, x, y + DERIVATIVE_OFFSET, 0);
 
         // compute gradients
         const dX = (right) - (left);

package/src/generation/filtering/numeric/complex/CellFilterAngleToNormal.spec.js

@@ -0,0 +1,30 @@
+import { CellFilterAngleToNormal } from "./CellFilterAngleToNormal.js";
+import { CellFilterLiteralFloat } from "../CellFilterLiteralFloat.js";
+import Vector3 from "../../../../core/geom/Vector3.js";
+import { GridData } from "../../../grid/GridData.js";
+import { DEG_TO_RAD } from "../../../../core/math/DEG_TO_RAD.js";
+
+test("constructor does not throw", () => {
+    expect(() => new CellFilterAngleToNormal()).not.toThrow();
+});
+
+test("angle to flat surface exactly on normal", () => {
+    const data = new GridData();
+
+    const filter = CellFilterAngleToNormal.from(CellFilterLiteralFloat.from(0), new Vector3(0, 0, 1));
+
+    filter.initialize(data, 0);
+
+    expect(filter.execute(data, 0, 0, 0)).toBeCloseTo(0);
+});
+
+test("angle to flat surface at 30deg off normal", () => {
+
+    const data = new GridData();
+
+    const filter = CellFilterAngleToNormal.from(CellFilterLiteralFloat.from(0), new Vector3(0, 0.49999999999999994, 0.8660254037844386));
+
+    filter.initialize(data, 0);
+
+    expect(filter.execute(data, 0, 0, 0)).toBeCloseTo(30 * DEG_TO_RAD);
+})

package/src/generation/filtering/numeric/complex/CellFilterGaussianBlur.js

@@ -47,6 +47,22 @@ function buildKernel(result, samplesX, samplesY, sigma_x, sigma_y) {
     return powerTotal;
 }
 
+/**
+ *
+ * even number of samples, make odd to ensure we sample reference point
+ * @param {number} x
+ * @return {number}
+ */
+function makeNextOdd(x) {
+    if (x % 2 === 0) {
+        // even, make odd
+        return x + 1;
+    }
+
+    // already odd
+    return x;
+}
+
 export class CellFilterGaussianBlur extends CellFilter {
     constructor() {
         super();
@@ -141,8 +157,8 @@ export class CellFilterGaussianBlur extends CellFilter {
 
         r.source = source;
 
-        r.samples_x = max2(2, Math.round(quality * x));
-        r.samples_y = max2(2, Math.round(quality * y));
+        r.samples_x = max2(3, makeNextOdd(Math.round(quality * x)));
+        r.samples_y = max2(3, makeNextOdd(Math.round(quality * y)));
 
         r.size_x = x;
         r.size_y = y;

package/src/generation/filtering/numeric/complex/CellFilterGaussianBlur.spec.js

@@ -0,0 +1,17 @@
+import { CellFilterGaussianBlur } from "./CellFilterGaussianBlur.js";
+import { GridData } from "../../../grid/GridData.js";
+import { CellFilterLiteralFloat } from "../CellFilterLiteralFloat.js";
+
+test("constructor does not throw", () => {
+    expect(() => new CellFilterGaussianBlur()).not.toThrow();
+});
+
+test("sample on constant value source", () => {
+    const data = new GridData();
+
+    const filter = CellFilterGaussianBlur.from(CellFilterLiteralFloat.from(7), 3, 3, 1);
+
+    filter.initialize(data, 0);
+
+    expect(filter.execute(data, 0, 0, 0)).toBeCloseTo(7);
+});

package/src/generation/filtering/numeric/complex/CellFilterSimplexNoise.js

@@ -4,7 +4,7 @@ import { CellFilterAdd } from "../math/algebra/CellFilterAdd.js";
 import { CellFilterMultiply } from "../math/algebra/CellFilterMultiply.js";
 import { CellFilterLiteralFloat } from "../CellFilterLiteralFloat.js";
 import { CellFilterDivide } from "../math/algebra/CellFilterDivide.js";
-import { createNoise2D } from "../../../../core/math/noise/create_noise_2d.js";
+import { create_simplex_noise_2d } from "../../../../core/math/noise/create_simplex_noise_2d.js";
 
 export class CellFilterSimplexNoise extends CellFilter {
     constructor() {
@@ -109,7 +109,7 @@ export class CellFilterSimplexNoise extends CellFilter {
     initialize(grid, seed) {
         this.random.setCurrentSeed(seed + this.__seed);
 
-        this.noise = createNoise2D(this.random);
+        this.noise = create_simplex_noise_2d(this.random);
 
         super.initialize(grid, seed);
     }

package/src/generation/grid/GridData.js

@@ -203,66 +203,6 @@ export class GridData {
         );
     }
 
-    /**
-     *
-     * @param {number} x
-     * @param {number} y
-     * @param {number} mask
-     */
-    clearTags(x, y, mask) {
-
-        const cellIndex = y * this.width + x;
-
-        const current = this.tags[cellIndex];
-
-        const newValue = current & (~mask);
-
-        this.tags[cellIndex] = newValue;
-    }
-
-    /**
-     *
-     * @param {number} x
-     * @param {number} y
-     * @param {number} tags
-     */
-    writeTags(x, y, tags) {
-        const cellIndex = y * this.width + x;
-
-        this.tags[cellIndex] = tags;
-    }
-
-    /**
-     *
-     * @param {number} x
-     * @param {number} y
-     * @param {number} mask
-     */
-    setTags(x, y, mask) {
-
-        const cellIndex = y * this.width + x;
-
-        const current = this.tags[cellIndex];
-
-        const newValue = current | mask;
-
-        this.tags[cellIndex] = newValue;
-    }
-
-    /**
-     *
-     * @param {number} x
-     * @param {number} y
-     * @return {number}
-     */
-    readTags(x, y) {
-        const _x = x | 0;
-        const _y = y | 0;
-
-        const cellIndex = _y * this.width + _x;
-
-        return this.tags[cellIndex];
-    }
 }
 
 

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;