@woosh/meep-engine 3.65.0 → 3.68.0

package/src/engine/graphics/sh3/sky/hosek/prototype_hosek.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=prototype_hosek.d.ts.map

package/src/engine/graphics/sh3/sky/hosek/prototype_hosek.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"prototype_hosek.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/sh3/sky/hosek/prototype_hosek.js"],"names":[],"mappings":""}

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

@@ -1,71 +0,0 @@
-import { v3_normalize_array } from "../../../../../core/geom/vec3/v3_normalize_array.js";
-import { CanvasView } from "../../../../../view/elements/CanvasView.js";
-import { Sampler2D } from "../../../texture/sampler/Sampler2D.js";
-import sampler2D2Canvas from "../../../texture/sampler/sampler2d_to_html_canvas.js";
-import { make_sky_hosek } from "../../path_tracer/make_sky_hosek.js";
-
-const view = new CanvasView();
-
-view.css({
-    position: 'fixed',
-    left: '10px',
-    top: '10px',
-    zIndex: 5
-});
-view.size.set(400, 400);
-
-document.body.append(view.el);
-
-view.link();
-
-const sampler = Sampler2D.float32(4, 400, 400);
-
-
-const sky = make_sky_hosek(
-    [0, 0.8, 0.4],
-    1,
-    0,
-    [0,0,0]
-);
-const vl_halfPi = Math.PI / 2;
-const color = [1, 1, 1, 1];
-for (let i = 0; i < sampler.width; i++) {
-    const u = i / (sampler.width - 1);
-
-    const x = u * 2 - 1;
-
-    for (let j = 0; j < sampler.height; j++) {
-        const v = j / (sampler.height - 1);
-
-        const y = v * 2 - 1;
-        const y2 = y * y;
-        // fisheye projection
-
-        const x2 = x * x;
-        const h2 = x2 + y2;
-
-        const theta = vl_halfPi - vl_halfPi * Math.sqrt(h2);
-        const phi = Math.atan2(y, x);
-        const v_x = Math.cos(phi) * Math.cos(theta);
-        const v_y = Math.sin(phi) * Math.cos(theta);
-        const v_z = Math.sin(theta);
-
-        const direction = [v_x, v_z, v_y];
-
-        v3_normalize_array(direction, 0, direction, 0);
-
-        sky(color, 0, direction, 0);
-
-        sampler.write(i, j, color);
-
-        // sampler.write(i, j, [f, f, f, 1]);
-
-    }
-    // sampler.write(i, sampler.height - 1, [f, f, f, 1]);
-}
-
-console.log(sampler);
-
-sampler2D2Canvas(sampler, 255, 0, view.el);
-
-

package/src/engine/graphics/sh3/sky/hosek/render_hosek_sky_to_equirectangular.d.ts

@@ -1,26 +0,0 @@
-/**
- * Render the Hosek sky into an equirectangular RGBA float buffer.
- *
- * The layout matches three.js' `equirectUv` (so the result can be used directly
- * as an EquirectangularReflectionMapping texture or fed to PMREMGenerator):
- *   u = atan2(z, x) / (2pi) + 0.5
- *   v = asin(y) / pi + 0.5
- * with +Y up, matching the engine convention.
- *
- * @param {number[]|Float32Array} sun direction towards the sun (engine frame, +Y up); need not be unit length
- * @param {number} width  number of horizontal (longitude) samples
- * @param {number} height number of vertical (latitude) samples
- * @param {object} [options]
- * @param {number} [options.turbidity=2] atmospheric turbidity, 1..10
- * @param {number} [options.overcast=0] 0 = clear, 1 = fully overcast
- * @param {number[]|Float32Array} [options.albedo=[0,0,0]] linear ground albedo
- * @param {Float32Array} [options.target] optional pre-allocated buffer of length width*height*4
- * @returns {Float32Array} RGBA, row 0 = bottom (-Y), length width*height*4
- */
-export function render_hosek_sky_to_equirectangular(sun: number[] | Float32Array, width: number, height: number, options?: {
-    turbidity?: number;
-    overcast?: number;
-    albedo?: number[] | Float32Array;
-    target?: Float32Array;
-}): Float32Array;
-//# sourceMappingURL=render_hosek_sky_to_equirectangular.d.ts.map

package/src/engine/graphics/sh3/sky/hosek/render_hosek_sky_to_equirectangular.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"render_hosek_sky_to_equirectangular.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/sh3/sky/hosek/render_hosek_sky_to_equirectangular.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;GAkBG;AACH,yDAVW,MAAM,EAAE,GAAC,YAAY,SACrB,MAAM,UACN,MAAM;IAEW,SAAS,GAA1B,MAAM;IACW,QAAQ,GAAzB,MAAM;IAC0B,MAAM,GAAtC,MAAM,EAAE,GAAC,YAAY;IACE,MAAM,GAA7B,YAAY;IACV,YAAY,CAgDxB"}

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

