@woosh/meep-engine 3.56.0 → 3.57.0

package/src/generation/foliage/config/LeafLobation.d.ts

@@ -0,0 +1,10 @@
+/**
+ * How a leaf blade is lobed (Ellis et al. 2009, Manual of Leaf Architecture).
+ */
+export type LeafLobation = number;
+export namespace LeafLobation {
+    let Unlobed: number;
+    let Pinnate: number;
+    let Palmate: number;
+}
+//# sourceMappingURL=LeafLobation.d.ts.map

package/src/generation/foliage/config/LeafLobation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LeafLobation.d.ts","sourceRoot":"","sources":["../../../../../src/generation/foliage/config/LeafLobation.js"],"names":[],"mappings":";;;2BAIU,MAAM"}

package/src/generation/foliage/config/LeafLobation.js

@@ -0,0 +1,14 @@
+/**
+ * How a leaf blade is lobed (Ellis et al. 2009, Manual of Leaf Architecture).
+ *
+ * @readonly
+ * @enum {number}
+ */
+export const LeafLobation = {
+    /** no lobes */
+    Unlobed: 0,
+    /** lobes along both sides of the midvein */
+    Pinnate: 1,
+    /** primary lobes radiating from the top of the petiole, each with its own primary vein */
+    Palmate: 2,
+};

package/src/generation/foliage/config/PhyllotaxisMode.d.ts

@@ -1,3 +1,13 @@
+/**
+ * Sample the phyllotactic azimuth angle for organ `index` under `mode`.
+ *
+ * @param {PhyllotaxisMode|number} mode
+ * @param {number} index integer organ index (may be negative)
+ * @param {number} [whorl_count=1] organs per whorl when `mode === PhyllotaxisMode.Whorled`
+ * @param {number} [base_phi=0] base azimuth offset (radians)
+ * @returns {number} azimuth angle in radians
+ */
+export function phyllotaxis_sample_angle(mode: PhyllotaxisMode | number, index: number, whorl_count?: number, base_phi?: number): number;
 /**
  * Botanical phyllotaxis arrangement modes for axillary buds, lateral branches, and leaf clusters.
  */
@@ -9,5 +19,6 @@ export namespace PhyllotaxisMode {
     let Opposite: number;
     let OppositeDecussate: number;
     let Whorled: number;
+    let FlareLobes: number;
 }
 //# sourceMappingURL=PhyllotaxisMode.d.ts.map

package/src/generation/foliage/config/PhyllotaxisMode.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"PhyllotaxisMode.d.ts","sourceRoot":"","sources":["../../../../../src/generation/foliage/config/PhyllotaxisMode.js"],"names":[],"mappings":";;;8BAIU,MAAM"}
+{"version":3,"file":"PhyllotaxisMode.d.ts","sourceRoot":"","sources":["../../../../../src/generation/foliage/config/PhyllotaxisMode.js"],"names":[],"mappings":"AA2BA;;;;;;;;GAQG;AACH,+CANW,eAAe,GAAC,MAAM,SACtB,MAAM,gBACN,MAAM,aACN,MAAM,GACJ,MAAM,CAqBlB;;;;8BA/CS,MAAM"}

package/src/generation/foliage/config/PhyllotaxisMode.js

@@ -1,3 +1,7 @@
+import { GOLDEN_RATIO } from "../../../core/math/GOLDEN_RATIO.js";
+import { PI2 } from "../../../core/math/PI2.js";
+
+const GOLDEN_ANGLE = PI2 / (GOLDEN_RATIO * GOLDEN_RATIO);
 /**
  * Botanical phyllotaxis arrangement modes for axillary buds, lateral branches, and leaf clusters.
  *
@@ -17,4 +21,36 @@ export const PhyllotaxisMode = {
     OppositeDecussate: 4,
     /** M-verticillate ring around node with half-step alternation, M >= 3 organs per node */
     Whorled: 5,
+    /** One organ on each crest of the parent's basal flare lobes (`flare_lobes`), so roots continue the buttresses */
+    FlareLobes: 6,
 };
