@woosh/meep-engine 2.163.11 → 2.165.0

package/src/core/math/physics/mie/MIE_PARTICLES_STANDARD_PRECOMPUTED.d.ts

@@ -4,6 +4,7 @@ export namespace MIE_PARTICLES_STANDARD_PRECOMPUTED {
         let cross_section_scattering: number[];
         let cross_section_extinction: number[];
         let g: number;
+        let albedo: number[];
     }
     namespace CONTINENTAL_HAZE_MEDIUM {
         let radius_1: number;
@@ -14,6 +15,8 @@ export namespace MIE_PARTICLES_STANDARD_PRECOMPUTED {
         export { cross_section_extinction_1 as cross_section_extinction };
         let g_1: number;
         export { g_1 as g };
+        let albedo_1: number[];
+        export { albedo_1 as albedo };
     }
     namespace CONTINENTAL_HAZE_LARGE {
         let radius_2: number;
@@ -24,6 +27,8 @@ export namespace MIE_PARTICLES_STANDARD_PRECOMPUTED {
         export { cross_section_extinction_2 as cross_section_extinction };
         let g_2: number;
         export { g_2 as g };
+        let albedo_2: number[];
+        export { albedo_2 as albedo };
     }
     namespace MARITIME_HAZE_SMALL {
         let radius_3: number;
@@ -34,6 +39,8 @@ export namespace MIE_PARTICLES_STANDARD_PRECOMPUTED {
         export { cross_section_extinction_3 as cross_section_extinction };
         let g_3: number;
         export { g_3 as g };
+        let albedo_3: number[];
+        export { albedo_3 as albedo };
     }
     namespace MARITIME_HAZE_MEDIUM {
         let radius_4: number;
@@ -44,6 +51,8 @@ export namespace MIE_PARTICLES_STANDARD_PRECOMPUTED {
         export { cross_section_extinction_4 as cross_section_extinction };
         let g_4: number;
         export { g_4 as g };
+        let albedo_4: number[];
+        export { albedo_4 as albedo };
     }
     namespace MARITIME_HAZE_LARGE {
         let radius_5: number;
@@ -54,6 +63,8 @@ export namespace MIE_PARTICLES_STANDARD_PRECOMPUTED {
         export { cross_section_extinction_5 as cross_section_extinction };
         let g_5: number;
         export { g_5 as g };
+        let albedo_5: number[];
+        export { albedo_5 as albedo };
     }
     namespace FOG_DROPLET_SMALL {
         let radius_6: number;
@@ -64,6 +75,8 @@ export namespace MIE_PARTICLES_STANDARD_PRECOMPUTED {
         export { cross_section_extinction_6 as cross_section_extinction };
         let g_6: number;
         export { g_6 as g };
+        let albedo_6: number[];
+        export { albedo_6 as albedo };
     }
     namespace FOG_DROPLET_MEDIUM {
         let radius_7: number;
@@ -74,6 +87,8 @@ export namespace MIE_PARTICLES_STANDARD_PRECOMPUTED {
         export { cross_section_extinction_7 as cross_section_extinction };
         let g_7: number;
         export { g_7 as g };
+        let albedo_7: number[];
+        export { albedo_7 as albedo };
     }
     namespace CLOUD_DROPLET_LARGE {
         let radius_8: number;
@@ -84,6 +99,8 @@ export namespace MIE_PARTICLES_STANDARD_PRECOMPUTED {
         export { cross_section_extinction_8 as cross_section_extinction };
         let g_8: number;
         export { g_8 as g };
+        let albedo_8: number[];
+        export { albedo_8 as albedo };
     }
     namespace SMOKE_PARTICLE_SMALL {
         let radius_9: number;
@@ -94,6 +111,8 @@ export namespace MIE_PARTICLES_STANDARD_PRECOMPUTED {
         export { cross_section_extinction_9 as cross_section_extinction };
         let g_9: number;
         export { g_9 as g };
+        let albedo_9: number[];
+        export { albedo_9 as albedo };
     }
     namespace SMOKE_PARTICLE_MEDIUM {
         let radius_10: number;
@@ -104,6 +123,8 @@ export namespace MIE_PARTICLES_STANDARD_PRECOMPUTED {
         export { cross_section_extinction_10 as cross_section_extinction };
         let g_10: number;
         export { g_10 as g };
+        let albedo_10: number[];
+        export { albedo_10 as albedo };
     }
     namespace SMOKE_PARTICLE_LARGE {
         let radius_11: number;
@@ -114,6 +135,8 @@ export namespace MIE_PARTICLES_STANDARD_PRECOMPUTED {
         export { cross_section_extinction_11 as cross_section_extinction };
         let g_11: number;
         export { g_11 as g };
+        let albedo_11: number[];
+        export { albedo_11 as albedo };
     }
     namespace SOOT_PARTICLE_SMALL {
         let radius_12: number;
@@ -124,6 +147,8 @@ export namespace MIE_PARTICLES_STANDARD_PRECOMPUTED {
         export { cross_section_extinction_12 as cross_section_extinction };
         let g_12: number;
         export { g_12 as g };
+        let albedo_12: number[];
+        export { albedo_12 as albedo };
     }
     namespace SOOT_AGGREGATE_MEDIUM {
         let radius_13: number;
@@ -134,6 +159,8 @@ export namespace MIE_PARTICLES_STANDARD_PRECOMPUTED {
         export { cross_section_extinction_13 as cross_section_extinction };
         let g_13: number;
         export { g_13 as g };
+        let albedo_13: number[];
+        export { albedo_13 as albedo };
     }
     namespace SOOT_AGGREGATE_LARGE {
         let radius_14: number;
@@ -144,6 +171,8 @@ export namespace MIE_PARTICLES_STANDARD_PRECOMPUTED {
         export { cross_section_extinction_14 as cross_section_extinction };
         let g_14: number;
         export { g_14 as g };
+        let albedo_14: number[];
+        export { albedo_14 as albedo };
     }
     namespace FINE_DUST_SMALL {
         let radius_15: number;
@@ -154,6 +183,8 @@ export namespace MIE_PARTICLES_STANDARD_PRECOMPUTED {
         export { cross_section_extinction_15 as cross_section_extinction };
         let g_15: number;
         export { g_15 as g };
+        let albedo_15: number[];
+        export { albedo_15 as albedo };
     }
     namespace COARSE_DUST_MEDIUM {
         let radius_16: number;
@@ -164,6 +195,8 @@ export namespace MIE_PARTICLES_STANDARD_PRECOMPUTED {
         export { cross_section_extinction_16 as cross_section_extinction };
         let g_16: number;
         export { g_16 as g };
+        let albedo_16: number[];
+        export { albedo_16 as albedo };
     }
     namespace COARSE_DUST_LARGE {
         let radius_17: number;
@@ -174,6 +207,8 @@ export namespace MIE_PARTICLES_STANDARD_PRECOMPUTED {
         export { cross_section_extinction_17 as cross_section_extinction };
         let g_17: number;
         export { g_17 as g };
+        let albedo_17: number[];
+        export { albedo_17 as albedo };
     }
     namespace POLLEN_PARTICLE_MEDIUM {
         let radius_18: number;
@@ -184,6 +219,8 @@ export namespace MIE_PARTICLES_STANDARD_PRECOMPUTED {
         export { cross_section_extinction_18 as cross_section_extinction };
         let g_18: number;
         export { g_18 as g };
+        let albedo_18: number[];
+        export { albedo_18 as albedo };
     }
     namespace POLLEN_PARTICLE_LARGE {
         let radius_19: number;
@@ -194,6 +231,8 @@ export namespace MIE_PARTICLES_STANDARD_PRECOMPUTED {
         export { cross_section_extinction_19 as cross_section_extinction };
         let g_19: number;
         export { g_19 as g };
+        let albedo_19: number[];
+        export { albedo_19 as albedo };
     }
 }
 //# sourceMappingURL=MIE_PARTICLES_STANDARD_PRECOMPUTED.d.ts.map

package/src/core/math/physics/mie/MIE_PARTICLES_STANDARD_PRECOMPUTED.js

@@ -2,13 +2,14 @@
  * 📚 Precomputed standard atmospheric particle library for rendering.
  *
  * This file is GENERATED. Do not edit by hand.
- * Generation settings: 380–780 nm, step_count=74, sRGB CMFs, medium=air.
+ * Generation settings: 380–780 nm, step_size=5 nm (81 samples), sRGB CMFs, medium=air.
  *
  * Each entry contains:
  * - radius: Particle radius in meters.
  * - cross_section_scattering: [R, G, B] scattering coefficients (m²).
  * - cross_section_extinction: [R, G, B] extinction coefficients (m²).
  * - g: Asymmetry parameter (average cosine of the scattering angle).
+ * - albedo: [R, G, B] single-scattering albedo — the scattered fraction of extinguished light, in [0,1].
  */
 export const MIE_PARTICLES_STANDARD_PRECOMPUTED = {
 
@@ -24,6 +25,7 @@ export const MIE_PARTICLES_STANDARD_PRECOMPUTED = {
     cross_section_scattering: [1.0372407599145680e-16, 2.1697944076390811e-16, 4.9834805745060257e-16],
     cross_section_extinction: [1.0390516205855430e-16, 2.1717567420831002e-16, 4.9879159253139388e-16],
     g: 0.06687111747972882,
+    albedo: [0.9985408461697118, 0.9990945681117027, 0.9988629217749472],
   },
   /**
    * MEDIUM — typical daytime urban/valley haze with gentle desaturation.
@@ -34,6 +36,7 @@ export const MIE_PARTICLES_STANDARD_PRECOMPUTED = {
     cross_section_scattering: [5.4565579877961842e-13, 6.8621977746322113e-13, 8.2869951608010304e-13],
     cross_section_extinction: [5.4570905150853122e-13, 6.8627271753511908e-13, 8.2881953884176050e-13],
     g: 0.72195208606467531,
+    albedo: [0.9999482576027167, 0.9999364568774085, 0.9995816510680566],
   },
   /**
    * LARGE — thicker land haze; think post‑inversion murk softening hills.
@@ -44,6 +47,7 @@ export const MIE_PARTICLES_STANDARD_PRECOMPUTED = {
     cross_section_scattering: [3.0366185612989802e-12, 2.1644690526988712e-12, 1.3935109366522711e-12],
     cross_section_extinction: [3.0370652035911430e-12, 2.1649491115406566e-12, 1.3945337813123169e-12],
     g: 0.6137288243405209,
+    albedo: [0.9998952697384723, 0.9998037766123345, 0.9990189659047288],
   },
 
   /**
@@ -56,6 +60,7 @@ export const MIE_PARTICLES_STANDARD_PRECOMPUTED = {
     cross_section_scattering: [5.5914464124496594e-17, 1.1568131266404890e-16, 2.6209632958954776e-16],
     cross_section_extinction: [5.5915758040155253e-17, 1.1568241782228503e-16, 2.6209808791233174e-16],
     g: 0.062667411576877274,
+    albedo: [1, 1, 0.9997202441579425],
   },
   /**
    * MEDIUM — bright, milky air on a breezy beach or around harbors.
@@ -66,6 +71,7 @@ export const MIE_PARTICLES_STANDARD_PRECOMPUTED = {
     cross_section_scattering: [2.7132966283888992e-13, 4.0042270998895428e-13, 5.5420120025016184e-13],
     cross_section_extinction: [2.7132992896636519e-13, 4.0042294960829909e-13, 5.5420156922320274e-13],
     g: 0.75572608442123446,
+    albedo: [1, 1, 0.9997260009141733],
   },
   /**
    * LARGE — thick marine layer look before it becomes fog.
@@ -76,6 +82,7 @@ export const MIE_PARTICLES_STANDARD_PRECOMPUTED = {
     cross_section_scattering: [3.0886970942611371e-12, 3.1506283070098210e-12, 2.6753836337037947e-12],
     cross_section_extinction: [3.0886995489983882e-12, 3.1506303784552175e-12, 2.6753868296970645e-12],
     g: 0.82009537287886958,
+    albedo: [1, 1, 0.9997254620813307],
   },
 
   /**
@@ -88,6 +95,7 @@ export const MIE_PARTICLES_STANDARD_PRECOMPUTED = {
     cross_section_scattering: [6.6872146821004324e-12, 5.4309369486615811e-12, 7.5571588161013023e-12],
     cross_section_extinction: [6.6872171928267207e-12, 5.4309373592604994e-12, 7.5571591319672130e-12],
     g: 0.66286908969703728,
+    albedo: [1, 1, 0.9997266227065711],
   },
   /**
    * MEDIUM — typical road fog reducing visibility to a few hundred meters.
@@ -98,6 +106,7 @@ export const MIE_PARTICLES_STANDARD_PRECOMPUTED = {
     cross_section_scattering: [1.7036472789376784e-10, 1.6665060947239930e-10, 1.6466175909414485e-10],
     cross_section_extinction: [1.7036520771027743e-10, 1.6665065143578210e-10, 1.6466177643977473e-10],
     g: 0.85263072331984047,
+    albedo: [1, 1, 0.9997265540670952],
   },
   /**
    * LARGE — bright, thick cloud core or dense sea fog.
@@ -108,6 +117,7 @@ export const MIE_PARTICLES_STANDARD_PRECOMPUTED = {
     cross_section_scattering: [6.5315742448115536e-10, 6.5618165104565060e-10, 6.5250478893917499e-10],
     cross_section_extinction: [6.5315858886811270e-10, 6.5618181350359152e-10, 6.5250489005400894e-10],
     g: 0.86080713114012297,
+    albedo: [1, 1, 0.9997265064666194],
   },
 
 
@@ -123,6 +133,7 @@ export const MIE_PARTICLES_STANDARD_PRECOMPUTED = {
     cross_section_scattering: [2.5095238381331490e-13, 3.2817527241713552e-13, 4.7184181688431561e-13],
     cross_section_extinction: [2.5244957121744367e-13, 3.3073489397071378e-13, 4.7766204956433065e-13],
     g: 0.64153537730937171,
+    albedo: [0.9940376689636649, 0.9921581959561507, 0.9874287159432464],
   },
   /**
    * MEDIUM — typical wildfire/chimney smoke drifting across a valley.
@@ -133,6 +144,7 @@ export const MIE_PARTICLES_STANDARD_PRECOMPUTED = {
     cross_section_scattering: [2.2186086454447846e-12, 1.8611290477348588e-12, 1.2017961650839806e-12],
     cross_section_extinction: [2.2347400788139265e-12, 1.8849701372888018e-12, 1.2529531542589939e-12],
     g: 0.68088789083915369,
+    albedo: [0.9925135411273615, 0.9880783700292635, 0.9592909905007622],
   },
   /**
    * LARGE — aged regional smoke layers that turn the sun orange.
@@ -143,6 +155,7 @@ export const MIE_PARTICLES_STANDARD_PRECOMPUTED = {
     cross_section_scattering: [9.7154096631596466e-12, 6.5695017319655712e-12, 6.5950874641241054e-12],
     cross_section_extinction: [9.9744536671262377e-12, 6.9383549994562171e-12, 7.2416530016257137e-12],
     g: 0.73891619526845487,
+    albedo: [0.9782832572395267, 0.9461858372785726, 0.9117468524231586],
   },
 
   /**
@@ -155,6 +168,7 @@ export const MIE_PARTICLES_STANDARD_PRECOMPUTED = {
     cross_section_scattering: [4.9471331742851396e-18, 1.1425655543629920e-17, 3.3950349242847612e-17],
     cross_section_extinction: [4.9469989827650098e-16, 6.4148352307268963e-16, 9.4380272697116261e-16],
     g: 0.018039326863221513,
+    albedo: [0.010285326290695309, 0.01831185679777372, 0.03622476700049886],
   },
   /**
    * MEDIUM — traffic/industrial pollution haze mixing into city air.
@@ -165,6 +179,7 @@ export const MIE_PARTICLES_STANDARD_PRECOMPUTED = {
     cross_section_scattering: [1.6352855504532771e-14, 2.6526196915106281e-14, 3.7046081158626368e-14],
     cross_section_extinction: [5.6514531230912217e-14, 7.3826992547192368e-14, 8.8338524712659901e-14],
     g: 0.31674236124633798,
+    albedo: [0.29546957226435, 0.3595390060739381, 0.4207032773370711],
   },
   /**
    * LARGE — heavy dirty smoke near source: burning oil/tires.
@@ -175,6 +190,7 @@ export const MIE_PARTICLES_STANDARD_PRECOMPUTED = {
     cross_section_scattering: [1.6063607357301153e-13, 1.6542541029497725e-13, 1.6709682614452953e-13],
     cross_section_extinction: [3.6165255982805808e-13, 3.6212311121035904e-13, 3.5517926834511851e-13],
     g: 0.69133198032115784,
+    albedo: [0.4441637960717832, 0.45681906031998054, 0.47032807048131975],
   },
 
 
@@ -190,6 +206,7 @@ export const MIE_PARTICLES_STANDARD_PRECOMPUTED = {
     cross_section_scattering: [2.6570379687422880e-12, 3.6996919661206611e-12, 4.5471939176491137e-12],
     cross_section_extinction: [2.8819492220384537e-12, 4.1008076519912007e-12, 5.1659038204372376e-12],
     g: 0.63886827482281139,
+    albedo: [0.9197730722024005, 0.9020084626161894, 0.8791962654314995],
   },
   /**
    * MEDIUM — moving dust clouds from vehicles or field winds.
@@ -200,6 +217,7 @@ export const MIE_PARTICLES_STANDARD_PRECOMPUTED = {
     cross_section_scattering: [3.5472196264524937e-11, 3.3430210987054714e-11, 3.2075451113920786e-11],
     cross_section_extinction: [4.2441528450403185e-11, 4.3597399152097500e-11, 4.3350184971955535e-11],
     g: 0.84075100028702532,
+    albedo: [0.8355771860125581, 0.7660764258472097, 0.7394172548514861],
   },
   /**
    * LARGE — sandstorm wall: near‑camera blowing sand/tan curtains.
@@ -210,6 +228,7 @@ export const MIE_PARTICLES_STANDARD_PRECOMPUTED = {
     cross_section_scattering: [3.1816278385853973e-10, 2.9406557017587955e-10, 2.6643041098315311e-10],
     cross_section_extinction: [3.7355130308305938e-10, 3.7144494812949936e-10, 3.6814067045857220e-10],
     g: 0.85247658559411998,
+    albedo: [0.851940172384625, 0.7916224939997588, 0.72361818240274],
   },
 
   /**
@@ -222,6 +241,7 @@ export const MIE_PARTICLES_STANDARD_PRECOMPUTED = {
     cross_section_scattering: [6.3652345959538284e-10, 6.2647624730458445e-10, 5.8718713214140584e-10],
     cross_section_extinction: [6.5918545142090177e-10, 6.5700023143709686e-10, 6.5127465699910976e-10],
     g: 0.81082270359712194,
+    albedo: [0.965664875936545, 0.9535618270156249, 0.9013536004003102],
   },
   /**
    * LARGE — visible puffs from trees (e.g., pine) or catkins in forests.
@@ -232,5 +252,6 @@ export const MIE_PARTICLES_STANDARD_PRECOMPUTED = {
     cross_section_scattering: [1.3961132818036018e-9, 1.3739693858138355e-9, 1.2750015299393954e-9],
     cross_section_extinction: [1.4562652589727905e-9, 1.4596101004954230e-9, 1.4523332353409636e-9],
     g: 0.81884345812519288,
+    albedo: [0.9586761245647418, 0.9413733861856849, 0.8776540420546609],
   },
 };

package/src/core/math/physics/mie/compute_mie_particle_properties_rgb.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"compute_mie_particle_properties_rgb.d.ts","sourceRoot":"","sources":["../../../../../../src/core/math/physics/mie/compute_mie_particle_properties_rgb.js"],"names":[],"mappings":"AAMA;;;;;;;;GAQG;AACH,8DALW,MAAM,uCAGN,MAAM;;;;;;EAwIhB"}
+{"version":3,"file":"compute_mie_particle_properties_rgb.d.ts","sourceRoot":"","sources":["../../../../../../src/core/math/physics/mie/compute_mie_particle_properties_rgb.js"],"names":[],"mappings":"AAMA;;;;;;;;GAQG;AACH,8DALW,MAAM,uCAGN,MAAM;;;;;;EA+JhB"}

package/src/core/math/physics/mie/compute_mie_particle_properties_rgb.js

@@ -24,7 +24,8 @@ export function compute_mie_particle_properties_rgb(
     assert.greaterThan(radius_m, 0, 'radius_m must be positive');
     assert.isFunction(n_p, 'n_p');
     assert.isFunction(n_med, 'n_med');
-    assert.isNonNegativeInteger(step_size_nm, 'step_size_nm');
+    // must be > 0: a zero step never advances the sweep loop (infinite loop).
+    assert.isPositiveInteger(step_size_nm, 'step_size_nm');
 
     const cmf = [0, 0, 0];
     let sum_Ey = 0;
@@ -33,6 +34,17 @@ export function compute_mie_particle_properties_rgb(
     const extinction_coefficients = [0, 0, 0];
     const sigma_a_med = [0, 0, 0];
 
+    // Single-scattering albedo ϖ(λ) = C_sca/C_ext is a per-wavelength quantity in [0, 1]. We
+    // accumulate it as its own tristimulus colour and resolve it BEFORE the XYZ→sRGB transform.
+    // Deriving albedo the other way — dividing the two finished sRGB coefficient triples — is wrong:
+    // the sRGB matrix has large negative off-diagonals, so the per-wavelength ordering C_sca ≤ C_ext
+    // (which holds component-wise in XYZ, where the CMF weights are non-negative) is destroyed
+    // channel-wise. That yields unphysical albedo — escaping the [min,max] spectral envelope, and for
+    // chromatic absorbers pinning to 0 (a scattering channel reported as a perfect absorber) or
+    // masking to 1 (an absorbing channel reported as non-absorbing). Integrating ϖ(λ) directly keeps
+    // it a true positive-weighted spectral mean.
+    const albedo_xyz = [0, 0, 0];
+
     const ir_particle = [];
     const ir_medium = [];
 
@@ -84,6 +96,12 @@ export function compute_mie_particle_properties_rgb(
         sigma_a_med[1] += properties.sigma_a_med * wY;
         sigma_a_med[2] += properties.sigma_a_med * wZ;
 
+        // integrate the per-wavelength single-scattering albedo as its own colour (see albedo_xyz note)
+        const single_scatter_albedo = properties.C_ext > 0 ? properties.C_sca / properties.C_ext : 0;
+        albedo_xyz[0] += single_scatter_albedo * wX;
+        albedo_xyz[1] += single_scatter_albedo * wY;
+        albedo_xyz[2] += single_scatter_albedo * wZ;
+
         // We weight 'g' by how much this wavelength contributes to
         // the Visible Luminance (Y) of the Scattered light.
         // If C_sca is 0, this wavelength should not affect the average G.
@@ -108,6 +126,10 @@ export function compute_mie_particle_properties_rgb(
     sigma_a_med[1] *= k;
     sigma_a_med[2] *= k;
 
+    albedo_xyz[0] *= k;
+    albedo_xyz[1] *= k;
+    albedo_xyz[2] *= k;
+
     // Resolve G
     // If the particle is invisible (no scattering), default to isotropic (0)
     const final_g = g_weight_total > 1e-20 ? (g_weighted_accumulator / g_weight_total) : 0;
@@ -118,6 +140,15 @@ export function compute_mie_particle_properties_rgb(
     xyz_to_rgb(extinction_coefficients, extinction_coefficients);
     xyz_to_rgb(sigma_a_med, sigma_a_med);
 
+    // Resolve the single-scattering albedo colour from its own integral. ϖ(λ)∈[0,1] is
+    // reflectance-like, so a saturated albedo spectrum can land marginally outside the sRGB gamut;
+    // clamp each channel back into [0,1].
+    const albedo = [0, 0, 0];
+    xyz_to_rgb(albedo, albedo_xyz);
+    albedo[0] = Math.min(1, Math.max(0, albedo[0]));
+    albedo[1] = Math.min(1, Math.max(0, albedo[1]));
+    albedo[2] = Math.min(1, Math.max(0, albedo[2]));
+
     // Perform gamut clamp to remove potential negative lobes
     scattering_coefficients[0] = Math.max(0, scattering_coefficients[0]);
     scattering_coefficients[1] = Math.max(0, scattering_coefficients[1]);
@@ -131,14 +162,6 @@ export function compute_mie_particle_properties_rgb(
     sigma_a_med[1] = Math.max(0, sigma_a_med[1]);
     sigma_a_med[2] = Math.max(0, sigma_a_med[2]);
 
-    // Derive the albedo.
-    // Prevent division by 0, and clamp gamut at the upper range to 1
-    const albedo = [
-        extinction_coefficients[0] !== 0 ? Math.min(1, scattering_coefficients[0] / extinction_coefficients[0]) : 0,
-        extinction_coefficients[1] !== 0 ? Math.min(1, scattering_coefficients[1] / extinction_coefficients[1]) : 0,
-        extinction_coefficients[2] !== 0 ? Math.min(1, scattering_coefficients[2] / extinction_coefficients[2]) : 0,
-    ];
-
     return {
         scattering_coefficients,
         extinction_coefficients,

package/src/core/math/physics/mie/compute_mie_phase.d.ts

@@ -7,10 +7,9 @@
  * @param {Float32Array} ab - The flat array of a_n, b_n coefficients from LorenzMie_coefs.
  * @param {number} C_sca total scattering cross-section for normalization
  * @param {number} wavelength - Wavelength of light in vacuum (in meters).
- * @param {vec2} n_med - Complex refractive index of the medium.
+ * @param {number[]|Float32Array|Float64Array} n_med - Complex refractive index of the medium.
  * @param {number} cos_theta - Cosine of the angle between incoming light and observation angle.
  * @returns {number} The normalized phase function value P(theta).
  */
-export function compute_mie_phase(ab: Float32Array, C_sca: number, n_med: typeof vec2, wavelength: number, cos_theta: number): number;
-import { vec2 } from "./lorenz_mie_coefs.js";
+export function compute_mie_phase(ab: Float32Array, C_sca: number, n_med: number[] | Float32Array | Float64Array, wavelength: number, cos_theta: number): number;
 //# sourceMappingURL=compute_mie_phase.d.ts.map

package/src/core/math/physics/mie/compute_mie_phase.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"compute_mie_phase.d.ts","sourceRoot":"","sources":["../../../../../../src/core/math/physics/mie/compute_mie_phase.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;GAYG;AACH,sCAPW,YAAY,SACZ,MAAM,kCACN,MAAM,aAEN,MAAM,GACJ,MAAM,CAsElB;qBAnFoB,uBAAuB"}
+{"version":3,"file":"compute_mie_phase.d.ts","sourceRoot":"","sources":["../../../../../../src/core/math/physics/mie/compute_mie_phase.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,sCAPW,YAAY,SACZ,MAAM,SAEN,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,cADlC,MAAM,aAEN,MAAM,GACJ,MAAM,CAsElB"}

package/src/core/math/physics/mie/compute_mie_phase.js

@@ -1,5 +1,3 @@
-import { vec2 } from "./lorenz_mie_coefs.js";
-
 /**
  * Computes the normalized Mie phase function value for a specific angle.
  *
@@ -9,7 +7,7 @@ import { vec2 } from "./lorenz_mie_coefs.js";
  * @param {Float32Array} ab - The flat array of a_n, b_n coefficients from LorenzMie_coefs.
  * @param {number} C_sca total scattering cross-section for normalization
  * @param {number} wavelength - Wavelength of light in vacuum (in meters).
- * @param {vec2} n_med - Complex refractive index of the medium.
+ * @param {number[]|Float32Array|Float64Array} n_med - Complex refractive index of the medium.
  * @param {number} cos_theta - Cosine of the angle between incoming light and observation angle.
  * @returns {number} The normalized phase function value P(theta).
  */

package/src/core/math/physics/mie/lorenz_mie_coefs.d.ts

@@ -1,4 +1,3 @@
-export function vec2(x: any, y: any): Float64Array;
 /**
  * Implementation of Lorenz-Mie theory.
  * Useful for calculating physically correct radiation scattering events for particles in a medium.

package/src/core/math/physics/mie/lorenz_mie_coefs.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"lorenz_mie_coefs.d.ts","sourceRoot":"","sources":["../../../../../../src/core/math/physics/mie/lorenz_mie_coefs.js"],"names":[],"mappings":"AAUA,mDAEC;AAgID;;;;;;;;;;;;;GAaG;AACH,+CATW,MAAM,YADN,MAAM,OAEN,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,SAClC,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,GAChC,YAAY,CAoGxB"}
+{"version":3,"file":"lorenz_mie_coefs.d.ts","sourceRoot":"","sources":["../../../../../../src/core/math/physics/mie/lorenz_mie_coefs.js"],"names":[],"mappings":"AAqIA;;;;;;;;;;;;;GAaG;AACH,+CATW,MAAM,YADN,MAAM,OAEN,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,SAClC,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,GAChC,YAAY,CAoGxB"}

package/src/core/math/physics/mie/lorenz_mie_coefs.js

@@ -5,13 +5,6 @@ import { complex_div } from "../../complex/complex_div.js";
 import { complex_mul } from "../../complex/complex_mul.js";
 import { complex_sub } from "../../complex/complex_sub.js";
 
-// Kept for compute_mie_phase.js. The complex algebra below is allocation-free (it calls the meep
-// complex primitives directly into reused scratch), so the old allocating cadd/cmult/cdiv wrappers
-// are gone.
-export function vec2(x, y) {
-    return new Float64Array([x, y]);
-}
-
 // ---------------------------------------------------------------------------------------------
 // Allocation-free complex algebra.
 //

package/src/engine/EngineHarness.js

@@ -359,14 +359,14 @@ export class EngineHarness {
     static async buildLights({
                                  engine,
                                  ecd = engine.entityManager.dataset,
-                                 shadowmapResolution = 1024,
+                                 shadowmapResolution = 2048,
                                  castShadow = true,
                                  sun = DEFAULT_SUNLIGHT_COLOR,
                                  sunIntensity = 0.9,
                                  sunDirection = new Vector3(0.17, -1, 0.17),
                                  sunShadowDistance = 1000,
                                  ambient = Color.white,
-                                 ambientIntensity = 0.1
+                                 ambientIntensity = 0.07
                              }) {
         const em = engine.entityManager;
 

package/src/engine/animation/curve/view/AnimationCurveView.js

@@ -1,7 +1,7 @@
 import { assert } from "../../../../core/assert.js";
 import AABB2 from "../../../../core/geom/2d/aabb/AABB2.js";
 import { m3_cm_compose_transform } from "../../../../core/geom/mat3/m3_cm_compose_transform.js";
-import { m3_cm_invert } from "../../../../core/geom/mat3/m3_cm_invert.js";
+import { m3_invert } from "../../../../core/geom/mat3/m3_invert.js";
 import { v2_length } from "../../../../core/geom/vec2/v2_length.js";
 import { v2_matrix3_cm_multiply } from "../../../../core/geom/vec2/v2_matrix3_cm_multiply.js";
 import { CanvasView } from "../../../../view/elements/CanvasView.js";
@@ -108,7 +108,7 @@ export class AnimationCurveView extends EmptyView {
             frame.x0, frame.y1, 0
         );
 
-        m3_cm_invert(this.#transform_inverse, this.#transform);
+        m3_invert(this.#transform_inverse, this.#transform);
     }
 
     /**

package/src/engine/asset/loaders/material/planeHash.js

@@ -1,4 +1,4 @@
-import { mortonEncode_magicbits } from "../../../../core/geom/3d/morton/mortonEncode_magicbits.js";
+import { v3_morton_encode_magicbits } from "../../../../core/geom/3d/morton/v3_morton_encode_magicbits.js";
 
 /**
  *
@@ -6,5 +6,5 @@ import { mortonEncode_magicbits } from "../../../../core/geom/3d/morton/mortonEn
  * @returns {number}
  */
 export function planeHash(plane) {
-    return mortonEncode_magicbits(plane.normal.x, plane.normal.y, plane.normal.z) ^ plane.constant;
+    return v3_morton_encode_magicbits(plane.normal.x, plane.normal.y, plane.normal.z) ^ plane.constant;
 }

package/src/engine/control/first-person/FirstPersonPlayerControllerSystem.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"FirstPersonPlayerControllerSystem.d.ts","sourceRoot":"","sources":["../../../../../src/engine/control/first-person/FirstPersonPlayerControllerSystem.js"],"names":[],"mappings":"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"}
+{"version":3,"file":"FirstPersonPlayerControllerSystem.d.ts","sourceRoot":"","sources":["../../../../../src/engine/control/first-person/FirstPersonPlayerControllerSystem.js"],"names":[],"mappings":"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"}

package/src/engine/control/first-person/FirstPersonPlayerControllerSystem.js

@@ -1,4 +1,7 @@
 import { assert } from "../../../core/assert.js";
+import { Ray3 } from "../../../core/geom/3d/ray/Ray3.js";
+import { CapsuleShape3D } from "../../../core/geom/3d/shape/CapsuleShape3D.js";
+import { TransformedShape3D } from "../../../core/geom/3d/shape/TransformedShape3D.js";
 import Quaternion from "../../../core/geom/Quaternion.js";
 import Vector3 from "../../../core/geom/Vector3.js";
 import { clamp } from "../../../core/math/clamp.js";
@@ -11,27 +14,24 @@ import Entity from "../../ecs/Entity.js";
 import { System } from "../../ecs/System.js";
 import { Transform } from "../../ecs/transform/Transform.js";
 import { Camera } from "../../graphics/ecs/camera/Camera.js";
-import { EyeOffsetStack } from "./composer/EyeOffsetStack.js";
-import { Ray3 } from "../../../core/geom/3d/ray/Ray3.js";
-import { CapsuleShape3D } from "../../../core/geom/3d/shape/CapsuleShape3D.js";
-import { TransformedShape3D } from "../../../core/geom/3d/shape/TransformedShape3D.js";
 import { BodyKind } from "../../physics/ecs/BodyKind.js";
 import { Collider } from "../../physics/ecs/Collider.js";
 import { PhysicsSystem } from "../../physics/ecs/PhysicsSystem.js";
 import { RigidBody } from "../../physics/ecs/RigidBody.js";
 import { PhysicsSurfacePoint } from "../../physics/queries/PhysicsSurfacePoint.js";
+import { KinematicMover } from "./collision/KinematicMover.js";
+import { EyeOffsetStack } from "./composer/EyeOffsetStack.js";
 import { FirstPersonPlayerController } from "./FirstPersonPlayerController.js";
 import { DecisionPoint } from "./mastery/DecisionPoint.js";
 import { computeJumpFromApex } from "./math/computeJumpFromApex.js";
-import { jumpForceForHeight, launchVelocityForForce } from "./math/jumpDynamics.js";
 import { computeLRCBreathRate } from "./math/computeLRCBreathRate.js";
 import { computeMassRatios } from "./math/computeMassRatios.js";
+import { jumpForceForHeight, launchVelocityForForce } from "./math/jumpDynamics.js";
 import { Spring } from "./math/Spring.js";
 import { stepTowards } from "./math/stepTowards.js";
 import { FirstPersonActionState, FirstPersonLocomotionMode } from "./pose/FirstPersonPose.js";
 import { FirstPersonPosture } from "./pose/FirstPersonPosture.js";
 import { FirstPersonSensors } from "./sensors/FirstPersonSensors.js";
-import { KinematicMover } from "./collision/KinematicMover.js";
 
 // ---------------------------------------------------------------------------
 // Scratch allocations — reused per frame to avoid GC pressure
@@ -582,7 +582,7 @@ export class FirstPersonPlayerControllerSystem extends System {
             camera.fov.set(controller.config.fov.base);
             camera.clip_near = 0.05;
             camera.clip_far = 1000;
-            camera.autoClip = false;
+            camera.autoClip = true;
 
             eye.add(eyeTransform);
             eye.add(camera);

package/src/engine/control/first-person/prototype_first_person_controller.js

@@ -3,7 +3,7 @@ import { Ray3 } from "../../../core/geom/3d/ray/Ray3.js";
 import { BoxShape3D } from "../../../core/geom/3d/shape/BoxShape3D.js";
 import { CapsuleShape3D } from "../../../core/geom/3d/shape/CapsuleShape3D.js";
 import { TransformedShape3D } from "../../../core/geom/3d/shape/TransformedShape3D.js";
-import { shape_mesh_from_geometry } from "../../../core/geom/3d/shape/shape_mesh_from_geometry.js";
+import { shape3_mesh_from_geometry } from "../../../core/geom/3d/shape/shape3_mesh_from_geometry.js";
 import Quaternion from "../../../core/geom/Quaternion.js";
 import Vector2 from "../../../core/geom/Vector2.js";
 import Vector3 from "../../../core/geom/Vector3.js";
@@ -243,7 +243,7 @@ function buildGym(ecd) {
 /**
  * Drop a torus-knot prop off to the side as a smoke test for
  * {@link MeshShape3D}: arbitrary indexed triangle mesh → tetrahedralised
- * collider via {@link shape_mesh_from_geometry}.
+ * collider via {@link shape3_mesh_from_geometry}.
  *
  * Dynamic body, so the player capsule (kinematic) can bump it around.
  * KinematicPosition bodies don't receive impulses themselves (the
@@ -273,7 +273,7 @@ function buildMeshShapeShowcase(ecd) {
         ? src_indices
         : Uint32Array.from(src_indices);
 
-    const shape = shape_mesh_from_geometry(positions, indices);
+    const shape = shape3_mesh_from_geometry(positions, indices);
 
     const material = new MeshStandardMaterial({ color: 0xffaa66, roughness: 0.5 });
     const sg = ShadedGeometry.from(geom, material);

package/src/engine/ecs/attachment/TransformAttachmentBinding.js

@@ -1,4 +1,4 @@
-import { mat4 } from "gl-matrix";
+import { m4_multiply } from "../../../core/geom/3d/mat4/m4_multiply.js";
 import { AttachmentBinding } from "./AttachmentBinding.js";
 
 const scratch_m4_0 = new Float32Array(16);
@@ -16,10 +16,10 @@ export class TransformAttachmentBinding extends AttachmentBinding {
         this.parentTransform.toMatrix(scratch_m4_1);
         this.attachment.transform.toMatrix(scratch_m4_2);
 
-        mat4.multiply(
+        m4_multiply(
             scratch_m4_0, scratch_m4_1, scratch_m4_0
         );
-        mat4.multiply(
+        m4_multiply(
             scratch_m4_0, scratch_m4_0, scratch_m4_2
         );