@woosh/meep-engine 2.131.16 → 2.131.19

package/editor/ecs/component/editors/geom/QuaternionEditor.js

@@ -1,8 +1,8 @@
-import { TypeEditor } from "../../TypeEditor.js";
 import Vector3 from "../../../../../src/core/geom/Vector3.js";
-import { makeV3_editor } from "../common/makeV3_editor.js";
 import { DEG_TO_RAD } from "../../../../../src/core/math/DEG_TO_RAD.js";
 import { RAD_TO_DEG } from "../../../../../src/core/math/RAD_TO_DEG.js";
+import { TypeEditor } from "../../TypeEditor.js";
+import { makeV3_editor } from "../common/makeV3_editor.js";
 
 export class QuaternionEditor extends TypeEditor {
     build(parent, field, registry) {
@@ -22,7 +22,7 @@ export class QuaternionEditor extends TypeEditor {
 
             lock = true;
 
-            q.__setFromEuler(
+            q.fromEulerAnglesXYZ(
                 euler.x * DEG_TO_RAD,
                 euler.y * DEG_TO_RAD,
                 euler.z * DEG_TO_RAD

package/editor/tools/TransformTool.js

@@ -103,7 +103,7 @@ class TransformContainer {
             allowWriteToSurrogate = false;
 
             try {
-                transform.rotation.__setFromEuler(surrogate.rotation.x, surrogate.rotation.y, surrogate.rotation.z, 'XYZ');
+                transform.rotation.fromEulerAnglesXYZ(surrogate.rotation.x, surrogate.rotation.y, surrogate.rotation.z);
             } catch (e) {
                 console.error(e);
             }
@@ -131,7 +131,13 @@ class TransformContainer {
 
         //set surrogate transform to match component
         surrogate.position.copy(transform.position);
-        transform.rotation.__setFromEuler(surrogate.rotation.x, surrogate.rotation.y, surrogate.rotation.z, surrogate.rotation.order);
+
+        if (surrogate.rotation.order === "XYZ") {
+            transform.rotation.fromEulerAnglesXYZ(surrogate.rotation.x, surrogate.rotation.y, surrogate.rotation.z);
+        } else {
+            throw new Error("Unsupported rotation order");
+        }
+
         surrogate.quaternion.copy(transform.rotation);
         surrogate.scale.copy(transform.scale);
 
@@ -160,7 +166,12 @@ class TransformContainer {
                 if (allowWriteToSurrogate) {
                     const rotation = transform.rotation;
 
-                    rotation.__setFromEuler(surrogate.rotation.x, surrogate.rotation.y, surrogate.rotation.z, surrogate.rotation.order);
+                    if (surrogate.rotation.order === "XYZ") {
+                        rotation.fromEulerAnglesXYZ(surrogate.rotation.x, surrogate.rotation.y, surrogate.rotation.z);
+                    } else {
+                        throw new Error("Unsupported rotation order");
+                    }
+
 
                     surrogate.quaternion.set(rotation.x, rotation.y, rotation.z, rotation.w);
                 }

package/package.json

@@ -5,7 +5,7 @@
   "description": "Pure JavaScript game engine. Fully featured and production ready.",
   "type": "module",
   "author": "Alexander Goldring",
-  "version": "2.131.16",
+  "version": "2.131.19",
   "main": "build/meep.module.js",
   "module": "build/meep.module.js",
   "exports": {

package/src/core/color/illuminant/planckian_radiance.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"planckian_radiance.d.ts","sourceRoot":"","sources":["../../../../../src/core/color/illuminant/planckian_radiance.js"],"names":[],"mappings":"AASA;;;;;GAKG;AACH,6CAJW,MAAM,KACN,MAAM,GACJ,MAAM,CAmBlB"}
+{"version":3,"file":"planckian_radiance.d.ts","sourceRoot":"","sources":["../../../../../src/core/color/illuminant/planckian_radiance.js"],"names":[],"mappings":"AAWA;;;;;GAKG;AACH,6CAJW,MAAM,KACN,MAAM,GACJ,MAAM,CAyBlB"}

package/src/core/color/illuminant/planckian_radiance.js

@@ -1,3 +1,5 @@
+import { assert } from "../../assert.js";
+
 /**
  * Second radiation constant (m·K)
  *
@@ -14,6 +16,12 @@ const PLANCK_C2 = 1.438776877e-2;
  * @returns {number} Relative spectral power
  */
 export function planckian_radiance(lambda_m, T) {
+    assert.isNumber(lambda_m, 'lambda_m');
+    assert.notNaN(lambda_m, 'lambda_m');
+    
+    assert.isNumber(T, 'T');
+    assert.notNaN(T, 'T');
+
     const lambda_T = lambda_m * T;
     const exponent = PLANCK_C2 / lambda_T;
 

package/src/core/color/kelvin/kelvin_to_rgb.d.ts

@@ -1,8 +1,11 @@
 /**
+ *
+ * Converts Kelvin temperature to RGB.
+ * Handles ranges 0K - 40000K
  *
  * Note: if you will need to covert the output to linear space ({@link sRGB_to_linear}) if you intend to perform any mixing on the color.
  *
- * @param {number[]} result RGB output The output is in non-linear (gamma corrected) space
+ * @param {number[]} result result RGB output (sRGB Gamma Corrected)
  * @param {number} result_offset
  * @param {number} temperature in Kelvin
  *

package/src/core/color/kelvin/kelvin_to_rgb.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"kelvin_to_rgb.d.ts","sourceRoot":"","sources":["../../../../../src/core/color/kelvin/kelvin_to_rgb.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;GAWG;AACH,sCARW,MAAM,EAAE,iBACR,MAAM,eACN,MAAM,QAuDhB"}
+{"version":3,"file":"kelvin_to_rgb.d.ts","sourceRoot":"","sources":["../../../../../src/core/color/kelvin/kelvin_to_rgb.js"],"names":[],"mappings":"AA6FA;;;;;;;;;;;;;;GAcG;AACH,sCARW,MAAM,EAAE,iBACR,MAAM,eACN,MAAM,QA6DhB"}

package/src/core/color/kelvin/kelvin_to_rgb.js

@@ -1,11 +1,104 @@
 import { assert } from "../../assert.js";
 import { clamp01 } from "../../math/clamp01.js";
+import { inverseLerp } from "../../math/inverseLerp.js";
+import { lerp } from "../../math/lerp.js";
+
+
+/**
+ * Red-dominant approximation
+ *
+ * Valid for < 6600K
+ *
+ * @param {number[]} out
+ * @param {number} t K/100
+ */
+function approximate_regime_red(out, t) {
+
+    const r = 1;
+
+    const g = clamp01(
+        -0.6088425710866344 - 0.001748900018414868 * (t - 2) + 0.4097731842899564 * Math.log(t - 2)
+    );
+
+    const b = t <= 20 ? 0 : clamp01(
+        -0.9990954974165059 + 0.0032447435545127036 * (t - 10) + 0.453646839257496 * Math.log(t - 10)
+    );
+
+    out[0] = r;
+    out[1] = g;
+    out[2] = b;
+}
+
 
 /**
+ * Blue-dominant approximation
+ *
+ * Valid for > 6600K
+ *
+ * @param {number[]} out
+ * @param {number} t K/100
+ */
+function approximate_regime_blue(out, t) {
+
+    const r = clamp01(
+        1.3803015908551253 + 0.0004478684462124118 * (t - 55) - 0.15785750232675008 * Math.log(t - 55)
+    ); // in normalized scale
+
+    const g = clamp01(
+        1.2762722061615583 + 0.0003115080994769546 * (t - 50) - 0.11013841706194392 * Math.log(t - 50)
+    );
+
+    const b = 1;
+
+    out[0] = r;
+    out[1] = g;
+    out[2] = b;
+}
+
+/**
+ * Black body
+ *
+ * Valid for < 1000K
+ *
+ * @param {number[]} out
+ * @param {number} t K/100
+ */
+function approximate_regime_blackbody(out, t) {
+    // 1. Handle "Black Body" cooling (below 1000K)
+
+    // These are the values the algorithm produces at exactly 1000K (t=10).
+    // We lock the hue here and just fade the brightness to zero.
+    const k1000_r = 1;
+    const k1000_g = 0.22926561084500907;
+    const k1000_b = 0;
+
+    // The Draper point (approx 798K) is where objects begin to glow visible red.
+    const DRAPER_POINT = 7.98; // 798K
+
+    // Note: We are attenuating Gamma-corrected values here.
+    // Physically strictly incorrect (should be linear), but visually acceptable
+    // and faster for this specific "fade to black" effect.
+    const brightness = Math.max(0, inverseLerp(DRAPER_POINT, 10, t));
+
+    out[0] = k1000_r * brightness;
+    out[1] = k1000_g * brightness;
+    out[2] = k1000_b * brightness;
+}
+
+/**
+ * Avoid heap allocation in the main function
+ * @type {number[]}
+ */
+const scratch_rgb = [0, 0, 0];
+
+/**
+ *
+ * Converts Kelvin temperature to RGB.
+ * Handles ranges 0K - 40000K
  *
  * Note: if you will need to covert the output to linear space ({@link sRGB_to_linear}) if you intend to perform any mixing on the color.
  *
- * @param {number[]} result RGB output The output is in non-linear (gamma corrected) space
+ * @param {number[]} result result RGB output (sRGB Gamma Corrected)
  * @param {number} result_offset
  * @param {number} temperature in Kelvin
  *
@@ -22,44 +115,50 @@ export function kelvin_to_rgb(
     assert.isNonNegativeInteger(result_offset, "result_offset");
     assert.isNumber(temperature, "temperature");
 
-    let r;
-    let g;
-    let b;
-
     // Temperature divided by 100 for calculations
     const t = temperature / 100;
 
-    if (t <= 66) {
+    if (t < 10) {
+
+        approximate_regime_blackbody(scratch_rgb, t);
+
+    } else {
+
+        const BLEND_MIN = 65;
+        const BLEND_MAX = 67;
+
+        if (t < BLEND_MIN) {
 
-        r = 1;
+            approximate_regime_red(scratch_rgb, t);
 
-        g = clamp01(
-            -0.6088425710866344 - 0.001748900018414868 * (t - 2) + 0.4097731842899564 * Math.log(t - 2)
-        );
+        } else if (t > BLEND_MAX) {
+
+            approximate_regime_blue(scratch_rgb, t);
 
-        if (t <= 20) {
-            b = 0;
         } else {
 
-            b = clamp01(
-                -0.9990954974165059 + 0.0032447435545127036 * (t - 10) + 0.453646839257496 * Math.log(t - 10)
-            );
+            // blend the two regimes to avoid discontinuity
+            const alpha = inverseLerp(BLEND_MIN, BLEND_MAX, t);
 
-        }
-    } else {
+            approximate_regime_red(scratch_rgb, t);
+            const r0 = scratch_rgb[0];
+            const g0 = scratch_rgb[1];
+            const b0 = scratch_rgb[2];
 
-        r = clamp01(
-            1.3803015908551253 + 0.0004478684462124118 * (t - 55) - 0.15785750232675008 * Math.log(t - 55)
-        ); // in normalized scale
+            approximate_regime_blue(scratch_rgb, t);
+            const r1 = scratch_rgb[0];
+            const g1 = scratch_rgb[1];
+            const b1 = scratch_rgb[2];
 
-        g = clamp01(
-            1.2762722061615583 + 0.0003115080994769546 * (t - 50) - 0.11013841706194392 * Math.log(t - 50)
-        );
+            scratch_rgb[0] = lerp(r0, r1, alpha);
+            scratch_rgb[1] = lerp(g0, g1, alpha);
+            scratch_rgb[2] = lerp(b0, b1, alpha);
+
+        }
 
-        b = 1;
     }
 
-    result[result_offset + 0] = r;
-    result[result_offset + 1] = g;
-    result[result_offset + 2] = b;
+    result[result_offset + 0] = scratch_rgb[0];
+    result[result_offset + 1] = scratch_rgb[1];
+    result[result_offset + 2] = scratch_rgb[2];
 }

package/src/core/color/kelvin/rgb_to_kelvin.d.ts

@@ -1,8 +1,11 @@
 /**
+ * Estimates the Color Temperature (Kelvin) from an RGB input.
  *
- * @see https://www.zombieprototypes.com/?p=210
  * @param {number[]|ArrayLike<number>|{0:number,1:number,2:number}} input input array
  * @param {number} [input_offset=0] offset into input array
+ * @returns {number} Temperature in Kelvin (approx 1000 to 40000)
+ *
+ * @see https://www.zombieprototypes.com/?p=210
  */
 export function rgb_to_kelvin(input: number[] | ArrayLike<number> | {
     0: number;

package/src/core/color/kelvin/rgb_to_kelvin.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"rgb_to_kelvin.d.ts","sourceRoot":"","sources":["../../../../../src/core/color/kelvin/rgb_to_kelvin.js"],"names":[],"mappings":"AAKA;;;;;GAKG;AACH,qCAHW,MAAM,EAAE,GAAC,UAAU,MAAM,CAAC,GAAC;IAAC,CAAC,EAAC,MAAM,CAAC;IAAA,CAAC,EAAC,MAAM,CAAC;IAAA,CAAC,EAAC,MAAM,CAAA;CAAC,iBACvD,MAAM,UAwChB"}
+{"version":3,"file":"rgb_to_kelvin.d.ts","sourceRoot":"","sources":["../../../../../src/core/color/kelvin/rgb_to_kelvin.js"],"names":[],"mappings":"AASA;;;;;;;;GAQG;AACH,qCANW,MAAM,EAAE,GAAC,UAAU,MAAM,CAAC,GAAC;IAAC,CAAC,EAAC,MAAM,CAAC;IAAA,CAAC,EAAC,MAAM,CAAC;IAAA,CAAC,EAAC,MAAM,CAAA;CAAC,iBACvD,MAAM,GACJ,MAAM,CA4DlB"}

package/src/core/color/kelvin/rgb_to_kelvin.js

@@ -1,13 +1,20 @@
 import { assert } from "../../assert.js";
 import { kelvin_to_rgb } from "./kelvin_to_rgb.js";
 
+/**
+ * Save allocation with re-usable scratch
+ * @type {number[]}
+ */
 const scratch_rgb = [];
 
 /**
+ * Estimates the Color Temperature (Kelvin) from an RGB input.
  *
- * @see https://www.zombieprototypes.com/?p=210
  * @param {number[]|ArrayLike<number>|{0:number,1:number,2:number}} input input array
  * @param {number} [input_offset=0] offset into input array
+ * @returns {number} Temperature in Kelvin (approx 1000 to 40000)
+ *
+ * @see https://www.zombieprototypes.com/?p=210
  */
 export function rgb_to_kelvin(
     input,
@@ -17,32 +24,50 @@ export function rgb_to_kelvin(
     assert.isNonNegativeInteger(input_offset, "input_offset");
 
     const r = input[input_offset];
-    const g = input[input_offset + 1];
     const b = input[input_offset + 2];
 
-    const blue_red_ratio = b / r;
+    let minTemperature = 1000;
+    let maxTemperature = 40000;
+
+    if (r + b === 0) {
+        // black, effectively 0 Kelvin
+        return 0;
+    }
+
+    if (r === 0) {
+        // blue dominance, produce maximum
+        // also, avoid division by 0
+        return maxTemperature;
+    }
+
+    const expected_blue_red_ratio = b / r;
 
     // use solver to reverse function, slow but hey - it works
-    let temperature;
+    let temperature = 0;
 
     const epsilon = 0.4;
 
-    let minTemperature = 1000;
-    let maxTemperature = 40000;
-
+    // binary search
     while (maxTemperature - minTemperature > epsilon) {
 
         temperature = (maxTemperature + minTemperature) * 0.5;
 
         kelvin_to_rgb(scratch_rgb, 0, temperature);
 
-        const br = scratch_rgb[2] / scratch_rgb[0];
+        const actual_b = scratch_rgb[2];
+        const actual_r = scratch_rgb[0];
+
+        // prevent division by 0
+        const safe_r = Math.max(1e-7, actual_r);
 
-        if (br >= blue_red_ratio) {
+        const br = actual_b / safe_r;
+
+        if (br >= expected_blue_red_ratio) {
             maxTemperature = temperature;
         } else {
             minTemperature = temperature;
         }
+
     }
 
     return Math.round(temperature);

package/src/core/geom/Quaternion.d.ts

@@ -71,7 +71,7 @@ export class Quaternion implements Iterable<number> {
      */
     w: number;
     /**
-     * Fired when value of the quaternion changes
+     * Fires when the value of the quaternion changes
      * Signature of the signal data is as follows:
      *      (new_x, new_y, new_z, new_w, old_x, old_y, old_z, old_w)
      * @readonly
@@ -122,6 +122,9 @@ export class Quaternion implements Iterable<number> {
      * Orient quaternion on a `forward` vector, with the spin matching `up` vector
      * Useful for `lookAt` operations, such as for camera or inverse kinematics.
      * Normalizes input, meaning input does not have to be normalized.
+     *
+     * NOTE: `forward` and `up` vectors being the same is allowed, but you will likely get unexpected rotation along the look axis, so prefer not to do it.
+     *
      * @param {number} fx forward vector
      * @param {number} fy forward vector
      * @param {number} fz forward vector
@@ -151,10 +154,20 @@ export class Quaternion implements Iterable<number> {
      */
     copyInverse(other: Quaternion): this;
     /**
-     * Calculates the inverse
+     * Calculates the inverse.
+     * Correctly handles unnormalized quaternions.
+     *
+     * If your quaternion is normalized, you can use {@link conjugate} instead for speed.
      * @returns {this}
+     * @see conjugate
      */
     invert(): this;
+    /**
+     * NOTE: this is the same as {@link invert} if the quaternion is normalized.
+     * @returns {this}
+     * @see invert
+     */
+    conjugate(): this;
     /**
      * Returns angle between this orientation and another
      * @param {Quaternion} other
@@ -256,17 +269,14 @@ export class Quaternion implements Iterable<number> {
      */
     lookAt(source: Vector3, target: Vector3, up?: Vector3): void;
     /**
-     * @deprecated use {@link random} instead
-     * @param {function():number} random
-     */
-    setRandom(random: () => number): void;
-    /**
+     * @deprecated use {@link fromEulerAnglesXYZ} or others specifically.
      *
      * @param {number} x
      * @param {number} y
      * @param {number} z
      * @param {String} [order='XYZ'] a combination of capital letters X,Y,Z. Examples: XYZ, YXZ
      * @returns {this}
+     *
      * @see fromEulerAnglesXYZ
      * @see fromEulerAnglesYXZ
      * @see fromEulerAnglesZXY
@@ -291,6 +301,21 @@ export class Quaternion implements Iterable<number> {
      * @param {Vector3} result
      */
     toEulerAnglesZYX(result: Vector3): void;
+    /**
+     * Set rotation from Euler angles in degrees.
+     *
+     * Order is explicitly XYZ.
+     *
+     * Utility shortcut, same as `fromEulerAnglesXYZ(x * π / 180, y * π / 180, z * π / 180)`
+     *
+     * @param {number} [x] angle in degrees
+     * @param {number} [y] angle in degrees
+     * @param {number} [z] angle in degrees
+     * @returns {this}
+     *
+     * @see fromEulerAnglesXYZ
+     */
+    fromDegrees(x?: number, y?: number, z?: number): this;
     /**
      * XYZ order
      * @source: https://stackoverflow.com/questions/12088610/conversion-between-euler-quaternion-like-in-unity3d-engine
@@ -445,11 +470,6 @@ export class Quaternion implements Iterable<number> {
      * @returns {this}
      */
     set(x: number, y: number, z: number, w: number): this;
-    /**
-     *
-     * @returns {this}
-     */
-    conjugate(): this;
     toJSON(): {
         x: number;
         y: number;
@@ -488,14 +508,14 @@ export class Quaternion implements Iterable<number> {
      * @param {number} [offset]
      * @returns {this}
      */
-    readFromArray(array: number[], offset?: number): this;
+    fromArray(array: number[], offset?: number): this;
     /**
      *
      * @param {number[]} [array]
      * @param {number} [offset]
      * @returns {number[]}
      */
-    writeToArray(array?: number[], offset?: number): number[];
+    toArray(array?: number[], offset?: number): number[];
     /**
      * Strict equality check
      * @param {Quaternion} other
@@ -525,15 +545,28 @@ export class Quaternion implements Iterable<number> {
      * @return {boolean}
      */
     _roughlyEquals(x: number, y: number, z: number, w: number, tolerance?: number): boolean;
+    /**
+     * @deprecated use {@link random} instead
+     * @param {function():number} random
+     */
+    setRandom(random: () => number): void;
     /**
      * Randomly orient current quaternion
-     * @param {function():number} [random] Defaults to {@link Math.random}
-     * @return {Quaternion}
+     * @param {function():number} [random=Math.random] Random number generator function.
      */
-    random(random?: () => number): Quaternion;
+    random(random?: () => number): this;
     toString(): string;
-    fromArray: (array: number[], offset?: number) => this;
-    toArray: (array?: number[], offset?: number) => number[];
+    /**
+     * @deprecated use `fromArray`
+     */
+    readFromArray: (array: number[], offset?: number) => this;
+    /**
+     * @deprecated use `toArray`
+     */
+    writeToArray: (array?: number[], offset?: number) => number[];
+    /**
+     * @deprecated use `toArray`
+     */
     asArray: (array?: number[], offset?: number) => number[];
     fromEulerAngles: (x: number, y: number, z: number) => this;
     /**

package/src/core/geom/Quaternion.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Quaternion.d.ts","sourceRoot":"","sources":["../../../../src/core/geom/Quaternion.js"],"names":[],"mappings":"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"}
+{"version":3,"file":"Quaternion.d.ts","sourceRoot":"","sources":["../../../../src/core/geom/Quaternion.js"],"names":[],"mappings":"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"}