@woosh/meep-engine 3.37.0 → 3.39.0

package/src/shade/renderer/shader/chunk/atmosphere/phase/ff/chunk_phase_fournier_forand.js

@@ -0,0 +1,153 @@
+import { CodeChunk } from "../../../../compiler/CodeChunk.js";
+import { PI_DECLARATION } from "../../../math/PI_DECLARATION.js";
+
+/**
+ * The Fournier-Forand phase function: scattering by a Junge (power-law) population of particles,
+ * the analytic form fitted to measured ocean phase functions. Parameterized by
+ *
+ *  - `nu` = (3 - junge_slope) / 2, in (-1, 0)
+ *  - `kappa` = 4 / (3 (n - 1)²), the value of FF's delta at 180 degrees
+ *
+ * which `fournier_forand_parameters_from_backscatter` derives from a backscatter fraction.
+ *
+ * Everything here takes `sin2_half` = sin²(psi / 2) = (1 - cos psi) / 2 rather than the cosine:
+ * the forward peak is so narrow that most of its mass sits at angles an f32 cosine rounds to
+ * exactly 1. A caller holding two unit directions gets it without cancellation as
+ * |a - b|² / 4. `phase_fournier_forand` takes a cosine for callers that only have one.
+ *
+ * With delta = kappa sin2_half, the density and the cumulative (fraction scattered into angles
+ * below psi) are
+ *
+ *      p(psi) = [ r - s / sin2_half ] / (4 pi delta^nu) + C' (3 cos² psi - 1)
+ *      F(psi) = [ 1 + delta q (1 - 1 / kappa) ] / delta^nu + (C / 8) cos psi sin² psi
+ *
+ *      q = (1 - delta^nu) / (1 - delta),   r = (nu - q) / (1 - delta),   s = r + q = (nu - delta q) / (1 - delta)
+ *      C = (1 - kappa^nu) / ((kappa - 1) kappa^nu),   C' = C / (16 pi)
+ *
+ * which is Mobley et al.'s form regrouped so that its removable singularities at delta = 1
+ * (psi of about 10 to 14 degrees for natural water) sit inside q and r. Within |e| < 0.25 of it,
+ * e = delta - 1, those are evaluated by their binomial series, q = sum_{k>=1} C(nu, k) e^(k-1) and
+ * r = sum_{k>=2} C(nu, k) e^(k-2); outside it directly. s is formed directly outside the band
+ * because r and q there are two large terms of opposite sign at small delta, deep in the forward
+ * peak, and their sum would lose every digit.
+ *
+ * Transcriptions of FF differ between sources, so this one is pinned by its specs rather than by
+ * any citation: it integrates to one, its cumulative is the integral of its density, and its
+ * backscatter is the fraction it was solved for. The sign of the cos psi sin² psi term is the one
+ * that makes the cumulative the integral of Mobley's density, whose last term is
+ * +C' (3 cos² psi - 1); it is invisible to normalization and to the backscatter fraction, because it
+ * vanishes at 0, 90 and 180 degrees.
+ *
+ * @see Fournier, Forand, "Analytic phase function for ocean water", Proc. SPIE 2258, 1994
+ * @see Mobley, Sundman, Boss, "Phase function effects on oceanic light fields", Applied Optics 41(6), 2002
+ */
+export const chunk_phase_fournier_forand = CodeChunk.from(
+    //language=WGSL
+    `
+// below this, sin2_half is clamped: a deflection of 2e-15 radians, and FF's density stays finite
+const FOURNIER_FORAND_SIN2_HALF_MIN: f32 = 1e-30;
+
+// half-width of the band around delta = 1 where q and r are summed as series; 14 terms reach
+// f32 precision at its edge
+const FOURNIER_FORAND_SERIES_BAND: f32 = 0.25;
+
+// q(delta) = (1 - delta^nu) / (1 - delta)
+fn fournier_forand_q(delta: f32, nu: f32) -> f32 {
+    let e = delta - 1.0;
+
+    if (abs(e) >= FOURNIER_FORAND_SERIES_BAND) {
+        return (1.0 - pow(delta, nu)) / (1.0 - delta);
+    }
+
+    // sum_{k>=1} C(nu, k) e^(k-1)
+    var coefficient = nu;
+    var power = 1.0;
+    var sum = nu;
+
+    for (var k = 1u; k < 14u; k++) {
+        let kf = f32(k);
+        coefficient *= (nu - kf) / (kf + 1.0);
+        power *= e;
+        sum += coefficient * power;
+    }
+
+    return sum;
+}
+
+// r(delta) = (nu - q) / (1 - delta), given q = fournier_forand_q(delta, nu)
+fn fournier_forand_r(delta: f32, nu: f32, q: f32) -> f32 {
+    let e = delta - 1.0;
+
+    if (abs(e) >= FOURNIER_FORAND_SERIES_BAND) {
+        return (nu - q) / (1.0 - delta);
+    }
+
+    // sum_{k>=2} C(nu, k) e^(k-2)
+    var coefficient = 0.5 * nu * (nu - 1.0);
+    var power = 1.0;
+    var sum = coefficient;
+
+    for (var k = 2u; k < 15u; k++) {
+        let kf = f32(k);
+        coefficient *= (nu - kf) / (kf + 1.0);
+        power *= e;
+        sum += coefficient * power;
+    }
+
+    return sum;
+}
+
+// s(delta) = r + q = (nu - delta q) / (1 - delta), given q and r
+fn fournier_forand_s(delta: f32, nu: f32, q: f32, r: f32) -> f32 {
+    if (abs(delta - 1.0) >= FOURNIER_FORAND_SERIES_BAND) {
+        return (nu - delta * q) / (1.0 - delta);
+    }
+
+    return r + q;
+}
+
+// probability density per steradian, normalized over the sphere
+fn phase_fournier_forand_u(sin2_half: f32, nu: f32, kappa: f32) -> f32 {
+    let u = clamp(sin2_half, FOURNIER_FORAND_SIN2_HALF_MIN, 1.0);
+
+    let delta = kappa * u;
+    let q = fournier_forand_q(delta, nu);
+    let r = fournier_forand_r(delta, nu, q);
+    let s = fournier_forand_s(delta, nu, q, r);
+
+    let kappa_nu = pow(kappa, nu);
+    let c = (1.0 - kappa_nu) / (16.0 * PI * (kappa - 1.0) * kappa_nu);
+
+    let cos_psi = 1.0 - 2.0 * u;
+
+    return (r - s / u) / (4.0 * PI * pow(delta, nu)) + c * (3.0 * cos_psi * cos_psi - 1.0);
+}
+
+fn phase_fournier_forand(cos_theta: f32, nu: f32, kappa: f32) -> f32 {
+    return phase_fournier_forand_u(0.5 * (1.0 - cos_theta), nu, kappa);
+}
+
+// fraction of the scattered light deflected by less than psi, sin2_half = sin²(psi / 2)
+fn fournier_forand_cdf_u(sin2_half: f32, nu: f32, kappa: f32) -> f32 {
+    if (sin2_half <= 0.0) {
+        return 0.0;
+    }
+
+    let u = clamp(sin2_half, FOURNIER_FORAND_SIN2_HALF_MIN, 1.0);
+
+    let delta = kappa * u;
+    let q = fournier_forand_q(delta, nu);
+
+    let kappa_nu = pow(kappa, nu);
+    let c = (1.0 - kappa_nu) / ((kappa - 1.0) * kappa_nu);
+
+    let cos_psi = 1.0 - 2.0 * u;
+    let sin2_psi = 4.0 * u * (1.0 - u);
+
+    return (1.0 + delta * q * (1.0 - 1.0 / kappa)) / pow(delta, nu) + 0.125 * c * cos_psi * sin2_psi;
+}
+    `,
+    [
+        PI_DECLARATION,
+    ]
+);