+
+/**
+ * Sample the phyllotactic azimuth angle for organ `index` under `mode`.
+ *
+ * @param {PhyllotaxisMode|number} mode
+ * @param {number} index integer organ index (may be negative)
+ * @param {number} [whorl_count=1] organs per whorl when `mode === PhyllotaxisMode.Whorled`
+ * @param {number} [base_phi=0] base azimuth offset (radians)
+ * @returns {number} azimuth angle in radians
+ */
+export function phyllotaxis_sample_angle(mode, index, whorl_count = 1, base_phi = 0) {
+    switch (mode) {
+        case PhyllotaxisMode.AlternateDistichous:
+            return base_phi + index * Math.PI;
+        case PhyllotaxisMode.Tristichous:
+            return base_phi + index * (PI2 / 3.0);
+        case PhyllotaxisMode.Opposite:
+            return base_phi + (index & 1) * Math.PI;
+        case PhyllotaxisMode.OppositeDecussate:
+            return base_phi + (index & 1) * Math.PI + (index >> 1) * (Math.PI * 0.5);
+        case PhyllotaxisMode.Whorled: {
+            const w_size = Math.max(1, whorl_count | 0);
+            const sub_idx = ((index % w_size) + w_size) % w_size;
+            return base_phi + (sub_idx * PI2) / w_size + (Math.floor(index / w_size) * Math.PI) / w_size;
+        }
+        case PhyllotaxisMode.SpiralGolden:
+        default:
+            return base_phi + index * GOLDEN_ANGLE;
+    }
+}

package/src/generation/foliage/config/ShootBudZone.d.ts

@@ -0,0 +1,105 @@
+/**
+ * Value of a per-order list at a 1-based branching `order`: orders past its end take its last value.
+ *
+ * @param {number[]} values
+ * @param {number} order 1-based
+ * @returns {number}
+ */
+export function shoot_order_value(values: number[], order: number): number;
+/**
+ * One zone of lateral buds along an annual extension unit, and what its buds grow into. A unit's zones are listed in
+ * `ShootSystemRule.zones`; the defaults are no zone at all.
+ *
+ * Every per-order list is indexed by the order of the mother axis, the carrier being order 1, and orders past its
+ * end take its last value.
+ */
+export class ShootBudZone {
+    /**
+     * @param {Partial<ShootBudZone>} [options]
+     * @returns {ShootBudZone}
+     */
+    static from(options?: Partial<ShootBudZone>): ShootBudZone;
+    /**
+     * Where the zone starts along its unit, 0 at the unit's base, 1 at its tip.
+     * @type {number}
+     */
+    u_min: number;
+    /**
+     * Where the zone ends along its unit.
+     * @type {number}
+     */
+    u_max: number;
+    /**
+     * Buds the zone holds on a unit of no length, per mother order; with {@link buds_per_metre}, a unit `l` metres long
+     * holds `round(buds + buds_per_metre * l)`.
+     * @type {number[]}
+     */
+    buds: number[];
+    /**
+     * Buds the zone gains per metre of unit, per mother order.
+     * @type {number[]}
+     */
+    buds_per_metre: number[];
+    /**
+     * Share of the zone's buds that grow a long shoot the spring after their unit grew (proleptic), per mother order.
+     * @type {number[]}
+     */
+    long: number[];
+    /**
+     * Share of the zone's buds that grow a long shoot in the same season as their unit (sylleptic), per mother order.
+     * @type {number[]}
+     */
+    sylleptic: number[];
+    /**
+     * Share of the zone's buds that grow a short shoot the spring after their unit grew, per mother order.
+     * @type {number[]}
+     */
+    short: number[];
+    /**
+     * Mean length (m) of a long shoot's first unit from this zone, before {@link length_slope}, per mother order.
+     * @type {number[]}
+     */
+    length: number[];
+    /**
+     * Mean length of a long shoot's first unit from this zone per metre of the mother unit it grows from, per mother
+     * order: a lateral's length is `length + length_slope * mother unit length`.
+     * @type {number[]}
+     */
+    length_slope: number[];
+    /**
+     * @param {Partial<ShootBudZone>} [overrides]
+     * @returns {this}
+     */
+    applyOverrides(overrides?: Partial<ShootBudZone>): this;
+    /**
+     * Buds the zone holds on a unit `length` metres long, on a mother of `order`.
+     * @param {number} length
+     * @param {number} order
+     * @returns {number}
+     */
+    bud_count(length: number, order: number): number;
+    /**
+     * @param {ShootBudZone} other
+     * @returns {this}
+     */
+    copy(other: ShootBudZone): this;
+    /**
+     * @returns {ShootBudZone}
+     */
+    clone(): ShootBudZone;
+    /**
+     * @param {ShootBudZone} other
+     * @returns {boolean}
+     */
+    equals(other: ShootBudZone): boolean;
+    /**
+     * @returns {number}
+     */
+    hash(): number;
+    /**
+     * @readonly
+     * @type {boolean}
+     */
+    readonly isShootBudZone: boolean;
+}
+//# sourceMappingURL=ShootBudZone.d.ts.map

