@woosh/meep-engine 3.38.0 → 3.40.0

package/src/shade/renderer/scene/GPUSceneContext.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUSceneContext.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/scene/GPUSceneContext.js"],"names":[],"mappings":"AAqEA;;;;;;;;;GASG;AACH;IA0II;;;;OAIG;IACH,sBAHW,eAAe,SACf,KAAK,EAiCf;IA5KD;;;OAGG;IACH,aAFU,MAAM,CAEE;IAElB;;OAEG;IACH,YAFU,kBAAkB,CAEjB;IAEX;;OAEG;IACH,WAFU,kBAAkB,CAElB;IAGV;;OAEG;IACH,sBAFU,cAAc,CAEH;IASrB;;;OAGG;IACH,mBAEC;IAOD,uCAEC;IAQD;;;OAGG;IACH,iCAEC;IAOD;;;OAGG;IACH,8CAEC;IAOD;;;OAGG;IACH,8CAEC;IA2HD;;OAEG;IACH,kDAEC;IAED;;OAEG;IACH,gDAEC;IAED;;OAEG;IACH,kDAEC;IAED;;;;;;;;;;;;;;;;;;;OAmBG;IACH;QAH0C,SAAS,GAAxC,oBAAoB;QAClB,yBAAyB,CAuDrC;IAED;;OAEG;IACH,6CAEC;IAYD;;;OAGG;IACH,kCAEC;IAED;;;;;OAKG;IACH,uCAEC;IAED;;;;;;;;;;;OAWG;IACH,uCAUC;IAED,+BAUC;IAED;;;;;;;;;;OAUG;IACH,yBAEC;IAED;;;;;OAKG;IACH,sCAMC;IAOD;;;;;;;OAOG;IACH,8EAEC;IA0BD;;;;;OAKG;IACH,cAsEC;IAED;;;OAGG;IACH,YAFW,eAAe,QA0BzB;IAED;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,cAHW,sBAAsB,cACtB,MAAM,QAuBhB;IAoCD;;;;;;OAMG;IACH,gBAiBC;IAoCL;;;OAGG;IACH,4BAFU,OAAO,CAE0B;;CAN1C;8BAtuBY,OAAO,uBAAuB,EAAE,eAAe;iCAC/C,OAAO,mCAAmC,EAAE,kBAAkB;iCAC9D,OAAO,mCAAmC,EAAE,kBAAkB;4BAC9D,OAAO,8BAA8B,EAAE,aAAa;8BACpD,OAAO,iDAAiD,EAAE,eAAe;+BAtBvD,iDAAiD;sBAI1D,YAAY;oCADE,uCAAuC;mCADxC,gCAAgC;oCAD/B,mDAAmD;kDAIrC,wCAAwC;0CAfhD,0DAA0D;8BAItE,8CAA8C;iCAF3C,iDAAiD;qCAG7C,qDAAqD;oCAGtD,qCAAqC;4BAC7C,gCAAgC;uCAOrB,iDAAiD;6BAM3D,wBAAwB;wCADb,mCAAmC;uCAdpC,wCAAwC"}
+{"version":3,"file":"GPUSceneContext.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/scene/GPUSceneContext.js"],"names":[],"mappings":"AAqEA;;;;;;;;;GASG;AACH;IA0II;;;;OAIG;IACH,sBAHW,eAAe,SACf,KAAK,EAoCf;IA/KD;;;OAGG;IACH,aAFU,MAAM,CAEE;IAElB;;OAEG;IACH,YAFU,kBAAkB,CAEjB;IAEX;;OAEG;IACH,WAFU,kBAAkB,CAElB;IAGV;;OAEG;IACH,sBAFU,cAAc,CAEH;IASrB;;;OAGG;IACH,mBAEC;IAOD,uCAEC;IAQD;;;OAGG;IACH,iCAEC;IAOD;;;OAGG;IACH,8CAEC;IAOD;;;OAGG;IACH,8CAEC;IA8HD;;OAEG;IACH,kDAEC;IAED;;OAEG;IACH,gDAEC;IAED;;OAEG;IACH,kDAEC;IAED;;;;;;;;;;;;;;;;;;;OAmBG;IACH;QAH0C,SAAS,GAAxC,oBAAoB;QAClB,yBAAyB,CAuDrC;IAED;;OAEG;IACH,6CAEC;IAYD;;;OAGG;IACH,kCAEC;IAED;;;;;OAKG;IACH,uCAEC;IAED;;;;;;;;;;;OAWG;IACH,uCAUC;IAED,+BAUC;IAED;;;;;;;;;;OAUG;IACH,yBAEC;IAED;;;;;OAKG;IACH,sCAMC;IAOD;;;;;;;OAOG;IACH,8EAEC;IA0BD;;;;;OAKG;IACH,cAsEC;IAED;;;OAGG;IACH,YAFW,eAAe,QA0BzB;IAED;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,cAHW,sBAAsB,cACtB,MAAM,QAuBhB;IAoCD;;;;;;OAMG;IACH,gBAiBC;IAoCL;;;OAGG;IACH,4BAFU,OAAO,CAE0B;;CAN1C;8BAzuBY,OAAO,uBAAuB,EAAE,eAAe;iCAC/C,OAAO,mCAAmC,EAAE,kBAAkB;iCAC9D,OAAO,mCAAmC,EAAE,kBAAkB;4BAC9D,OAAO,8BAA8B,EAAE,aAAa;8BACpD,OAAO,iDAAiD,EAAE,eAAe;+BAtBvD,iDAAiD;sBAI1D,YAAY;oCADE,uCAAuC;mCADxC,gCAAgC;oCAD/B,mDAAmD;kDAIrC,wCAAwC;0CAfhD,0DAA0D;8BAItE,8CAA8C;iCAF3C,iDAAiD;qCAG7C,qDAAqD;oCAGtD,qCAAqC;4BAC7C,gCAAgC;uCAOrB,iDAAiD;6BAM3D,wBAAwB;wCADb,mCAAmC;uCAdpC,wCAAwC"}

