@woosh/meep-engine 2.49.7 → 2.49.9

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