@woosh/meep-engine 2.49.7 → 2.49.8

package/src/core/geom/2d/Rectangle.spec.js

@@ -1,4 +1,19 @@
 import Rectangle from "./Rectangle.js";
+import Vector2 from "../Vector2.js";
+
+test("constructor", () => {
+    expect(() => new Rectangle()).not.toThrow();
+});
+
+test("default constructor produces 0 size rectangle with valid position", () => {
+    const r = new Rectangle();
+
+    expect(r.size.x).toBe(0);
+    expect(r.size.y).toBe(0);
+
+    expect(r.position.x).not.toBeNaN();
+    expect(r.position.y).not.toBeNaN();
+});
 
 test("toArray works correctly", () => {
     const v = new Rectangle(1, 2, 3, 4);
@@ -9,3 +24,39 @@ test("toArray works correctly", () => {
 
     expect(actual).toEqual([1, 2, 3, 4]);
 });
+
+test("toJSON", () => {
+    const r = new Rectangle(1, 3, 7, 11);
+
+    expect(r.toJSON()).toEqual({
+        position: { x: 1, y: 3 },
+        size: { x: 7, y: 11 }
+    });
+});
+
+test("fromJSON", () => {
+
+    const r = new Rectangle();
+
+    r.fromJSON({
+        position: { x: 1, y: 3 },
+        size: { x: 7, y: 11 }
+    });
+
+    expect(r.position.x).toBe(1);
+    expect(r.position.y).toBe(3);
+
+    expect(r.size.x).toBe(7);
+    expect(r.size.y).toBe(11);
+});
+
+test("computeCenter", () => {
+    const r = new Rectangle(1, 3, 7, 11);
+
+    const center = new Vector2();
+
+    r.computeCenter(center);
+
+    expect(center.x).toBe(4.5);
+    expect(center.y).toBe(8.5);
+});

package/src/core/geom/3d/aabb/aabb3_intersects_ray.spec.js

@@ -1,6 +1,96 @@
 import { seededRandom } from "../../../math/random/seededRandom.js";
 import { aabb3_intersects_ray } from "./aabb3_intersects_ray.js";
 
+test("axis aligned ray on X", () => {
+    expect(aabb3_intersects_ray(
+        -0.5, -0.5, -0.5,
+        +0.5, +0.5, +0.5,
+        -1, 0, 0,
+        1, 0, 0
+    )).toBe(true);
+
+    expect(aabb3_intersects_ray(
+        -0.5, -0.5, -0.5,
+        +0.5, +0.5, +0.5,
+        -1, 0, 0,
+        -1, 0, 0
+    )).toBe(false);
+
+    expect(aabb3_intersects_ray(
+        -0.5, -0.5, -0.5,
+        +0.5, +0.5, +0.5,
+        1, 0, 0,
+        -1, 0, 0
+    )).toBe(true);
+
+    expect(aabb3_intersects_ray(
+        -0.5, -0.5, -0.5,
+        +0.5, +0.5, +0.5,
+        1, 0, 0,
+        1, 0, 0
+    )).toBe(false);
+});
+
+test("axis aligned ray on Y", () => {
+    expect(aabb3_intersects_ray(
+        -0.5, -0.5, -0.5,
+        +0.5, +0.5, +0.5,
+        0, -1, 0,
+        0, 1, 0
+    )).toBe(true);
+
+    expect(aabb3_intersects_ray(
+        -0.5, -0.5, -0.5,
+        +0.5, +0.5, +0.5,
+        0, -1, 0,
+        0, -1, 0
+    )).toBe(false);
+
+    expect(aabb3_intersects_ray(
+        -0.5, -0.5, -0.5,
+        +0.5, +0.5, +0.5,
+        0, 1, 0,
+        0, -1, 0
+    )).toBe(true);
+
+    expect(aabb3_intersects_ray(
+        -0.5, -0.5, -0.5,
+        +0.5, +0.5, +0.5,
+        0, 1, 0,
+        0, 1, 0
+    )).toBe(false);
+});
+
+test("axis aligned ray on Z", () => {
+    expect(aabb3_intersects_ray(
+        -0.5, -0.5, -0.5,
+        +0.5, +0.5, +0.5,
+        0, 0, -1,
+        0, 0, 1
+    )).toBe(true);
+
+    expect(aabb3_intersects_ray(
+        -0.5, -0.5, -0.5,
+        +0.5, +0.5, +0.5,
+        0, 0, -1,
+        0, 0, -1
+    )).toBe(false);
+
+    expect(aabb3_intersects_ray(
+        -0.5, -0.5, -0.5,
+        +0.5, +0.5, +0.5,
+        0, 0, 1,
+        0, 0, -1
+    )).toBe(true);
+
+    expect(aabb3_intersects_ray(
+        -0.5, -0.5, -0.5,
+        +0.5, +0.5, +0.5,
+        0, 0, 1,
+        0, 0, 1
+    )).toBe(false);
+});
+
 test.skip("performance raycast", () => {
     const rng = seededRandom(42);
 

package/src/core/geom/3d/line/line3_compute_nearest_point_to_point.spec.js

@@ -0,0 +1,61 @@
+import { line3_compute_nearest_point_to_point } from "./line3_compute_nearest_point_to_point.js";
+
+test("aligned with the start of the line", () => {
+    const result = [];
+
+    line3_compute_nearest_point_to_point(result, 0,
+        1, 3, 7, 11, 13, 17,
+        1, 3, 7
+    );
+
+    expect(result).toEqual([1, 3, 7])
+});
+
+test("aligned with the end of the line", () => {
+    const result = [];
+
+    line3_compute_nearest_point_to_point(result, 0,
+        1, 3, 7, 11, 13, 17,
+        11, 13, 17
+    );
+
+    expect(result).toEqual([11, 13, 17])
+});
+
+test("ref point is on line past line ends", () => {
+
+    const result = [];
+
+    line3_compute_nearest_point_to_point(result, 0,
+        -1, 0, 0, 3, 0, 0,
+        -2, 0, 0
+    );
+
+    expect(result).toEqual([-1, 0, 0])
+
+    line3_compute_nearest_point_to_point(result, 0,
+        -1, 0, 0, 3, 0, 0,
+        7, 0, 0
+    );
+
+    expect(result).toEqual([3, 0, 0])
+});
+
+test("ref point is on the line", () => {
+
+    const result = [];
+
+    line3_compute_nearest_point_to_point(result, 0,
+        -1, 0, 0, 3, 0, 0,
+        1, 0, 0
+    );
+
+    expect(result).toEqual([1, 0, 0])
+
+    line3_compute_nearest_point_to_point(result, 0,
+        -1, 0, 0, 3, 0, 0,
+        2, 0, 0
+    );
+
+    expect(result).toEqual([2, 0, 0])
+});

package/src/core/geom/3d/morton/mortonEncode_magicbits.js

@@ -1,37 +1,4 @@
-/**
- * method to separate bits from a given integer 3 positions apart
- * we only look at the first 10 bits
- *
- * @example when input is ABC, output bits are A00B00C
- * @param {number} a
- * @returns {number}
- */
-function split_by_3(a) {
-    let x = a;
-    x = (x | x << 16) & 0x30000ff;
-    x = (x | x << 8) & 0x0300f00f;
-    x = (x | x << 4) & 0x30c30c3;
-    x = (x | x << 2) & 0x9249249;
-    return x;
-}
-
-/**
- * method to separate bits from a given integer 2 positions apart
- *
- * @example when input is ABC, output bits are A00B00C
- * @see https://github.com/Forceflow/libmorton/blob/234a443ca8e2c64f6385f1a9d6ee10a70d08a3fa/include/libmorton/morton2D.h#L99
- * @param {number} a
- * @returns {number}
- */
-export function split_by_2(a) {
-    let x = a;
-    x = (x | x << 16) & 0x0000FFFF;
-    x = (x | x << 8) & 0x00FF00FF;
-    x = (x | x << 4) & 0x0F0F0F0F;
-    x = (x | x << 2) & 0x33333333;
-    x = (x | x << 1) & 0x55555555;
-    return x;
-}
+import { split_by_3 } from "./split_by_3.js";
 
 /**
  * Based on article and C++ source code:

package/src/core/geom/3d/morton/split_by_2.js

@@ -0,0 +1,17 @@
+/**
+ * method to separate bits from a given integer 2 positions apart
+ *
+ * @example when input is ABC, output bits are A00B00C
+ * @see https://github.com/Forceflow/libmorton/blob/234a443ca8e2c64f6385f1a9d6ee10a70d08a3fa/include/libmorton/morton2D.h#L99
+ * @param {number} a
+ * @returns {number}
+ */
+export function split_by_2(a) {
+    let x = a;
+    x = (x | x << 16) & 0x0000FFFF;
+    x = (x | x << 8) & 0x00FF00FF;
+    x = (x | x << 4) & 0x0F0F0F0F;
+    x = (x | x << 2) & 0x33333333;
+    x = (x | x << 1) & 0x55555555;
+    return x;
+}

package/src/core/geom/3d/morton/split_by_3.js

@@ -0,0 +1,16 @@
+/**
+ * method to separate bits from a given integer 3 positions apart
+ * we only look at the first 10 bits
+ *
+ * @example when input is ABC, output bits are A00B00C
+ * @param {number} a
+ * @returns {number}
+ */
+export function split_by_3(a) {
+    let x = a;
+    x = (x | x << 16) & 0x30000ff;
+    x = (x | x << 8) & 0x0300f00f;
+    x = (x | x << 4) & 0x30c30c3;
+    x = (x | x << 2) & 0x9249249;
+    return x;
+}

package/src/core/geom/3d/plane/computePlaneLineIntersection.js

@@ -15,7 +15,12 @@ import { v3_dot } from "../../v3_dot.js";
  * @param {number} dist Plane distance
  * @returns {boolean} true if intersection is found, false otherwise
  */
-export function computePlaneLineIntersection(out, originX, originY, originZ, directionX, directionY, directionZ, normalX, normalY, normalZ, dist) {
+export function computePlaneLineIntersection(
+    out,
+    originX, originY, originZ,
+    directionX, directionY, directionZ,
+    normalX, normalY, normalZ, dist
+) {
     const denom = v3_dot(directionX, directionY, directionZ, normalX, normalY, normalZ);
 
     const p = v3_dot(normalX, normalY, normalZ, originX, originY, originZ) + dist;

package/src/core/geom/3d/sphere/sphere_intersects_ray.spec.js

@@ -47,3 +47,14 @@ test("ray from +Z to -Z intersects sphere", () => {
         0, 0, -1
     )).toBe(true);
 });
+
+
+// negative cases
+
+test("ray from -X to -X", () => {
+    expect(sphere_intersects_ray(
+        0, 0, 0, 1,
+        -2, 0, 0,
+        -1, 0, 0
+    )).toBe(false);
+});

package/src/core/geom/3d/sphere/sphere_radius_sqr_from_v3_array_transformed.spec.js

@@ -0,0 +1,8 @@
+import { sphere_radius_sqr_from_v3_array_transformed } from "./sphere_radius_sqr_from_v3_array_transformed.js";
+import { MATRIX_4_IDENTITY } from "../matrix/MATRIX_4_IDENTITY.js";
+
+test("base case", () => {
+    expect(sphere_radius_sqr_from_v3_array_transformed([0, 0, 0], 3, MATRIX_4_IDENTITY)).toBe(0);
+    expect(sphere_radius_sqr_from_v3_array_transformed([1, 0, 0], 3, MATRIX_4_IDENTITY)).toBe(1);
+    expect(sphere_radius_sqr_from_v3_array_transformed([-1, 0, 0], 3, MATRIX_4_IDENTITY)).toBe(1);
+});

package/src/core/geom/3d/topology/samples/sampleFloodFill.js

@@ -9,7 +9,7 @@ import { topo_mesh_to_three_buffer_geometry } from "../topo_mesh_to_three_buffer
 import { three_buffer_geometry_to_topo_mesh } from "../three_buffer_geometry_to_topo_mesh.js";
 import { mesh_flood_fill } from "../util/mesh_flood_fill.js";
 import { compute_aabb_from_points } from "../../aabb/compute_aabb_from_points.js";
-import { AABB3 } from "../../../../bvh2/aabb3/AABB3.js";
+import { AABB3 } from "../../../../geom/3d/aabb/AABB3.js";
 import { mergeVertices } from "three/examples/jsm/utils/BufferGeometryUtils.js";
 import { makeGeometryIndexed } from "../../../../../engine/graphics/geometry/buffered/makeGeometryIndexed.js";
 import { v3_dot } from "../../../v3_dot.js";
@@ -23,10 +23,10 @@ import { SGMeshEvents } from "../../../../../engine/graphics/ecs/mesh-v2/aggrega
 import { Color } from "../../../../color/Color.js";
 import { seededRandom } from "../../../../math/random/seededRandom.js";
 import { expandConnectivityByLocality } from "../expandConnectivityByLocality.js";
-import { buildCubeURLs } from "../../../../../engine/graphics/texture/cubemap/buildCubeURLs.js";
 import { EntityNode } from "../../../../../engine/ecs/parent/EntityNode.js";
 import { TransformAttachmentSystem } from "../../../../../engine/ecs/transform-attachment/TransformAttachmentSystem.js";
 import { make_ray_from_viewport_position } from "../../../../../engine/graphics/make_ray_from_viewport_position.js";
+import { load_and_set_cubemap_v0 } from "../../../../../engine/graphics/load_and_set_cubemap_v0.js";
 
 const harness = new EngineHarness();
 
@@ -98,7 +98,7 @@ async function main(engine) {
         enableTerrain: false
     });
 
-    engine.graphics.loadEnvironmentMap(buildCubeURLs('data/textures/cubemaps/hip_miramar/32/', '.png'));
+    load_and_set_cubemap_v0(engine.graphics,'data/textures/cubemaps/hip_miramar/32/', '.png')
 
     const path = 'data/models/sponza-pbr/gltf/sponza.glb';
 

package/src/core/geom/3d/topology/struct/binary/io/OrderedEdge.js

@@ -1,4 +1,4 @@
-import { split_by_2 } from "../../../../morton/mortonEncode_magicbits.js";
+import { split_by_2 } from "../../../../morton/split_by_2.js";
 
 export class OrderedEdge {
     /**

package/src/core/geom/random/randomPointOnBox.spec.js

@@ -0,0 +1,57 @@
+import { randomPointOnBox } from "./randomPointOnBox.js";
+
+function assert_point_on_box(sample) {
+
+    const x = sample[0];
+    const y = sample[1];
+    const z = sample[2];
+
+    function assert_range(v) {
+        expect(v).toBeGreaterThanOrEqual(-0.5);
+        expect(v).toBeLessThanOrEqual(0.5);
+    }
+
+    if (Math.abs(x) === 0.5 && Math.abs(y) === 0.5) {
+        assert_range(z);
+    } else if (Math.abs(x) === 0.5 && Math.abs(z) === 0.5) {
+        assert_range(y);
+    } else if (Math.abs(y) === 0.5 && Math.abs(z) === 0.5) {
+        assert_range(x);
+    } else if (Math.abs(x) === 0.5) {
+        assert_range(y);
+        assert_range(z);
+    } else if (Math.abs(y) === 0.5) {
+        assert_range(x);
+        assert_range(z);
+    } else if (Math.abs(z) === 0.5) {
+        assert_range(y);
+        assert_range(x);
+    } else {
+        throw new Error(`Unexpected ${sample}`);
+    }
+
+}
+
+test("samples are on box shell", () => {
+    function validate(sample_value) {
+
+        const sample = [];
+
+        randomPointOnBox(() => sample_value, sample, 0);
+
+        assert_point_on_box(sample);
+    }
+
+    validate(0);
+    validate(1);
+
+    validate(0.1);
+    validate(0.2);
+    validate(0.3);
+    validate(0.4);
+    validate(0.5);
+    validate(0.6);
+    validate(0.7);
+    validate(0.8);
+    validate(0.9);
+});

package/src/engine/Engine.d.ts

@@ -12,7 +12,9 @@ import {EnginePluginManager} from "./plugin/EnginePluginManager";
 import ConcurrentExecutor from "../core/process/executor/ConcurrentExecutor";
 
 export interface IEngineInitializationOptions {
-    entityManager?: EntityManager
+    entityManager?: EntityManager,
+    enableAudio?: boolean
+    enableGraphics?: boolean
 }
 
 export default class Engine {
@@ -25,7 +27,7 @@ export default class Engine {
     public readonly sound: SoundEngine
     public readonly graphics: GraphicsEngine
     public readonly devices: { keyboard: KeyboardDevice, pointer: PointerDevice }
-    public readonly assetManager: AssetManager
+    public readonly assetManager: AssetManager<Engine>
     public readonly ticker: Ticker
     public readonly plugins: EnginePluginManager
     public readonly executor: ConcurrentExecutor

package/src/engine/Engine.js

@@ -5,7 +5,6 @@
 import ConcurrentExecutor from '../core/process/executor/ConcurrentExecutor.js';
 
 import { AssetManager } from './asset/AssetManager.js';
-import InputEngine from './InputEngine.js';
 import { GraphicsEngine } from './graphics/GraphicsEngine.js';
 import SoundEngine from './sound/SoundEngine.js';
 import { PerspectiveCamera as ThreePerspectiveCamera } from 'three';
@@ -49,9 +48,15 @@ class Engine {
      *
      * @param {EnginePlatform} platform
      * @param {EntityManager} [entityManager]
+     * @param enableGraphics
+     * @param enableAudio
      * @constructor
      */
-    constructor(platform, { entityManager } = {}) {
+    constructor(platform, {
+        entityManager,
+        enableGraphics = true,
+        enableAudio = true
+    } = {}) {
         assert.defined(platform, 'platform');
 
         /**
@@ -105,7 +110,7 @@ class Engine {
          * @type {AssetManager<Engine>}
          */
         this.assetManager = new AssetManager({
-            context:this,
+            context: this,
             executor: this.executor
         });
 
@@ -159,11 +164,6 @@ class Engine {
             });
         }
 
-
-        this.initialize();
-    }
-
-    initialize() {
         // initialize performance metrics
         this.performance.create({
             name: METRIC_ID_RENDER
@@ -218,29 +218,39 @@ class Engine {
         this.camera = new ThreePerspectiveCamera(45, innerWidth / innerHeight, 1, 50);
 
 
-        /**
-         *
-         * @type {GraphicsEngine}
-         */
-        const ge = this.graphics = new GraphicsEngine(this.camera, this.entityManager);
+        if (enableGraphics !== false) {
 
-        try {
-            ge.start();
-        } catch (e) {
-            logger.info("Failed to start GraphicEngine: ", e);
-        }
+            const graphicsEngine = new GraphicsEngine(this.camera, this.entityManager);
 
-        this.inputEngine = new InputEngine(ge.domElement, window);
+            /**
+             *
+             * @type {GraphicsEngine}
+             */
+            this.graphics = graphicsEngine;
 
-        //sound engine
-        const soundEngine = new SoundEngine();
-        soundEngine.volume = 1;
+            try {
+                graphicsEngine.start();
+            } catch (e) {
+                logger.info("Failed to start GraphicEngine: ", e);
+            }
 
-        /**
-         *
-         * @type {SoundEngine}
-         */
-        this.sound = soundEngine;
+        } else {
+            logger.info('enableGraphics option is not set, no graphics engine will be created');
+        }
+
+        if (enableAudio !== false) {
+            //sound engine
+            const soundEngine = new SoundEngine();
+            soundEngine.volume = 1;
+
+            /**
+             *
+             * @type {SoundEngine}
+             */
+            this.sound = soundEngine;
+        } else {
+            logger.info('enableAudio option is not set, no audio engine will be created');
+        }
 
         /**
          * Graphical User Interface engine
@@ -281,14 +291,20 @@ class Engine {
         this.plugins.initialize(this);
     }
 
+
+    get inputEngine() {
+        throw new Error('Deprecated, use .devices instead');
+    }
+
+    /**
+     * @deprecated
+     */
     get grid() {
         throw new Error('Deprecated, use systems/components to achieve the same functionality as before');
     }
 
     initializeViews() {
 
-        const viewport = this.graphics.viewport;
-
         const gameView = new EmptyView();
 
         gameView.addClass('game-view');
@@ -299,23 +315,28 @@ class Engine {
             position: "absolute",
             pointerEvents: "none"
         });
-
-        viewport.css({
-            pointerEvents: "auto"
-        });
-
         this.gameView = gameView;
 
-        gameView.addChild(viewport);
 
         this.viewStack = new ViewStack();
-        this.viewStack.push(gameView,'game-view');
+        this.viewStack.push(gameView, 'game-view');
 
-        //bind size of renderer viewport to game view
-        viewport.bindSignal(gameView.size.onChanged, viewport.size.set.bind(viewport.size));
-        gameView.on.linked.add(function () {
-            viewport.size.copy(gameView.size);
-        });
+        if (this.graphics !== undefined) {
+
+            const viewport = this.graphics.viewport;
+
+            viewport.css({
+                pointerEvents: "auto"
+            });
+
+            gameView.addChild(viewport);
+            //bind size of renderer viewport to game view
+            viewport.bindSignal(gameView.size.onChanged, viewport.size.set.bind(viewport.size));
+            gameView.on.linked.add(function () {
+                viewport.size.copy(gameView.size);
+            });
+
+        }
     }
 
     initializeSettings() {

package/src/engine/Engine.spec.js

@@ -0,0 +1,11 @@
+import Engine from "./Engine.js";
+import { InMemoryEnginePlatform } from "./platform/InMemoryEnginePlatform.js";
+
+test("constructor does not throw", () => {
+    const platform = new InMemoryEnginePlatform();
+
+    expect(() => new Engine(platform, {
+        enableAudio: false,
+        enableGraphics: false
+    })).not.toThrow();
+});

package/src/engine/InputEngine.js

@@ -4,8 +4,20 @@
  * 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 = {};
 

package/src/engine/graphics/GraphicsEngine.js

@@ -36,7 +36,6 @@ import { MaterialManager } from "./material/manager/MaterialManager.js";
 import { ShadowMapRenderer } from "./shadows/ShadowMapRenderer.js";
 import { CameraViewManager } from "./render/view/CameraViewManager.js";
 import { StandardFrameBuffers } from "./StandardFrameBuffers.js";
-import { load_environment_map } from "./texture/cubemap/load_environment_map.js";
 import { CompositingStages } from "./composit/CompositingStages.js";
 import { DEG_TO_RAD } from "../../core/math/DEG_TO_RAD.js";
 
@@ -256,22 +255,12 @@ GraphicsEngine.prototype.getRenderer = function () {
 };
 
 /**
- *
+ * @deprecated
  * @param {string[]|string} paths URLs to faces of the cubemap
  * @returns {Promise<Texture>}
  */
 GraphicsEngine.prototype.loadEnvironmentMap = async function (paths) {
-
-    const { filtered } = await load_environment_map({
-        path: paths,
-        renderer: this.renderer,
-        original: false,
-        filtered: true
-    });
-
-    this.scene.environment = filtered;
-
-    return filtered;
+    throw new Error('Deprecated use `load_and_set_cubemap_v0` instead');
 }
 
 GraphicsEngine.prototype.updateSize = function () {