@woosh/meep-engine 3.56.0 → 3.57.0

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

@@ -0,0 +1,135 @@
+import { assert } from "../../../core/assert.js";
+import { hash_mix2 } from "../../../core/math/hash/hash_mix2.js";
+import { computeHashFloat } from "../../../core/primitives/numbers/computeHashFloat.js";
+import { PhyllotaxisMode } from "./PhyllotaxisMode.js";
+
+/**
+ * Foliage edge of the generator graph: every branch grown by generator `source` carries leaf cards
+ * shaped by `TreeSpeciesConfig.foliage`. Several rules may name different sources, so foliage can sit on
+ * twigs, boughs and epicormic sprouts alike.
+ *
+ * How many cards a carrier gets is not authored: it follows from the carrier's leafy length, the card size and the
+ * atlas's leaf coverage (see `foliage_cards_per_metre`).
+ */
+export class FoliageSpawnRule {
+    /**
+     * Carrier branch generator index into `TreeSpeciesConfig.branches`.
+     * @type {number}
+     */
+    source = 2;
+
+    /**
+     * Bare fraction [0, 0.9] at the base of a carrier branch without leaves.
+     * @type {number}
+     */
+    attach_min = 0.2;
+
+    /**
+     * Phyllotactic arrangement of the lateral cards.
+     * @type {PhyllotaxisMode|number}
+     */
+    phyllotaxis_mode = PhyllotaxisMode.SpiralGolden;
+
+    /**
+     * Cards per node when `phyllotaxis_mode === PhyllotaxisMode.Whorled`.
+     * @type {number}
+     */
+    whorl_count = 3;
+
+    /**
+     * Whether the carriers are short shoots: each year's unit bears `FoliageConfig.leaves_per_short_shoot` leaves
+     * crowded at its tip.
+     * @type {boolean}
+     */
+    short_shoot = false;
+
+    /**
+     * Petiole insertion angle (radians) relative to the carrier branch tangent. Sets how far the cards reach out from
+     * the shoot, and with it how much leaf the shoot wears.
+     * @type {number}
+     */
+    insertion_angle = 0.85;
+
+    /**
+     * @param {Partial<FoliageSpawnRule>} [options]
+     * @returns {FoliageSpawnRule}
+     */
+    static from(options = {}) {
+        const r = new FoliageSpawnRule();
+        r.applyOverrides(options);
+        return r;
+    }
+
+    /**
+     * @param {Partial<FoliageSpawnRule>} [overrides]
+     * @returns {this}
+     */
+    applyOverrides(overrides = {}) {
+        if (overrides === null || overrides === undefined) {
+            return this;
+        }
+        if (overrides.source !== undefined) this.source = overrides.source | 0;
+        if (overrides.attach_min !== undefined) this.attach_min = overrides.attach_min;
+        if (overrides.phyllotaxis_mode !== undefined) this.phyllotaxis_mode = overrides.phyllotaxis_mode;
+        if (overrides.whorl_count !== undefined) this.whorl_count = Math.max(1, overrides.whorl_count | 0);
+        if (overrides.short_shoot !== undefined) this.short_shoot = Boolean(overrides.short_shoot);
+        if (overrides.insertion_angle !== undefined) this.insertion_angle = overrides.insertion_angle;
+        return this;
+    }
+
+    /**
+     * @param {FoliageSpawnRule} other
+     * @returns {this}
+     */
+    copy(other) {
+        assert.defined(other, 'other');
+        this.source = other.source;
+        this.attach_min = other.attach_min;
+        this.phyllotaxis_mode = other.phyllotaxis_mode;
+        this.whorl_count = other.whorl_count;
+        this.short_shoot = other.short_shoot;
+        this.insertion_angle = other.insertion_angle;
+        return this;
+    }
+
+    /**
+     * @returns {FoliageSpawnRule}
+     */
+    clone() {
+        const r = new FoliageSpawnRule();
+        r.copy(this);
+        return r;
+    }
+
+    /**
+     * @param {FoliageSpawnRule} other
+     * @returns {boolean}
+     */
+    equals(other) {
+        if (this === other) return true;
+        if (!other || !other.isFoliageSpawnRule) return false;
+        return this.source === other.source
+            && this.attach_min === other.attach_min
+            && this.phyllotaxis_mode === other.phyllotaxis_mode
+            && this.whorl_count === other.whorl_count
+            && this.short_shoot === other.short_shoot
+            && this.insertion_angle === other.insertion_angle;
+    }
+
+    /**
+     * @returns {number}
+     */
+    hash() {
+        let h = hash_mix2(this.source, computeHashFloat(this.attach_min));
+        h = hash_mix2(h, this.phyllotaxis_mode);
+        h = hash_mix2(h, computeHashFloat(this.insertion_angle));
+        h = hash_mix2(h, this.short_shoot ? 1 : 0);
+        return h;
+    }
+}
+
+/**
+ * @readonly
+ * @type {boolean}
+ */
+FoliageSpawnRule.prototype.isFoliageSpawnRule = true;

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