package/src/shade/renderer/shader/chunk/atmosphere/phase/ff/chunk_sample_fournier_forand.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Samples a deflection from the Fournier-Forand phase function by inverting its closed-form
+ * cumulative, `fournier_forand_cdf_u`, for a uniform `xi` in [0, 1]. Returns sin²(psi / 2), not
+ * the cosine — see `chunk_phase_fournier_forand` for why — so a direction is built from
+ * cos psi = 1 - 2 u and sin psi = 2 sqrt(u (1 - u)).
+ *
+ * Newton's method on s = ln(sin²(psi / 2)), where the cumulative is close to a straight line
+ * (F ≈ (kappa u)^(-nu) through the forward peak, which is also the starting guess), safeguarded
+ * by a bracket that falls back to bisection. It stops at |F - xi| <= 1e-6, or after 32 steps.
+ */
+export const chunk_sample_fournier_forand: CodeChunk;
+import { CodeChunk } from "../../../../compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_sample_fournier_forand.d.ts.map

package/src/shade/renderer/shader/chunk/atmosphere/phase/ff/chunk_sample_fournier_forand.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_sample_fournier_forand.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/shade/renderer/shader/chunk/atmosphere/phase/ff/chunk_sample_fournier_forand.js"],"names":[],"mappings":"AAIA;;;;;;;;;GASG;AACH,qDA0CE;0BAxDwB,mCAAmC"}