package/src/generation/foliage/config/ShootBudZone.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ShootBudZone.d.ts","sourceRoot":"","sources":["../../../../../src/generation/foliage/config/ShootBudZone.js"],"names":[],"mappings":"AAMA;;;;;;GAMG;AACH,0CAJW,MAAM,EAAE,SACR,MAAM,GACJ,MAAM,CAIlB;AAED;;;;;;GAMG;AACH;IAyDI;;;OAGG;IACH,sBAHW,QAAQ,YAAY,CAAC,GACnB,YAAY,CAMxB;IAhED;;;OAGG;IACH,OAFU,MAAM,CAEJ;IAEZ;;;OAGG;IACH,OAFU,MAAM,CAEJ;IAEZ;;;;OAIG;IACH,MAFU,MAAM,EAAE,CAEP;IAEX;;;OAGG;IACH,gBAFU,MAAM,EAAE,CAEG;IAErB;;;OAGG;IACH,MAFU,MAAM,EAAE,CAEP;IAEX;;;OAGG;IACH,WAFU,MAAM,EAAE,CAEF;IAEhB;;;OAGG;IACH,OAFU,MAAM,EAAE,CAEN;IAEZ;;;OAGG;IACH,QAFU,MAAM,EAAE,CAEF;IAEhB;;;;OAIG;IACH,cAFU,MAAM,EAAE,CAEC;IAYnB;;;OAGG;IACH,2BAHW,QAAQ,YAAY,CAAC,GACnB,IAAI,CAgBhB;IAED;;;;;OAKG;IACH,kBAJW,MAAM,SACN,MAAM,GACJ,MAAM,CAIlB;IAED;;;OAGG;IACH,YAHW,YAAY,GACV,IAAI,CAchB;IAED;;OAEG;IACH,SAFa,YAAY,CAMxB;IAED;;;OAGG;IACH,cAHW,YAAY,GACV,OAAO,CAcnB;IAED;;OAEG;IACH,QAFa,MAAM,CAYlB;IAGL;;;OAGG;IACH,yBAFU,OAAO,CAEoB;CANpC"}

package/src/generation/foliage/config/ShootBudZone.js

