@woosh/meep-engine 2.36.28 → 2.37.0

package/core/bvh2/bvh3/{bvh_query_user_data_by_frustum.js → bvh_query_user_data_overlaps_frustum.js}

@@ -14,12 +14,11 @@ const scratch_aabb = [];
  * @param {ExplicitBinaryBoundingVolumeHierarchy} bvh
  * @param {number[]|Float32Array} frustum
  */
-export function bvh_query_user_data_by_frustum(
+export function bvh_query_user_data_overlaps_frustum(
     result,
     result_offset,
     bvh,
-    frustum
-) {
+    frustum) {
     const root = bvh.root;
 
     if (root === NULL_NODE) {
@@ -30,9 +29,9 @@ export function bvh_query_user_data_by_frustum(
      *
      * @type {number}
      */
-    let traversal_cursor = 0;
+    let traversal_cursor = 1;
 
-    traversal_stack[traversal_cursor++] = root;
+    traversal_stack[0] = root;
 
     let result_cursor = result_offset;
 

package/core/bvh2/traversal/ThreeClippingPlaneComputingBVHVisitor.js

@@ -1,6 +1,6 @@
 import { computePointDistanceToPlane } from "../../geom/Plane.js";
 import { BVHVisitor } from "./BVHVisitor.js";
-import { read_frustum_planes_to_array } from "../../../engine/graphics/render/forward_plus/cluster/read_frustum_planes_to_array.js";
+import { read_frustum_planes_to_array } from "../../geom/3d/frustum/read_frustum_planes_to_array.js";
 import { __detailed_box_volume_intersection } from "./__detailed_box_volume_intersection.js";
 
 export class ThreeClippingPlaneComputingBVHVisitor extends BVHVisitor {

package/core/color/Color.js

@@ -1,7 +1,6 @@
 import { assert } from "../assert.js";
 import Signal from "../events/signal/Signal.js";
 import { parseColor } from "./ColorUtils.js";
-import { clamp } from "../math/clamp.js";
 import { min2 } from "../math/min2.js";
 import { max2 } from "../math/max2.js";
 import { min3 } from "../math/min3.js";
@@ -9,7 +8,11 @@ import { computeHashIntegerArray } from "../collection/array/computeHashIntegerA
 import { computeHashFloat } from "../math/hash/computeHashFloat.js";
 import { rgb2hsv } from "./rgb2hsv.js";
 import { rgb2uint24 } from "./rgb2uint24.js";
+import { clamp01 } from "../math/clamp01.js";
 
+/**
+ * @class
+ */
 export class Color {
     /**
      *
@@ -44,6 +47,54 @@ export class Color {
         this.onChanged = new Signal();
     }
 
+    /**
+     *
+     * @returns {number}
+     */
+    get 0() {
+        return this.r;
+    }
+
+    /**
+     *
+     * @param {number} v
+     */
+    set 0(v) {
+        this.r = v;
+    }
+
+    /**
+     *
+     * @returns {number}
+     */
+    get 1() {
+        return this.g;
+    }
+
+    /**
+     *
+     * @param {number} v
+     */
+    set 1(v) {
+        this.g = v;
+    }
+
+    /**
+     *
+     * @returns {number}
+     */
+    get 2() {
+        return this.b;
+    }
+
+    /**
+     *
+     * @param {number} v
+     */
+    set 2(v) {
+        this.b = v;
+    }
+
     /**
      *
      * @param {number} r
@@ -227,8 +278,8 @@ export class Color {
             _h = h + 1;
         }
 
-        const _s = clamp(s, 0, 1);
-        const _v = clamp(v, 0, 1);
+        const _s = clamp01(s);
+        const _v = clamp01(v);
 
         let r, g, b;
 

package/core/color/hsv2rgb.js

@@ -1,4 +1,4 @@
-import { clamp } from "../math/clamp.js";
+import { clamp01 } from "../math/clamp01.js";
 
 /**
  *
@@ -15,8 +15,8 @@ export function hsv2rgb(h, s, v) {
         _h = h + 1;
     }
 
-    const _s = clamp(s, 0, 1);
-    const _v = clamp(v, 0, 1);
+    const _s = clamp01(s);
+    const _v = clamp01(v);
 
     let r, g, b, i, f, p, q, t;
 

package/core/color/kelvin_to_rgb.js

@@ -0,0 +1,51 @@
+import { clamp01 } from "../math/clamp01.js";
+
+/**
+ * @see https://www.zombieprototypes.com/?p=210
+ * @see https://tannerhelland.com/2012/09/18/convert-temperature-rgb-algorithm-code.html
+ * TODO: not sure if output is in linear or sRGB space, looking at the way colors look in Unity - it appears that colors are in sRGB and need to be shifted to linear before being used
+ * @param {number[]} result RGB output
+ * @param {number} result_offset
+ * @param {number} temperature in Kelvin
+ */
+export function kelvin_to_rgb(result, result_offset, temperature) {
+    let r;
+    let g;
+    let b;
+
+    // Temperature divided by 100 for calculations
+    const t = temperature / 100;
+
+    if (t <= 66) {
+        r = 1;
+
+        g = clamp01(
+            -0.6088425710866344 - 0.001748900018414868 * (t - 2) + 0.4097731842899564 * Math.log(t - 2)
+        );
+
+        if (t <= 20) {
+            b = 0;
+        } else {
+
+            b = clamp01(
+                -0.9990954974165059 + 0.0032447435545127036 * (t - 10) + 0.453646839257496 * Math.log(t - 10)
+            );
+
+        }
+    } else {
+
+        r = clamp01(
+            1.3803015908551253 + 0.0004478684462124118 * (t - 55) - 0.15785750232675008 * Math.log(t - 55)
+        ); // in normalized scale
+
+        g = clamp01(
+            1.2762722061615583 + 0.0003115080994769546 * (t - 50) - 0.11013841706194392 * Math.log(t - 50)
+        );
+
+        b = 1;
+    }
+
+    result[result_offset + 0] = r;
+    result[result_offset + 1] = g;
+    result[result_offset + 2] = b;
+}

package/core/color/kelvin_to_rgb.spec.js

@@ -0,0 +1,61 @@
+import { kelvin_to_rgb } from "./kelvin_to_rgb.js";
+import { v3_distance } from "../geom/v3_distance.js";
+import { Color } from "./Color.js";
+
+function rgb([r255, g255, b255]) {
+    return [r255 * 255, g255 * 255, b255 * 255];
+}
+
+function closeTo(actual, expected, error = 0.05) {
+    const distance = v3_distance(
+        actual[0], actual[1], actual[2],
+        expected[0], expected[1], expected[2]
+    );
+
+    expect(distance).toBeLessThan(error * 255);
+}
+
+/**
+ * NOTE: original function is fit from that dataset
+ * @see http://www.vendian.org/mncharity/dir3/blackbody/UnstableURLs/bbr_color.html
+ * @type {(number|string)[]}
+ */
+const bbr_color_table_2deg = [
+    1000, "#ff3300",
+    1100, "#ff4500",
+    2000, "#ff8d0b",
+    3000, "#ffb969",
+    4000, "#ffd5a1",
+    5000, "#ffe7cc",
+    6000, "#fff4ed",
+    7000, "#f7f5ff",
+    8000, "#e5e9ff",
+    9000, "#d9e1ff",
+    10000, "#cfdaff",
+    11000, "#c8d5ff",
+    12000, "#c3d1ff",
+    13000, "#beceff",
+    14000, "#bacbff",
+    15000, "#b7c9ff",
+    15000, "#b7c9ff",
+    16000, "#b5c7ff",
+    20000, "#adc1ff",
+    30000, "#a5baff",
+    40000, "#a1b7ff",
+];
+
+test("table", () => {
+    const t = [];
+
+    for (let i = 0; i < bbr_color_table_2deg.length;) {
+        const temp = bbr_color_table_2deg[i++];
+        const color = bbr_color_table_2deg[i++];
+
+        kelvin_to_rgb(t, 0, temp);
+
+        const color_obj = Color.parse(color);
+
+        closeTo(rgb(t), [color_obj.r * 255, color_obj.g * 255, color_obj.b * 255]);
+
+    }
+});

package/core/color/linear_to_sRGB.js

@@ -0,0 +1,17 @@
+
+function convert(c){
+    return ( c < 0.0031308 ) ? c * 12.92 : 1.055 * ( Math.pow( c, 0.41666 ) ) - 0.055;
+}
+
+/**
+ *
+ * @param {number[]} output
+ * @param {number} output_offset
+ * @param {number[]} input
+ * @param {number} input_offset
+ */
+export function linear_to_sRGB(output, output_offset, input, input_offset) {
+    output[output_offset] = convert(input[input_offset]);
+    output[output_offset + 1] = convert(input[input_offset + 1]);
+    output[output_offset + 2] = convert(input[input_offset + 2]);
+}

package/core/color/prototype_kelvin_to_rgb.js

@@ -0,0 +1,44 @@
+import { CanvasView } from "../../view/elements/CanvasView.js";
+import { kelvin_to_rgb } from "./kelvin_to_rgb.js";
+import { lerp } from "../math/lerp.js";
+import { Sampler2D } from "../../engine/graphics/texture/sampler/Sampler2D.js";
+import sampler2D2Canvas from "../../engine/graphics/texture/sampler/Sampler2D2Canvas.js";
+import { sRGB_to_linear } from "./sRGB_to_linear.js";
+
+const view = new CanvasView();
+
+view.css({
+    position: 'fixed',
+    left: '10px',
+    top: '10px',
+    zIndex: 5
+});
+view.size.set(400, 50);
+
+document.body.append(view.el);
+
+view.link();
+
+const sampler = Sampler2D.float32(4, 400, 50);
+
+const color = [1, 1, 1, 1];
+for (let i = 0; i < sampler.width; i++) {
+    const f = i / (sampler.width - 1);
+    const k = lerp(1500, 20000, f);
+    kelvin_to_rgb(color, 0, k);
+
+    sRGB_to_linear(color, 0, color, 0);
+
+    for (let j = 0; j < sampler.height; j++) {
+        sampler.set(i, j, color);
+        // sampler.set(i, j, [f, f, f, 1]);
+
+    }
+    // sampler.set(i, sampler.height - 1, [f, f, f, 1]);
+}
+
+console.log(sampler);
+
+sampler2D2Canvas(sampler, 255, 0, view.el);
+
+

package/core/color/rgb_to_kelvin.js

@@ -0,0 +1,34 @@
+import { kelvin_to_rgb } from "./kelvin_to_rgb.js";
+
+const scratch_rgb = [];
+
+/**
+ *
+ * @see https://www.zombieprototypes.com/?p=210
+ * @param {number[]|ArrayLike<number>|{0:number,1:number,2:number}} input input array
+ * @param {number} input_offset offset into input array
+ */
+export function rgb_to_kelvin(input, input_offset = 0) {
+    const r = input[input_offset];
+    const g = input[input_offset + 1];
+    const b = input[input_offset + 2];
+
+    // use solver to reverse function, slow but hey - it works
+    var temperature;
+    var epsilon=0.4;
+    var minTemperature = 1000;
+    var maxTemperature = 40000;
+
+    while (maxTemperature - minTemperature > epsilon) {
+        temperature = (maxTemperature + minTemperature) / 2;
+         kelvin_to_rgb(scratch_rgb,0,temperature);
+        if ((scratch_rgb[2] / scratch_rgb[0]) >= (b / r)) {
+            maxTemperature = temperature;
+        } else {
+            minTemperature = temperature;
+        }
+    }
+
+    return Math.round(temperature);
+
+}

package/core/color/rgb_to_kelvin.spec.js

@@ -0,0 +1,15 @@
+import { rgb_to_kelvin } from "./rgb_to_kelvin.js";
+import { Color } from "./Color.js";
+
+
+test("1000 K", () => {
+    const actual = rgb_to_kelvin(Color.parse("#ff3e00"));
+
+    expect(Math.abs(actual - 1000)).toBeLessThan(100);
+});
+
+test("40000 K", () => {
+    const actual = rgb_to_kelvin(Color.parse("#8cb4ff"));
+
+    expect(Math.abs(actual - 40000)).toBeLessThan(100);
+});

package/core/color/sRGB_to_linear.js

@@ -0,0 +1,16 @@
+function convert(c) {
+    return (c < 0.04045) ? c * 0.0773993808 : Math.pow(c * 0.9478672986 + 0.0521327014, 2.4);
+}
+
+/**
+ *
+ * @param {number[]} output
+ * @param {number} output_offset
+ * @param {number[]} input
+ * @param {number} input_offset
+ */
+export function sRGB_to_linear(output, output_offset, input, input_offset) {
+    output[output_offset] = convert(input[input_offset]);
+    output[output_offset + 1] = convert(input[input_offset + 1]);
+    output[output_offset + 2] = convert(input[input_offset + 2]);
+}

package/core/geom/3d/frustum/read_frustum_planes_to_array.d.ts

@@ -0,0 +1,3 @@
+import {Plane} from "three";
+
+export function read_frustum_planes_to_array(planes: Plane[], array: ArrayLike<number>);

package/{engine/graphics/render/forward_plus/cluster → core/geom/3d/frustum}/read_frustum_planes_to_array.js

@@ -1,4 +1,4 @@
-import { assert } from "../../../../../core/assert.js";
+import { assert } from "../../../assert.js";
 
 /**
  *

package/core/geom/3d/line/line3_computeSegmentPointDistance_sqr.js

@@ -1,5 +1,5 @@
-import { clamp } from "../../../math/clamp.js";
 import { v3_distance_sqr } from "../../v3_distance_sqr.js";
+import { clamp01 } from "../../../math/clamp01.js";
 
 /**
  * Computes shortest distance between a line segment(defined by 2 points) and a point
@@ -29,7 +29,7 @@ export function line3_computeSegmentPointDistance_sqr(x0, y0, z0, x1, y1, z1, px
 
     const d3 = line_delta_x * sp0_x + line_delta_y * sp0_y + line_delta_z * sp0_z;
 
-    const t = clamp(d3 / d2, 0, 1);
+    const t = clamp01(d3 / d2);
 
     // compute point on the line
     const lp_x = line_delta_x * t + x0;

package/core/geom/LineSegment.js

@@ -1,8 +1,8 @@
 /**
  * Created by Alex on 18/03/14.
  */
-import { clamp } from "../math/clamp.js";
 import Vector3 from "./Vector3.js";
+import { clamp01 } from "../math/clamp01.js";
 
 
 const SMALL_NUM = 1e-9;
@@ -30,7 +30,7 @@ LineSegment.prototype.closestPointToPointParameter = function (point, clampToLin
 
     if (clampToLine) {
 
-        t = clamp(t, 0, 1);
+        t = clamp01(t);
 
     }
 

package/core/geom/Vector3.js

@@ -928,6 +928,20 @@ class Vector3 {
     static distance(a, b) {
         return v3_length(a.x - b.x, a.y - b.y, a.z - b.z);
     }
+
+    /**
+     *
+     * @param {number[]} input
+     * @param {number} [offset]
+     * @returns {Vector3}
+     */
+    static fromArray(input, offset = 0) {
+        return new Vector3(
+            input[offset],
+            input[offset + 1],
+            input[offset + 2]
+        );
+    }
 }
 
 Vector3.prototype.lengthSq = Vector3.prototype.lengthSqr;

package/core/math/DEG_TO_RAD.js

@@ -0,0 +1 @@
+export const DEG_TO_RAD = Math.PI / 180;

package/core/math/MathUtils.spec.js

@@ -10,7 +10,6 @@ import { min3 } from "./min3.js";
 import { sign } from "./sign.js";
 import { isValueBetween } from "./isValueBetween.js";
 import { isValueBetweenInclusive } from "./isValueBetweenInclusive.js";
-import { solveQuadratic } from "./solveQuadratic.js";
 import { overlap1D } from "./overlap1D.js";
 import { computeHashFloat } from "./hash/computeHashFloat.js";
 
@@ -223,18 +222,6 @@ test("isValueBetweenInclusive", () => {
 });
 
 
-test("solveQuadratic", () => {
-    expect(solveQuadratic(0, 0, 0)).toStrictEqual([0, 0]);
-
-    expect(solveQuadratic(0, 0, 1)).toStrictEqual(null);
-
-    expect(solveQuadratic(0, 2, 3)).toStrictEqual([-1.5, -1.5]);
-
-    expect(solveQuadratic(1, -2, -3)).toStrictEqual([-1, 3]);
-
-    expect(solveQuadratic(1, -2, 3)).toBe(null);
-});
-
 test('overlap1D', () => {
     expect(overlap1D(0, 0, 0, 0)).toBe(false);
     expect(overlap1D(-3, -1, -2, -0.5)).toBe(true);

package/core/math/RAD_TO_DEG.js

@@ -0,0 +1 @@
+export const RAD_TO_DEG = 180 / Math.PI;

package/core/math/clamp01.js

@@ -0,0 +1,15 @@
+/**
+ * Clamps a value to 0..1 range
+ * Same as `clamp(value, 0, 1)`
+ * @param {number} value
+ * @returns {number}
+ */
+export function clamp01(value) {
+    if (value < 0) {
+        return 0;
+    } else if (value > 1) {
+        return 1;
+    } else {
+        return value;
+    }
+}

package/core/math/fract.js

@@ -0,0 +1,10 @@
+/**
+ * compute the fractional part of the argument
+ * GLSL "fract" function port
+ * @see https://www.khronos.org/registry/OpenGL-Refpages/gl4/html/fract.xhtml
+ * @param {number} v
+ * @returns {number} returns the fractional part of x. This is calculated as x - floor(x).
+ */
+export function fract(v) {
+    return v % 1;
+}

package/core/math/newton_solver_1d.js

@@ -0,0 +1,21 @@
+/**
+ * Newtonian solver, works by moving along the curve in the direction of gradient
+ * @template T
+ * @param {function(T):number} f
+ * @param {T} xStart
+ * @param {number} [max_steps]
+ * @param {number} [eps]
+ * @returns {number}
+ */
+export function newton_solver_1d(f, xStart, max_steps = 1000, eps = 0.00000001) {
+    let x = xStart, fx;
+
+    let remaining_steps = max_steps;
+
+    while ((remaining_steps--) && Math.abs(fx = f(x)) > eps) {
+        const dfdx = (f(x + eps) - fx) / eps;
+        x = x - fx / dfdx;
+    }
+
+    return x;
+}

package/core/math/smoothStep.js

@@ -1,4 +1,4 @@
-import { clamp } from "./clamp.js";
+import { clamp01 } from "./clamp01.js";
 
 /**
  * Adapted from OpenGL spec
@@ -11,7 +11,7 @@ export function smoothStep(edge0, edge1, x) {
 
     const span = edge1 - edge0;
 
-    const t = clamp((x - edge0) / span, 0, 1);
+    const t = clamp01((x - edge0) / span);
 
     return t * t * (3 - 2 * t);
-}
+}

package/core/math/solveQuadratic.js

@@ -1,25 +1,45 @@
 /**
- * Return solutions for quadratic
+ * Return solutions for a quadratic equation
  * @param {number} a
  * @param {number} b
  * @param {number} c
- * @returns {number[]|null}
+ * @param {number[]} result solutions are written here
+ * @param {number} result_offset offset into result array where solutions are written to
+ * @returns {number} number of found solutions (roots)
  */
-export function solveQuadratic(a, b, c) {
-    let sol = null;
+export function solveQuadratic(result, result_offset, a, b, c) {
+
     if (Math.abs(a) < 1e-6) {
         if (Math.abs(b) < 1e-6) {
-            sol = Math.abs(c) < 1e-6 ? [0, 0] : null;
+            if (Math.abs(c) < 1e-6) {
+
+                result[result_offset] = 0;
+                result[result_offset + 1] = 0;
+
+                return 2;
+
+            }
         } else {
-            sol = [-c / b, -c / b];
+            result[result_offset] = -c / b;
+            result[result_offset + 1] = -c / b;
+
+            return 2;
         }
     } else {
-        let disc = b * b - 4 * a * c;
-        if (disc >= 0) {
-            disc = Math.sqrt(disc);
-            a = 2 * a;
-            sol = [(-b - disc) / a, (-b + disc) / a];
+        const disc_sqr = b * b - 4 * a * c;
+
+        if (disc_sqr >= 0) {
+            const disc = Math.sqrt(disc_sqr);
+            const a2 = 2 * a;
+
+            result[result_offset] = (-b - disc) / a2;
+            result[result_offset + 1] = (-b + disc) / a2;
+
+            return 2;
         }
+
     }
-    return sol;
+
+    // no roots
+    return 0;
 }

package/core/math/solveQuadratic.spec.js

@@ -0,0 +1,18 @@
+import { solveQuadratic } from "./solveQuadratic.js";
+
+test("solveQuadratic", () => {
+    const roots = [];
+
+    solveQuadratic(roots, 0, 0, 0, 0)
+    expect(roots).toStrictEqual([0, 0]);
+
+    expect(solveQuadratic(roots, 0, 0, 0, 1)).toStrictEqual(0);
+
+    solveQuadratic(roots, 0, 0, 2, 3);
+    expect(roots).toStrictEqual([-1.5, -1.5]);
+
+    solveQuadratic(roots, 0, 1, -2, -3);
+    expect(roots).toStrictEqual([-1, 3]);
+
+    expect(solveQuadratic(roots, 0, 1, -2, 3)).toBe(0);
+});

package/core/primitives/strings/StringUtils.js

@@ -93,3 +93,13 @@ export function computeCommonPrefix(strings) {
 export function camelToKebab(string) {
     return string.replace(/([a-z])([A-Z])/g, '$1-$2').toLowerCase();
 }
+
+
+/**
+ *
+ * @param {string} string
+ * @returns {string}
+ */
+export function kebabToUnderscore(string) {
+    return string.replace('-', '_');
+}

package/core/process/task/TaskUtils.js

@@ -2,10 +2,10 @@
  * Created by Alex on 22/05/2016.
  */
 import { randomizeArrayElementOrder } from "../../collection/ArrayUtils.js";
-import { clamp } from "../../math/clamp.js";
 import { seededRandom } from "../../math/random/seededRandom.js";
 import Task from "./Task.js";
 import TaskSignal from "./TaskSignal.js";
+import { clamp01 } from "../../math/clamp01.js";
 
 /**
  *
@@ -180,7 +180,7 @@ export function delayTask(delay, name = "unnamed") {
                 fraction = 0;
             }
 
-            return clamp(fraction, 0, 1);
+            return clamp01(fraction);
         },
         estimatedDuration
     });