package/src/shade/renderer/shader/chunk/atmosphere/phase/ff/chunk_sample_fournier_forand.js

@@ -0,0 +1,57 @@
+import { CodeChunk } from "../../../../compiler/CodeChunk.js";
+import { PI_DECLARATION } from "../../../math/PI_DECLARATION.js";
+import { chunk_phase_fournier_forand } from "./chunk_phase_fournier_forand.js";
+
+/**
+ * Samples a deflection from the Fournier-Forand phase function by inverting its closed-form
+ * cumulative, `fournier_forand_cdf_u`, for a uniform `xi` in [0, 1]. Returns sin²(psi / 2), not
+ * the cosine — see `chunk_phase_fournier_forand` for why — so a direction is built from
+ * cos psi = 1 - 2 u and sin psi = 2 sqrt(u (1 - u)).
+ *
+ * Newton's method on s = ln(sin²(psi / 2)), where the cumulative is close to a straight line
+ * (F ≈ (kappa u)^(-nu) through the forward peak, which is also the starting guess), safeguarded
+ * by a bracket that falls back to bisection. It stops at |F - xi| <= 1e-6, or after 32 steps.
+ */
+export const chunk_sample_fournier_forand = CodeChunk.from(
+    //language=WGSL
+    `
+fn sample_fournier_forand_sin2_half(xi: f32, nu: f32, kappa: f32) -> f32 {
+    var low = log(FOURNIER_FORAND_SIN2_HALF_MIN);
+    var high = 0.0;
+
+    var s = clamp(log(max(xi, FOURNIER_FORAND_SIN2_HALF_MIN)) / -nu - log(kappa), low, high);
+
+    for (var step = 0u; step < 32u; step++) {
+        let u = exp(s);
+        let error = fournier_forand_cdf_u(u, nu, kappa) - xi;
+
+        if (abs(error) <= 1e-6) {
+            break;
+        }
+
+        if (error > 0.0) {
+            high = s;
+        } else {
+            low = s;
+        }
+
+        // dF/ds = u dF/du = 4 pi u p(u), as d(solid angle) = 4 pi du
+        let slope = 4.0 * PI * u * phase_fournier_forand_u(u, nu, kappa);
+
+        var next = s - error / slope;
+
+        if (!(next > low && next < high)) {
+            next = 0.5 * (low + high);
+        }
+
+        s = next;
+    }
+
+    return exp(s);
+}
+    `,
+    [
+        PI_DECLARATION,
+        chunk_phase_fournier_forand,
+    ]
+);

package/src/shade/renderer/shader/chunk/atmosphere/phase/ff/fournier_forand_parameters_from_backscatter.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Backscatter fraction of a Fournier-Forand phase function: the share of scattered light that
+ * leaves at more than 90 degrees.
+ *
+ *      B = 1 - (1 - d^(nu + 1) - (1 - d^nu) / 2) / ((1 - d) d^nu),     d = kappa / 2
+ *
+ * @param {number} nu (3 - junge_slope) / 2
+ * @param {number} kappa 4 / (3 (n - 1)²), the value of the FF delta at 180 degrees
+ * @returns {number}
+ *
+ * @see Mobley, Sundman, Boss, "Phase function effects on oceanic light fields", Applied Optics 41(6), 2002
+ */
+export function fournier_forand_backscatter_fraction(nu: number, kappa: number): number;
+/**
+ * The Fournier-Forand phase function for particles of a given backscatter fraction, chosen on
+ * Mobley et al. 2002's line through Petzold's measurements. Mobley shows that underwater light
+ * fields depend mostly on the backscatter fraction being right; this is how a water medium states
+ * its particle phase function by that one number. Petzold's average, B = 0.0183, gives
+ * junge_slope 3.5835 and n 1.10.
+ *
+ * Backscatter grows monotonically with the Junge slope along the line, so the slope is found by
+ * bisection.
+ *
+ * @param {number} backscatter_fraction in the range the line reaches: above 0 (Junge slope 3) and
+ * below 0.5 (Junge slope 5). Natural waters sit around 0.005 to 0.05
+ * @returns {{junge_slope: number, refractive_index: number, nu: number, kappa: number}} `nu` and
+ * `kappa` are what the shader's Fournier-Forand chunks take
+ */
+export function fournier_forand_parameters_from_backscatter(backscatter_fraction: number): {
+    junge_slope: number;
+    refractive_index: number;
+    nu: number;
+    kappa: number;
+};
+/**
+ * The backscatter fractions {@link fournier_forand_parameters_from_backscatter} reaches, inclusive:
+ * the ends of the Mobley line it solves along.
+ * @type {number}
+ */
+export const FOURNIER_FORAND_BACKSCATTER_MIN: number;
+/**
+ * @type {number}
+ */
+export const FOURNIER_FORAND_BACKSCATTER_MAX: number;
+//# sourceMappingURL=fournier_forand_parameters_from_backscatter.d.ts.map

