@woosh/meep-engine 3.38.0 → 3.39.0

package/src/shade/renderer/medium/participating_medium_serialization.js

@@ -0,0 +1,181 @@
+import { assert } from "../../../core/assert.js";
+import { PhaseCornetteShanks } from "./phase/PhaseCornetteShanks.js";
+import { PhaseDraine } from "./phase/PhaseDraine.js";
+import { PhaseFournierForand } from "./phase/PhaseFournierForand.js";
+import { PhaseHenyeyGreenstein } from "./phase/PhaseHenyeyGreenstein.js";
+import { PhaseJendersieDeon } from "./phase/PhaseJendersieDeon.js";
+import { PhaseRayleigh } from "./phase/PhaseRayleigh.js";
+import { PhaseWaterMolecular } from "./phase/PhaseWaterMolecular.js";
+
+/**
+ * How each phase function is written: a type id, a JSON name and its parameters, in order.
+ *
+ * **The ids and names are wire format.** Saved content refers to them; never renumber or rename,
+ * only append.
+ */
+const PHASES = [
+    { id: 0, name: "HenyeyGreenstein", klass: PhaseHenyeyGreenstein, parameters: ["g"] },
+    { id: 1, name: "CornetteShanks", klass: PhaseCornetteShanks, parameters: ["g"] },
+    { id: 2, name: "Rayleigh", klass: PhaseRayleigh, parameters: [] },
+    { id: 3, name: "Draine", klass: PhaseDraine, parameters: ["g", "alpha"] },
+    { id: 4, name: "WaterMolecular", klass: PhaseWaterMolecular, parameters: ["depolarization"] },
+    { id: 5, name: "FournierForand", klass: PhaseFournierForand, parameters: ["backscatter_fraction"] },
+    { id: 6, name: "JendersieDeon", klass: PhaseJendersieDeon, parameters: ["diameter_micron"] },
+];
+
+/**
+ * @param {Object} phase
+ */
+function phase_entry_of(phase) {
+    for (let i = 0; i < PHASES.length; i++) {
+        if (phase instanceof PHASES[i].klass) {
+            return PHASES[i];
+        }
+    }
+
+    throw new Error(`No serialization for phase function ${phase?.constructor?.name}`);
+}
+
+/**
+ * @param {Object} entry
+ * @param {Object<string, number>} values
+ */
+function phase_construct(entry, values) {
+    if (entry.parameters.length === 0) {
+        return new entry.klass();
+    }
+
+    return new entry.klass(values);
+}
+
+/**
+ * Write a medium: absorption, priority, then each lobe's scattering, phase type and parameters.
+ *
+ * Shared by everything that saves a medium — water today, materials later — so there is one
+ * format, not one per owner.
+ *
+ * @param {import("../../../core/binary/BinaryBuffer.js").BinaryBuffer} buffer
+ * @param {import("./ParticipatingMedium.js").ParticipatingMedium} medium
+ */
+export function serialize_participating_medium(buffer, medium) {
+    assert.defined(medium, 'medium');
+    assert.equal(medium.isParticipatingMedium, true, 'medium.isParticipatingMedium !== true');
+
+    for (let i = 0; i < 3; i++) {
+        buffer.writeFloat32(medium.absorption[i]);
+    }
+
+    buffer.writeUintVar(medium.priority);
+
+    const lobes = medium.lobes;
+
+    buffer.writeUintVar(lobes.length);
+
+    for (let i = 0; i < lobes.length; i++) {
+        const lobe = lobes[i];
+        const entry = phase_entry_of(lobe.phase);
+
+        for (let c = 0; c < 3; c++) {
+            buffer.writeFloat32(lobe.scattering[c]);
+        }
+
+        buffer.writeUint8(entry.id);
+
+        for (const name of entry.parameters) {
+            buffer.writeFloat32(lobe.phase[name]);
+        }
+    }
+}
+
+/**
+ * Read a medium written by {@link serialize_participating_medium} into `medium`, replacing its
+ * absorption, priority and lobes.
+ *
+ * @param {import("../../../core/binary/BinaryBuffer.js").BinaryBuffer} buffer
+ * @param {import("./ParticipatingMedium.js").ParticipatingMedium} medium
+ */
+export function deserialize_participating_medium(buffer, medium) {
+    assert.defined(medium, 'medium');
+
+    const absorption = [buffer.readFloat32(), buffer.readFloat32(), buffer.readFloat32()];
+    const priority = buffer.readUintVar();
+    const lobe_count = buffer.readUintVar();
+
+    medium.clear_lobes();
+    medium.absorption = absorption;
+    medium.priority = priority;
+
+    for (let i = 0; i < lobe_count; i++) {
+        const scattering = [buffer.readFloat32(), buffer.readFloat32(), buffer.readFloat32()];
+        const id = buffer.readUint8();
+        const entry = PHASES.find(e => e.id === id);
+
+        assert.defined(entry, `phase type id ${id}`);
+
+        const values = {};
+
+        for (const name of entry.parameters) {
+            values[name] = buffer.readFloat32();
+        }
+
+        medium.add_lobe(scattering, phase_construct(entry, values));
+    }
+
+    medium.needsUpdate = true;
+}
+
+/**
+ * @param {import("./ParticipatingMedium.js").ParticipatingMedium} medium
+ * @returns {Object}
+ */
+export function participating_medium_to_json(medium) {
+    assert.defined(medium, 'medium');
+
+    return {
+        absorption: medium.absorption.slice(),
+        priority: medium.priority,
+        lobes: medium.lobes.map(lobe => {
+            const entry = phase_entry_of(lobe.phase);
+            const phase = { type: entry.name };
+
+            for (const name of entry.parameters) {
+                phase[name] = lobe.phase[name];
+            }
+
+            return { scattering: lobe.scattering.slice(), phase };
+        }),
+    };
+}
+
+/**
+ * Replace `medium`'s absorption, priority and lobes with those of a {@link participating_medium_to_json}
+ * record.
+ *
+ * @param {import("./ParticipatingMedium.js").ParticipatingMedium} medium
+ * @param {Object} json
+ */
+export function participating_medium_from_json(medium, json) {
+    assert.defined(medium, 'medium');
+    assert.defined(json, 'json');
+    assert.isArray(json.lobes, 'json.lobes');
+
+    medium.clear_lobes();
+    medium.absorption = Array.from(json.absorption);
+    medium.priority = json.priority;
+
+    for (const lobe of json.lobes) {
+        const entry = PHASES.find(e => e.name === lobe.phase.type);
+
+        assert.defined(entry, `phase type '${lobe.phase.type}'`);
+
+        const values = {};
+
+        for (const name of entry.parameters) {
+            values[name] = lobe.phase[name];
+        }
+
+        medium.add_lobe(Array.from(lobe.scattering), phase_construct(entry, values));
+    }
+
+    medium.needsUpdate = true;
+}