package/src/shade/renderer/scene/GPUSceneContext.js

@@ -248,7 +248,10 @@ export class GPUSceneContext {
 
         this.volumetric_light_map = new Brick4LightMap(device);
 
-        this.#volumetrics = new GPUSceneVolumetrics(device, scene.volumetrics);
+        this.#volumetrics = new GPUSceneVolumetrics(
+            this.#scene_database.get('participating_media_volumes'),
+            scene.volumetrics
+        );
 
         this.#animation_manager = new GPUAnimationManager(device, `GPUSceneContext[${this.id}]/Animation`, this);
     }

package/src/shade/renderer/scene/SCENE_DATABASE_SPEC.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SCENE_DATABASE_SPEC.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/scene/SCENE_DATABASE_SPEC.js"],"names":[],"mappings":"AAIA;;;;;GAKG;AACH,wDAGG;sCAbmC,0CAA0C"}
+{"version":3,"file":"SCENE_DATABASE_SPEC.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/scene/SCENE_DATABASE_SPEC.js"],"names":[],"mappings":"AAOA;;;;;GAKG;AACH,wDASG;sCAtBmC,0CAA0C"}

package/src/shade/renderer/scene/SCENE_DATABASE_SPEC.js

@@ -1,6 +1,9 @@
 import { GPUDatabaseDefinition } from "../buffer/table/GPUDatabaseDefinition.js";
 import { MESH_INSTANCE_METADATA_STRUCT } from "./MESH_INSTANCE_METADATA_STRUCT.js";
 import { NODE3D_STRUCT } from "./NODE3D_STRUCT.js";
