@woosh/meep-engine 2.49.8 → 2.49.9

package/package.json

@@ -5,7 +5,7 @@
   "description": "Fully featured ECS game engine written in JavaScript",
   "type": "module",
   "author": "Alexander Goldring",
-  "version": "2.49.8",
+  "version": "2.49.9",
   "main": "build/meep.module.js",
   "module": "build/meep.module.js",
   "exports": {

package/src/core/math/bessel_i0.spec.js

@@ -0,0 +1,43 @@
+import { bessel_j0 } from "./bessel_j0.js";
+
+test("sanity", () => {
+    const v = bessel_j0(0);
+
+    expect(typeof v).toBe("number");
+    expect(v).not.toBeNaN();
+
+});
+
+test("sweep through low positive values", () => {
+    // https://www.wolframalpha.com/input?i=besselj%5B0%2Cx%5D
+
+    expect(bessel_j0(0)).toBeCloseTo(1, 1);
+    expect(bessel_j0(0.1)).toBeCloseTo(0.997, 1);
+    expect(bessel_j0(0.2)).toBeCloseTo(0.990, 1);
+    expect(bessel_j0(0.3)).toBeCloseTo(0.977, 1);
+    expect(bessel_j0(0.4)).toBeCloseTo(0.960, 1);
+    expect(bessel_j0(0.5)).toBeCloseTo(0.938, 1);
+    expect(bessel_j0(0.6)).toBeCloseTo(0.912, 1);
+    expect(bessel_j0(0.7)).toBeCloseTo(0.881, 1);
+    expect(bessel_j0(0.8)).toBeCloseTo(0.846, 1);
+    expect(bessel_j0(0.9)).toBeCloseTo(0.807, 1);
+    expect(bessel_j0(1)).toBeCloseTo(0.765, 1);
+    expect(bessel_j0(2)).toBeCloseTo(0.223, 1);
+
+});
+
+test("roots", () => {
+
+    expect(bessel_j0(2.40482555769577)).toBeCloseTo(0, 1);
+    expect(bessel_j0(-2.40482555769577)).toBeCloseTo(0, 1);
+
+    expect(bessel_j0(5.52007811028631)).toBeCloseTo(0, 1);
+    expect(bessel_j0(-5.52007811028631)).toBeCloseTo(0, 1);
+
+    expect(bessel_j0(8.65372791291101)).toBeCloseTo(0, 1);
+    expect(bessel_j0(-8.65372791291101)).toBeCloseTo(0, 1);
+
+    expect(bessel_j0(11.7915344390143)).toBeCloseTo(0, 1);
+    expect(bessel_j0(-11.7915344390143)).toBeCloseTo(0, 1);
+
+});

package/src/core/math/bessel_j0.js

@@ -0,0 +1,30 @@
+import { assert } from "../assert.js";
+
+const q = 0.7172491568;
+const p0 = 0.6312725339;
+const ps0 = 0.4308049446;
+const p1 = 0.3500347951;
+const ps1 = 0.4678202347;
+const p2 = -0.06207747907;
+const ps2 = 0.04253832927;
+// const lamb4 = (lamb * lamb) * (lamb * lamb);
+const lamb4 = 0.559840650625;
+
+/**
+ * Bessel first order function of zeroth order
+ * @see https://link.springer.com/article/10.1007/s40314-020-01238-z
+ * @see https://www.shadertoy.com/view/Wt3czM
+ * @param {number} x
+ * @return {number}
+ */
+export function bessel_j0(x) {
+    assert.notNaN(x, 'x');
+
+    const xx = x * x;
+
+    const t0 = Math.sqrt(1.0 + lamb4 * xx);
+    const t1 = Math.sqrt(t0);
+
+    return xx === 0.0 ? 1.0 : 1.0 / (t1 * (1.0 + q * xx)) * ((p0 + p1 * xx + p2 * t0) * Math.cos(x) + ((ps0 + ps1 * xx) * t0 + ps2 * xx) * (Math.sin(x) / x));
+
+}

package/src/core/math/hash/murmur3_32.spec.js

@@ -0,0 +1,8 @@
+import { murmur3_32 } from "./murmur3_32.js";
+
+test("hashing [0] with 0 seed", () => {
+    const hash = murmur3_32(new Uint32Array([0]), 0);
+    expect(typeof hash).toBe("number");
+    expect(Number.isInteger(hash)).toBe(true);
+    expect(hash).not.toBeNaN();
+});

package/src/core/math/hash/squirrel3.spec.js

@@ -0,0 +1,16 @@
+import { squirrel3 } from "./squirrel3.js";
+
+function expect_integer(v) {
+
+    expect(typeof v).toBe("number");
+    expect(Number.isInteger(v)).toBe(true);
+    expect(v).not.toBeNaN();
+}
+
+test("sanity check", () => {
+    expect_integer(squirrel3(0));
+    expect_integer(squirrel3(1));
+    expect_integer(squirrel3(-1));
+
+    expect(squirrel3(0)).not.toEqual(squirrel3(1));
+});

package/src/core/math/interval/NumericInterval.js

@@ -111,6 +111,7 @@ export class NumericInterval {
 
     /**
      * Whether min and max are the same
+     * In other words if span is 0
      * @returns {boolean}
      */
     isExact() {

package/src/core/math/{bessel_i0.js → modified_bessel_i0.js}

@@ -1,14 +1,16 @@
 import { assert } from "../assert.js";
 
+// const lamb = 0.865;
+
 /**
- * Modified bessel function of the first kind
+ * Modified bessel function of the first kind zeroth order
  * @see https://mathworld.wolfram.com/ModifiedBesselFunctionoftheFirstKind.html
  * @see https://computergraphics.stackexchange.com/questions/6393/kaiser-windowed-sinc-filter-for-mip-mapping
  * @see https://github.com/terifan/ImageResampler/blob/dbc212ce6aaa769bf3c9623cb6ead58ffd51d76c/src/org/terifan/image_resampler/FilterFactory.java
  * @param {number} x
  * @returns {number}
  */
-export function bessel_i0(x) {
+export function modified_bessel_i0(x) {
     assert.notNaN(x, 'x');
 
     let sum = 1.0;
@@ -24,3 +26,4 @@ export function bessel_i0(x) {
 
     return sum;
 }
+

package/src/core/math/noise/{create_noise_2d.js → create_simplex_noise_2d.js}

@@ -58,9 +58,9 @@ const grad4 = /*#__PURE__*/ new Float64Array([0, 1, 1, 1, 0, 1, 1, -1, 0, 1, -1,
 /**
  * Creates a 2D noise function
  * @param random the random function that will be used to build the permutation table
- * @returns {function(x:number, y:number):number}
+ * @returns {function(x:number, y:number):number} producing values in range -1 .. 1
  */
-export function createNoise2D(random = Math.random) {
+export function create_simplex_noise_2d(random = Math.random) {
     // allocate continuous chunk of memory
     const buffer = new ArrayBuffer(512 * 2);
 

package/src/core/math/noise/create_simplex_noise_2d.spec.js

@@ -0,0 +1,21 @@
+import { create_simplex_noise_2d } from "./create_simplex_noise_2d.js";
+
+test("sample 10 points in 0..1 range", () => {
+    const noise2d = create_simplex_noise_2d(() => 0);
+
+    const COUNT = 10;
+    for (let i = 0; i < COUNT; i++) {
+        const u = i / (COUNT - 1);
+        for (let j = 0; j < COUNT; j++) {
+            const v = j / (COUNT - 1);
+
+            const value = noise2d(u, v);
+
+            expect(typeof value).toBe('number');
+            expect(value).not.toBeNaN();
+
+            expect(value).toBeGreaterThanOrEqual(-1);
+            expect(value).toBeLessThanOrEqual(1);
+        }
+    }
+});

package/src/core/math/normalizeArrayVector.spec.js

@@ -0,0 +1,15 @@
+import { normalizeArrayVector } from "./normalizeArrayVector.js";
+
+test("1d vector normalization", () => {
+    const v = [7];
+
+    normalizeArrayVector(v, v, 1);
+
+    expect(v[0]).toBeCloseTo(1);
+
+    v[0] = -13;
+
+    normalizeArrayVector(v, v, 1);
+
+    expect(v[0]).toBeCloseTo(-1);
+});

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

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

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

@@ -1,19 +1,19 @@
 import { inverseLerp } from "../../inverseLerp.js";
 
 /**
- *
+ * Approximates logarithmic decay, except it goes to 0 at max
+ * Estimation is done using a 5th degree polynomial
  * @param {number} distance
  * @param {number} min
  * @param {number} max
  * @return {number}
  */
 export function interpolate_irradiance_lograrithmic(distance, min, max) {
-    if (distance >= max) {
-        return 0;
-    }
 
     if (distance <= min) {
         return 1;
+    } else if (distance >= max) {
+        return 0;
     }
 
     const x = inverseLerp(min, max, distance);

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

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

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