@@ -0,0 +1,9 @@
+/**
+ * What one foliage atlas tile, and so one card, draws.
+ */
+export type FoliageTileContent = number;
+export namespace FoliageTileContent {
+    let Leaf: number;
+    let NeedleShoot: number;
+}
+//# sourceMappingURL=FoliageTileContent.d.ts.map

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

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

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

@@ -0,0 +1,12 @@
+/**
+ * What one foliage atlas tile, and so one card, draws.
+ *
+ * @readonly
+ * @enum {number}
+ */
+export const FoliageTileContent = {
+    /** one leaf: a simple blade, or a compound leaf's leaflets along its rachis (`LeafArchitecture.leaflets`) */
+    Leaf: 0,
+    /** a stretch of shoot with its needles, as many as the shoot bears there (`FoliageConfig.leaves_per_metre`) */
+    NeedleShoot: 1,
+};

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

@@ -0,0 +1,12 @@
+/**
+ * Shape of a leaf blade's apex, the margin between the apex and the point a quarter of the blade's length below it
+ * (Ellis et al. 2009, Manual of Leaf Architecture).
+ */
+export type LeafApexShape = number;
+export namespace LeafApexShape {
+    let Straight: number;
+    let Convex: number;
+    let Acuminate: number;
+    let Rounded: number;
+}
+//# sourceMappingURL=LeafApexShape.d.ts.map

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

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

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

@@ -0,0 +1,17 @@
+/**
+ * Shape of a leaf blade's apex, the margin between the apex and the point a quarter of the blade's length below it
+ * (Ellis et al. 2009, Manual of Leaf Architecture).
+ *
+ * @readonly
+ * @enum {number}
+ */
+export const LeafApexShape = {
+    /** the margin runs straight to the apex */
+    Straight: 0,
+    /** the margin bulges outward on its way to the apex */
+    Convex: 1,
+    /** the margin is concave near the apex, which draws out into a narrow tip */
+    Acuminate: 2,
+    /** the margin meets the apex in a smooth arc */
+    Rounded: 3,
+};

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

