@woosh/meep-engine 2.131.16 → 2.131.17

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.17",
   "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);