package/src/shade/renderer/medium/phase/MediumPhaseFunction.d.ts

@@ -0,0 +1,48 @@
+/**
+ * @typedef {Object} MediumPhaseLobeRecord
+ * @property {number[]} scattering RGB scattering coefficient of the lobe, 1/m
+ * @property {number} kind a {@link MEDIUM_PHASE_LOBE_KIND}
+ * @property {number} p0
+ * @property {number} p1
+ */
+/**
+ * A phase function a medium's scattering can have: what it is to a person (Henyey-Greenstein with
+ * this g, Fournier-Forand with that backscatter fraction), and how it reduces to the GPU's lobes,
+ * of which there are only two kinds (see {@link MEDIUM_PHASE_LOBE_KIND}).
+ *
+ * @abstract
+ */
+export class MediumPhaseFunction {
+    /**
+     * How many GPU lobes {@link write_gpu_lobes} appends.
+     * @abstract
+     * @returns {number}
+     */
+    get gpu_lobe_count(): number;
+    /**
+     * Append the GPU lobes this phase function reduces to, sharing out `scattering` between them.
+     *
+     * @abstract
+     * @param {number[]} scattering RGB scattering coefficient this phase function applies to, 1/m
+     * @param {MediumPhaseLobeRecord[]} output
+     */
+    write_gpu_lobes(scattering: number[], output: MediumPhaseLobeRecord[]): void;
+    /**
+     * @readonly
+     * @type {boolean}
+     */
+    readonly isMediumPhaseFunction: boolean;
+}
+export type MediumPhaseLobeRecord = {
+    /**
+     * RGB scattering coefficient of the lobe, 1/m
+     */
+    scattering: number[];
+    /**
+     * a {@link MEDIUM_PHASE_LOBE_KIND }
+     */
+    kind: number;
+    p0: number;
+    p1: number;
+};
+//# sourceMappingURL=MediumPhaseFunction.d.ts.map