@@ -0,0 +1,219 @@
+import { assert } from "../../../core/assert.js";
+import { isArrayEqualStrict } from "../../../core/collection/array/isArrayEqualStrict.js";
+import { hash_mix2 } from "../../../core/math/hash/hash_mix2.js";
+import { computeHashFloatArray } from "../../../core/math/hash/computeHashFloatArray.js";
+import { computeHashFloat } from "../../../core/primitives/numbers/computeHashFloat.js";
+
+/**
+ * Value of a per-order list at a 1-based branching `order`: orders past its end take its last value.
+ *
+ * @param {number[]} values
+ * @param {number} order 1-based
+ * @returns {number}
+ */
+export function shoot_order_value(values, order) {
+    return values[Math.min(values.length, Math.max(1, order)) - 1];
+}
+
+/**
+ * One zone of lateral buds along an annual extension unit, and what its buds grow into. A unit's zones are listed in
+ * `ShootSystemRule.zones`; the defaults are no zone at all.
+ *
+ * Every per-order list is indexed by the order of the mother axis, the carrier being order 1, and orders past its
+ * end take its last value.
+ */
+export class ShootBudZone {
+    /**
+     * Where the zone starts along its unit, 0 at the unit's base, 1 at its tip.
+     * @type {number}
+     */
+    u_min = 0.0;
+
+    /**
+     * Where the zone ends along its unit.
+     * @type {number}
+     */
+    u_max = 1.0;
+
+    /**
+     * Buds the zone holds on a unit of no length, per mother order; with {@link buds_per_metre}, a unit `l` metres long
+     * holds `round(buds + buds_per_metre * l)`.
+     * @type {number[]}
+     */
+    buds = [0];
+
+    /**
+     * Buds the zone gains per metre of unit, per mother order.
+     * @type {number[]}
+     */
+    buds_per_metre = [0];
+
+    /**
+     * Share of the zone's buds that grow a long shoot the spring after their unit grew (proleptic), per mother order.
+     * @type {number[]}
+     */
+    long = [0];
+
+    /**
+     * Share of the zone's buds that grow a long shoot in the same season as their unit (sylleptic), per mother order.
+     * @type {number[]}
+     */
+    sylleptic = [0];
+
+    /**
+     * Share of the zone's buds that grow a short shoot the spring after their unit grew, per mother order.
+     * @type {number[]}
+     */
+    short = [0];
+
+    /**
+     * Mean length (m) of a long shoot's first unit from this zone, before {@link length_slope}, per mother order.
+     * @type {number[]}
+     */
+    length = [0.05];
+
+    /**
+     * Mean length of a long shoot's first unit from this zone per metre of the mother unit it grows from, per mother
+     * order: a lateral's length is `length + length_slope * mother unit length`.
+     * @type {number[]}
+     */
+    length_slope = [0];
+
+    /**
+     * @param {Partial<ShootBudZone>} [options]
+     * @returns {ShootBudZone}
+     */
+    static from(options = {}) {
+        const r = new ShootBudZone();
+        r.applyOverrides(options);
+        return r;
+    }
+
+    /**
+     * @param {Partial<ShootBudZone>} [overrides]
+     * @returns {this}
+     */
+    applyOverrides(overrides = {}) {
+        if (overrides === null || overrides === undefined) {
+            return this;
+        }
+        if (overrides.u_min !== undefined) this.u_min = Math.min(1, Math.max(0, overrides.u_min));
+        if (overrides.u_max !== undefined) this.u_max = Math.min(1, Math.max(0, overrides.u_max));
+        if (overrides.buds !== undefined) this.buds = signed_list(overrides.buds);
+        if (overrides.buds_per_metre !== undefined) this.buds_per_metre = positive_list(overrides.buds_per_metre, 0);
+        if (overrides.long !== undefined) this.long = share_list(overrides.long);
+        if (overrides.sylleptic !== undefined) this.sylleptic = share_list(overrides.sylleptic);
+        if (overrides.short !== undefined) this.short = share_list(overrides.short);
+        if (overrides.length !== undefined) this.length = positive_list(overrides.length, 1e-3);
+        if (overrides.length_slope !== undefined) this.length_slope = positive_list(overrides.length_slope, 0);
+        return this;
+    }
+
+    /**
+     * Buds the zone holds on a unit `length` metres long, on a mother of `order`.
+     * @param {number} length
+     * @param {number} order
+     * @returns {number}
+     */
+    bud_count(length, order) {
+        return Math.max(0, Math.round(shoot_order_value(this.buds, order) + shoot_order_value(this.buds_per_metre, order) * length));
+    }
+
+    /**
+     * @param {ShootBudZone} other
+     * @returns {this}
+     */
+    copy(other) {
+        assert.defined(other, 'other');
+        this.u_min = other.u_min;
+        this.u_max = other.u_max;
+        this.buds = other.buds.slice();
+        this.buds_per_metre = other.buds_per_metre.slice();
+        this.long = other.long.slice();
+        this.sylleptic = other.sylleptic.slice();
+        this.short = other.short.slice();
+        this.length = other.length.slice();
+        this.length_slope = other.length_slope.slice();
+        return this;
+    }
+
+    /**
+     * @returns {ShootBudZone}
+     */
+    clone() {
+        const r = new ShootBudZone();
+        r.copy(this);
+        return r;
+    }
+
+    /**
+     * @param {ShootBudZone} other
+     * @returns {boolean}
+     */
+    equals(other) {
+        if (this === other) return true;
+        if (!other || !other.isShootBudZone) return false;
+        return this.u_min === other.u_min
+            && this.u_max === other.u_max
+            && isArrayEqualStrict(this.buds, other.buds)
+            && isArrayEqualStrict(this.buds_per_metre, other.buds_per_metre)
+            && isArrayEqualStrict(this.long, other.long)
+            && isArrayEqualStrict(this.sylleptic, other.sylleptic)
+            && isArrayEqualStrict(this.short, other.short)
+            && isArrayEqualStrict(this.length, other.length)
+            && isArrayEqualStrict(this.length_slope, other.length_slope);
+    }
+
+    /**
+     * @returns {number}
+     */
+    hash() {
+        let h = hash_mix2(computeHashFloat(this.u_min), computeHashFloat(this.u_max));
+        h = hash_mix2(h, computeHashFloatArray(this.buds));
+        h = hash_mix2(h, computeHashFloatArray(this.buds_per_metre));
+        h = hash_mix2(h, computeHashFloatArray(this.long));
+        h = hash_mix2(h, computeHashFloatArray(this.sylleptic));
+        h = hash_mix2(h, computeHashFloatArray(this.short));
+        h = hash_mix2(h, computeHashFloatArray(this.length));
+        h = hash_mix2(h, computeHashFloatArray(this.length_slope));
+        return h;
+    }
+}
+
+/**
+ * @readonly
+ * @type {boolean}
+ */
+ShootBudZone.prototype.isShootBudZone = true;
+
+/**
+ * @param {number[]} values
+ * @returns {number[]}
+ */
+function share_list(values) {
+    assert.isArray(values, 'values');
+    assert.greaterThan(values.length, 0, 'values.length');
+    return values.map(v => Math.min(1, Math.max(0, v)));
+}
+
+/**
+ * A per-order list whose values may be negative: an intercept of a fitted line.
+ * @param {number[]} values
+ * @returns {number[]}
+ */
+function signed_list(values) {
+    assert.isArray(values, 'values');
+    assert.greaterThan(values.length, 0, 'values.length');
+    return values.slice();
+}
+
+/**
+ * @param {number[]} values
+ * @param {number} min
+ * @returns {number[]}
+ */
+function positive_list(values, min) {
+    assert.isArray(values, 'values');
+    assert.greaterThan(values.length, 0, 'values.length');
+    return values.map(v => Math.max(min, v));
+}