@@ -0,0 +1,155 @@
+/**
+ * A species' mature leaf, in the terms floras describe it (Ellis et al. 2009, Manual of Leaf Architecture): the
+ * blade's size and outline, its lobes, its teeth and its petiole. A compound leaf is `leaflets` blades of this shape
+ * along a rachis. `leaf_geometry` draws it.
+ *
+ * Lengths are in metres; angles in radians.
+ */
+export class LeafArchitecture {
+    /**
+     * @param {Partial<LeafArchitecture>} [options]
+     * @returns {LeafArchitecture}
+     */
+    static from(options?: Partial<LeafArchitecture>): LeafArchitecture;
+    /**
+     * Length of the blade along its midvein, from the top of the petiole to the apex (m). For a compound leaf, of
+     * its largest leaflet.
+     * @type {number}
+     */
+    blade_length: number;
+    /**
+     * Blade length over its greatest width.
+     * @type {number}
+     */
+    length_width_ratio: number;
+    /**
+     * Where the blade is widest, as a fraction of its length from the base: below 0.4 ovate, above 0.6 obovate.
+     * @type {number}
+     */
+    widest_at: number;
+    /**
+     * Angle at the apex between the margins where they cross the perpendicular to the midvein a quarter of the
+     * blade's length below it (Ellis et al. 2009). Over pi the apex is reflex.
+     * @type {number}
+     */
+    apex_angle: number;
+    /**
+     * @type {LeafApexShape|number}
+     */
+    apex_shape: LeafApexShape | number;
+    /**
+     * Angle at the base, measured as {@link apex_angle} a quarter of the blade's length above it.
+     * @type {number}
+     */
+    base_angle: number;
+    /**
+     * @type {LeafBaseShape|number}
+     */
+    base_shape: LeafBaseShape | number;
+    /**
+     * How far basal lobes reach below the top of the petiole, as a fraction of the blade's length, for
+     * `LeafBaseShape.Cordate` and `LeafBaseShape.Lobate`.
+     * @type {number}
+     */
+    base_lobe_depth: number;
+    /**
+     * @type {LeafLobation|number}
+     */
+    lobation: LeafLobation | number;
+    /**
+     * Lobes: pairs along the sides for `LeafLobation.Pinnate` (the apex is a lobe of its own), primary lobes in all
+     * for `LeafLobation.Palmate`.
+     * @type {number}
+     */
+    lobes: number;
+    /**
+     * How deep the sinuses between lobes cut: the fraction of the way from the blade's outline to the midvein
+     * (pinnate) or to the top of the petiole (palmate).
+     * @type {number}
+     */
+    sinus_depth: number;
+    /**
+     * Angle between the outermost primary lobes' axes, for `LeafLobation.Palmate`.
+     * @type {number}
+     */
+    lobe_spread: number;
+    /**
+     * Length of the outermost primary lobes over the central one's, for `LeafLobation.Palmate`; the lobes between
+     * them in proportion.
+     * @type {number}
+     */
+    lateral_lobe_length: number;
+    /**
+     * Teeth per centimetre of margin; 0 for an entire margin.
+     * @type {number}
+     */
+    teeth_per_cm: number;
+    /**
+     * Height of a tooth (m).
+     * @type {number}
+     */
+    tooth_depth: number;
+    /**
+     * 1: simple teeth; 2: each tooth carries smaller ones (doubly serrate).
+     * @type {number}
+     */
+    tooth_orders: number;
+    /**
+     * Pairs of secondary veins off the midvein. On a lobed blade each lobe takes one.
+     * @type {number}
+     */
+    secondary_veins: number;
+    /**
+     * Angle between the secondary veins and the midvein, towards the apex. A pinnate lobe follows the vein that
+     * feeds it, so it leans by as much.
+     * @type {number}
+     */
+    secondary_angle: number;
+    /**
+     * Petiole length (m).
+     * @type {number}
+     */
+    petiole_length: number;
+    /**
+     * Leaflets of a compound leaf along its rachis; 1 for a simple leaf.
+     * @type {number}
+     */
+    leaflets: number;
+    /**
+     * Length of a compound leaf's rachis, from its first leaflets to its last (m).
+     * @type {number}
+     */
+    rachis_length: number;
+    /**
+     * @param {Partial<LeafArchitecture>} [overrides]
+     * @returns {this}
+     */
+    applyOverrides(overrides?: Partial<LeafArchitecture>): this;
+    /**
+     * @param {LeafArchitecture} other
+     * @returns {this}
+     */
+    copy(other: LeafArchitecture): this;
+    /**
+     * @returns {LeafArchitecture}
+     */
+    clone(): LeafArchitecture;
+    /**
+     * @param {LeafArchitecture} other
+     * @returns {boolean}
+     */
+    equals(other: LeafArchitecture): boolean;
+    /**
+     * @returns {number}
+     */
+    hash(): number;
+    /**
+     * @readonly
+     * @type {boolean}
+     */
+    readonly isLeafArchitecture: boolean;
+}
+import { LeafApexShape } from "./LeafApexShape.js";
+import { LeafBaseShape } from "./LeafBaseShape.js";
+import { LeafLobation } from "./LeafLobation.js";
+//# sourceMappingURL=LeafArchitecture.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"LeafArchitecture.d.ts","sourceRoot":"","sources":["../../../../../src/generation/foliage/config/LeafArchitecture.js"],"names":[],"mappings":"AAOA;;;;;;GAMG;AACH;IAmII;;;OAGG;IACH,sBAHW,QAAQ,gBAAgB,CAAC,GACvB,gBAAgB,CAM5B;IA1ID;;;;OAIG;IACH,cAFU,MAAM,CAEI;IAEpB;;;OAGG;IACH,oBAFU,MAAM,CAES;IAEzB;;;OAGG;IACH,WAFU,MAAM,CAEA;IAEhB;;;;OAIG;IACH,YAFU,MAAM,CAES;IAEzB;;OAEG;IACH,YAFU,aAAa,GAAC,MAAM,CAEI;IAElC;;;OAGG;IACH,YAFU,MAAM,CAES;IAEzB;;OAEG;IACH,YAFU,aAAa,GAAC,MAAM,CAEI;IAElC;;;;OAIG;IACH,iBAFU,MAAM,CAEM;IAEtB;;OAEG;IACH,UAFU,YAAY,GAAC,MAAM,CAEG;IAEhC;;;;OAIG;IACH,OAFU,MAAM,CAEN;IAEV;;;;OAIG;IACH,aAFU,MAAM,CAEE;IAElB;;;OAGG;IACH,aAFU,MAAM,CAEU;IAE1B;;;;OAIG;IACH,qBAFU,MAAM,CAEU;IAE1B;;;OAGG;IACH,cAFU,MAAM,CAEG;IAEnB;;;OAGG;IACH,aAFU,MAAM,CAEE;IAElB;;;OAGG;IACH,cAFU,MAAM,CAEC;IAEjB;;;OAGG;IACH,iBAFU,MAAM,CAEI;IAEpB;;;;OAIG;IACH,iBAFU,MAAM,CAEc;IAE9B;;;OAGG;IACH,gBAFU,MAAM,CAEM;IAEtB;;;OAGG;IACH,UAFU,MAAM,CAEH;IAEb;;;OAGG;IACH,eAFU,MAAM,CAEI;IAYpB;;;OAGG;IACH,2BAHW,QAAQ,gBAAgB,CAAC,GACvB,IAAI,CA4BhB;IAED;;;OAGG;IACH,YAHW,gBAAgB,GACd,IAAI,CA0BhB;IAED;;OAEG;IACH,SAFa,gBAAgB,CAI5B;IAED;;;OAGG;IACH,cAHW,gBAAgB,GACd,OAAO,CA0BnB;IAED;;OAEG;IACH,QAFa,MAAM,CAyBlB;IAGL;;;OAGG;IACH,6BAFU,OAAO,CAE4B;CAN5C;8BAtR6B,oBAAoB;8BACpB,oBAAoB;6BACrB,mBAAmB"}

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