package/src/shade/renderer/medium/phase/MediumPhaseFunction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MediumPhaseFunction.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/medium/phase/MediumPhaseFunction.js"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH;;;;;;GAMG;AACH;IACI;;;;OAIG;IACH,6BAEC;IAED;;;;;;OAMG;IACH,4BAHW,MAAM,EAAE,UACR,qBAAqB,EAAE,QAIjC;IAGL;;;OAGG;IACH,gCAFU,OAAO,CAEkC;CANlD;;;;;gBAjCa,MAAM,EAAE;;;;UACR,MAAM;QACN,MAAM;QACN,MAAM"}

package/src/shade/renderer/medium/phase/MediumPhaseFunction.js

@@ -0,0 +1,42 @@
+/**
+ * @typedef {Object} MediumPhaseLobeRecord
+ * @property {number[]} scattering RGB scattering coefficient of the lobe, 1/m
+ * @property {number} kind a {@link MEDIUM_PHASE_LOBE_KIND}
+ * @property {number} p0
+ * @property {number} p1
+ */
+
+/**
+ * A phase function a medium's scattering can have: what it is to a person (Henyey-Greenstein with
+ * this g, Fournier-Forand with that backscatter fraction), and how it reduces to the GPU's lobes,
+ * of which there are only two kinds (see {@link MEDIUM_PHASE_LOBE_KIND}).
+ *
+ * @abstract
+ */
+export class MediumPhaseFunction {
+    /**
+     * How many GPU lobes {@link write_gpu_lobes} appends.
+     * @abstract
+     * @returns {number}
+     */
+    get gpu_lobe_count() {
+        throw new Error('abstract');
+    }
+
+    /**
+     * Append the GPU lobes this phase function reduces to, sharing out `scattering` between them.
+     *
+     * @abstract
+     * @param {number[]} scattering RGB scattering coefficient this phase function applies to, 1/m
+     * @param {MediumPhaseLobeRecord[]} output
+     */
+    write_gpu_lobes(scattering, output) {
+        throw new Error('abstract');
+    }
+}
+
+/**
+ * @readonly
+ * @type {boolean}
+ */
+MediumPhaseFunction.prototype.isMediumPhaseFunction = true;

package/src/shade/renderer/medium/phase/PhaseCornetteShanks.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Cornette-Shanks: Henyey-Greenstein given the (1 + mu²) of Rayleigh's limit, a better fit to Mie
+ * than one Henyey-Greenstein lobe. What the sky integrator uses for aerosols.
+ *
+ * @see Cornette, Shanks, "Physically reasonable analytic expression for the single-scattering phase function", Applied Optics 31(16), 1992
+ */
+export class PhaseCornetteShanks extends MediumPhaseFunction {
+    /**
+     * @param {Object} options
+     * @param {number} options.g
+     */
+    constructor({ g }: {
+        g: number;
+    });
+    /**
+     * anisotropy, in (-1, 1)
+     * @type {number}
+     */
+    g: number;
+    write_gpu_lobes(scattering: any, output: any): void;
+}
+import { MediumPhaseFunction } from "./MediumPhaseFunction.js";
+//# sourceMappingURL=PhaseCornetteShanks.d.ts.map

package/src/shade/renderer/medium/phase/PhaseCornetteShanks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PhaseCornetteShanks.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/medium/phase/PhaseCornetteShanks.js"],"names":[],"mappings":"AAIA;;;;;GAKG;AACH;IAOI;;;OAGG;IACH;QAF2B,CAAC,EAAjB,MAAM;OAWhB;IAnBD;;;OAGG;IACH,GAFU,MAAM,CAEV;IAqBN,oDAOC;CACJ;oCA1CmC,0BAA0B"}

package/src/shade/renderer/medium/phase/PhaseCornetteShanks.js