package/src/shade/renderer/shader/chunk/atmosphere/phase/ff/fournier_forand_parameters_from_backscatter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fournier_forand_parameters_from_backscatter.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/shade/renderer/shader/chunk/atmosphere/phase/ff/fournier_forand_parameters_from_backscatter.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;GAWG;AACH,yDANW,MAAM,SACN,MAAM,GACJ,MAAM,CASlB;AAuCD;;;;;;;;;;;;;;GAcG;AACH,kFALW,MAAM,GAEJ;IAAC,WAAW,EAAE,MAAM,CAAC;IAAC,gBAAgB,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAC,CAsCtF;AA9DD;;;;GAIG;AACH,8CAFU,MAAM,CAE2E;AAE3F;;GAEG;AACH,8CAFU,MAAM,CAE2E"}

package/src/shade/renderer/shader/chunk/atmosphere/phase/ff/fournier_forand_parameters_from_backscatter.js

@@ -0,0 +1,109 @@
+import { assert } from "../../../../../../../core/assert.js";
+
+/**
+ * Backscatter fraction of a Fournier-Forand phase function: the share of scattered light that
+ * leaves at more than 90 degrees.
+ *
+ *      B = 1 - (1 - d^(nu + 1) - (1 - d^nu) / 2) / ((1 - d) d^nu),     d = kappa / 2
+ *
+ * @param {number} nu (3 - junge_slope) / 2
+ * @param {number} kappa 4 / (3 (n - 1)²), the value of the FF delta at 180 degrees
+ * @returns {number}
+ *
+ * @see Mobley, Sundman, Boss, "Phase function effects on oceanic light fields", Applied Optics 41(6), 2002
+ */
+export function fournier_forand_backscatter_fraction(nu, kappa) {
+    const delta_90 = kappa / 2;
+    const delta_90_nu = Math.pow(delta_90, nu);
+
+    return 1 - (1 - delta_90 * delta_90_nu - 0.5 * (1 - delta_90_nu)) / ((1 - delta_90) * delta_90_nu);
+}
+
+/**
+ * Mobley et al. 2002's relation between the particles' real refractive index and the Junge slope
+ * of their size distribution, along which Fournier-Forand reproduces Petzold's measured phase
+ * functions: n = 1.01 + 0.1542 (junge_slope - 3).
+ *
+ * @param {number} junge_slope
+ * @returns {number}
+ */
+function refractive_index_on_mobley_line(junge_slope) {
+    return 1.01 + 0.1542 * (junge_slope - 3);
+}
+
+/**
+ * @param {number} junge_slope
+ * @returns {number}
+ */
+function backscatter_on_mobley_line(junge_slope) {
+    const n = refractive_index_on_mobley_line(junge_slope);
+
+    return fournier_forand_backscatter_fraction((3 - junge_slope) / 2, 4 / (3 * (n - 1) * (n - 1)));
+}
+
+const JUNGE_SLOPE_MIN = 3 + 1e-6;
+const JUNGE_SLOPE_MAX = 5 - 1e-6;
+
+/**
+ * The backscatter fractions {@link fournier_forand_parameters_from_backscatter} reaches, inclusive:
+ * the ends of the Mobley line it solves along.
+ * @type {number}
+ */
+export const FOURNIER_FORAND_BACKSCATTER_MIN = backscatter_on_mobley_line(JUNGE_SLOPE_MIN);
+
+/**
+ * @type {number}
+ */
+export const FOURNIER_FORAND_BACKSCATTER_MAX = backscatter_on_mobley_line(JUNGE_SLOPE_MAX);
+
+/**
+ * The Fournier-Forand phase function for particles of a given backscatter fraction, chosen on
+ * Mobley et al. 2002's line through Petzold's measurements. Mobley shows that underwater light
+ * fields depend mostly on the backscatter fraction being right; this is how a water medium states
+ * its particle phase function by that one number. Petzold's average, B = 0.0183, gives
+ * junge_slope 3.5835 and n 1.10.
+ *
+ * Backscatter grows monotonically with the Junge slope along the line, so the slope is found by
+ * bisection.
+ *
+ * @param {number} backscatter_fraction in the range the line reaches: above 0 (Junge slope 3) and
+ * below 0.5 (Junge slope 5). Natural waters sit around 0.005 to 0.05
+ * @returns {{junge_slope: number, refractive_index: number, nu: number, kappa: number}} `nu` and
+ * `kappa` are what the shader's Fournier-Forand chunks take
+ */
+export function fournier_forand_parameters_from_backscatter(backscatter_fraction) {
+    assert.isNumber(backscatter_fraction, 'backscatter_fraction');
+    assert.greaterThanOrEqual(
+        backscatter_fraction,
+        backscatter_on_mobley_line(JUNGE_SLOPE_MIN),
+        'backscatter_fraction below what Fournier-Forand reaches on the Mobley line'
+    );
+    assert.lessThanOrEqual(
+        backscatter_fraction,
+        backscatter_on_mobley_line(JUNGE_SLOPE_MAX),
+        'backscatter_fraction above what Fournier-Forand reaches on the Mobley line'
+    );
+
+    let low = JUNGE_SLOPE_MIN;
+    let high = JUNGE_SLOPE_MAX;
+
+    for (let i = 0; i < 64; i++) {
+        const middle = 0.5 * (low + high);
+
+        if (backscatter_on_mobley_line(middle) < backscatter_fraction) {
+            low = middle;
+        } else {
+            high = middle;
+        }
+    }
+
+    const junge_slope = 0.5 * (low + high);
+    const refractive_index = refractive_index_on_mobley_line(junge_slope);
+
+    return {
+        junge_slope,
+        refractive_index,
+        nu: (3 - junge_slope) / 2,
+        kappa: 4 / (3 * (refractive_index - 1) * (refractive_index - 1)),
+    };
+}