@@ -0,0 +1,288 @@
+import { assert } from "../../../core/assert.js";
+import { hash_mix2 } from "../../../core/math/hash/hash_mix2.js";
+import { computeHashFloat } from "../../../core/primitives/numbers/computeHashFloat.js";
+import { LeafApexShape } from "./LeafApexShape.js";
+import { LeafBaseShape } from "./LeafBaseShape.js";
+import { LeafLobation } from "./LeafLobation.js";
+
+/**
+ * A species' mature leaf, in the terms floras describe it (Ellis et al. 2009, Manual of Leaf Architecture): the
+ * blade's size and outline, its lobes, its teeth and its petiole. A compound leaf is `leaflets` blades of this shape
+ * along a rachis. `leaf_geometry` draws it.
+ *
+ * Lengths are in metres; angles in radians.
+ */
+export class LeafArchitecture {
+    /**
+     * Length of the blade along its midvein, from the top of the petiole to the apex (m). For a compound leaf, of
+     * its largest leaflet.
+     * @type {number}
+     */
+    blade_length = 0.08;
+
+    /**
+     * Blade length over its greatest width.
+     * @type {number}
+     */
+    length_width_ratio = 2.0;
+
+    /**
+     * Where the blade is widest, as a fraction of its length from the base: below 0.4 ovate, above 0.6 obovate.
+     * @type {number}
+     */
+    widest_at = 0.5;
+
+    /**
+     * Angle at the apex between the margins where they cross the perpendicular to the midvein a quarter of the
+     * blade's length below it (Ellis et al. 2009). Over pi the apex is reflex.
+     * @type {number}
+     */
+    apex_angle = Math.PI / 2;
+
+    /**
+     * @type {LeafApexShape|number}
+     */
+    apex_shape = LeafApexShape.Convex;
+
+    /**
+     * Angle at the base, measured as {@link apex_angle} a quarter of the blade's length above it.
+     * @type {number}
+     */
+    base_angle = Math.PI / 2;
+
+    /**
+     * @type {LeafBaseShape|number}
+     */
+    base_shape = LeafBaseShape.Convex;
+
+    /**
+     * How far basal lobes reach below the top of the petiole, as a fraction of the blade's length, for
+     * `LeafBaseShape.Cordate` and `LeafBaseShape.Lobate`.
+     * @type {number}
+     */
+    base_lobe_depth = 0.0;
+
+    /**
+     * @type {LeafLobation|number}
+     */
+    lobation = LeafLobation.Unlobed;
+
+    /**
+     * Lobes: pairs along the sides for `LeafLobation.Pinnate` (the apex is a lobe of its own), primary lobes in all
+     * for `LeafLobation.Palmate`.
+     * @type {number}
+     */
+    lobes = 0;
+
+    /**
+     * How deep the sinuses between lobes cut: the fraction of the way from the blade's outline to the midvein
+     * (pinnate) or to the top of the petiole (palmate).
+     * @type {number}
+     */
+    sinus_depth = 0.0;
+
+    /**
+     * Angle between the outermost primary lobes' axes, for `LeafLobation.Palmate`.
+     * @type {number}
+     */
+    lobe_spread = Math.PI / 2;
+
+    /**
+     * Length of the outermost primary lobes over the central one's, for `LeafLobation.Palmate`; the lobes between
+     * them in proportion.
+     * @type {number}
+     */
+    lateral_lobe_length = 1.0;
+
+    /**
+     * Teeth per centimetre of margin; 0 for an entire margin.
+     * @type {number}
+     */
+    teeth_per_cm = 0.0;
+
+    /**
+     * Height of a tooth (m).
+     * @type {number}
+     */
+    tooth_depth = 0.0;
+
+    /**
+     * 1: simple teeth; 2: each tooth carries smaller ones (doubly serrate).
+     * @type {number}
+     */
+    tooth_orders = 1;
+
+    /**
+     * Pairs of secondary veins off the midvein. On a lobed blade each lobe takes one.
+     * @type {number}
+     */
+    secondary_veins = 8;
+
+    /**
+     * Angle between the secondary veins and the midvein, towards the apex. A pinnate lobe follows the vein that
+     * feeds it, so it leans by as much.
+     * @type {number}
+     */
+    secondary_angle = Math.PI / 3;
+
+    /**
+     * Petiole length (m).
+     * @type {number}
+     */
+    petiole_length = 0.01;
+
+    /**
+     * Leaflets of a compound leaf along its rachis; 1 for a simple leaf.
+     * @type {number}
+     */
+    leaflets = 1;
+
+    /**
+     * Length of a compound leaf's rachis, from its first leaflets to its last (m).
+     * @type {number}
+     */
+    rachis_length = 0.0;
+
+    /**
+     * @param {Partial<LeafArchitecture>} [options]
+     * @returns {LeafArchitecture}
+     */
+    static from(options = {}) {
+        const r = new LeafArchitecture();
+        r.applyOverrides(options);
+        return r;
+    }
+
+    /**
+     * @param {Partial<LeafArchitecture>} [overrides]
+     * @returns {this}
+     */
+    applyOverrides(overrides = {}) {
+        if (overrides === null || overrides === undefined) {
+            return this;
+        }
+        if (overrides.blade_length !== undefined) this.blade_length = Math.max(1e-4, overrides.blade_length);
+        if (overrides.length_width_ratio !== undefined) this.length_width_ratio = Math.max(0.2, overrides.length_width_ratio);
+        if (overrides.widest_at !== undefined) this.widest_at = Math.min(0.9, Math.max(0.1, overrides.widest_at));
+        if (overrides.apex_angle !== undefined) this.apex_angle = Math.min(2 * Math.PI - 0.1, Math.max(0.05, overrides.apex_angle));
+        if (overrides.apex_shape !== undefined) this.apex_shape = overrides.apex_shape;
+        if (overrides.base_angle !== undefined) this.base_angle = Math.min(2 * Math.PI - 0.1, Math.max(0.05, overrides.base_angle));
+        if (overrides.base_shape !== undefined) this.base_shape = overrides.base_shape;
+        if (overrides.base_lobe_depth !== undefined) this.base_lobe_depth = Math.min(0.5, Math.max(0, overrides.base_lobe_depth));
+        if (overrides.lobation !== undefined) this.lobation = overrides.lobation;
+        if (overrides.lobes !== undefined) this.lobes = Math.max(0, overrides.lobes | 0);
+        if (overrides.sinus_depth !== undefined) this.sinus_depth = Math.min(0.95, Math.max(0, overrides.sinus_depth));
+        if (overrides.lobe_spread !== undefined) this.lobe_spread = Math.min(2 * Math.PI - 0.2, Math.max(0, overrides.lobe_spread));
+        if (overrides.lateral_lobe_length !== undefined) this.lateral_lobe_length = Math.min(1.5, Math.max(0.05, overrides.lateral_lobe_length));
+        if (overrides.teeth_per_cm !== undefined) this.teeth_per_cm = Math.max(0, overrides.teeth_per_cm);
+        if (overrides.tooth_depth !== undefined) this.tooth_depth = Math.max(0, overrides.tooth_depth);
+        if (overrides.tooth_orders !== undefined) this.tooth_orders = Math.min(2, Math.max(1, overrides.tooth_orders | 0));
+        if (overrides.secondary_veins !== undefined) this.secondary_veins = Math.max(0, overrides.secondary_veins | 0);
+        if (overrides.secondary_angle !== undefined) this.secondary_angle = Math.min(Math.PI / 2, Math.max(0.1, overrides.secondary_angle));
+        if (overrides.petiole_length !== undefined) this.petiole_length = Math.max(0, overrides.petiole_length);
+        if (overrides.leaflets !== undefined) this.leaflets = Math.max(1, overrides.leaflets | 0);
+        if (overrides.rachis_length !== undefined) this.rachis_length = Math.max(0, overrides.rachis_length);
+        return this;
+    }
+
+    /**
+     * @param {LeafArchitecture} other
+     * @returns {this}
+     */
+    copy(other) {
+        assert.defined(other, 'other');
+        this.blade_length = other.blade_length;
+        this.length_width_ratio = other.length_width_ratio;
+        this.widest_at = other.widest_at;
+        this.apex_angle = other.apex_angle;
+        this.apex_shape = other.apex_shape;
+        this.base_angle = other.base_angle;
+        this.base_shape = other.base_shape;
+        this.base_lobe_depth = other.base_lobe_depth;
+        this.lobation = other.lobation;
+        this.lobes = other.lobes;
+        this.sinus_depth = other.sinus_depth;
+        this.lobe_spread = other.lobe_spread;
+        this.lateral_lobe_length = other.lateral_lobe_length;
+        this.teeth_per_cm = other.teeth_per_cm;
+        this.tooth_depth = other.tooth_depth;
+        this.tooth_orders = other.tooth_orders;
+        this.secondary_veins = other.secondary_veins;
+        this.secondary_angle = other.secondary_angle;
+        this.petiole_length = other.petiole_length;
+        this.leaflets = other.leaflets;
+        this.rachis_length = other.rachis_length;
+        return this;
+    }
+
+    /**
+     * @returns {LeafArchitecture}
+     */
+    clone() {
+        return new LeafArchitecture().copy(this);
+    }
+
+    /**
+     * @param {LeafArchitecture} other
+     * @returns {boolean}
+     */
+    equals(other) {
+        if (this === other) return true;
+        if (!other || !other.isLeafArchitecture) return false;
+        return this.blade_length === other.blade_length
+            && this.length_width_ratio === other.length_width_ratio
+            && this.widest_at === other.widest_at
+            && this.apex_angle === other.apex_angle
+            && this.apex_shape === other.apex_shape
+            && this.base_angle === other.base_angle
+            && this.base_shape === other.base_shape
+            && this.base_lobe_depth === other.base_lobe_depth
+            && this.lobation === other.lobation
+            && this.lobes === other.lobes
+            && this.sinus_depth === other.sinus_depth
+            && this.lobe_spread === other.lobe_spread
+            && this.lateral_lobe_length === other.lateral_lobe_length
+            && this.teeth_per_cm === other.teeth_per_cm
+            && this.tooth_depth === other.tooth_depth
+            && this.tooth_orders === other.tooth_orders
+            && this.secondary_veins === other.secondary_veins
+            && this.secondary_angle === other.secondary_angle
+            && this.petiole_length === other.petiole_length
+            && this.leaflets === other.leaflets
+            && this.rachis_length === other.rachis_length;
+    }
+
+    /**
+     * @returns {number}
+     */
+    hash() {
+        let h = computeHashFloat(this.blade_length);
+        h = hash_mix2(h, computeHashFloat(this.length_width_ratio));
+        h = hash_mix2(h, computeHashFloat(this.widest_at));
+        h = hash_mix2(h, computeHashFloat(this.apex_angle));
+        h = hash_mix2(h, this.apex_shape);
+        h = hash_mix2(h, computeHashFloat(this.base_angle));
+        h = hash_mix2(h, this.base_shape);
+        h = hash_mix2(h, computeHashFloat(this.base_lobe_depth));
+        h = hash_mix2(h, this.lobation);
+        h = hash_mix2(h, this.lobes);
+        h = hash_mix2(h, computeHashFloat(this.sinus_depth));
+        h = hash_mix2(h, computeHashFloat(this.lobe_spread));
+        h = hash_mix2(h, computeHashFloat(this.lateral_lobe_length));
+        h = hash_mix2(h, computeHashFloat(this.teeth_per_cm));
+        h = hash_mix2(h, computeHashFloat(this.tooth_depth));
+        h = hash_mix2(h, this.tooth_orders);
+        h = hash_mix2(h, this.secondary_veins);
+        h = hash_mix2(h, computeHashFloat(this.secondary_angle));
+        h = hash_mix2(h, computeHashFloat(this.petiole_length));
+        h = hash_mix2(h, this.leaflets);
+        h = hash_mix2(h, computeHashFloat(this.rachis_length));
+        return h;
+    }
+}
+
+/**
+ * @readonly
+ * @type {boolean}
+ */
+LeafArchitecture.prototype.isLeafArchitecture = true;

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