+import { PARTICIPATING_MEDIA_VOLUME_STRUCT } from "../volumetrics/PARTICIPATING_MEDIA_VOLUME_STRUCT.js";
+import { WATER_BODY_STRUCT } from "../water/medium/WATER_BODIES_STRUCT.js";
+import { WATER_WAVE_RECORD_STRUCT } from "../water/surface/WATER_WAVE_RECORD_STRUCT.js";
 
 /**
  * Schema for the scene's GPU-resident records — meshes and the
@@ -11,8 +14,21 @@ import { NODE3D_STRUCT } from "./NODE3D_STRUCT.js";
 export const SCENE_DATABASE_SPEC = GPUDatabaseDefinition.from({
     meshes: MESH_INSTANCE_METADATA_STRUCT,
     transforms: NODE3D_STRUCT,
+    // the scene's fog, smoke and cloud volumes (SceneVolumetrics), written whole by
+    // GPUSceneVolumetrics whenever their version moves; read by the froxel volumetrics and by the
+    // ray passes through chunk_participating_media_volumes_iterate
+    participating_media_volumes: PARTICIPATING_MEDIA_VOLUME_STRUCT,
+    water_bodies: WATER_BODY_STRUCT,
+    water_waves: WATER_WAVE_RECORD_STRUCT,
 });
 
+SCENE_DATABASE_SPEC.add_link({ table: 'water_bodies', field: 'node', target_database: SCENE_DATABASE_SPEC,
+    target_table: 'transforms', nullable: false, owning: false });
+SCENE_DATABASE_SPEC.add_link({ table: 'water_bodies', field: 'wave', target_database: SCENE_DATABASE_SPEC,
+    target_table: 'water_waves', nullable: true, owning: true });
+SCENE_DATABASE_SPEC.add_link({ table: 'water_waves', field: 'node', target_database: SCENE_DATABASE_SPEC,
+    target_table: 'transforms', nullable: false, owning: false });
+
 // A mesh's transform. A mesh row and its transforms row are the same row — the entity's, one on —
 // so this word always names its own index, and it is declared as the link it is.
 SCENE_DATABASE_SPEC.add_link({

package/src/shade/renderer/shader/chunk/atmosphere/C_MIE_SCATTERING_DECLARATION.d.ts

@@ -4,7 +4,18 @@
  */
 export const C_MIE_SCATTERING_DECLARATION: CodeChunk;
 /**
- * Mie absorption
+ * Mie extinction: scattering plus absorption. Hillaire's Earth authors this and the scattering,
+ * not the absorption -- 0.004440 and 0.003996 per km.
+ *
+ * @see https://github.com/sebh/UnrealEngineSkyAtmosphere/blob/183ead5bdacc701b3b626347a680a2f3cd3d4fbd/Application/SkyAtmosphereCommon.cpp#L40
+ */
+export const C_MIE_EXTINCTION_DECLARATION: CodeChunk;
+/**
+ * Mie absorption, derived the way Hillaire does: extinction less scattering, 0.444e-6 per metre,
+ * a tenth of the extinction. The shadertoy port wrote the 4.4 extinction here as the absorption,
+ * which put the extinction at 8.396e-6.
+ *
+ * @see https://github.com/sebh/UnrealEngineSkyAtmosphere/blob/183ead5bdacc701b3b626347a680a2f3cd3d4fbd/Application/Game.cpp#L707
  */
 export const C_MIE_ABSORPTION_DECLARATION: CodeChunk;
 import { CodeChunk } from "../../compiler/CodeChunk.js";

package/src/shade/renderer/shader/chunk/atmosphere/C_MIE_SCATTERING_DECLARATION.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"C_MIE_SCATTERING_DECLARATION.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/atmosphere/C_MIE_SCATTERING_DECLARATION.js"],"names":[],"mappings":"AAEA;;;GAGG;AACH,qDAGE;AAEF;;GAEG;AACH,qDAGE;0BAjBwB,6BAA6B"}
+{"version":3,"file":"C_MIE_SCATTERING_DECLARATION.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/atmosphere/C_MIE_SCATTERING_DECLARATION.js"],"names":[],"mappings":"AAEA;;;GAGG;AACH,qDAGE;AAEF;;;;;GAKG;AACH,qDAGE;AAEF;;;;;;GAMG;AACH,qDAOE;0BApCwB,6BAA6B"}

package/src/shade/renderer/shader/chunk/atmosphere/C_MIE_SCATTERING_DECLARATION.js