package/src/shade/renderer/shader/chunk/atmosphere/phase/jd/chunk_phase_draine.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_phase_draine.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/shade/renderer/shader/chunk/atmosphere/phase/jd/chunk_phase_draine.js"],"names":[],"mappings":"AAGA;;;;;GAKG;AACH,iCAFU,SAAS,CAsBZ;0BA7BmB,mCAAmC"}
+{"version":3,"file":"chunk_phase_draine.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/shade/renderer/shader/chunk/atmosphere/phase/jd/chunk_phase_draine.js"],"names":[],"mappings":"AAGA;;;;;GAKG;AACH,iCAFU,SAAS,CAyBZ;0BAhCmB,mCAAmC"}

package/src/shade/renderer/shader/chunk/atmosphere/phase/jd/chunk_phase_draine.js

@@ -14,9 +14,12 @@ fn phase_draine(cos_theta: f32, g: f32, alpha: f32) -> f32 {
     let g2 = g * g;
     let cos2 = cos_theta * cos_theta;
 
-    // Henyey-Greenstein part of the equation
-    let denom_hg = 1.0 + g2 - 2.0 * g * cos_theta;
-    let hg_term = (1.0 - g2) / pow(denom_hg, 1.5);
+    // Henyey-Greenstein part of the equation, (1 - g²) / (1 + g² - 2g cos)^1.5 — written so that it
+    // does not cancel: straight ahead the denominator is (1 - g)², which in f32 is rounding noise as
+    // 1 + g² - 2g once g passes about 0.9997, and zero at g = 0.9999
+    let one_minus_g = 1.0 - g;
+    let denom_hg = one_minus_g * one_minus_g + 2.0 * g * (1.0 - cos_theta);
+    let hg_term = one_minus_g * (1.0 + g) / pow(denom_hg, 1.5);
 
     // Draine-specific part
     let num_draine = 1.0 + alpha * cos2;

package/src/shade/renderer/shader/chunk/atmosphere/phase/jd/chunk_sample_draine.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Samples the cosine of the scattering angle from the Draine phase function `phase_draine(mu, g,
+ * alpha)` — Henyey-Greenstein (alpha = 0), Cornette-Shanks (alpha = 1), Rayleigh (g = 0,
+ * alpha = 1) and the molecular water phase (g = 0, alpha = (1 - d) / (1 + d)) alike. Draws from
+ * `random()`.
+ *
+ * Draine is Henyey-Greenstein times `(1 + alpha mu²)` up to a constant, so a Henyey-Greenstein
+ * proposal accepted with probability `(1 + alpha mu²) / max(1, 1 + alpha)` is exactly Draine. The
+ * expected number of proposals is `max(1, 1 + alpha) / (1 + alpha (1 + 2 g²) / 3)`: at most 3, for
+ * any g, as alpha grows. For alpha >= 0 only: below 0 the acceptance is `1 + alpha (1 + 2 g²) / 3`,
+ * which falls toward 0 as alpha nears -1 with g near ±1 (0.023 at g 0.99, alpha -0.99), and the
+ * proposal cap below then biases what it draws.
+ *
+ * Exact rather than closed form because the closed form loses the distribution where the engine's
+ * lobes live: see `chunk_sample_draine_cos`.
+ *
+ * After 64 rejected proposals the last one is returned. With an acceptance rate of at least 1/3
+ * that happens with probability below 6e-12.
+ *
+ * @see Jendersie, d'Eon, "An Approximate Mie Scattering Function for Fog and Cloud Rendering", SIGGRAPH 2023
+ */
+export const chunk_sample_draine: CodeChunk;
+import { CodeChunk } from "../../../../compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_sample_draine.d.ts.map

package/src/shade/renderer/shader/chunk/atmosphere/phase/jd/chunk_sample_draine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_sample_draine.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/shade/renderer/shader/chunk/atmosphere/phase/jd/chunk_sample_draine.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,4CAuBE;0BAhDwB,mCAAmC"}

package/src/shade/renderer/shader/chunk/atmosphere/phase/jd/chunk_sample_draine.js

@@ -0,0 +1,49 @@
+import { CodeChunk } from "../../../../compiler/CodeChunk.js";
+import { chunk_random } from "../../../random/chunk_random.js";
+import { chunk_sample_henyey_greenstein_cos } from "../chunk_sample_henyey_greenstein_cos.js";
+
+/**
+ * Samples the cosine of the scattering angle from the Draine phase function `phase_draine(mu, g,
+ * alpha)` — Henyey-Greenstein (alpha = 0), Cornette-Shanks (alpha = 1), Rayleigh (g = 0,
+ * alpha = 1) and the molecular water phase (g = 0, alpha = (1 - d) / (1 + d)) alike. Draws from
+ * `random()`.
+ *
+ * Draine is Henyey-Greenstein times `(1 + alpha mu²)` up to a constant, so a Henyey-Greenstein
+ * proposal accepted with probability `(1 + alpha mu²) / max(1, 1 + alpha)` is exactly Draine. The
+ * expected number of proposals is `max(1, 1 + alpha) / (1 + alpha (1 + 2 g²) / 3)`: at most 3, for
+ * any g, as alpha grows. For alpha >= 0 only: below 0 the acceptance is `1 + alpha (1 + 2 g²) / 3`,
+ * which falls toward 0 as alpha nears -1 with g near ±1 (0.023 at g 0.99, alpha -0.99), and the
+ * proposal cap below then biases what it draws.
+ *
+ * Exact rather than closed form because the closed form loses the distribution where the engine's
+ * lobes live: see `chunk_sample_draine_cos`.
+ *
+ * After 64 rejected proposals the last one is returned. With an acceptance rate of at least 1/3
+ * that happens with probability below 6e-12.
+ *
+ * @see Jendersie, d'Eon, "An Approximate Mie Scattering Function for Fog and Cloud Rendering", SIGGRAPH 2023
+ */
+export const chunk_sample_draine = CodeChunk.from(
+    //language=WGSL
+    `
+fn sample_draine(g: f32, alpha: f32) -> f32 {
+    let bound = max(1.0, 1.0 + alpha);
+
+    var mu = 0.0;
+
+    for (var attempt = 0u; attempt < 64u; attempt++) {
+        mu = sample_henyey_greenstein_cos(random(), g);
+
+        if (random() * bound <= 1.0 + alpha * mu * mu) {
+            break;
+        }
+    }
+
+    return mu;
+}
+    `,
+    [
+        chunk_random,
+        chunk_sample_henyey_greenstein_cos,
+    ]
+);

package/src/shade/renderer/shader/chunk/atmosphere/phase/jd/chunk_sample_draine_cos.d.ts

@@ -7,6 +7,24 @@
  *      - `alpha` The "alpha" shape parameter.
  *
  * @see "An Approximate Mie Scattering Function for Fog and Cloud Rendering" by Johannes Jendersie & Eugene d’Eon, NVIDIA. SIGGRAPH 2023. https://research.nvidia.com/labs/rtr/approximate-mie/publications/approximate-mie.pdf
+ *
+ * @deprecated use `chunk_sample_draine`. The closed form is ill-conditioned for small `g` and large
+ * `alpha`, in f64 as much as in f32, and it divides by both. Measured 2026-10-02 as the largest
+ * |CDF(sample(xi)) - xi| over 400 stratified xi, against quadrature of the Draine density:
+ *
+ * | g     | alpha | error (f32) |
+ * |-------|-------|-------------|
+ * | 0.8   | 1     | 4e-6        |
+ * | 0.5   | 250   | 8e-3        |
+ * | 0.1   | 250   | 9e-2        |
+ * | 0.01  | 50    | 0.19        |
+ * | 0.01  | 1     | 4e-2        |
+ * | 0.003 | 1     | 1.0         |
+ * | 0.001 | 50    | non-finite  |
+ *
+ * At g = 0 or alpha = 0 it divides by zero.
+ *
+ * alpha = 250 with g below 0.7 is what the Jendersie-d'Eon fits give for droplets under 1.5 µm.
  */
 export const chunk_sample_draine_cos: CodeChunk;
 import { CodeChunk } from "../../../../compiler/CodeChunk.js";

package/src/shade/renderer/shader/chunk/atmosphere/phase/jd/chunk_sample_draine_cos.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_sample_draine_cos.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/shade/renderer/shader/chunk/atmosphere/phase/jd/chunk_sample_draine_cos.js"],"names":[],"mappings":"AAEA;;;;;;;;;GASG;AACH,gDA+BE;0BA3CwB,mCAAmC"}
+{"version":3,"file":"chunk_sample_draine_cos.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/shade/renderer/shader/chunk/atmosphere/phase/jd/chunk_sample_draine_cos.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,gDA+BE;0BA7DwB,mCAAmC"}

package/src/shade/renderer/shader/chunk/atmosphere/phase/jd/chunk_sample_draine_cos.js

@@ -9,6 +9,24 @@ import { CodeChunk } from "../../../../compiler/CodeChunk.js";
  *      - `alpha` The "alpha" shape parameter.
  *
  * @see "An Approximate Mie Scattering Function for Fog and Cloud Rendering" by Johannes Jendersie & Eugene d’Eon, NVIDIA. SIGGRAPH 2023. https://research.nvidia.com/labs/rtr/approximate-mie/publications/approximate-mie.pdf
+ *
+ * @deprecated use `chunk_sample_draine`. The closed form is ill-conditioned for small `g` and large
+ * `alpha`, in f64 as much as in f32, and it divides by both. Measured 2026-10-02 as the largest
+ * |CDF(sample(xi)) - xi| over 400 stratified xi, against quadrature of the Draine density:
+ *
+ * | g     | alpha | error (f32) |
+ * |-------|-------|-------------|
+ * | 0.8   | 1     | 4e-6        |
+ * | 0.5   | 250   | 8e-3        |
+ * | 0.1   | 250   | 9e-2        |
+ * | 0.01  | 50    | 0.19        |
+ * | 0.01  | 1     | 4e-2        |
+ * | 0.003 | 1     | 1.0         |
+ * | 0.001 | 50    | non-finite  |
+ *
+ * At g = 0 or alpha = 0 it divides by zero.
+ *
+ * alpha = 250 with g below 0.7 is what the Jendersie-d'Eon fits give for droplets under 1.5 µm.
  */
 export const chunk_sample_draine_cos = CodeChunk.from(
     //language=WGSL

package/src/shade/renderer/shader/chunk/atomic/chunk_atomic_add_f32_storage.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Atomic f32 addition over a read-write storage atomic<u32> cell containing f32 bits.
+ *
+ * Each compare-exchange attempt adds to the current float value and writes the sum
+ * as plain f32 bits. Failed or spurious exchanges retry from a fresh atomic load,
+ * so concurrent additions are not lost.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_atomic_add_f32_storage: CodeChunk;
+import { CodeChunk } from "../../compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_atomic_add_f32_storage.d.ts.map

package/src/shade/renderer/shader/chunk/atomic/chunk_atomic_add_f32_storage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_atomic_add_f32_storage.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/atomic/chunk_atomic_add_f32_storage.js"],"names":[],"mappings":"AAEA;;;;;;;;GAQG;AACH,2CAFU,SAAS,CAehB;0BAxBuB,6BAA6B"}

package/src/shade/renderer/shader/chunk/atomic/chunk_atomic_max_f32_storage.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Atomic f32 maximum over a read-write storage atomic<u32> cell containing f32 bits.
+ *
+ * Compare-exchange retries keep the cell in plain f32 representation. If the stored
+ * value already bounds the contribution, the function exits without an exchange.
+ * Infinities are supported; the stored value and contribution must not be NaN.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_atomic_max_f32_storage: CodeChunk;
+import { CodeChunk } from "../../compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_atomic_max_f32_storage.d.ts.map

package/src/shade/renderer/shader/chunk/atomic/chunk_atomic_max_f32_storage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_atomic_max_f32_storage.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/atomic/chunk_atomic_max_f32_storage.js"],"names":[],"mappings":"AAEA;;;;;;;;GAQG;AACH,2CAFU,SAAS,CAkBhB;0BA3BuB,6BAA6B"}

package/src/shade/renderer/shader/chunk/atomic/chunk_atomic_min_f32_storage.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Atomic f32 minimum over a read-write storage atomic<u32> cell containing f32 bits.
+ *
+ * Compare-exchange retries keep the cell in plain f32 representation. If the stored
+ * value already bounds the contribution, the function exits without an exchange.
+ * Infinities are supported; the stored value and contribution must not be NaN.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_atomic_min_f32_storage: CodeChunk;
+import { CodeChunk } from "../../compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_atomic_min_f32_storage.d.ts.map

package/src/shade/renderer/shader/chunk/atomic/chunk_atomic_min_f32_storage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_atomic_min_f32_storage.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/atomic/chunk_atomic_min_f32_storage.js"],"names":[],"mappings":"AAEA;;;;;;;;GAQG;AACH,2CAFU,SAAS,CAkBhB;0BA3BuB,6BAA6B"}

package/src/shade/renderer/shader/chunk/brdf/dfg/chunk_integrate_brdf.d.ts

@@ -1,4 +1,7 @@
 /**
+ * The engine ships this integrated once, as `assets/textures/split_sum.bin` (`generate_dfg_texture`, run on a
+ * device), so changing what it integrates means regenerating that; `split_sum_asset.spec.js` holds the asset
+ * to the integral.
  * @see https://github.com/qiutang98/flower/blob/d67c6f1ae36bad18f6da15a70e2fe8d2949bf401/install/shader/brdf_lut.glsl
  * @see https://www.shadertoy.com/view/fdd3zf
  * @type {CodeChunk}

package/src/shade/renderer/shader/chunk/brdf/dfg/chunk_integrate_brdf.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_integrate_brdf.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/brdf/dfg/chunk_integrate_brdf.js"],"names":[],"mappings":"AAKA;;;;GAIG;AACH,mCAFU,SAAS,CA4DlB;0BApEyB,gCAAgC"}
+{"version":3,"file":"chunk_integrate_brdf.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/brdf/dfg/chunk_integrate_brdf.js"],"names":[],"mappings":"AAKA;;;;;;;GAOG;AACH,mCAFU,SAAS,CA4DlB;0BAvEyB,gCAAgC"}

package/src/shade/renderer/shader/chunk/brdf/dfg/chunk_integrate_brdf.js

@@ -4,6 +4,9 @@ import { chunk_importance_sample_GGX } from "../chunk_importance_sample_GGX.js";
 import { chunk_V_GGX_SmithCorrelated } from "../chunk_V_GGX_SmithCorrelated.js";
 
 /**
+ * The engine ships this integrated once, as `assets/textures/split_sum.bin` (`generate_dfg_texture`, run on a
+ * device), so changing what it integrates means regenerating that; `split_sum_asset.spec.js` holds the asset
+ * to the integral.
  * @see https://github.com/qiutang98/flower/blob/d67c6f1ae36bad18f6da15a70e2fe8d2949bf401/install/shader/brdf_lut.glsl
  * @see https://www.shadertoy.com/view/fdd3zf
  * @type {CodeChunk}

package/src/shade/renderer/shader/chunk/brdf/dfg/shader_split_sum_dgf_lut.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_split_sum_dgf_lut.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/brdf/dfg/shader_split_sum_dgf_lut.js"],"names":[],"mappings":"AAoBA,mDAQG;4BA3ByB,yBAAyB"}
+{"version":3,"file":"shader_split_sum_dgf_lut.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/brdf/dfg/shader_split_sum_dgf_lut.js"],"names":[],"mappings":"AAoBA,mDAUG;4BA7ByB,yBAAyB"}

package/src/shade/renderer/shader/chunk/brdf/dfg/shader_split_sum_dgf_lut.js

@@ -24,6 +24,8 @@ export const shader_split_sum_dgf_lut = ImageShader.from({
         body,
     }),
     targets: [{
-        format: "rg16float",
+        // f32, though the LUT ships as f16: written to an rg16float target the RTX 4090 rounded toward zero,
+        // half an f16 ulp low on average; `generate_dfg_texture` encodes to f16 itself, to nearest
+        format: "rg32float",
     }]
 });