package/src/generation/foliage/config/ShootGrowthConfig.d.ts

@@ -0,0 +1,84 @@
+/**
+ * How a species' twig systems grow together, season by season, in the light they make for each other (see
+ * `tree_skeleton_grow_shoots`): how old the framework is, and how a shoot's vigour follows the light it receives.
+ *
+ * Vigour is the bifurcation ratio Rb, the net shoots a shoot leaves a year (Niinemets & Lukjanova 2003, New Phytol.
+ * 158: 75-89). It rises with light: from 1, where shoots just replace themselves, at {@link compensation_light}, to
+ * {@link vigour} at {@link saturation_light}, flat above, and below 1 in deeper shade, where a branch thins and dies.
+ * The defaults are chosen; each preset says where its own come from.
+ */
+export class ShootGrowthConfig {
+    /**
+     * @param {Partial<ShootGrowthConfig>} [options]
+     * @returns {ShootGrowthConfig}
+     */
+    static from(options?: Partial<ShootGrowthConfig>): ShootGrowthConfig;
+    /**
+     * Length (m) the leader grows a year. It dates the framework: every branch elongates at this rate from when its
+     * parent's growth reached where it joins, so the tree is as old as its longest path from the base took to grow.
+     * @type {number}
+     */
+    leader_growth: number;
+    /**
+     * Net shoots a shoot leaves a year in full light (Rb at or above {@link saturation_light}).
+     * @type {number}
+     */
+    vigour: number;
+    /**
+     * Relative irradiance (1 under open sky) at which a shoot just replaces itself: Rb = 1.
+     * @type {number}
+     */
+    compensation_light: number;
+    /**
+     * Relative irradiance at and above which a shoot grows at its full {@link vigour}.
+     * @type {number}
+     */
+    saturation_light: number;
+    /**
+     * Clumping of leaves within a voxel of the light field (Omega): 1 spreads them at random, below 1 bunches them on
+     * their shoots, which lets more light through.
+     * @type {number}
+     */
+    leaf_clumping: number;
+    /**
+     * Edge (m) of a voxel of the light field: the scale over which leaf area is averaged. 0.25 m is chosen, about a
+     * shoot system's.
+     * @type {number}
+     */
+    light_cell: number;
+    /**
+     * Net shoots a shoot leaves a year at relative irradiance `light`.
+     * @param {number} light
+     * @returns {number}
+     */
+    net_yield(light: number): number;
+    /**
+     * @param {Partial<ShootGrowthConfig>} [overrides]
+     * @returns {this}
+     */
+    applyOverrides(overrides?: Partial<ShootGrowthConfig>): this;
+    /**
+     * @param {ShootGrowthConfig} other
+     * @returns {this}
+     */
+    copy(other: ShootGrowthConfig): this;
+    /**
+     * @returns {ShootGrowthConfig}
+     */
+    clone(): ShootGrowthConfig;
+    /**
+     * @param {ShootGrowthConfig} other
+     * @returns {boolean}
+     */
+    equals(other: ShootGrowthConfig): boolean;
+    /**
+     * @returns {number}
+     */
+    hash(): number;
+    /**
+     * @readonly
+     * @type {boolean}
+     */
+    readonly isShootGrowthConfig: boolean;
+}
+//# sourceMappingURL=ShootGrowthConfig.d.ts.map

