@woosh/meep-engine 3.38.0 → 3.40.0

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

@@ -0,0 +1,211 @@
+import { assert } from "../../../core/assert.js";
+import Signal from "../../../core/events/signal/Signal.js";
+import { MEDIUM_PHASE_LOBE_LIMIT } from "./MEDIUM_STRUCT.js";
+
+/**
+ * @typedef {import("./phase/MediumPhaseFunction.js").MediumPhaseFunction} MediumPhaseFunction
+ * @typedef {import("./phase/MediumPhaseFunction.js").MediumPhaseLobeRecord} MediumPhaseLobeRecord
+ * @typedef {import("../material/ShadeMaterial.js").ShadeMaterial} ShadeMaterial
+ */
+
+/**
+ * @param {number[]} rgb
+ * @param {string} name
+ */
+function assert_coefficient(rgb, name) {
+    assert.isArrayLike(rgb, name);
+    assert.equal(rgb.length, 3, `${name}.length`);
+
+    for (let i = 0; i < 3; i++) {
+        assert.isFinite(rgb[i], `${name}[${i}]`);
+        assert.greaterThanOrEqual(rgb[i], 0, `${name}[${i}]`);
+    }
+}
+
+/**
+ * One scattering component of a medium.
+ */
+export class ParticipatingMediumLobe {
+    /**
+     * @param {number[]} scattering RGB scattering coefficient, 1/m
+     * @param {MediumPhaseFunction} phase
+     */
+    constructor(scattering, phase) {
+        /**
+         * RGB scattering coefficient, 1/m
+         * @type {number[]}
+         */
+        this.scattering = scattering;
+
+        /**
+         * @type {MediumPhaseFunction}
+         */
+        this.phase = phase;
+    }
+}
+
+/**
+ * What light does inside a region: how much is absorbed and how much scattered per metre, per
+ * channel, and in which directions the scattered light goes. Water is pure water's absorption plus
+ * whatever is dissolved, scattered by the molecules themselves and by particles; glass is
+ * absorption alone; fog is droplets.
+ *
+ * Coefficients are RGB in 1/m, in the renderer's linear working colour space. Absorption is the
+ * whole medium's; scattering is declared one component at a time with its own phase function,
+ * because a medium's components scatter differently (water's molecules almost evenly, its
+ * particles almost all forward) and the phase function at a point is their mixture, weighted by
+ * each one's scattering:
+ *
+ *      water.absorption = [0.35, 0.067, 0.019];
+ *      water.add_lobe([0.0009, 0.0019, 0.0045], new PhaseWaterMolecular({ depolarization: 0.039 }));
+ *      water.add_lobe([0.05, 0.05, 0.05], new PhaseFournierForand({ backscatter_fraction: 0.0183 }));
+ *
+ * The index of refraction is not here: it belongs to the surface the medium is entered through.
+ */
+export class ParticipatingMedium {
+    /**
+     * Absorption coefficient sigma_a, RGB, 1/m.
+     * @type {number[]}
+     */
+    absorption = [0, 0, 0];
+
+    /**
+     * Where regions bounded by refracting surfaces overlap — water modelled into the wall of the
+     * glass holding it — the medium of higher priority is the one that fills the overlap.
+     * A non-negative integer.
+     * @type {number}
+     */
+    priority = 0;
+
+    /**
+     * @type {ParticipatingMediumLobe[]}
+     */
+    #lobes = [];
+
+    /**
+     * @type {number}
+     */
+    #version = 0;
+
+    /** Authored coefficients changed; resident consumers can queue a write without polling. */
+    onChanged = new Signal();
+
+    /**
+     * Bumped whenever something that reaches the GPU changes, so the resident media table knows to
+     * repack this medium — the contract {@link ShadeMaterial#version} has. {@link add_lobe} and
+     * {@link clear_lobes} bump it themselves; {@link absorption}, {@link priority} and a lobe's
+     * phase parameters are public fields, so after writing one of those, set {@link needsUpdate}.
+     *
+     * @returns {number}
+     */
+    get version() {
+        return this.#version;
+    }
+
+    /**
+     * Mark the medium changed, so its GPU record is repacked.
+     *
+     * @param {boolean} value
+     */
+    set needsUpdate(value) {
+        if (value) {
+            this.#version++;
+            this.onChanged.dispatch();
+        }
+    }
+
+    /**
+     * The scattering components, in the order they were added.
+     * @returns {ReadonlyArray<ParticipatingMediumLobe>}
+     */
+    get lobes() {
+        return this.#lobes;
+    }
+
+    /**
+     * How many lobes the GPU carries for this medium; at most {@link MEDIUM_PHASE_LOBE_LIMIT}.
+     * @returns {number}
+     */
+    get gpu_lobe_count() {
+        let count = 0;
+
+        for (let i = 0; i < this.#lobes.length; i++) {
+            count += this.#lobes[i].phase.gpu_lobe_count;
+        }
+
+        return count;
+    }
+
+    /**
+     * Add a scattering component.
+     *
+     * @param {number[]} scattering RGB scattering coefficient sigma_s of this component, 1/m
+     * @param {MediumPhaseFunction} phase
+     */
+    add_lobe(scattering, phase) {
+        assert_coefficient(scattering, 'scattering');
+        assert.defined(phase, 'phase');
+        assert.equal(phase.isMediumPhaseFunction, true, 'phase.isMediumPhaseFunction !== true');
+        assert.lessThanOrEqual(
+            this.gpu_lobe_count + phase.gpu_lobe_count,
+            MEDIUM_PHASE_LOBE_LIMIT,
+            `a medium carries at most ${MEDIUM_PHASE_LOBE_LIMIT} GPU lobes`
+        );
+
+        this.#lobes.push(new ParticipatingMediumLobe(scattering.slice(), phase));
+
+        this.#version++;
+        this.onChanged.dispatch();
+    }
+
+    /**
+     * Remove every scattering component; the medium only absorbs afterwards.
+     */
+    clear_lobes() {
+        this.#lobes.length = 0;
+
+        this.#version++;
+        this.onChanged.dispatch();
+    }
+
+    /**
+     * The value {@link MEDIUM_STRUCT} is written from: unused lobe slots are zero.
+     *
+     * @returns {{absorption: number[], priority: number, lobe_count: number, lobes: MediumPhaseLobeRecord[]}}
+     */
+    to_gpu_record() {
+        assert_coefficient(this.absorption, 'absorption');
+        assert.isNonNegativeInteger(this.priority, 'priority');
+
+        /** @type {MediumPhaseLobeRecord[]} */
+        const lobes = [];
+
+        for (let i = 0; i < this.#lobes.length; i++) {
+            const lobe = this.#lobes[i];
+
+            lobe.phase.write_gpu_lobes(lobe.scattering, lobes);
+        }
+
+        const lobe_count = lobes.length;
+
+        // add_lobe checks this, but a lobe's phase can be replaced after
+        assert.lessThanOrEqual(lobe_count, MEDIUM_PHASE_LOBE_LIMIT, 'GPU lobes');
+
+        while (lobes.length < MEDIUM_PHASE_LOBE_LIMIT) {
+            lobes.push({ scattering: [0, 0, 0], kind: 0, p0: 0, p1: 0 });
+        }
+
+        return {
+            absorption: this.absorption.slice(),
+            priority: this.priority,
+            lobe_count,
+            lobes,
+        };
+    }
+}
+
+/**
+ * @readonly
+ * @type {boolean}
+ */
+ParticipatingMedium.prototype.isParticipatingMedium = true;

