@woosh/meep-engine 3.56.0 → 3.58.0

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

@@ -0,0 +1,217 @@
+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 { AnimationCurve } from "../../../engine/animation/curve/AnimationCurve.js";
+import { PhyllotaxisMode } from "./PhyllotaxisMode.js";
+
+/**
+ * Directed edge of the branch generator graph: every branch grown by generator `source` spawns lateral
+ * branches of generator `target` along `[attach_min, attach_max]` of its spine.
+ *
+ * Generators are indices into `TreeSpeciesConfig.branches`, and `target > source` always holds, so the
+ * graph is acyclic by construction and generator 0 (the trunk) is its only root.
+ */
+export class BranchSpawnRule {
+    /**
+     * Parent generator index.
+     * @type {number}
+     */
+    source = 0;
+
+    /**
+     * Child generator index (`> source`).
+     * @type {number}
+     */
+    target = 1;
+
+    /**
+     * Number of child branches spawned along a full-length parent.
+     * @type {number}
+     */
+    count = 10;
+
+    /**
+     * Start of the attachment interval along the parent spine, normalized `t` in [0, 1].
+     * @type {number}
+     */
+    attach_min = 0.25;
+
+    /**
+     * End of the attachment interval along the parent spine, normalized `t` in [0, 1].
+     * @type {number}
+     */
+    attach_max = 1.0;
+
+    /**
+     * Phyllotactic arrangement of the spawned children.
+     * @type {PhyllotaxisMode|number}
+     */
+    phyllotaxis_mode = PhyllotaxisMode.SpiralGolden;
+
+    /**
+     * Children per whorl when `phyllotaxis_mode === PhyllotaxisMode.Whorled`.
+     * @type {number}
+     */
+    whorl_count = 3;
+
+    /**
+     * Random azimuthal jitter in radians.
+     * @type {number}
+     */
+    azimuth_jitter = 0.15;
+
+    /**
+     * Axillary insertion (polar divergence) angle in radians from the parent tangent.
+     * @type {number}
+     */
+    insertion_angle = 0.72;
+
+    /**
+     * Random variation in insertion angle (radians).
+     * @type {number}
+     */
+    insertion_angle_variation = 0.12;
+
+    /**
+     * 1D Hermite curve scaling the insertion angle along the parent's normalized position t in [0, 1].
+     * @type {AnimationCurve}
+     */
+    insertion_angle_profile = AnimationCurve.linear(0, 1.0, 1, 0.65);
+
+    /**
+     * 1D Hermite curve scaling the child's length along the parent's normalized position t in [0, 1].
+     * @type {AnimationCurve}
+     */
+    length_profile = AnimationCurve.constant(0, 1, 1);
+
+    /**
+     * Weight [0, 1] of the sympodial recoil each emission imparts on the parent spine
+     * (scales the parent generator's `nodal_kink_strength`; 0 for whorls, roots and sprouts).
+     * @type {number}
+     */
+    parent_kink = 1.0;
+
+    /**
+     * Whether the spawned children belong to the crown: their length follows the crown envelope at their height,
+     * and they are kept inside it (containment, space colonization). `false` for roots and trunk sprouts. Only crown rules self-prune (see
+     * `BranchGeneratorConfig.self_pruning`).
+     * @type {boolean}
+     */
+    crown_envelope = true;
+
+    /**
+     * @param {Partial<BranchSpawnRule>} [options]
+     * @returns {BranchSpawnRule}
+     */
+    static from(options = {}) {
+        const r = new BranchSpawnRule();
+        r.applyOverrides(options);
+        return r;
+    }
+
+    /**
+     * @param {Partial<BranchSpawnRule>} [overrides]
+     * @returns {this}
+     */
+    applyOverrides(overrides = {}) {
+        if (overrides === null || overrides === undefined) {
+            return this;
+        }
+        if (overrides.source !== undefined) this.source = overrides.source | 0;
+        if (overrides.target !== undefined) this.target = overrides.target | 0;
+        if (overrides.count !== undefined) this.count = Math.max(0, overrides.count | 0);
+        if (overrides.attach_min !== undefined) this.attach_min = overrides.attach_min;
+        if (overrides.attach_max !== undefined) this.attach_max = overrides.attach_max;
+        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.azimuth_jitter !== undefined) this.azimuth_jitter = overrides.azimuth_jitter;
+        if (overrides.insertion_angle !== undefined) this.insertion_angle = overrides.insertion_angle;
+        if (overrides.insertion_angle_variation !== undefined) this.insertion_angle_variation = overrides.insertion_angle_variation;
+        if (overrides.insertion_angle_profile !== undefined) this.insertion_angle_profile.copy(overrides.insertion_angle_profile);
+        if (overrides.length_profile !== undefined) this.length_profile.copy(overrides.length_profile);
+        if (overrides.parent_kink !== undefined) this.parent_kink = overrides.parent_kink;
+        if (overrides.crown_envelope !== undefined) this.crown_envelope = Boolean(overrides.crown_envelope);
+        return this;
+    }
+
+    /**
+     * @param {BranchSpawnRule} other
+     * @returns {this}
+     */
+    copy(other) {
+        assert.defined(other, 'other');
+        this.source = other.source;
+        this.target = other.target;
+        this.count = other.count;
+        this.attach_min = other.attach_min;
+        this.attach_max = other.attach_max;
+        this.phyllotaxis_mode = other.phyllotaxis_mode;
+        this.whorl_count = other.whorl_count;
+        this.azimuth_jitter = other.azimuth_jitter;
+        this.insertion_angle = other.insertion_angle;
+        this.insertion_angle_variation = other.insertion_angle_variation;
+        this.insertion_angle_profile.copy(other.insertion_angle_profile);
+        this.length_profile.copy(other.length_profile);
+        this.parent_kink = other.parent_kink;
+        this.crown_envelope = other.crown_envelope;
+        return this;
+    }
+
+    /**
+     * @returns {BranchSpawnRule}
+     */
+    clone() {
+        const r = new BranchSpawnRule();
+        r.copy(this);
+        return r;
+    }
+
+    /**
+     * @param {BranchSpawnRule} other
+     * @returns {boolean}
+     */
+    equals(other) {
+        if (this === other) return true;
+        if (!other || !other.isBranchSpawnRule) return false;
+        return this.source === other.source
+            && this.target === other.target
+            && this.count === other.count
+            && this.attach_min === other.attach_min
+            && this.attach_max === other.attach_max
+            && this.phyllotaxis_mode === other.phyllotaxis_mode
+            && this.whorl_count === other.whorl_count
+            && this.azimuth_jitter === other.azimuth_jitter
+            && this.insertion_angle === other.insertion_angle
+            && this.insertion_angle_variation === other.insertion_angle_variation
+            && this.insertion_angle_profile.equals(other.insertion_angle_profile)
+            && this.length_profile.equals(other.length_profile)
+            && this.parent_kink === other.parent_kink
+            && this.crown_envelope === other.crown_envelope;
+    }
+
+    /**
+     * @returns {number}
+     */
+    hash() {
+        let h = hash_mix2(this.source, this.target);
+        h = hash_mix2(h, this.count);
+        h = hash_mix2(h, computeHashFloat(this.attach_min));
+        h = hash_mix2(h, computeHashFloat(this.attach_max));
+        h = hash_mix2(h, this.phyllotaxis_mode);
+        h = hash_mix2(h, this.whorl_count);
+        h = hash_mix2(h, computeHashFloat(this.azimuth_jitter));
+        h = hash_mix2(h, computeHashFloat(this.insertion_angle));
+        h = hash_mix2(h, computeHashFloat(this.insertion_angle_variation));
+        h = hash_mix2(h, this.insertion_angle_profile.hash());
+        h = hash_mix2(h, computeHashFloat(this.parent_kink));
+        h = hash_mix2(h, this.crown_envelope ? 1 : 0);
+        h = hash_mix2(h, this.length_profile.hash());
+        return h;
+    }
+}
+
+/**
+ * @readonly
+ * @type {boolean}
+ */
+BranchSpawnRule.prototype.isBranchSpawnRule = true;

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