package/src/generation/foliage/config/ShootGrowthConfig.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ShootGrowthConfig.d.ts","sourceRoot":"","sources":["../../../../../src/generation/foliage/config/ShootGrowthConfig.js"],"names":[],"mappings":"AAIA;;;;;;;;GAQG;AACH;IAmDI;;;OAGG;IACH,sBAHW,QAAQ,iBAAiB,CAAC,GACxB,iBAAiB,CAM7B;IA1DD;;;;OAIG;IACH,eAFU,MAAM,CAEI;IAEpB;;;OAGG;IACH,QAFU,MAAM,CAEH;IAEb;;;OAGG;IACH,oBAFU,MAAM,CAEU;IAE1B;;;OAGG;IACH,kBAFU,MAAM,CAEQ;IAExB;;;;OAIG;IACH,eAFU,MAAM,CAEI;IAEpB;;;;OAIG;IACH,YAFU,MAAM,CAEE;IAElB;;;;OAIG;IACH,iBAHW,MAAM,GACJ,MAAM,CAMlB;IAYD;;;OAGG;IACH,2BAHW,QAAQ,iBAAiB,CAAC,GACxB,IAAI,CAahB;IAED;;;OAGG;IACH,YAHW,iBAAiB,GACf,IAAI,CAWhB;IAED;;OAEG;IACH,SAFa,iBAAiB,CAI7B;IAED;;;OAGG;IACH,cAHW,iBAAiB,GACf,OAAO,CAWnB;IAED;;OAEG;IACH,QAFa,MAAM,CASlB;IAGL;;;OAGG;IACH,8BAFU,OAAO,CAE8B;CAN9C"}

package/src/generation/foliage/config/ShootGrowthConfig.js