package/src/shade/renderer/medium/chunk_medium_lobe_phase.d.ts

@@ -0,0 +1,13 @@
+/**
+ * One GPU lobe's phase function, normalized over the sphere: `medium_lobe_phase(lobe, cos_theta,
+ * sin2_half)`, with `sin2_half` = sin²(θ/2), which carries a Fournier-Forand lobe's forward peak
+ * where `cos_theta` has rounded to one.
+ *
+ * Every renderer reading a {@link MEDIUM_STRUCT} evaluates lobes with this, so the path tracer and
+ * the real-time water cannot disagree about what a medium scatters where.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_medium_lobe_phase: CodeChunk;
+import { CodeChunk } from "../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_medium_lobe_phase.d.ts.map

package/src/shade/renderer/medium/chunk_medium_lobe_phase.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_medium_lobe_phase.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/medium/chunk_medium_lobe_phase.js"],"names":[],"mappings":"AAMA;;;;;;;;;GASG;AACH,sCAFU,SAAS,CAkBjB;0BA9BwB,iCAAiC"}

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

@@ -0,0 +1,33 @@
+import { chunk_phase_fournier_forand } from "../shader/chunk/atmosphere/phase/ff/chunk_phase_fournier_forand.js";
+import { chunk_phase_draine } from "../shader/chunk/atmosphere/phase/jd/chunk_phase_draine.js";
+import { CodeChunk } from "../shader/compiler/CodeChunk.js";
+import { MEDIUM_PHASE_LOBE_KIND } from "./MEDIUM_PHASE_LOBE_KIND.js";
+import { MEDIUM_PHASE_LOBE_STRUCT } from "./MEDIUM_STRUCT.js";
+
+/**
+ * One GPU lobe's phase function, normalized over the sphere: `medium_lobe_phase(lobe, cos_theta,
+ * sin2_half)`, with `sin2_half` = sin²(θ/2), which carries a Fournier-Forand lobe's forward peak
+ * where `cos_theta` has rounded to one.
+ *
+ * Every renderer reading a {@link MEDIUM_STRUCT} evaluates lobes with this, so the path tracer and
+ * the real-time water cannot disagree about what a medium scatters where.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_medium_lobe_phase = CodeChunk.from(
+    //language=WGSL
+    `
+fn medium_lobe_phase(lobe: ${MEDIUM_PHASE_LOBE_STRUCT.wgsl_ref}, cos_theta: f32, sin2_half: f32) -> f32 {
+    if (lobe.kind == ${MEDIUM_PHASE_LOBE_KIND.FournierForand}u) {
+        return phase_fournier_forand_u(sin2_half, lobe.p0, lobe.p1);
+    }
+
+    return phase_draine(cos_theta, lobe.p0, lobe.p1);
+}
+    `,
+    [
+        MEDIUM_PHASE_LOBE_STRUCT.declaration_chunk,
+        chunk_phase_draine,
+        chunk_phase_fournier_forand,
+    ]
+);

package/src/shade/renderer/medium/participating_medium_serialization.d.ts

@@ -0,0 +1,32 @@
+/**
+ * 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: import("../../../core/binary/BinaryBuffer.js").BinaryBuffer, medium: import("./ParticipatingMedium.js").ParticipatingMedium): void;
+/**
+ * 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: import("../../../core/binary/BinaryBuffer.js").BinaryBuffer, medium: import("./ParticipatingMedium.js").ParticipatingMedium): void;
+/**
+ * @param {import("./ParticipatingMedium.js").ParticipatingMedium} medium
+ * @returns {Object}
+ */
+export function participating_medium_to_json(medium: import("./ParticipatingMedium.js").ParticipatingMedium): any;
+/**
+ * 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: import("./ParticipatingMedium.js").ParticipatingMedium, json: any): void;
+//# sourceMappingURL=participating_medium_serialization.d.ts.map

package/src/shade/renderer/medium/participating_medium_serialization.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"participating_medium_serialization.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/medium/participating_medium_serialization.js"],"names":[],"mappings":"AAkDA;;;;;;;;GAQG;AACH,uDAHW,OAAO,sCAAsC,EAAE,YAAY,UAC3D,OAAO,0BAA0B,EAAE,mBAAmB,QA8BhE;AAED;;;;;;GAMG;AACH,yDAHW,OAAO,sCAAsC,EAAE,YAAY,UAC3D,OAAO,0BAA0B,EAAE,mBAAmB,QA8BhE;AAED;;;GAGG;AACH,qDAHW,OAAO,0BAA0B,EAAE,mBAAmB,OAoBhE;AAED;;;;;;GAMG;AACH,uDAHW,OAAO,0BAA0B,EAAE,mBAAmB,mBA2BhE"}

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"}