@@ -0,0 +1,45 @@
+import { assert } from "../../../../core/assert.js";
+import { MEDIUM_PHASE_LOBE_KIND } from "../MEDIUM_PHASE_LOBE_KIND.js";
+import { MediumPhaseFunction } from "./MediumPhaseFunction.js";
+
+/**
+ * Cornette-Shanks: Henyey-Greenstein given the (1 + mu²) of Rayleigh's limit, a better fit to Mie
+ * than one Henyey-Greenstein lobe. What the sky integrator uses for aerosols.
+ *
+ * @see Cornette, Shanks, "Physically reasonable analytic expression for the single-scattering phase function", Applied Optics 31(16), 1992
+ */
+export class PhaseCornetteShanks extends MediumPhaseFunction {
+    /**
+     * anisotropy, in (-1, 1)
+     * @type {number}
+     */
+    g = 0;
+
+    /**
+     * @param {Object} options
+     * @param {number} options.g
+     */
+    constructor({ g }) {
+        super();
+
+        assert.isNumber(g, 'g');
+        // as f32, which is what the lobe is evaluated in: 1 - 1e-9 is a delta there
+        assert.greaterThan(Math.fround(g), -1, 'g');
+        assert.lessThan(Math.fround(g), 1, 'g');
+
+        this.g = g;
+    }
+
+    get gpu_lobe_count() {
+        return 1;
+    }
+
+    write_gpu_lobes(scattering, output) {
+        output.push({
+            scattering: scattering.slice(),
+            kind: MEDIUM_PHASE_LOBE_KIND.Draine,
+            p0: this.g,
+            p1: 1,
+        });
+    }
+}

package/src/shade/renderer/medium/phase/PhaseDraine.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Draine's phase function, `phase_draine(mu, g, alpha)`: Henyey-Greenstein times (1 + alpha mu²),
+ * normalized. The family the other analytic phases are members of.
+ *
+ * @see Draine, "Scattering by Interstellar Dust Grains. I.", ApJ 598, 2003
+ */
+export class PhaseDraine extends MediumPhaseFunction {
+    /**
+     * @param {Object} options
+     * @param {number} options.g
+     * @param {number} options.alpha
+     */
+    constructor({ g, alpha }: {
+        g: number;
+        alpha: number;
+    });
+    /**
+     * anisotropy, in (-1, 1)
+     * @type {number}
+     */
+    g: number;
+    /**
+     * weight of the mu² term, above -1
+     * @type {number}
+     */
+    alpha: number;
+    write_gpu_lobes(scattering: any, output: any): void;
+}
+import { MediumPhaseFunction } from "./MediumPhaseFunction.js";
+//# sourceMappingURL=PhaseDraine.d.ts.map

package/src/shade/renderer/medium/phase/PhaseDraine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PhaseDraine.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/medium/phase/PhaseDraine.js"],"names":[],"mappings":"AAIA;;;;;GAKG;AACH;IAaI;;;;OAIG;IACH;QAH2B,CAAC,EAAjB,MAAM;QACU,KAAK,EAArB,MAAM;OAiBhB;IAhCD;;;OAGG;IACH,GAFU,MAAM,CAEV;IAEN;;;OAGG;IACH,OAFU,MAAM,CAEN;IA4BV,oDAOC;CACJ;oCAvDmC,0BAA0B"}

package/src/shade/renderer/medium/phase/PhaseDraine.js

@@ -0,0 +1,58 @@
+import { assert } from "../../../../core/assert.js";
+import { MEDIUM_PHASE_LOBE_KIND } from "../MEDIUM_PHASE_LOBE_KIND.js";
+import { MediumPhaseFunction } from "./MediumPhaseFunction.js";
+
+/**
+ * Draine's phase function, `phase_draine(mu, g, alpha)`: Henyey-Greenstein times (1 + alpha mu²),
+ * normalized. The family the other analytic phases are members of.
+ *
+ * @see Draine, "Scattering by Interstellar Dust Grains. I.", ApJ 598, 2003
+ */
+export class PhaseDraine extends MediumPhaseFunction {
+    /**
+     * anisotropy, in (-1, 1)
+     * @type {number}
+     */
+    g = 0;
+
+    /**
+     * weight of the mu² term, above -1
+     * @type {number}
+     */
+    alpha = 0;
+
+    /**
+     * @param {Object} options
+     * @param {number} options.g
+     * @param {number} options.alpha
+     */
+    constructor({ g, alpha }) {
+        super();
+
+        assert.isNumber(g, 'g');
+        // as f32, which is what the lobe is evaluated in: 1 - 1e-9 is a delta there
+        assert.greaterThan(Math.fround(g), -1, 'g');
+        assert.lessThan(Math.fround(g), 1, 'g');
+
+        assert.isNumber(alpha, 'alpha');
+        // sample_draine draws it by rejection from Henyey-Greenstein, which below 0 accepts too little
+        assert.greaterThanOrEqual(alpha, 0, 'alpha');
+        assert.isFinite(alpha, 'alpha');
+
+        this.g = g;
+        this.alpha = alpha;
+    }
+
+    get gpu_lobe_count() {
+        return 1;
+    }
+
+    write_gpu_lobes(scattering, output) {
+        output.push({
+            scattering: scattering.slice(),
+            kind: MEDIUM_PHASE_LOBE_KIND.Draine,
+            p0: this.g,
+            p1: this.alpha,
+        });
+    }
+}