@@ -0,0 +1,146 @@
+import { assert } from "../../../core/assert.js";
+import { hash_mix2 } from "../../../core/math/hash/hash_mix2.js";
+import { computeHashFloat } from "../../../core/primitives/numbers/computeHashFloat.js";
+
+/**
+ * How a species' twig systems grow together, season by season, in the light they make for each other (see
+ * `tree_skeleton_grow_shoots`): how old the framework is, and how a shoot's vigour follows the light it receives.
+ *
+ * Vigour is the bifurcation ratio Rb, the net shoots a shoot leaves a year (Niinemets & Lukjanova 2003, New Phytol.
+ * 158: 75-89). It rises with light: from 1, where shoots just replace themselves, at {@link compensation_light}, to
+ * {@link vigour} at {@link saturation_light}, flat above, and below 1 in deeper shade, where a branch thins and dies.
+ * The defaults are chosen; each preset says where its own come from.
+ */
+export class ShootGrowthConfig {
+    /**
+     * Length (m) the leader grows a year. It dates the framework: every branch elongates at this rate from when its
+     * parent's growth reached where it joins, so the tree is as old as its longest path from the base took to grow.
+     * @type {number}
+     */
+    leader_growth = 0.3;
+
+    /**
+     * Net shoots a shoot leaves a year in full light (Rb at or above {@link saturation_light}).
+     * @type {number}
+     */
+    vigour = 1.5;
+
+    /**
+     * Relative irradiance (1 under open sky) at which a shoot just replaces itself: Rb = 1.
+     * @type {number}
+     */
+    compensation_light = 0.22;
+
+    /**
+     * Relative irradiance at and above which a shoot grows at its full {@link vigour}.
+     * @type {number}
+     */
+    saturation_light = 0.30;
+
+    /**
+     * Clumping of leaves within a voxel of the light field (Omega): 1 spreads them at random, below 1 bunches them on
+     * their shoots, which lets more light through.
+     * @type {number}
+     */
+    leaf_clumping = 1.0;
+
+    /**
+     * Edge (m) of a voxel of the light field: the scale over which leaf area is averaged. 0.25 m is chosen, about a
+     * shoot system's.
+     * @type {number}
+     */
+    light_cell = 0.25;
+
+    /**
+     * Net shoots a shoot leaves a year at relative irradiance `light`.
+     * @param {number} light
+     * @returns {number}
+     */
+    net_yield(light) {
+        const span = Math.max(1e-6, this.saturation_light - this.compensation_light);
+        const slope = (this.vigour - 1) / span;
+        return Math.max(0, Math.min(this.vigour, 1 + (light - this.compensation_light) * slope));
+    }
+
+    /**
+     * @param {Partial<ShootGrowthConfig>} [options]
+     * @returns {ShootGrowthConfig}
+     */
+    static from(options = {}) {
+        const r = new ShootGrowthConfig();
+        r.applyOverrides(options);
+        return r;
+    }
+
+    /**
+     * @param {Partial<ShootGrowthConfig>} [overrides]
+     * @returns {this}
+     */
+    applyOverrides(overrides = {}) {
+        if (overrides === null || overrides === undefined) {
+            return this;
+        }
+        if (overrides.leader_growth !== undefined) this.leader_growth = Math.max(0.01, overrides.leader_growth);
+        if (overrides.vigour !== undefined) this.vigour = Math.max(0, overrides.vigour);
+        if (overrides.compensation_light !== undefined) this.compensation_light = Math.min(1, Math.max(0, overrides.compensation_light));
+        if (overrides.saturation_light !== undefined) this.saturation_light = Math.min(1, Math.max(0, overrides.saturation_light));
+        if (overrides.leaf_clumping !== undefined) this.leaf_clumping = Math.min(1, Math.max(0, overrides.leaf_clumping));
+        if (overrides.light_cell !== undefined) this.light_cell = Math.max(0.02, overrides.light_cell);
+        return this;
+    }
+
+    /**
+     * @param {ShootGrowthConfig} other
+     * @returns {this}
+     */
+    copy(other) {
+        assert.defined(other, 'other');
+        this.leader_growth = other.leader_growth;
+        this.vigour = other.vigour;
+        this.compensation_light = other.compensation_light;
+        this.saturation_light = other.saturation_light;
+        this.leaf_clumping = other.leaf_clumping;
+        this.light_cell = other.light_cell;
+        return this;
+    }
+
+    /**
+     * @returns {ShootGrowthConfig}
+     */
+    clone() {
+        return new ShootGrowthConfig().copy(this);
+    }
+
+    /**
+     * @param {ShootGrowthConfig} other
+     * @returns {boolean}
+     */
+    equals(other) {
+        if (this === other) return true;
+        if (!other || !other.isShootGrowthConfig) return false;
+        return this.leader_growth === other.leader_growth
+            && this.vigour === other.vigour
+            && this.compensation_light === other.compensation_light
+            && this.saturation_light === other.saturation_light
+            && this.leaf_clumping === other.leaf_clumping
+            && this.light_cell === other.light_cell;
+    }
+
+    /**
+     * @returns {number}
+     */
+    hash() {
+        let h = hash_mix2(computeHashFloat(this.leader_growth), computeHashFloat(this.vigour));
+        h = hash_mix2(h, computeHashFloat(this.compensation_light));
+        h = hash_mix2(h, computeHashFloat(this.saturation_light));
+        h = hash_mix2(h, computeHashFloat(this.leaf_clumping));
+        h = hash_mix2(h, computeHashFloat(this.light_cell));
+        return h;
+    }
+}
+
+/**
+ * @readonly
+ * @type {boolean}
+ */
+ShootGrowthConfig.prototype.isShootGrowthConfig = true;