@woosh/meep-engine 2.162.0 → 2.163.1

package/src/engine/graphics/sh3/sky/hosek/sky_hosek_compute_irradiance_by_direction.js

@@ -1,395 +1,388 @@
-// --- Mathematical constants -------------------------------------------------
-
-import { vec3 } from "gl-matrix";
-import { rgb_to_xyz } from "../../../../../core/color/xyz/rgb_to_xyz.js";
-import { xyz_to_rgb } from "../../../../../core/color/xyz/xyz_to_rgb.js";
-import { v3_dot } from "../../../../../core/geom/vec3/v3_dot.js";
-import { clamp } from "../../../../../core/math/clamp.js";
-import { clamp01 } from "../../../../../core/math/clamp01.js";
-import { lerp } from "../../../../../core/math/lerp.js";
-import { kHosekCoeffsX, kHosekCoeffsY, kHosekCoeffsZ, kHosekRadX, kHosekRadY, kHosekRadZ } from "./data.js";
-
-const vl_pi = (3.14159265358979323846);
-const vl_halfPi = (vl_pi / 2.0);
-const vl_quarterPi = (vl_pi / 4.0);
-const vl_twoPi = (2.0 * vl_pi);
-
-
-/**
- *
- * @param {number[]|Float32Array} w float[6]
- * @param {number[]|Float32Array} data float[6]
- * @param {number} data_offset
- * @return {number}
- */
-function EvalQuintic_2(w, data, data_offset) {
-    return w[0] * data[data_offset + 0]
-        + w[1] * data[data_offset + 1]
-        + w[2] * data[data_offset + 2]
-        + w[3] * data[data_offset + 3]
-        + w[4] * data[data_offset + 4]
-        + w[5] * data[data_offset + 5];
-}
-
-/**
- *
- * @param {number[]|Float32Array} w float[6]
- * @param {number[]|Float32Array} data float[6][9] flattened
- * @param {number} data_offset
- * @param {number[]|Float32Array} coeffs float[9] output is written here
- * @param {number} coeffs_offset
- */
-function EvalQuintic_3(w, data, data_offset, coeffs, coeffs_offset) {
-    for (let i = 0; i < 9; i++) {
-        coeffs[coeffs_offset + i] = w[0] * data[data_offset + 0 * 6 + i]
-            + w[1] * data[data_offset + 1 * 6 + i]
-            + w[2] * data[data_offset + 2 * 6 + i]
-            + w[3] * data[data_offset + 3 * 6 + i]
-            + w[4] * data[data_offset + 4 * 6 + i]
-            + w[5] * data[data_offset + 5 * 6 + i];
-    }
-}
-
-/**
- *
- * @param {number} s
- * @param {number[]|ArrayLike<number>|Float32Array} w
- */
-function FindQuinticWeights(s, w) {
-    const s1 = s;
-    const s2 = s1 * s1;
-    const s3 = s1 * s2;
-    const s4 = s2 * s2;
-    const s5 = s2 * s3;
-
-    const is1 = 1.0 - s1;
-    const is2 = is1 * is1;
-    const is3 = is1 * is2;
-    const is4 = is2 * is2;
-    const is5 = is2 * is3;
-
-    w[0] = is5;
-    w[1] = is4 * s1 * 5.0;
-    w[2] = is3 * s2 * 10.0;
-    w[3] = is2 * s3 * 10.0;
-    w[4] = is1 * s4 * 5.0;
-    w[5] = s5;
-}
-
-/**
- *
- * @param {number[]|Float32Array} dataset9 albedo x 2, turbidity x 10, quintics x 6, weights x 9
- * @param {number[]|Float32Array} datasetR albedo x 2, turbidity x 10, quintics x 6
- * @param {number} turbidity
- * @param {number} albedo
- * @param {number} solarElevation
- * @param {number[]|Float32Array} coeffs result is written here
- * @param {number} coeffs_offset
- * @return {number}
- * @constructor
- */
-function FindHosekCoeffs
-(
-    dataset9,
-    datasetR,
-    turbidity,
-    albedo,
-    solarElevation,
-    coeffs,
-    coeffs_offset
-) {
-    const tbi = clamp(Math.floor(turbidity), 1, 9);
-
-    const tbf = turbidity - tbi;
-
-    const s = Math.pow(solarElevation / vl_halfPi, (1.0 / 3.0));
-
-    const quinticWeights = new Float32Array(6);
-    FindQuinticWeights(s, quinticWeights);
-
-    const ic = new Float32Array(4 * 9);
-
-    const size_set9_1 = 6 * 9;
-    const size_set9_0 = 10 * size_set9_1;
-    EvalQuintic_3(quinticWeights, dataset9, (tbi - 1) * size_set9_1, ic, 0);
-    EvalQuintic_3(quinticWeights, dataset9, size_set9_0 + (tbi - 1) * size_set9_1, ic, 9);
-    EvalQuintic_3(quinticWeights, dataset9, tbi * size_set9_1, ic, 18);
-    EvalQuintic_3(quinticWeights, dataset9, size_set9_0 + tbi * size_set9_1, ic, 27);
-
-    const size_set_R_1 = 6;
-    const size_set_R_0 = 10 * size_set_R_1;
-    const ir = [
-        EvalQuintic_2(quinticWeights, datasetR, (tbi - 1) * size_set_R_1),
-        EvalQuintic_2(quinticWeights, datasetR, size_set_R_0 + (tbi - 1) * size_set_R_1),
-        EvalQuintic_2(quinticWeights, datasetR, tbi * size_set_R_1),
-        EvalQuintic_2(quinticWeights, datasetR, size_set_R_0 + tbi * size_set_R_1),
-    ];
-
-    const cw = [
-        (1.0 - albedo) * (1.0 - tbf),
-        albedo * (1.0 - tbf),
-        (1.0 - albedo) * tbf,
-        albedo * tbf,
-    ];
-
-    for (let i = 0; i < 9; i++) {
-        coeffs[coeffs_offset + i] = cw[0] * ic[i]
-            + cw[1] * ic[9 + i]
-            + cw[2] * ic[2 * 9 + i]
-            + cw[3] * ic[3 * 9 + i];
-    }
-
-    return cw[0] * ir[0] + cw[1] * ir[1] + cw[2] * ir[2] + cw[3] * ir[3];
-}
-
-/**
- *
- * Hosek:
- * (1 + A e ^ (B / cos(t))) (1 + C e ^ (D g) + E cos(g) ^ 2   + F mieM(g, G)  + H cos(t)^1/2 + (I - 1))
- *
- * These bits are the same as Preetham, but do different jobs in some cases
- * A: sky gradient, carries white -> blue gradient
- * B: sky tightness
- * C: sun, carries most of sun-centred blue term
- * D: sun tightness, higher = tighter
- * E: rosy hue around sun
- *
- * Hosek-specific:
- * F: mie term, does most of the heavy lifting for sunset glow
- * G: mie tuning
- * H: zenith gradient
- * I: constant term balanced with H
- *
- * Notes:
- * A/B still carries some of the "blue" base of sky, but much comes from C/D
- * C/E minimal effect in sunset situations, carry bulk of sun halo in sun-overhead
- * F/G sunset glow, but also takes sun halo from yellowish to white overhead
- * @param {number[]|Float32Array} coeffs
- * @param {number} coeffs_offset
- * @param {number} cosTheta
- * @param {number} gamma
- * @param {number} cosGamma
- * @return {number}
- * @constructor
- */
-function EvalHosekCoeffs(
-    coeffs,
-    coeffs_offset,
-    cosTheta,
-    gamma,
-    cosGamma
-) {
-    const c_0 = coeffs[coeffs_offset + 0];
-    const c_1 = coeffs[coeffs_offset + 1];
-    const c_2 = coeffs[coeffs_offset + 2];
-    const c_3 = coeffs[coeffs_offset + 3];
-    const c_4 = coeffs[coeffs_offset + 4];
-    const c_5 = coeffs[coeffs_offset + 5];
-    const c_6 = coeffs[coeffs_offset + 6];
-    const c_7 = coeffs[coeffs_offset + 7];
-    const c_8 = coeffs[coeffs_offset + 8];
-
-    // Current coeffs ordering is AB I CDEF HG
-    //                            01 2 3456 78
-    const expM = Math.exp(c_4 * gamma);   // D g
-    const rayM = cosGamma * cosGamma;       // Rayleigh scattering
-    const mieM = (1.0 + rayM) / Math.pow((1.0 + c_8 * c_8 - 2.0 * c_8 * cosGamma), 1.5);  // G
-    const zenith = Math.sqrt(cosTheta);           // vertical zenith gradient
-
-    return (
-            1.0 + c_0 * Math.exp(c_1 / (cosTheta + 0.01))     // A, B
-        )
-        * (1.0
-            + c_3 * expM     // C
-            + c_5 * rayM     // E
-            + c_6 * mieM     // F
-            + c_7 * zenith   // H
-            + (c_2 - 1.0)   // I
-        );
-}
-
-/**
- *
- * @param {number} thetaS
- * @param {number} T
- * @return {number}
- */
-function ZenithLuminance(thetaS, T) {
-    const chi = (4.0 / 9.0 - T / 120.0) * (vl_pi - 2.0 * thetaS);
-    let Lz = (4.0453 * T - 4.9710) * Math.tan(chi) - 0.2155 * T + 2.4192;
-    Lz *= 1000.0;   // conversion from kcd/m^2 to cd/m^2
-    return Lz;
-}
-
-/**
- * @see https://github.com/andrewwillmott/sun-sky/blob/master/SunSky.cpp
- * @param {number[]} mCoeffsXYZ  output, float[3][9], Hosek 9-term distribution coefficients
- * @param {number[]} mRadXYZ  output, vec3, Overall average radiance
- * @param {vec3} sun_direction
- * @param {number} turbidity should be between 1 and 10
- * @param {vec3} rgbAlbedo albedo in linear color space (make sure it's not sRGB)
- * @param {number} overcast
- */
-export function sky_hosek_precompute(
-    mCoeffsXYZ,
-    mRadXYZ,
-    sun_direction,
-    turbidity,
-    rgbAlbedo,
-    overcast
-) {
-
-    const mToSun = sun_direction;
-
-    const sun_x = mToSun[0];
-    const sun_y = mToSun[1];
-    const sun_z = mToSun[2];
-
-    const solarElevation = sun_z > 0 ? Math.asin(sun_z) : 0;
-
-    const albedo = [];
-    rgb_to_xyz(albedo, rgbAlbedo);
-
-    /**
-     * Hosek 9-term distribution coefficients
-     * float[3][9]
-     * @type {Float32Array}
-     */
-    // const mCoeffsXYZ = new Float32Array(3 * 9);
-
-    /**
-     * Overall average radiance
-     * Vec3f
-     * @type {Float32Array}
-     */
-    //const mRadXYZ = new Float32Array(3);
-
-    // Note that the hosek coefficients change with time of day, vs. Preetham where the 'upper' coefficients stay the same,
-    // and only the scaler mPerezInvDen, consisting of time-dependent normalisation and zenith luminnce factors, changes.
-    mRadXYZ[0] = FindHosekCoeffs(kHosekCoeffsX, kHosekRadX, turbidity, albedo[0], solarElevation, mCoeffsXYZ, 0);
-    mRadXYZ[1] = FindHosekCoeffs(kHosekCoeffsY, kHosekRadY, turbidity, albedo[1], solarElevation, mCoeffsXYZ, 9);
-    mRadXYZ[2] = FindHosekCoeffs(kHosekCoeffsZ, kHosekRadZ, turbidity, albedo[2], solarElevation, mCoeffsXYZ, 18);
-
-    vec3.scale(mRadXYZ, mRadXYZ, 683); // convert to luminance in lumens
-
-
-    if (sun_z < 0.0)   // sun below horizon?
-    {
-        const s = clamp01(1.0 + sun_z * 50.0);   // goes from 1 to 0 as the sun sets
-        const is = 1.0 - s;
-
-        // Emulate Preetham's zenith darkening
-        const darken = ZenithLuminance(Math.acos(sun_z), turbidity) / ZenithLuminance(vl_halfPi, turbidity);
-
-        // Take C/E/F which control sun term to zero
-        for (let j = 0; j < 3; j++) {
-            mCoeffsXYZ[j * 9 + 3] *= s;
-            mCoeffsXYZ[j * 9 + 5] *= s;
-            mCoeffsXYZ[j * 9 + 6] *= s;
-
-            // Take horizon term H to zero, as it's an orange glow at this point
-            mCoeffsXYZ[j * 9 + 7] *= s;
-
-            // Take I term back to 1
-            mCoeffsXYZ[j * 9 + 2] *= s;
-            mCoeffsXYZ[j * 9 + 2] += is;
-        }
-
-        vec3.scale(mRadXYZ, mRadXYZ, darken);
-    }
-
-    if (overcast !== 0.0)      // Handle overcast term
-    {
-        const is = overcast;
-        const s = 1.0 - overcast;     // goes to 0 as we go to overcast
-
-        // Hosek isn't self-normalising, unlike Preetham/CIE, which divides by PreethamLower().
-        // Thus when we lerp to the CIE overcast model, we get some non-linearities.
-        // We deal with this by using ratios of normalisation terms to balance.
-        // Another difference is that Hosek is relative to the average radiance,
-        // whereas CIE is the zenith radiance, so rather than taking the zenith
-        // as normalising as in CIE, we average over the zenith and two horizon
-        // points.
-        const cosGammaZ = sun_z;
-        const gammaZ = Math.acos(cosGammaZ);
-        const cosGammaH = sun_y;
-        const gammaHP = Math.acos(sun_y);
-        const gammaHN = vl_pi - gammaHP;
-
-        const sc0 = EvalHosekCoeffs(mCoeffsXYZ, 1 * 9, 1.0, gammaZ, cosGammaZ) * 2.0
-            + EvalHosekCoeffs(mCoeffsXYZ, 1 * 9, 0.0, gammaHP, +cosGammaH)
-            + EvalHosekCoeffs(mCoeffsXYZ, 1 * 9, 0.0, gammaHN, -cosGammaH);
-
-        for (let j = 0; j < 3; j++) {
-            // sun flare -> 0 strength/base chroma
-            // Take C/E/F which control sun term to zero
-            mCoeffsXYZ[j * 9 + 3] *= s;
-            mCoeffsXYZ[j * 9 + 5] *= s;
-            mCoeffsXYZ[j * 9 + 6] *= s;
-
-            // Take H back to 0
-            mCoeffsXYZ[j * 9 + 7] *= s;
-
-            // Take I term back to 1
-            mCoeffsXYZ[j * 9 + 2] *= s;
-            mCoeffsXYZ[j * 9 + 2] += is;
-
-            // Take A/B to  CIE cloudy sky model: 4, -0.7
-            mCoeffsXYZ[j * 9 + 0] = lerp(mCoeffsXYZ[j * 9 + 0], 4.0, is);
-            mCoeffsXYZ[j * 9 + 1] = lerp(mCoeffsXYZ[j * 9 + 1], -0.7, is);
-        }
-
-        const sc1 = EvalHosekCoeffs(mCoeffsXYZ, 1 * 9, 1.0, gammaZ, cosGammaZ) * 2.0
-            + EvalHosekCoeffs(mCoeffsXYZ, 1 * 9, 0.0, gammaHP, +cosGammaH)
-            + EvalHosekCoeffs(mCoeffsXYZ, 1 * 9, 0.0, gammaHN, -cosGammaH);
-
-        const rescale = sc0 / sc1;
-        vec3.scale(mRadXYZ, mRadXYZ, rescale);
-
-
-        // move back to white point
-        mRadXYZ[0] = lerp(mRadXYZ[0], mRadXYZ[1], is);
-        mRadXYZ[2] = lerp(mRadXYZ[2], mRadXYZ[1], is);
-    }
-
-}
-
-
-/**
- *
- * @param {number[]|Float32Array} out vec3 in RGB color space
- * @param {number[]|Float32Array} mCoeffsXYZ float[3][9]
- * @param {number[]|Float32Array} mRadXYZ vec3
- * @param {number[]|Float32Array} mToSun vec3
- * @param {number} direction_x
- * @param {number} direction_y
- * @param {number} direction_z
- */
-export function sky_hosek_compute_irradiance_by_direction(
-    out,
-    mCoeffsXYZ,
-    mRadXYZ,
-    mToSun,
-    direction_x,
-    direction_y,
-    direction_z,
-) {
-    let cosTheta = direction_z;
-    const cosGamma = v3_dot(mToSun[0], mToSun[1], mToSun[2], direction_x, direction_y, direction_z);
-    const gamma = Math.acos(cosGamma);
-
-    if (cosTheta < 0.0) {
-        // clamp angle
-        cosTheta = 0.0;
-    }
-
-    const x = EvalHosekCoeffs(mCoeffsXYZ, 0, cosTheta, gamma, cosGamma);
-    const y = EvalHosekCoeffs(mCoeffsXYZ, 9, cosTheta, gamma, cosGamma);
-    const z = EvalHosekCoeffs(mCoeffsXYZ, 18, cosTheta, gamma, cosGamma);
-
-    out[0] = x * mRadXYZ[0];
-    out[1] = y * mRadXYZ[1];
-    out[2] = z * mRadXYZ[2];
-
-    xyz_to_rgb(out, out);
-}
+import { rgb_to_xyz } from "../../../../../core/color/xyz/rgb_to_xyz.js";
+import { xyz_to_rgb } from "../../../../../core/color/xyz/xyz_to_rgb.js";
+import { v3_angle_cos_between } from "../../../../../core/geom/vec3/v3_angle_cos_between.js";
+import { v3_array_scale } from "../../../../../core/geom/vec3/v3_array_scale.js";
+import { v3_length } from "../../../../../core/geom/vec3/v3_length.js";
+import { clamp } from "../../../../../core/math/clamp.js";
+import { clamp01 } from "../../../../../core/math/clamp01.js";
+import { lerp } from "../../../../../core/math/lerp.js";
+import { kHosekCoeffsX, kHosekCoeffsY, kHosekCoeffsZ, kHosekRadX, kHosekRadY, kHosekRadZ } from "./data.js";
+
+const HALF_PI = Math.PI * 0.5;
+
+
+/**
+ *
+ * @param {number[]|Float32Array} w float[6]
+ * @param {number[]|Float32Array} data float[6]
+ * @param {number} data_offset
+ * @return {number}
+ */
+function EvalQuintic_2(w, data, data_offset) {
+    return w[0] * data[data_offset + 0]
+        + w[1] * data[data_offset + 1]
+        + w[2] * data[data_offset + 2]
+        + w[3] * data[data_offset + 3]
+        + w[4] * data[data_offset + 4]
+        + w[5] * data[data_offset + 5];
+}
+
+/**
+ *
+ * @param {number[]|Float32Array} w float[6]
+ * @param {number[]|Float32Array} data float[6][9] flattened
+ * @param {number} data_offset
+ * @param {number[]|Float32Array} coeffs float[9] output is written here
+ * @param {number} coeffs_offset
+ */
+function EvalQuintic_3(w, data, data_offset, coeffs, coeffs_offset) {
+    for (let i = 0; i < 9; i++) {
+        coeffs[coeffs_offset + i] = w[0] * data[data_offset + 0 * 9 + i]
+            + w[1] * data[data_offset + 1 * 9 + i]
+            + w[2] * data[data_offset + 2 * 9 + i]
+            + w[3] * data[data_offset + 3 * 9 + i]
+            + w[4] * data[data_offset + 4 * 9 + i]
+            + w[5] * data[data_offset + 5 * 9 + i];
+    }
+}
+
+/**
+ *
+ * @param {number} s
+ * @param {number[]|ArrayLike<number>|Float32Array} w
+ */
+function FindQuinticWeights(s, w) {
+    const s1 = s;
+    const s2 = s1 * s1;
+    const s3 = s1 * s2;
+    const s4 = s2 * s2;
+    const s5 = s2 * s3;
+
+    const is1 = 1.0 - s1;
+    const is2 = is1 * is1;
+    const is3 = is1 * is2;
+    const is4 = is2 * is2;
+    const is5 = is2 * is3;
+
+    w[0] = is5;
+    w[1] = is4 * s1 * 5.0;
+    w[2] = is3 * s2 * 10.0;
+    w[3] = is2 * s3 * 10.0;
+    w[4] = is1 * s4 * 5.0;
+    w[5] = s5;
+}
+
+// Reusable scratch buffers for FindHosekCoeffs. Safe to share: evaluation is
+// synchronous and non-reentrant, and each call fully overwrites them.
+const quinticWeights = new Float32Array(6);
+const ic = new Float32Array(4 * 9);
+
+/**
+ *
+ * @param {number[]|Float32Array} dataset9 albedo x 2, turbidity x 10, quintics x 6, weights x 9
+ * @param {number[]|Float32Array} datasetR albedo x 2, turbidity x 10, quintics x 6
+ * @param {number} turbidity
+ * @param {number} albedo
+ * @param {number} solarElevation
+ * @param {number[]|Float32Array} coeffs result is written here
+ * @param {number} coeffs_offset
+ * @return {number}
+ * @constructor
+ */
+function FindHosekCoeffs
+(
+    dataset9,
+    datasetR,
+    turbidity,
+    albedo,
+    solarElevation,
+    coeffs,
+    coeffs_offset
+) {
+    const tbi = clamp(Math.floor(turbidity), 1, 9);
+
+    const tbf = turbidity - tbi;
+
+    const s = Math.cbrt(solarElevation / HALF_PI);
+
+    FindQuinticWeights(s, quinticWeights);
+
+    const size_set9_1 = 6 * 9;
+    const size_set9_0 = 10 * size_set9_1;
+    EvalQuintic_3(quinticWeights, dataset9, (tbi - 1) * size_set9_1, ic, 0);
+    EvalQuintic_3(quinticWeights, dataset9, size_set9_0 + (tbi - 1) * size_set9_1, ic, 9);
+    EvalQuintic_3(quinticWeights, dataset9, tbi * size_set9_1, ic, 18);
+    EvalQuintic_3(quinticWeights, dataset9, size_set9_0 + tbi * size_set9_1, ic, 27);
+
+    const size_set_R_1 = 6;
+    const size_set_R_0 = 10 * size_set_R_1;
+    const ir_0 = EvalQuintic_2(quinticWeights, datasetR, (tbi - 1) * size_set_R_1);
+    const ir_1 = EvalQuintic_2(quinticWeights, datasetR, size_set_R_0 + (tbi - 1) * size_set_R_1);
+    const ir_2 = EvalQuintic_2(quinticWeights, datasetR, tbi * size_set_R_1);
+    const ir_3 = EvalQuintic_2(quinticWeights, datasetR, size_set_R_0 + tbi * size_set_R_1);
+
+    const cw_0 = (1.0 - albedo) * (1.0 - tbf);
+    const cw_1 = albedo * (1.0 - tbf);
+    const cw_2 = (1.0 - albedo) * tbf;
+    const cw_3 = albedo * tbf;
+
+    for (let i = 0; i < 9; i++) {
+        coeffs[coeffs_offset + i] = cw_0 * ic[i]
+            + cw_1 * ic[9 + i]
+            + cw_2 * ic[2 * 9 + i]
+            + cw_3 * ic[3 * 9 + i];
+    }
+
+    return cw_0 * ir_0 + cw_1 * ir_1 + cw_2 * ir_2 + cw_3 * ir_3;
+}
+
+/**
+ *
+ * Hosek:
+ * (1 + A e ^ (B / cos(t))) (1 + C e ^ (D g) + E cos(g) ^ 2   + F mieM(g, G)  + H cos(t)^1/2 + (I - 1))
+ *
+ * These bits are the same as Preetham, but do different jobs in some cases
+ * A: sky gradient, carries white -> blue gradient
+ * B: sky tightness
+ * C: sun, carries most of sun-centred blue term
+ * D: sun tightness, higher = tighter
+ * E: rosy hue around sun
+ *
+ * Hosek-specific:
+ * F: mie term, does most of the heavy lifting for sunset glow
+ * G: mie tuning
+ * H: zenith gradient
+ * I: constant term balanced with H
+ *
+ * Notes:
+ * A/B still carries some of the "blue" base of sky, but much comes from C/D
+ * C/E minimal effect in sunset situations, carry bulk of sun halo in sun-overhead
+ * F/G sunset glow, but also takes sun halo from yellowish to white overhead
+ * @param {number[]|Float32Array} coeffs
+ * @param {number} coeffs_offset
+ * @param {number} cosTheta
+ * @param {number} gamma
+ * @param {number} cosGamma
+ * @return {number}
+ * @constructor
+ */
+function EvalHosekCoeffs(
+    coeffs,
+    coeffs_offset,
+    cosTheta,
+    gamma,
+    cosGamma
+) {
+    const c_0 = coeffs[coeffs_offset + 0];
+    const c_1 = coeffs[coeffs_offset + 1];
+    const c_2 = coeffs[coeffs_offset + 2];
+    const c_3 = coeffs[coeffs_offset + 3];
+    const c_4 = coeffs[coeffs_offset + 4];
+    const c_5 = coeffs[coeffs_offset + 5];
+    const c_6 = coeffs[coeffs_offset + 6];
+    const c_7 = coeffs[coeffs_offset + 7];
+    const c_8 = coeffs[coeffs_offset + 8];
+
+    // Current coeffs ordering is AB I CDEF HG
+    //                            01 2 3456 78
+    const expM = Math.exp(c_4 * gamma);   // D g
+    const rayM = cosGamma * cosGamma;       // Rayleigh scattering
+    const mieM = (1.0 + rayM) / Math.pow((1.0 + c_8 * c_8 - 2.0 * c_8 * cosGamma), 1.5);  // G
+    const zenith = Math.sqrt(cosTheta);           // vertical zenith gradient
+
+    return (
+            1.0 + c_0 * Math.exp(c_1 / (cosTheta + 0.01))     // A, B
+        )
+        * (1.0
+            + c_3 * expM     // C
+            + c_5 * rayM     // E
+            + c_6 * mieM     // F
+            + c_7 * zenith   // H
+            + (c_2 - 1.0)   // I
+        );
+}
+
+/**
+ *
+ * @param {number} thetaS
+ * @param {number} T
+ * @return {number}
+ */
+function ZenithLuminance(thetaS, T) {
+    const chi = (4.0 / 9.0 - T / 120.0) * (Math.PI - 2.0 * thetaS);
+    let Lz = (4.0453 * T - 4.9710) * Math.tan(chi) - 0.2155 * T + 2.4192;
+    Lz *= 1000.0;   // conversion from kcd/m^2 to cd/m^2
+    return Lz;
+}
+
+/**
+ * @see https://github.com/andrewwillmott/sun-sky/blob/master/SunSky.cpp
+ * @param {number[]} mCoeffsXYZ  output, float[3][9], Hosek 9-term distribution coefficients
+ * @param {number[]} mRadXYZ  output, vec3, Overall average radiance
+ * @param {number[]|Float32Array} sun_direction direction to the sun, engine frame (+Y up)
+ * @param {number} turbidity should be between 1 and 10
+ * @param {number[]|Float32Array} rgbAlbedo albedo in linear color space (make sure it's not sRGB)
+ * @param {number} overcast
+ */
+export function sky_hosek_precompute(
+    mCoeffsXYZ,
+    mRadXYZ,
+    sun_direction,
+    turbidity,
+    rgbAlbedo,
+    overcast
+) {
+
+    const mToSun = sun_direction;
+
+    const sun_x = mToSun[0];
+    const sun_y = mToSun[1];
+    const sun_z = mToSun[2];
+
+    // Y is up (engine convention): solar elevation is measured from the Y component.
+    const solarElevation = sun_y > 0 ? Math.asin(sun_y) : 0;
+
+    const albedo = [];
+    rgb_to_xyz(albedo, rgbAlbedo);
+
+
+    // Note that the hosek coefficients change with time of day, vs. Preetham where the 'upper' coefficients stay the same,
+    // and only the scaler mPerezInvDen, consisting of time-dependent normalisation and zenith luminnce factors, changes.
+    mRadXYZ[0] = FindHosekCoeffs(kHosekCoeffsX, kHosekRadX, turbidity, albedo[0], solarElevation, mCoeffsXYZ, 0);
+    mRadXYZ[1] = FindHosekCoeffs(kHosekCoeffsY, kHosekRadY, turbidity, albedo[1], solarElevation, mCoeffsXYZ, 9);
+    mRadXYZ[2] = FindHosekCoeffs(kHosekCoeffsZ, kHosekRadZ, turbidity, albedo[2], solarElevation, mCoeffsXYZ, 18);
+
+    v3_array_scale(mRadXYZ, 0, mRadXYZ, 0, 683); // convert to luminance in lumens
+
+
+    if (sun_y < 0.0)   // sun below horizon?
+    {
+        const s = clamp01(1.0 + sun_y * 50.0);   // goes from 1 to 0 as the sun sets
+        const is = 1.0 - s;
+
+        // Emulate Preetham's zenith darkening
+        const darken = ZenithLuminance(Math.acos(sun_y), turbidity) / ZenithLuminance(HALF_PI, turbidity);
+
+        // Take C/E/F which control sun term to zero
+        for (let j = 0; j < 3; j++) {
+            mCoeffsXYZ[j * 9 + 3] *= s;
+            mCoeffsXYZ[j * 9 + 5] *= s;
+            mCoeffsXYZ[j * 9 + 6] *= s;
+
+            // Take horizon term H to zero, as it's an orange glow at this point
+            mCoeffsXYZ[j * 9 + 7] *= s;
+
+            // Take I term back to 1
+            mCoeffsXYZ[j * 9 + 2] *= s;
+            mCoeffsXYZ[j * 9 + 2] += is;
+        }
+
+        v3_array_scale(mRadXYZ, 0, mRadXYZ, 0, darken);
+    }
+
+    if (overcast !== 0.0)      // Handle overcast term
+    {
+        const is = overcast;
+        const s = 1.0 - overcast;     // goes to 0 as we go to overcast
+
+        // Hosek isn't self-normalising, unlike Preetham/CIE, which divides by PreethamLower().
+        // Thus when we lerp to the CIE overcast model, we get some non-linearities.
+        // We deal with this by using ratios of normalisation terms to balance.
+        // Another difference is that Hosek is relative to the average radiance,
+        // whereas CIE is the zenith radiance, so rather than taking the zenith
+        // as normalising as in CIE, we average over the zenith and two horizon
+        // points.
+        const cosGammaZ = sun_y;
+        const gammaZ = Math.acos(cosGammaZ);
+        const cosGammaH = sun_z;
+        const gammaHP = Math.acos(sun_z);
+        const gammaHN = Math.PI - gammaHP;
+
+        const sc0 = EvalHosekCoeffs(mCoeffsXYZ, 1 * 9, 1.0, gammaZ, cosGammaZ) * 2.0
+            + EvalHosekCoeffs(mCoeffsXYZ, 1 * 9, 0.0, gammaHP, +cosGammaH)
+            + EvalHosekCoeffs(mCoeffsXYZ, 1 * 9, 0.0, gammaHN, -cosGammaH);
+
+        for (let j = 0; j < 3; j++) {
+            // sun flare -> 0 strength/base chroma
+            // Take C/E/F which control sun term to zero
+            mCoeffsXYZ[j * 9 + 3] *= s;
+            mCoeffsXYZ[j * 9 + 5] *= s;
+            mCoeffsXYZ[j * 9 + 6] *= s;
+
+            // Take H back to 0
+            mCoeffsXYZ[j * 9 + 7] *= s;
+
+            // Take I term back to 1
+            mCoeffsXYZ[j * 9 + 2] *= s;
+            mCoeffsXYZ[j * 9 + 2] += is;
+
+            // Take A/B to  CIE cloudy sky model: 4, -0.7
+            mCoeffsXYZ[j * 9 + 0] = lerp(mCoeffsXYZ[j * 9 + 0], 4.0, is);
+            mCoeffsXYZ[j * 9 + 1] = lerp(mCoeffsXYZ[j * 9 + 1], -0.7, is);
+        }
+
+        const sc1 = EvalHosekCoeffs(mCoeffsXYZ, 1 * 9, 1.0, gammaZ, cosGammaZ) * 2.0
+            + EvalHosekCoeffs(mCoeffsXYZ, 1 * 9, 0.0, gammaHP, +cosGammaH)
+            + EvalHosekCoeffs(mCoeffsXYZ, 1 * 9, 0.0, gammaHN, -cosGammaH);
+
+        const rescale = sc0 / sc1;
+        v3_array_scale(mRadXYZ, 0, mRadXYZ, 0, rescale);
+
+
+        // move back to white point
+        mRadXYZ[0] = lerp(mRadXYZ[0], mRadXYZ[1], is);
+        mRadXYZ[2] = lerp(mRadXYZ[2], mRadXYZ[1], is);
+    }
+
+}
+
+
+/**
+ *
+ * @param {number[]|Float32Array} out vec3 in RGB color space
+ * @param {number[]|Float32Array} mCoeffsXYZ float[3][9]
+ * @param {number[]|Float32Array} mRadXYZ vec3
+ * @param {number[]|Float32Array} mToSun vec3, direction to the sun, engine frame (+Y up)
+ * @param {number} direction_x
+ * @param {number} direction_y up axis (engine +Y up)
+ * @param {number} direction_z
+ */
+export function sky_hosek_compute_irradiance_by_direction(
+    out,
+    mCoeffsXYZ,
+    mRadXYZ,
+    mToSun,
+    direction_x,
+    direction_y,
+    direction_z,
+) {
+    // Normalise the view direction so cosTheta stays a true cosine even when the
+    // caller passes a non-unit direction.
+    const direction_length = v3_length(direction_x, direction_y, direction_z);
+    const inv_direction_length = direction_length !== 0.0 ? 1.0 / direction_length : 0.0;
+
+    let cosTheta = direction_y * inv_direction_length;
+
+    // v3_angle_cos_between divides by both magnitudes and clamps to [-1, 1], so it
+    // is robust to non-unit inputs and gamma = acos(cosGamma) can never be NaN.
+    const cosGamma = v3_angle_cos_between(
+        mToSun[0], mToSun[1], mToSun[2],
+        direction_x, direction_y, direction_z
+    );
+    const gamma = Math.acos(cosGamma);
+
+    if (cosTheta < 0.0) {
+        // clamp angle
+        cosTheta = 0.0;
+    }
+
+    const x = EvalHosekCoeffs(mCoeffsXYZ, 0, cosTheta, gamma, cosGamma);
+    const y = EvalHosekCoeffs(mCoeffsXYZ, 9, cosTheta, gamma, cosGamma);
+    const z = EvalHosekCoeffs(mCoeffsXYZ, 18, cosTheta, gamma, cosGamma);
+
+    out[0] = x * mRadXYZ[0];
+    out[1] = y * mRadXYZ[1];
+    out[2] = z * mRadXYZ[2];
+
+    xyz_to_rgb(out, out);
+}