@@ -1,70 +0,0 @@
-import { make_sky_hosek } from "../../path_tracer/make_sky_hosek.js";
-
-const TWO_PI = Math.PI * 2;
-
-/**
- * Render the Hosek sky into an equirectangular RGBA float buffer.
- *
- * The layout matches three.js' `equirectUv` (so the result can be used directly
- * as an EquirectangularReflectionMapping texture or fed to PMREMGenerator):
- *   u = atan2(z, x) / (2pi) + 0.5
- *   v = asin(y) / pi + 0.5
- * with +Y up, matching the engine convention.
- *
- * @param {number[]|Float32Array} sun direction towards the sun (engine frame, +Y up); need not be unit length
- * @param {number} width  number of horizontal (longitude) samples
- * @param {number} height number of vertical (latitude) samples
- * @param {object} [options]
- * @param {number} [options.turbidity=2] atmospheric turbidity, 1..10
- * @param {number} [options.overcast=0] 0 = clear, 1 = fully overcast
- * @param {number[]|Float32Array} [options.albedo=[0,0,0]] linear ground albedo
- * @param {Float32Array} [options.target] optional pre-allocated buffer of length width*height*4
- * @returns {Float32Array} RGBA, row 0 = bottom (-Y), length width*height*4
- */
-export function render_hosek_sky_to_equirectangular(sun, width, height, options = {}) {
-    const {
-        turbidity = 2,
-        overcast = 0,
-        albedo = [0, 0, 0],
-        target
-    } = options;
-
-    const sky = make_sky_hosek(sun, turbidity, overcast, albedo);
-
-    const data = target !== undefined ? target : new Float32Array(width * height * 4);
-
-    const direction = [0, 0, 0];
-
-    let p = 0;
-
-    for (let j = 0; j < height; j++) {
-        const v = (j + 0.5) / height;
-
-        // v = asin(y)/pi + 0.5  =>  y = sin((v - 0.5) * pi)
-        const latitude = (v - 0.5) * Math.PI;
-        const y = Math.sin(latitude);
-        const cos_latitude = Math.cos(latitude);
-
-        for (let i = 0; i < width; i++) {
-            const u = (i + 0.5) / width;
-
-            // u = atan2(z, x)/(2pi) + 0.5  =>  atan2(z, x) = (u - 0.5) * 2pi
-            const longitude = (u - 0.5) * TWO_PI;
-
-            direction[0] = cos_latitude * Math.cos(longitude);
-            direction[1] = y;
-            direction[2] = cos_latitude * Math.sin(longitude);
-
-            const offset = p * 4;
-
-            // writes linear RGB into data[offset .. offset + 2]
-            sky(data, offset, direction, 0);
-
-            data[offset + 3] = 1;
-
-            p++;
-        }
-    }
-
-    return data;
-}

package/src/engine/graphics/sh3/sky/hosek/sky_hosek_compute_irradiance_by_direction.d.ts

@@ -1,22 +0,0 @@
-/**
- * @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: number[], mRadXYZ: number[], sun_direction: number[] | Float32Array, turbidity: number, rgbAlbedo: number[] | Float32Array, overcast: number): void;
-/**
- *
- * @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: number[] | Float32Array, mCoeffsXYZ: number[] | Float32Array, mRadXYZ: number[] | Float32Array, mToSun: number[] | Float32Array, direction_x: number, direction_y: number, direction_z: number): void;
-//# sourceMappingURL=sky_hosek_compute_irradiance_by_direction.d.ts.map

package/src/engine/graphics/sh3/sky/hosek/sky_hosek_compute_irradiance_by_direction.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"sky_hosek_compute_irradiance_by_direction.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/sh3/sky/hosek/sky_hosek_compute_irradiance_by_direction.js"],"names":[],"mappings":"AAyNA;;;;;;;;GAQG;AACH,iDAPW,MAAM,EAAE,WACR,MAAM,EAAE,iBACR,MAAM,EAAE,GAAC,YAAY,aACrB,MAAM,aACN,MAAM,EAAE,GAAC,YAAY,YACrB,MAAM,QAgHhB;AAGD;;;;;;;;;GASG;AACH,+DARW,MAAM,EAAE,GAAC,YAAY,cACrB,MAAM,EAAE,GAAC,YAAY,WACrB,MAAM,EAAE,GAAC,YAAY,UACrB,MAAM,EAAE,GAAC,YAAY,eACrB,MAAM,eACN,MAAM,eACN,MAAM,QAwChB"}

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

@@ -1,388 +0,0 @@
-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_cos_angle } from "../../../../../core/geom/vec3/v3_cos_angle.js";
-import { v3_scale_array } from "../../../../../core/geom/vec3/v3_scale_array.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_scale_array(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_scale_array(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_scale_array(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_cos_angle 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_cos_angle(
-        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);
-}

package/src/engine/graphics3/make_default_environment.d.ts

@@ -1,15 +0,0 @@
-/**
- * Build the environment the engine lights with when nobody has supplied one.
- *
- * **Shade assumes global illumination**, and that is a deliberate quality decision rather than a
- * limitation: indirect light is on, and a scene with no environment renders unlit. So the default is
- * something the engine *provides*. Turning GI off is the thing that takes an explicit choice.
- *
- * The map is octahedral because that is the projection `scene.lights.environment` is sampled with,
- * and half-float because that is what the octahedral path is built for.
- *
- * @returns {ShadeTexture}
- */
-export function make_default_environment(): ShadeTexture;
-import { ShadeTexture } from "../../shade/renderer/texture/ShadeTexture.js";
-//# sourceMappingURL=make_default_environment.d.ts.map

package/src/engine/graphics3/make_default_environment.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"make_default_environment.d.ts","sourceRoot":"","sources":["../../../../src/engine/graphics3/make_default_environment.js"],"names":[],"mappings":"AA4DA;;;;;;;;;;;GAWG;AACH,4CAFa,YAAY,CAwCxB;6BAvG4B,8CAA8C"}