@@ -7,6 +7,6 @@ export namespace FoliageCardType {
     let CrossCard: number;
     let TriStarCluster: number;
     let RibbedFrond: number;
-    let OctagonalCutoutHull: number;
+    let CutoutHull: number;
 }
 //# sourceMappingURL=FoliageCardType.d.ts.map

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

@@ -13,6 +13,6 @@ export const FoliageCardType = {
     TriStarCluster: 2,
     /** Multi-segment curved Cubic Hermite ribbed frond (palms, ferns, weeping boughs) */
     RibbedFrond: 3,
-    /** Tight hexagonal/octagonal alpha-bound hull trimming empty corners */
-    OctagonalCutoutHull: 4,
+    /** Convex hull fitted to the atlas tile's leaf silhouette (`FoliageAtlasCutout`), folded along its midrib */
+    CutoutHull: 4,
 };

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

@@ -1,5 +1,8 @@
 /**
- * Configuration for phyllotactic leaf/frond placement, card topology, heliotropism, and canopy AO.
+ * Leaf card / frond geometry, heliotropism and canopy AO of a tree's foliage. Which branches carry it, is described
+ * by `TreeSpeciesConfig.foliage_rules`; how densely follows from the leaves the shoots bear, or on a branch not grown
+ * by annual units, from the card and the shoot (`foliage_cards_per_metre`). A card is the size of the leaf it draws
+ * (`foliage_tile_layout`).
  */
 export class FoliageConfig {
     /**
@@ -7,66 +10,42 @@ export class FoliageConfig {
      * @returns {FoliageConfig}
      */
     static from(options?: Partial<FoliageConfig>): FoliageConfig;
-    /**
-     * Whether foliage geometry is generated.
-     * @type {boolean}
-     */
-    enabled: boolean;
     /**
      * Leaf cluster card or frond mesh topology.
      * @type {FoliageCardType|number}
      */
     card_type: FoliageCardType | number;
     /**
-     * Minimum branch recursion level that carries foliage cards.
-     * @type {number}
-     */
-    attach_min_level: number;
-    /**
-     * Number of phyllotactic nodes along each qualifying carrier branch.
-     * @type {number}
-     */
-    cards_per_branch: number;
-    /**
-     * Number of terminal rosette cards clustered at the branch tip (t = 1).
-     * @type {number}
-     */
-    terminal_rosette_count: number;
-    /**
-     * Bare fraction [0, 0.9] at the base of a carrier branch without leaves.
-     * @type {number}
-     */
-    bare_ratio: number;
-    /**
-     * Phyllotactic arrangement mode for leaf attachments.
-     * @type {PhyllotaxisMode|number}
-     */
-    phyllotaxis_mode: PhyllotaxisMode | number;
-    /**
-     * Organs per node when `phyllotaxis_mode === PhyllotaxisMode.Whorled`.
+     * Relative random variance in card dimensions [0, 0.8].
      * @type {number}
      */
-    whorl_count: number;
+    size_variance: number;
     /**
-     * Petiole insertion angle (radians) relative to carrier branch tangent.
-     * @type {number}
+     * Share of an annual unit's leaves alive at each age in years, this year's unit first, on branches grown by annual
+     * units (`TreeSpeciesConfig.shoot_rules`): `[1]` keeps leaves one season, as a deciduous tree does; an
+     * evergreen's needle cohorts thin out over its list, and units older than it carry none.
+     * @type {number[]}
      */
-    insertion_angle: number;
+    leaf_survival: number[];
     /**
-     * Base width of a leaf cluster card or frond (meters).
+     * Leaves on an annual unit of no length, on branches grown by annual units; with {@link leaves_per_metre}, a unit
+     * `l` metres long bears `leaves_per_unit + leaves_per_metre * l`. The default is oak's: a leaf in the axil of each
+     * of the 4 subapical buds and of each median bud, `(l + 2.70) / 0.98` of them (cm) [Buck-Sorlin & Bell 2000,
+     * Forestry 73(1): 1-19, Table 5, footnote 3 p. 5]: 10.6 on a median 3.8 cm shoot, against 11.2 counted by
+     * Tree Physiology (2015).
      * @type {number}
      */
-    card_width: number;
+    leaves_per_unit: number;
     /**
-     * Base length of a leaf cluster card or frond from petiole pivot to tip (meters).
+     * Leaves an annual unit gains per metre of its length, see {@link leaves_per_unit}.
      * @type {number}
      */
-    card_length: number;
+    leaves_per_metre: number;
     /**
-     * Relative random variance in card dimensions [0, 0.8].
+     * Leaves a short shoot bears each year, crowded at its tip, on branches grown by annual units.
      * @type {number}
      */
-    size_variance: number;
+    leaves_per_short_shoot: number;
     /**
      * Transverse V-fold dihedral angle (radians) across the midrib.
      * @type {number}
@@ -118,10 +97,10 @@ export class FoliageConfig {
      */
     color_variation: number;
     /**
-     * @param {Partial<FoliageConfig>|boolean} [overrides]
+     * @param {Partial<FoliageConfig>} [overrides]
      * @returns {this}
      */
-    applyOverrides(overrides?: Partial<FoliageConfig> | boolean): this;
+    applyOverrides(overrides?: Partial<FoliageConfig>): this;
     /**
      * @param {FoliageConfig} other
      * @returns {this}
@@ -147,5 +126,4 @@ export class FoliageConfig {
     readonly isFoliageConfig: boolean;
 }
 import { FoliageCardType } from "./FoliageCardType.js";
-import { PhyllotaxisMode } from "./PhyllotaxisMode.js";
 //# sourceMappingURL=FoliageConfig.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"FoliageConfig.d.ts","sourceRoot":"","sources":["../../../../../src/generation/foliage/config/FoliageConfig.js"],"names":[],"mappings":"AAMA;;GAEG;AACH;IAqII;;;OAGG;IACH,sBAHW,QAAQ,aAAa,CAAC,GACpB,aAAa,CAMzB;IA5ID;;;OAGG;IACH,SAFU,OAAO,CAEF;IAEf;;;OAGG;IACH,WAFU,eAAe,GAAC,MAAM,CAEQ;IAExC;;;OAGG;IACH,kBAFU,MAAM,CAEK;IAErB;;;OAGG;IACH,kBAFU,MAAM,CAEM;IAEtB;;;OAGG;IACH,wBAFU,MAAM,CAEW;IAE3B;;;OAGG;IACH,YAFU,MAAM,CAEC;IAEjB;;;OAGG;IACH,kBAFU,eAAe,GAAC,MAAM,CAEgB;IAEhD;;;OAGG;IACH,aAFU,MAAM,CAEA;IAEhB;;;OAGG;IACH,iBAFU,MAAM,CAEO;IAEvB;;;OAGG;IACH,YAFU,MAAM,CAEE;IAElB;;;OAGG;IACH,aAFU,MAAM,CAEG;IAEnB;;;OAGG;IACH,eAFU,MAAM,CAEI;IAEpB;;;OAGG;IACH,YAFU,MAAM,CAEE;IAElB;;;OAGG;IACH,aAFU,MAAM,CAEG;IAEnB;;;OAGG;IACH,cAFU,MAAM,CAEG;IAEnB;;;OAGG;IACH,gBAFU,MAAM,CAEG;IAEnB;;;OAGG;IACH,cAFU,MAAM,CAEG;IAEnB;;;OAGG;IACH,cAFU,MAAM,CAEI;IAEpB;;;OAGG;IACH,gBAFU,MAAM,CAEM;IAEtB;;;OAGG;IACH,kBAFU,MAAM,CAEQ;IAExB;;;OAGG;IACH,mBAFU,MAAM,CAES;IAEzB;;;OAGG;IACH,iBAFU,MAAM,CAEO;IAYvB;;;OAGG;IACH,2BAHW,QAAQ,aAAa,CAAC,GAAC,OAAO,GAC5B,IAAI,CAiChB;IAED;;;OAGG;IACH,YAHW,aAAa,GACX,IAAI,CA2BhB;IAED;;OAEG;IACH,SAFa,aAAa,CAMzB;IAED;;;OAGG;IACH,cAHW,aAAa,GACX,OAAO,CA2BnB;IAED;;OAEG;IACH,QAFa,MAAM,CAclB;IAGL;;;OAGG;IACH,0BAFU,OAAO,CAEsB;CANtC;gCAjR+B,sBAAsB;gCACtB,sBAAsB"}
+{"version":3,"file":"FoliageConfig.d.ts","sourceRoot":"","sources":["../../../../../src/generation/foliage/config/FoliageConfig.js"],"names":[],"mappings":"AAOA;;;;;GAKG;AACH;IAuGI;;;OAGG;IACH,sBAHW,QAAQ,aAAa,CAAC,GACpB,aAAa,CAMzB;IA9GD;;;OAGG;IACH,WAFU,eAAe,GAAC,MAAM,CAEQ;IAExC;;;OAGG;IACH,eAFU,MAAM,CAEI;IAEpB;;;;;OAKG;IACH,eAFU,MAAM,EAAE,CAEE;IAEpB;;;;;;;OAOG;IACH,iBAFU,MAAM,CAEkB;IAElC;;;OAGG;IACH,kBAFU,MAAM,CAEc;IAE9B;;;OAGG;IACH,wBAFU,MAAM,CAEW;IAE3B;;;OAGG;IACH,YAFU,MAAM,CAEE;IAElB;;;OAGG;IACH,aAFU,MAAM,CAEG;IAEnB;;;OAGG;IACH,cAFU,MAAM,CAEG;IAEnB;;;OAGG;IACH,gBAFU,MAAM,CAEG;IAEnB;;;OAGG;IACH,cAFU,MAAM,CAEG;IAEnB;;;OAGG;IACH,cAFU,MAAM,CAEI;IAEpB;;;OAGG;IACH,gBAFU,MAAM,CAEM;IAEtB;;;OAGG;IACH,kBAFU,MAAM,CAEQ;IAExB;;;OAGG;IACH,mBAFU,MAAM,CAES;IAEzB;;;OAGG;IACH,iBAFU,MAAM,CAEO;IAYvB;;;OAGG;IACH,2BAHW,QAAQ,aAAa,CAAC,GACpB,IAAI,CA4BhB;IAED;;;OAGG;IACH,YAHW,aAAa,GACX,IAAI,CAqBhB;IAED;;OAEG;IACH,SAFa,aAAa,CAMzB;IAED;;;OAGG;IACH,cAHW,aAAa,GACX,OAAO,CAqBnB;IAED;;OAEG;IACH,QAFa,MAAM,CAWlB;IAGL;;;OAGG;IACH,0BAFU,OAAO,CAEsB;CANtC;gCAjO+B,sBAAsB"}

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

@@ -1,19 +1,17 @@
 import { assert } from "../../../core/assert.js";
 import { hash_mix2 } from "../../../core/math/hash/hash_mix2.js";
+import { isArrayEqualStrict } from "../../../core/collection/array/isArrayEqualStrict.js";
+import { computeHashFloatArray } from "../../../core/math/hash/computeHashFloatArray.js";
 import { computeHashFloat } from "../../../core/primitives/numbers/computeHashFloat.js";
 import { FoliageCardType } from "./FoliageCardType.js";
-import { PhyllotaxisMode } from "./PhyllotaxisMode.js";
 
 /**
- * Configuration for phyllotactic leaf/frond placement, card topology, heliotropism, and canopy AO.
+ * Leaf card / frond geometry, heliotropism and canopy AO of a tree's foliage. Which branches carry it, is described
+ * by `TreeSpeciesConfig.foliage_rules`; how densely follows from the leaves the shoots bear, or on a branch not grown
+ * by annual units, from the card and the shoot (`foliage_cards_per_metre`). A card is the size of the leaf it draws
+ * (`foliage_tile_layout`).
  */
 export class FoliageConfig {
-    /**
-     * Whether foliage geometry is generated.
-     * @type {boolean}
-     */
-    enabled = true;
-
     /**
      * Leaf cluster card or frond mesh topology.
      * @type {FoliageCardType|number}
@@ -21,64 +19,40 @@ export class FoliageConfig {
     card_type = FoliageCardType.FoldedVCard;
 
     /**
-     * Minimum branch recursion level that carries foliage cards.
-     * @type {number}
-     */
-    attach_min_level = 2;
-
-    /**
-     * Number of phyllotactic nodes along each qualifying carrier branch.
-     * @type {number}
-     */
-    cards_per_branch = 10;
-
-    /**
-     * Number of terminal rosette cards clustered at the branch tip (t = 1).
-     * @type {number}
-     */
-    terminal_rosette_count = 3;
-
-    /**
-     * Bare fraction [0, 0.9] at the base of a carrier branch without leaves.
-     * @type {number}
-     */
-    bare_ratio = 0.2;
-
-    /**
-     * Phyllotactic arrangement mode for leaf attachments.
-     * @type {PhyllotaxisMode|number}
-     */
-    phyllotaxis_mode = PhyllotaxisMode.SpiralGolden;
-
-    /**
-     * Organs per node when `phyllotaxis_mode === PhyllotaxisMode.Whorled`.
+     * Relative random variance in card dimensions [0, 0.8].
      * @type {number}
      */
-    whorl_count = 3;
+    size_variance = 0.2;
 
     /**
-     * Petiole insertion angle (radians) relative to carrier branch tangent.
-     * @type {number}
+     * Share of an annual unit's leaves alive at each age in years, this year's unit first, on branches grown by annual
+     * units (`TreeSpeciesConfig.shoot_rules`): `[1]` keeps leaves one season, as a deciduous tree does; an
+     * evergreen's needle cohorts thin out over its list, and units older than it carry none.
+     * @type {number[]}
      */
-    insertion_angle = 0.85;
+    leaf_survival = [1];
 
     /**
-     * Base width of a leaf cluster card or frond (meters).
+     * Leaves on an annual unit of no length, on branches grown by annual units; with {@link leaves_per_metre}, a unit
+     * `l` metres long bears `leaves_per_unit + leaves_per_metre * l`. The default is oak's: a leaf in the axil of each
+     * of the 4 subapical buds and of each median bud, `(l + 2.70) / 0.98` of them (cm) [Buck-Sorlin & Bell 2000,
+     * Forestry 73(1): 1-19, Table 5, footnote 3 p. 5]: 10.6 on a median 3.8 cm shoot, against 11.2 counted by
+     * Tree Physiology (2015).
      * @type {number}
      */
-    card_width = 0.85;
+    leaves_per_unit = 4 + 2.70 / 0.98;
 
     /**
-     * Base length of a leaf cluster card or frond from petiole pivot to tip (meters).
+     * Leaves an annual unit gains per metre of its length, see {@link leaves_per_unit}.
      * @type {number}
      */
-    card_length = 0.95;
+    leaves_per_metre = 100 / 0.98;
 
     /**
-     * Relative random variance in card dimensions [0, 0.8].
+     * Leaves a short shoot bears each year, crowded at its tip, on branches grown by annual units.
      * @type {number}
      */
-    size_variance = 0.2;
+    leaves_per_short_shoot = 2;
 
     /**
      * Transverse V-fold dihedral angle (radians) across the midrib.
@@ -151,29 +125,24 @@ export class FoliageConfig {
     }
 
     /**
-     * @param {Partial<FoliageConfig>|boolean} [overrides]
+     * @param {Partial<FoliageConfig>} [overrides]
      * @returns {this}
      */
     applyOverrides(overrides = {}) {
         if (overrides === null || overrides === undefined) {
             return this;
         }
-        if (typeof overrides === "boolean") {
-            this.enabled = overrides;
-            return this;
-        }
-        if (overrides.enabled !== undefined) this.enabled = Boolean(overrides.enabled);
+        assert.ok(typeof overrides === "object", "foliage overrides are card geometry; a bare tree has empty foliage_rules");
         if (overrides.card_type !== undefined) this.card_type = overrides.card_type;
-        if (overrides.attach_min_level !== undefined) this.attach_min_level = Math.max(0, overrides.attach_min_level | 0);
-        if (overrides.cards_per_branch !== undefined) this.cards_per_branch = Math.max(0, overrides.cards_per_branch | 0);
-        if (overrides.terminal_rosette_count !== undefined) this.terminal_rosette_count = Math.max(0, overrides.terminal_rosette_count | 0);
-        if (overrides.bare_ratio !== undefined) this.bare_ratio = overrides.bare_ratio;
-        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.insertion_angle !== undefined) this.insertion_angle = overrides.insertion_angle;
-        if (overrides.card_width !== undefined) this.card_width = overrides.card_width;
-        if (overrides.card_length !== undefined) this.card_length = overrides.card_length;
         if (overrides.size_variance !== undefined) this.size_variance = overrides.size_variance;
+        if (overrides.leaves_per_unit !== undefined) this.leaves_per_unit = Math.max(0, overrides.leaves_per_unit);
+        if (overrides.leaves_per_metre !== undefined) this.leaves_per_metre = Math.max(0, overrides.leaves_per_metre);
+        if (overrides.leaves_per_short_shoot !== undefined) this.leaves_per_short_shoot = Math.max(0, overrides.leaves_per_short_shoot | 0);
+        if (overrides.leaf_survival !== undefined) {
+            assert.isArray(overrides.leaf_survival, 'leaf_survival');
+            assert.greaterThan(overrides.leaf_survival.length, 0, 'leaf_survival.length');
+            this.leaf_survival = overrides.leaf_survival.map(v => Math.min(1, Math.max(0, v)));
+        }
         if (overrides.fold_angle !== undefined) this.fold_angle = overrides.fold_angle;
         if (overrides.arch_height !== undefined) this.arch_height = overrides.arch_height;
         if (overrides.camber_droop !== undefined) this.camber_droop = overrides.camber_droop;
@@ -193,18 +162,12 @@ export class FoliageConfig {
      */
     copy(other) {
         assert.defined(other, 'other');
-        this.enabled = other.enabled;
         this.card_type = other.card_type;
-        this.attach_min_level = other.attach_min_level;
-        this.cards_per_branch = other.cards_per_branch;
-        this.terminal_rosette_count = other.terminal_rosette_count;
-        this.bare_ratio = other.bare_ratio;
-        this.phyllotaxis_mode = other.phyllotaxis_mode;
-        this.whorl_count = other.whorl_count;
-        this.insertion_angle = other.insertion_angle;
-        this.card_width = other.card_width;
-        this.card_length = other.card_length;
         this.size_variance = other.size_variance;
+        this.leaf_survival = other.leaf_survival.slice();
+        this.leaves_per_unit = other.leaves_per_unit;
+        this.leaves_per_metre = other.leaves_per_metre;
+        this.leaves_per_short_shoot = other.leaves_per_short_shoot;
         this.fold_angle = other.fold_angle;
         this.arch_height = other.arch_height;
         this.camber_droop = other.camber_droop;
@@ -234,18 +197,12 @@ export class FoliageConfig {
     equals(other) {
         if (this === other) return true;
         if (!other || !other.isFoliageConfig) return false;
-        return this.enabled === other.enabled
-            && this.card_type === other.card_type
-            && this.attach_min_level === other.attach_min_level
-            && this.cards_per_branch === other.cards_per_branch
-            && this.terminal_rosette_count === other.terminal_rosette_count
-            && this.bare_ratio === other.bare_ratio
-            && this.phyllotaxis_mode === other.phyllotaxis_mode
-            && this.whorl_count === other.whorl_count
-            && this.insertion_angle === other.insertion_angle
-            && this.card_width === other.card_width
-            && this.card_length === other.card_length
+        return this.card_type === other.card_type
             && this.size_variance === other.size_variance
+            && isArrayEqualStrict(this.leaf_survival, other.leaf_survival)
+            && this.leaves_per_unit === other.leaves_per_unit
+            && this.leaves_per_metre === other.leaves_per_metre
+            && this.leaves_per_short_shoot === other.leaves_per_short_shoot
             && this.fold_angle === other.fold_angle
             && this.arch_height === other.arch_height
             && this.camber_droop === other.camber_droop
@@ -262,16 +219,13 @@ export class FoliageConfig {
      * @returns {number}
      */
     hash() {
-        let h = hash_mix2(this.enabled ? 1 : 0, this.card_type);
-        h = hash_mix2(h, this.attach_min_level);
-        h = hash_mix2(h, this.cards_per_branch);
-        h = hash_mix2(h, this.terminal_rosette_count);
-        h = hash_mix2(h, this.phyllotaxis_mode);
-        h = hash_mix2(h, computeHashFloat(this.card_width));
-        h = hash_mix2(h, computeHashFloat(this.card_length));
-        h = hash_mix2(h, computeHashFloat(this.fold_angle));
+        let h = hash_mix2(this.card_type, computeHashFloat(this.fold_angle));
         h = hash_mix2(h, computeHashFloat(this.phototropism));
         h = hash_mix2(h, computeHashFloat(this.gravitropism));
+        h = hash_mix2(h, computeHashFloatArray(this.leaf_survival));
+        h = hash_mix2(h, computeHashFloat(this.leaves_per_unit));
+        h = hash_mix2(h, computeHashFloat(this.leaves_per_metre));
+        h = hash_mix2(h, this.leaves_per_short_shoot);
         return h;
     }
 }

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

@@ -7,11 +7,6 @@ export class FoliageMaterialConfig {
      * @returns {FoliageMaterialConfig}
      */
     static from(options?: Partial<FoliageMaterialConfig>): FoliageMaterialConfig;
-    /**
-     * Procedural per-variant tile resolution (pixels, power of two).
-     * @type {number}
-     */
-    resolution: number;
     /**
      * Mature sun-facing leaf lamina color (sRGB).
      * @type {Color}
@@ -29,15 +24,20 @@ export class FoliageMaterialConfig {
      */
     autumn_tint: number;
     /**
-     * Leaf cluster silhouette style: `"ovate" | "lobed" | "serrated" | "palmate" | "needle" | "frond"`.
-     * @type {string}
+     * The species' leaf, or its needle: what every tile draws, at its true size (`foliage_tile_layout`).
+     * @type {LeafArchitecture}
      */
-    leaf_shape: string;
+    leaf: LeafArchitecture;
     /**
-     * Number of leaflets arranged on the twig cluster card.
+     * What a tile, and so a card, draws: one leaf, or a stretch of needle shoot.
+     * @type {FoliageTileContent|number}
+     */
+    tile_content: FoliageTileContent | number;
+    /**
+     * Angle (radians) at which a needle shoot's needles leave it, for `FoliageTileContent.NeedleShoot`.
      * @type {number}
      */
-    leaflets_per_cluster: number;
+    needle_angle: number;
     /**
      * Base PBR roughness [0, 1].
      * @type {number}
@@ -48,16 +48,6 @@ export class FoliageMaterialConfig {
      * @type {number}
      */
     vein_strength: number;
-    /**
-     * Horizontal UV coordinate [0, 1] on the foliage card where the drawn woody stem/petiole attaches to the branch.
-     * @type {number}
-     */
-    stem_anchor_u: number;
-    /**
-     * Vertical UV coordinate [0, 1] on the foliage card where the drawn woody stem/petiole attaches to the branch.
-     * @type {number}
-     */
-    stem_anchor_v: number;
     /**
      * Number of ontogenetic foliage card variants packed into the material atlas [1, 16].
      * Variant 0 represents newly flushed juvenile apical leaves; Variant `variant_count - 1`
@@ -140,4 +130,6 @@ export class FoliageMaterialConfig {
     readonly isFoliageMaterialConfig: boolean;
 }
 import { Color } from "../../../core/color/Color.js";
+import { LeafArchitecture } from "./LeafArchitecture.js";
+import { FoliageTileContent } from "./FoliageTileContent.js";
 //# sourceMappingURL=FoliageMaterialConfig.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"FoliageMaterialConfig.d.ts","sourceRoot":"","sources":["../../../../../src/generation/foliage/config/FoliageMaterialConfig.js"],"names":[],"mappings":"AAMA;;GAEG;AACH;IA2HC;;;OAGG;IACH,sBAHW,QAAQ,qBAAqB,CAAC,GAC5B,qBAAqB,CAMjC;IAlID;;;OAGG;IACH,YAFU,MAAM,CAEC;IAEjB;;;OAGG;IACH,eAFU,KAAK,CAEkC;IAEjD;;;OAGG;IACH,iBAFU,KAAK,CAEoC;IAEnD;;;;OAIG;IACH,aAFU,MAAM,CAEE;IAElB;;;OAGG;IACH,YAFU,MAAM,CAEK;IAErB;;;OAGG;IACH,sBAFU,MAAM,CAES;IAEzB;;;OAGG;IACH,WAFU,MAAM,CAEC;IAEjB;;;OAGG;IACH,eAFU,MAAM,CAEI;IAEpB;;;OAGG;IACH,eAFU,MAAM,CAEI;IAEpB;;;OAGG;IACH,eAFU,MAAM,CAEI;IAEpB;;;;;OAKG;IACH,eAFU,MAAM,CAEE;IAElB;;;OAGG;IACH,sBAFU,MAAM,CAEY;IAE5B;;;OAGG;IACH,sBAFU,MAAM,CAEY;IAE5B;;;OAGG;IACH,0BAFU,MAAM,CAEgB;IAEhC;;;OAGG;IACH,wBAFU,MAAM,CAEc;IAE9B;;;;;OAKG;IACH,YAFU,MAAM,CAEC;IAEjB;;;;OAIG;IACH,oBAFU,MAAM,CAEU;IAE1B;;;;OAIG;IACH,uBAFU,MAAM,CAEa;IAE7B;;;;OAIG;IACH,kBAFU,MAAM,CAEQ;IAYxB;;;OAGG;IACH,2BAHW,QAAQ,qBAAqB,CAAC,GAC5B,IAAI,CAsChB;IAED;;;OAGG;IACH,YAHW,qBAAqB,GACnB,IAAI,CAwBhB;IAED;;OAEG;IACH,SAFa,qBAAqB,CAMjC;IAED;;;OAGG;IACH,cAHW,qBAAqB,GACnB,OAAO,CAwBnB;IAED;;OAEG;IACH,QAFa,MAAM,CAqBlB;IAGF;;;OAGG;IACH,kCAFU,OAAO,CAEsC;CANtD;sBA/QqB,8BAA8B"}
+{"version":3,"file":"FoliageMaterialConfig.d.ts","sourceRoot":"","sources":["../../../../../src/generation/foliage/config/FoliageMaterialConfig.js"],"names":[],"mappings":"AAOA;;GAEG;AACH;IA+GC;;;OAGG;IACH,sBAHW,QAAQ,qBAAqB,CAAC,GAC5B,qBAAqB,CAMjC;IAtHD;;;OAGG;IACH,eAFU,KAAK,CAEkC;IAEjD;;;OAGG;IACH,iBAFU,KAAK,CAEoC;IAEnD;;;;OAIG;IACH,aAFU,MAAM,CAEE;IAElB;;;OAGG;IACH,MAFU,gBAAgB,CAEI;IAE9B;;;OAGG;IACH,cAFU,kBAAkB,GAAC,MAAM,CAEI;IAEvC;;;OAGG;IACH,cAFU,MAAM,CAEG;IAEnB;;;OAGG;IACH,WAFU,MAAM,CAEC;IAEjB;;;OAGG;IACH,eAFU,MAAM,CAEI;IAEpB;;;;;OAKG;IACH,eAFU,MAAM,CAEE;IAElB;;;OAGG;IACH,sBAFU,MAAM,CAEY;IAE5B;;;OAGG;IACH,sBAFU,MAAM,CAEY;IAE5B;;;OAGG;IACH,0BAFU,MAAM,CAEgB;IAEhC;;;OAGG;IACH,wBAFU,MAAM,CAEc;IAE9B;;;;;OAKG;IACH,YAFU,MAAM,CAEC;IAEjB;;;;OAIG;IACH,oBAFU,MAAM,CAEU;IAE1B;;;;OAIG;IACH,uBAFU,MAAM,CAEa;IAE7B;;;;OAIG;IACH,kBAFU,MAAM,CAEQ;IAYxB;;;OAGG;IACH,2BAHW,QAAQ,qBAAqB,CAAC,GAC5B,IAAI,CAoChB;IAED;;;OAGG;IACH,YAHW,qBAAqB,GACnB,IAAI,CAsBhB;IAED;;OAEG;IACH,SAFa,qBAAqB,CAMjC;IAED;;;OAGG;IACH,cAHW,qBAAqB,GACnB,OAAO,CAsBnB;IAED;;OAEG;IACH,QAFa,MAAM,CAoBlB;IAGF;;;OAGG;IACH,kCAFU,OAAO,CAEsC;CANtD;sBA7PqB,8BAA8B;iCAInB,uBAAuB;mCADrB,yBAAyB"}