@@ -10,9 +10,28 @@ export const C_MIE_SCATTERING_DECLARATION = CodeChunk.from(
 );
 
 /**
- * Mie absorption
+ * Mie extinction: scattering plus absorption. Hillaire's Earth authors this and the scattering,
+ * not the absorption -- 0.004440 and 0.003996 per km.
+ *
+ * @see https://github.com/sebh/UnrealEngineSkyAtmosphere/blob/183ead5bdacc701b3b626347a680a2f3cd3d4fbd/Application/SkyAtmosphereCommon.cpp#L40
+ */
+export const C_MIE_EXTINCTION_DECLARATION = CodeChunk.from(
+    //language=WGSL
+    "const C_MIE_EXTINCTION = vec3(4.44) * 1e-6;"
+);
+
+/**
+ * Mie absorption, derived the way Hillaire does: extinction less scattering, 0.444e-6 per metre,
+ * a tenth of the extinction. The shadertoy port wrote the 4.4 extinction here as the absorption,
+ * which put the extinction at 8.396e-6.
+ *
+ * @see https://github.com/sebh/UnrealEngineSkyAtmosphere/blob/183ead5bdacc701b3b626347a680a2f3cd3d4fbd/Application/Game.cpp#L707
  */
 export const C_MIE_ABSORPTION_DECLARATION = CodeChunk.from(
     //language=WGSL
-    "const C_MIE_ABSORPTION = vec3(4.4) * 1e-6;"
-);
+    "const C_MIE_ABSORPTION = C_MIE_EXTINCTION - C_MIE_SCATTERING;",
+    [
+        C_MIE_EXTINCTION_DECLARATION,
+        C_MIE_SCATTERING_DECLARATION,
+    ]
+);

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

@@ -0,0 +1,18 @@
+/**
+ * Inverse CDF of the Henyey-Greenstein phase function: the cosine of the scattering angle, in the
+ * convention of `phase_mie` (`chunk_phase_mie_henyey_greenstein`) — +1 is straight on — for a
+ * uniform `xi` in [0, 1].
+ *
+ * The textbook inverse, `(1 + g² - ((1 - g²) / (1 - g + 2 g xi))²) / (2 g)`, cancels to O(g) in the
+ * numerator and divides by `g`, so it loses digits as g shrinks and needs an isotropic special case
+ * at g = 0. With `w = 2 xi - 1` the same function is
+ *
+ *      mu = (w + g) / (1 + g w) + g (1 - g²) (1 - w²) / (2 (1 + g w)²)
+ *
+ * which needs no special case (mu = w at g = 0), and lands exactly on -1 and +1 at the ends of the
+ * interval for every g in (-1, 1): there the second term is zero and the first is a ratio of two
+ * exact differences. `1 - w²` is formed as `4 xi (1 - xi)` so it does not cancel near the ends.
+ */
+export const chunk_sample_henyey_greenstein_cos: CodeChunk;
+import { CodeChunk } from "../../../compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_sample_henyey_greenstein_cos.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_sample_henyey_greenstein_cos.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/atmosphere/phase/chunk_sample_henyey_greenstein_cos.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;GAcG;AACH,2DAaE;0BA9BwB,gCAAgC"}

package/src/shade/renderer/shader/chunk/atmosphere/phase/chunk_sample_henyey_greenstein_cos.js