@@ -0,0 +1,14 @@
+/**
+ * Shape of a leaf blade's base, the margin between the petiole and the point a quarter of the blade's length above it
+ * (Ellis et al. 2009, Manual of Leaf Architecture).
+ */
+export type LeafBaseShape = number;
+export namespace LeafBaseShape {
+    let Straight: number;
+    let Convex: number;
+    let Rounded: number;
+    let Truncate: number;
+    let Cordate: number;
+    let Lobate: number;
+}
+//# sourceMappingURL=LeafBaseShape.d.ts.map

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

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

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

@@ -0,0 +1,21 @@
+/**
+ * Shape of a leaf blade's base, the margin between the petiole and the point a quarter of the blade's length above it
+ * (Ellis et al. 2009, Manual of Leaf Architecture).
+ *
+ * @readonly
+ * @enum {number}
+ */
+export const LeafBaseShape = {
+    /** the margin runs straight from the petiole (cuneate) */
+    Straight: 0,
+    /** the margin bulges outward from the petiole */
+    Convex: 1,
+    /** the margin leaves the petiole in a smooth arc */
+    Rounded: 2,
+    /** the base is cut square across the petiole */
+    Truncate: 3,
+    /** the blade reaches below the petiole in two rounded lobes either side of a sinus */
+    Cordate: 4,
+    /** small lobes (auricles) stand either side of the petiole */
+    Lobate: 5,
+};