@woosh/meep-engine 2.49.7 → 2.49.9

package/src/core/math/physics/irradiance/interpolate_irradiance_smith.js

@@ -8,7 +8,7 @@
  */
 export function interpolate_irradiance_smith(distance, min, max) {
 
-    if (distance < min) {
+    if (distance <= min) {
         return 1;
     } else if (distance > max) {
         return 0;

package/src/core/math/physics/irradiance/interpolate_irradiance_smith.spec.js

@@ -0,0 +1,20 @@
+import { interpolate_irradiance_smith } from "./interpolate_irradiance_smith.js";
+
+test("sanity check", () => {
+
+    expect(interpolate_irradiance_smith(3, 3, 3)).toBe(1);
+
+    expect(interpolate_irradiance_smith(3, 3, 7)).toBe(1);
+
+    expect(interpolate_irradiance_smith(7, 3, 7)).toBe(0);
+
+    expect(interpolate_irradiance_smith(0, 3, 7)).toBe(1);
+
+    expect(interpolate_irradiance_smith(11, 3, 7)).toBe(0);
+
+    const mid = interpolate_irradiance_smith(5, 3, 7);
+
+    expect(mid).toBeGreaterThan(0);
+    expect(mid).toBeLessThan(1);
+
+});

package/src/core/math/random/seededRandomMersenneTwister.spec.js

@@ -0,0 +1,10 @@
+import { seededRandomMersenneTwister } from "./seededRandomMersenneTwister.js";
+
+test("sanity", () => {
+    const rng = seededRandomMersenneTwister(0);
+
+    const v0 = rng();
+
+    expect(v0).toBeLessThanOrEqual(1);
+    expect(v0).toBeGreaterThanOrEqual(0);
+});

package/src/core/math/spline/spline_bezier3.js

@@ -9,7 +9,7 @@
  * @param {number} p3 end point
  * @returns {number}
  */
-function spline_bezier3(t, p0, p1, p2, p3) {
+export function spline_bezier3(t, p0, p1, p2, p3) {
     // first we compute necessary factors for each point
     const nt = 1 - t;
 

package/src/core/math/spline/spline_bezier3_bounds.js

@@ -1,6 +1,7 @@
 import { min2 } from "../min2.js";
 import { max2 } from "../max2.js";
 import { assert } from "../../assert.js";
+import { spline_bezier3 } from './spline_bezier3'
 
 /**
  * Compute bounds of a 3-rd degree bezier curve
@@ -15,7 +16,7 @@ import { assert } from "../../assert.js";
  * @param {number} p2
  * @param {number} p3
  */
-function spline_bezier3_bounds(result, result_offset, result_stride, p0, p1, p2, p3) {
+export function spline_bezier3_bounds(result, result_offset, result_stride, p0, p1, p2, p3) {
     assert.greaterThan(result_stride, 0, 'result_stride must be greater than 0');
     assert.isInteger(result_stride, 'result_stride');
 

package/src/core/math/spline/spline_bezier3_bounds.spec.js

@@ -0,0 +1,37 @@
+import { spline_bezier3_bounds } from "./spline_bezier3_bounds.js";
+
+test("spline of 0 length", () => {
+    const bounds = [];
+
+    spline_bezier3_bounds(
+        bounds, 0, 1,
+        0, 0, 0, 0
+    );
+
+    expect(bounds[0]).toBeCloseTo(0);
+    expect(bounds[1]).toBeCloseTo(0);
+});
+
+test("line-shaped spline of", () => {
+    const bounds = [];
+
+    spline_bezier3_bounds(
+        bounds, 0, 1,
+        -2, -1, 1, 2
+    );
+
+    expect(bounds[0]).toBeCloseTo(-2);
+    expect(bounds[1]).toBeCloseTo(2);
+});
+
+test("overshooting control point spline of", () => {
+    const bounds = [];
+
+    spline_bezier3_bounds(
+        bounds, 0, 1,
+        0, -1, 1, 0
+    );
+
+    expect(bounds[0]).toBeLessThan(0);
+    expect(bounds[1]).toBeGreaterThan(0);
+});

package/src/core/math/statistics/computeSampleSize_Cochran.spec.js

@@ -0,0 +1,12 @@
+import { computeSampleSize_Cochran } from "./computeSampleSize_Cochran.js";
+
+test("sanity for 95% confidence", () => {
+    function execute(error) {
+        return Math.floor(computeSampleSize_Cochran(1.95996, 0.5, error))
+    }
+
+    expect(execute(0.05)).toEqual(384);
+    expect(execute(0.035)).toEqual(783);
+    expect(execute(0.025)).toEqual(1536);
+    expect(execute(0.01)).toEqual(9603);
+});

package/src/core/math/statistics/computeStatisticalPartialMedian.js

@@ -1,4 +1,5 @@
 import { compareNumbersAscending } from "../../function/Functions.js";
+import { assert } from "../../assert.js";
 
 /**
  *
@@ -8,6 +9,9 @@ import { compareNumbersAscending } from "../../function/Functions.js";
  * @returns {number}
  */
 export function computeStatisticalPartialMedian(values, start, end) {
+    assert.isArrayLike(values, 'values');
+    assert.lessThan(end, values.length);
+
     const copy = values.slice();
 
     copy.sort(compareNumbersAscending);

package/src/core/math/statistics/computeStatisticalPartialMedian.spec.js

@@ -0,0 +1,13 @@
+import { computeStatisticalPartialMedian } from "./computeStatisticalPartialMedian.js";
+
+test("single item", () => {
+    expect(computeStatisticalPartialMedian([7], 0, 0)).toEqual(7);
+});
+
+test("[1,2,1]", () => {
+    expect(computeStatisticalPartialMedian([1,2,1], 0, 2)).toEqual(1);
+});
+
+test("[7,6,2,4,1]", () => {
+    expect(computeStatisticalPartialMedian([7,6,2,4,1], 0, 4)).toEqual(4);
+});

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/achievements/Achievement.spec.js

@@ -0,0 +1,21 @@
+import { Achievement } from "./Achievement.js";
+
+test("constructor does not throw", () => {
+    expect(() => new Achievement()).not.toThrow();
+});
+
+test("fromJSON correctness", () => {
+    const achievement = new Achievement();
+
+    achievement.fromJSON({
+        id: "x",
+        condition: "hello == kitty",
+        icon: "y",
+        secret: true
+    });
+
+    expect(achievement.id).toEqual("x");
+    expect(achievement.condition).toEqual("hello == kitty");
+    expect(achievement.icon).toEqual("y");
+    expect(achievement.secret).toEqual(true);
+});

package/src/engine/animation/curve/compression/prototypeCurveCompression.js

@@ -4,7 +4,7 @@ import { Keyframe } from "../Keyframe.js";
 import { EngineConfiguration } from "../../../EngineConfiguration.js";
 import GUIElementSystem from "../../../ecs/gui/GUIElementSystem.js";
 import ViewportPositionSystem from "../../../ecs/gui/position/ViewportPositionSystem.js";
-import { animation_curve_to_float_array } from "./animation_curve_to_float_array.js";
+import { sample_animation_curve_to_float_array } from "./sample_animation_curve_to_float_array.js";
 import { downsample_float_array_curve_by_error } from "./downsample_float_array_curve_by_error.js";
 import { build_plot_entity_from_array } from "../draw/build_plot_entity_from_array.js";
 
@@ -28,7 +28,7 @@ async function init() {
 
 function build_error_scale(ecd, curve) {
     const curve_data = [];
-    animation_curve_to_float_array(curve_data, curve, 0, 256);
+    sample_animation_curve_to_float_array(curve_data, 0, curve, 256);
 
 
     build_plot_entity_from_array({

package/src/engine/animation/curve/compression/{animation_curve_to_float_array.js → sample_animation_curve_to_float_array.js}

@@ -5,10 +5,15 @@
  * Sample entire animation curve into a flat array with discrete equal intervals
  * @param {number[]|Float32Array} out
  * @param {number} out_offset
- * @param {number} sample_count
  * @param {AnimationCurve} curve
+ * @param {number} sample_count
  */
-export function animation_curve_to_float_array(out, curve, out_offset = 0, sample_count = out.length) {
+export function sample_animation_curve_to_float_array(
+    out,
+    out_offset,
+    curve,
+    sample_count = out.length
+) {
     const keyframes = curve.keys;
     const keyframe_count = keyframes.length;
 
@@ -25,8 +30,10 @@ export function animation_curve_to_float_array(out, curve, out_offset = 0, sampl
     const time_end = key_last.time;
     const time_span = time_end - time_start;
 
+    const multiplier = sample_count > 1 ? 1 / (sample_count - 1) : 0;
+
     for (let i = 0; i < sample_count; i++) {
-        const f = i / (sample_count - 1);
+        const f = i * multiplier;
 
         const t = time_start + (f * time_span);
 

package/src/engine/animation/curve/compression/sample_animation_curve_to_float_array.spec.js

@@ -0,0 +1,29 @@
+import { AnimationCurve } from "../AnimationCurve.js";
+import { sample_animation_curve_to_float_array } from "./sample_animation_curve_to_float_array.js";
+import { Keyframe } from "../Keyframe.js";
+
+test("0 samples should produce valid result", () => {
+
+    const curve = new AnimationCurve();
+
+    const result = new Float32Array(0);
+
+    expect(() => sample_animation_curve_to_float_array(result, 0, curve, 0)).not.toThrow();
+});
+
+test("3 samples on a line", () => {
+
+
+    const curve = new AnimationCurve();
+    curve.add(Keyframe.from(-1, -1))
+    curve.add(Keyframe.from(1, 7))
+
+    curve.smoothAllTangents();
+
+    const result = new Float32Array(3);
+    sample_animation_curve_to_float_array(result, 0, curve, 3);
+
+    expect(result[0]).toBeCloseTo(-1);
+    expect(result[1]).toBeCloseTo(3);
+    expect(result[2]).toBeCloseTo(7);
+});

package/src/engine/animation/curve/draw/build_curve_editor.js

@@ -1,10 +1,10 @@
 import Vector2 from "../../../../core/geom/Vector2.js";
 import EmptyView from "../../../../view/elements/EmptyView.js";
 import { CanvasView } from "../../../../view/elements/CanvasView.js";
-import AABB2 from "../../../../core/geom/AABB2.js";
+import AABB2 from "../../../../core/geom/2d/aabb/AABB2.js";
 import Signal from "../../../../core/events/signal/Signal.js";
 import ObservedValue from "../../../../core/model/ObservedValue.js";
-import { animation_curve_to_float_array } from "../compression/animation_curve_to_float_array.js";
+import { sample_animation_curve_to_float_array } from "../compression/sample_animation_curve_to_float_array.js";
 import { plot_data } from "./plot_data.js";
 import { DraggableAspect } from "../../../ui/DraggableAspect.js";
 import { min2 } from "../../../../core/math/min2.js";
@@ -123,7 +123,7 @@ export function build_curve_editor({
         const width = graph.size.x;
         const data = new Float32Array(width);
 
-        animation_curve_to_float_array(data, curve, 0, data.length);
+        sample_animation_curve_to_float_array(data, 0, curve, data.length);
 
         plot_data({
             data,

package/src/engine/development/performance/RingBufferMetric.js

@@ -58,7 +58,7 @@ export class RingBufferMetric extends AbstractMetric {
         } else {
 
             result.mean = computeStatisticalMean(array, 0, data_count);
-            result.median = computeStatisticalPartialMedian(array, 0, data_count);
+            result.median = computeStatisticalPartialMedian(array, 0, data_count - 1);
             result.max = computeArrayMax(array, 0, data_count);
             result.min = computeArrayMin(array, 0, data_count);