@@ -0,0 +1,31 @@
+import { CodeChunk } from "../../../compiler/CodeChunk.js";
+
+/**
+ * Inverse CDF of the Henyey-Greenstein phase function: the cosine of the scattering angle, in the
+ * convention of `phase_mie` (`chunk_phase_mie_henyey_greenstein`) — +1 is straight on — for a
+ * uniform `xi` in [0, 1].
+ *
+ * The textbook inverse, `(1 + g² - ((1 - g²) / (1 - g + 2 g xi))²) / (2 g)`, cancels to O(g) in the
+ * numerator and divides by `g`, so it loses digits as g shrinks and needs an isotropic special case
+ * at g = 0. With `w = 2 xi - 1` the same function is
+ *
+ *      mu = (w + g) / (1 + g w) + g (1 - g²) (1 - w²) / (2 (1 + g w)²)
+ *
+ * which needs no special case (mu = w at g = 0), and lands exactly on -1 and +1 at the ends of the
+ * interval for every g in (-1, 1): there the second term is zero and the first is a ratio of two
+ * exact differences. `1 - w²` is formed as `4 xi (1 - xi)` so it does not cancel near the ends.
+ */
+export const chunk_sample_henyey_greenstein_cos = CodeChunk.from(
+    //language=WGSL
+    `
+fn sample_henyey_greenstein_cos(xi: f32, g: f32) -> f32 {
+    let w = 2.0 * xi - 1.0;
+    let denominator = 1.0 + g * w;
+
+    let mobius = (w + g) / denominator;
+    let correction = g * (1.0 - g * g) * (4.0 * xi * (1.0 - xi)) / (2.0 * denominator * denominator);
+
+    return clamp(mobius + correction, -1.0, 1.0);
+}
+    `
+);

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

@@ -0,0 +1,43 @@
+/**
+ * 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;
+import { CodeChunk } from "../../../../compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_phase_fournier_forand.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_phase_fournier_forand.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/shade/renderer/shader/chunk/atmosphere/phase/ff/chunk_phase_fournier_forand.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AACH,oDA6GE;0BAxJwB,mCAAmC"}

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/build_lut_fog_parameters_jendersie_deon.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"build_lut_fog_parameters_jendersie_deon.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/shade/renderer/shader/chunk/atmosphere/phase/jd/build_lut_fog_parameters_jendersie_deon.js"],"names":[],"mappings":"AAeA;;;;;;;;;GASG;AACH,qEAPW,MAAM,iBACN,MAAM,iBACN,MAAM,GACJ,YAAY,CAoDxB;6BArE4B,wCAAwC"}
+{"version":3,"file":"build_lut_fog_parameters_jendersie_deon.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/shade/renderer/shader/chunk/atmosphere/phase/jd/build_lut_fog_parameters_jendersie_deon.js"],"names":[],"mappings":"AAcA;;;;;;;;;GASG;AACH,qEAPW,MAAM,iBACN,MAAM,iBACN,MAAM,GACJ,YAAY,CAoDxB;6BArE4B,wCAAwC"}

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

@@ -1,5 +1,4 @@
 import { assert } from "../../../../../../../core/assert.js";
-import { to_half_float_uint16 } from "../../../../../../../core/binary/to_half_float_uint16.js";
 import { BinaryDataType } from "../../../../../../../core/binary/type/BinaryDataType.js";
 import { ColorSpace } from "../../../../../texture/ColorSpace.js";
 import { ShadeTexture } from "../../../../../texture/ShadeTexture.js";
@@ -33,7 +32,7 @@ export function build_lut_fog_parameters_jendersie_deon(
     const log_d_min = Math.log(min_diameter);
     const log_range = Math.log(max_diameter) - log_d_min;
 
-    const u16 = new Uint16Array(resolution * 4);
+    const f16 = new Float16Array(resolution * 4);
 
     const sample = [];
     for (let i = 0; i < resolution; i++) {
@@ -49,7 +48,7 @@ export function build_lut_fog_parameters_jendersie_deon(
         );
 
         for (let j = 0; j < 4; j++) {
-            u16[i * 4 + j] = to_half_float_uint16(sample[j]);
+            f16[i * 4 + j] = sample[j];
         }
 
         assert.greaterThanOrEqual(sample[3],0, "w_D must not be negative");
@@ -57,7 +56,7 @@ export function build_lut_fog_parameters_jendersie_deon(
     }
 
     const image = ShadeImage.fromArrayBuffer(
-        u16.buffer,
+        f16.buffer,
         4,
         BinaryDataType.Float16,
         resolution, 1, 1,
@@ -71,4 +70,4 @@ export function build_lut_fog_parameters_jendersie_deon(
     texture.dimensions = 1;
 
     return texture;
-}
+}