package/src/shade/renderer/medium/phase/PhaseFournierForand.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Fournier-Forand, the phase function of the particles in natural water, stated by one number: the
+ * share of their scattering that goes backwards. Petzold's average is 0.0183. The shape follows
+ * Mobley et al. 2002's line through Petzold's measurements (see
+ * `fournier_forand_parameters_from_backscatter`).
+ */
+export class PhaseFournierForand extends MediumPhaseFunction {
+    /**
+     * @param {Object} options
+     * @param {number} options.backscatter_fraction
+     */
+    constructor({ backscatter_fraction }: {
+        backscatter_fraction: number;
+    });
+    /**
+     * fraction of the scattering deflected by more than 90 degrees, in [3.3e-10, 0.4999994] — the
+     * range the Fournier-Forand line reaches
+     * @type {number}
+     */
+    backscatter_fraction: number;
+    write_gpu_lobes(scattering: any, output: any): void;
+}
+import { MediumPhaseFunction } from "./MediumPhaseFunction.js";
+//# sourceMappingURL=PhaseFournierForand.d.ts.map

package/src/shade/renderer/medium/phase/PhaseFournierForand.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PhaseFournierForand.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/medium/phase/PhaseFournierForand.js"],"names":[],"mappings":"AASA;;;;;GAKG;AACH;IAQI;;;OAGG;IACH;QAF2B,oBAAoB,EAApC,MAAM;OAWhB;IApBD;;;;OAIG;IACH,sBAFU,MAAM,CAEc;IAqB9B,oDASC;CACJ;oCA7CmC,0BAA0B"}

package/src/shade/renderer/medium/phase/PhaseFournierForand.js

@@ -0,0 +1,53 @@
+import { assert } from "../../../../core/assert.js";
+import {
+    FOURNIER_FORAND_BACKSCATTER_MAX,
+    FOURNIER_FORAND_BACKSCATTER_MIN,
+    fournier_forand_parameters_from_backscatter
+} from "../../shader/chunk/atmosphere/phase/ff/fournier_forand_parameters_from_backscatter.js";
+import { MEDIUM_PHASE_LOBE_KIND } from "../MEDIUM_PHASE_LOBE_KIND.js";
+import { MediumPhaseFunction } from "./MediumPhaseFunction.js";
+
+/**
+ * Fournier-Forand, the phase function of the particles in natural water, stated by one number: the
+ * share of their scattering that goes backwards. Petzold's average is 0.0183. The shape follows
+ * Mobley et al. 2002's line through Petzold's measurements (see
+ * `fournier_forand_parameters_from_backscatter`).
+ */
+export class PhaseFournierForand extends MediumPhaseFunction {
+    /**
+     * fraction of the scattering deflected by more than 90 degrees, in [3.3e-10, 0.4999994] — the
+     * range the Fournier-Forand line reaches
+     * @type {number}
+     */
+    backscatter_fraction = 0.0183;
+
+    /**
+     * @param {Object} options
+     * @param {number} options.backscatter_fraction
+     */
+    constructor({ backscatter_fraction }) {
+        super();
+
+        assert.isNumber(backscatter_fraction, 'backscatter_fraction');
+        // what the parameter solve reaches, so that a medium fails here rather than when uploaded
+        assert.greaterThanOrEqual(backscatter_fraction, FOURNIER_FORAND_BACKSCATTER_MIN, 'backscatter_fraction');
+        assert.lessThanOrEqual(backscatter_fraction, FOURNIER_FORAND_BACKSCATTER_MAX, 'backscatter_fraction');
+
+        this.backscatter_fraction = backscatter_fraction;
+    }
+
+    get gpu_lobe_count() {
+        return 1;
+    }
+
+    write_gpu_lobes(scattering, output) {
+        const { nu, kappa } = fournier_forand_parameters_from_backscatter(this.backscatter_fraction);
+
+        output.push({
+            scattering: scattering.slice(),
+            kind: MEDIUM_PHASE_LOBE_KIND.FournierForand,
+            p0: nu,
+            p1: kappa,
+        });
+    }
+}

package/src/shade/renderer/medium/phase/PhaseHenyeyGreenstein.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Henyey-Greenstein: one lobe, its anisotropy g the mean cosine of the scattering angle. What the
+ * froxel volumetrics use for every fog volume.
+ */
+export class PhaseHenyeyGreenstein extends MediumPhaseFunction {
+    /**
+     * @param {Object} options
+     * @param {number} options.g
+     */
+    constructor({ g }: {
+        g: number;
+    });
+    /**
+     * anisotropy, in (-1, 1)
+     * @type {number}
+     */
+    g: number;
+    write_gpu_lobes(scattering: any, output: any): void;
+}
+import { MediumPhaseFunction } from "./MediumPhaseFunction.js";
+//# sourceMappingURL=PhaseHenyeyGreenstein.d.ts.map

package/src/shade/renderer/medium/phase/PhaseHenyeyGreenstein.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PhaseHenyeyGreenstein.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/medium/phase/PhaseHenyeyGreenstein.js"],"names":[],"mappings":"AAIA;;;GAGG;AACH;IAOI;;;OAGG;IACH;QAF2B,CAAC,EAAjB,MAAM;OAWhB;IAnBD;;;OAGG;IACH,GAFU,MAAM,CAEV;IAqBN,oDAOC;CACJ;oCAxCmC,0BAA0B"}

package/src/shade/renderer/medium/phase/PhaseHenyeyGreenstein.js

@@ -0,0 +1,43 @@
+import { assert } from "../../../../core/assert.js";
+import { MEDIUM_PHASE_LOBE_KIND } from "../MEDIUM_PHASE_LOBE_KIND.js";
+import { MediumPhaseFunction } from "./MediumPhaseFunction.js";
+
+/**
+ * Henyey-Greenstein: one lobe, its anisotropy g the mean cosine of the scattering angle. What the
+ * froxel volumetrics use for every fog volume.
+ */
+export class PhaseHenyeyGreenstein extends MediumPhaseFunction {
+    /**
+     * anisotropy, in (-1, 1)
+     * @type {number}
+     */
+    g = 0;
+
+    /**
+     * @param {Object} options
+     * @param {number} options.g
+     */
+    constructor({ g }) {
+        super();
+
+        assert.isNumber(g, 'g');
+        // as f32, which is what the lobe is evaluated in: 1 - 1e-9 is a delta there
+        assert.greaterThan(Math.fround(g), -1, 'g');
+        assert.lessThan(Math.fround(g), 1, 'g');
+
+        this.g = g;
+    }
+
+    get gpu_lobe_count() {
+        return 1;
+    }
+
+    write_gpu_lobes(scattering, output) {
+        output.push({
+            scattering: scattering.slice(),
+            kind: MEDIUM_PHASE_LOBE_KIND.Draine,
+            p0: this.g,
+            p1: 0,
+        });
+    }
+}

package/src/shade/renderer/medium/phase/PhaseJendersieDeon.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Jendersie and d'Eon's fit to Mie scattering by water droplets of one diameter: a
+ * Henyey-Greenstein lobe and a Draine lobe, mixed. For fog and cloud droplets. It reduces to two GPU
+ * lobes, the mixture weight going into how the scattering is shared between them, so the fit's
+ * lookup texture is not needed.
+ *
+ * @see Jendersie, d'Eon, "An Approximate Mie Scattering Function for Fog and Cloud Rendering", SIGGRAPH 2023
+ */
+export class PhaseJendersieDeon extends MediumPhaseFunction {
+    /**
+     * @param {Object} options
+     * @param {number} options.diameter_micron within the fit's range, 0.01 to 50
+     */
+    constructor({ diameter_micron }: {
+        diameter_micron: number;
+    });
+    /**
+     * droplet diameter, micrometres
+     * @type {number}
+     */
+    diameter_micron: number;
+    write_gpu_lobes(scattering: any, output: any): void;
+}
+import { MediumPhaseFunction } from "./MediumPhaseFunction.js";
+//# sourceMappingURL=PhaseJendersieDeon.d.ts.map

package/src/shade/renderer/medium/phase/PhaseJendersieDeon.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PhaseJendersieDeon.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/medium/phase/PhaseJendersieDeon.js"],"names":[],"mappings":"AAWA;;;;;;;GAOG;AACH;IAOI;;;OAGG;IACH;QAF2B,eAAe,EAA/B,MAAM;OAUhB;IAlBD;;;OAGG;IACH,iBAFU,MAAM,CAEK;IAoBrB,oDAoBC;CACJ;oCAxDmC,0BAA0B"}