@woosh/meep-engine 3.56.0 → 3.57.0

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

@@ -0,0 +1,144 @@
+/**
+ * Peripheral shoot system edge of the generator graph: every living branch grown by generator `source` carries a
+ * twig system grown year by year from its own buds, each axis of which is a branch of generator `target` (see
+ * `tree_skeleton_grow_shoots`).
+ *
+ * The model is the oak's [BB2000, BB1998], generalised: each year every living axis grows a terminal extension unit,
+ * and the buds on its units grow into long shoots (the spring after, or the same season), short shoots, or nothing,
+ * by bud zone and branching order. How many seasons, and how many new shoots survive in the light they get, is the
+ * species' `ShootGrowthConfig`. Per-order lists are indexed from order 1 (the carrier is `carrier_order`), and
+ * orders past their end take their last value.
+ *
+ * The defaults are pedunculate and sessile oak, from the peripheral branches of mature crowns measured by
+ * Buck-Sorlin & Bell (2000), Models of crown architecture in Quercus petraea and Q. robur: shoot lengths and bud
+ * numbers, Forestry 73(1): 1-19 [BB2000], and the shoot shedding of a free-standing Q. robur measured by
+ * Buck-Sorlin & Bell (1998), A quantification of shoot shedding in pedunculate oak (Quercus robur L.), Botanical
+ * Journal of the Linnean Society 127: 371-391 [BB1998].
+ */
+export class ShootSystemRule {
+    /**
+     * @param {Partial<ShootSystemRule>} [options]
+     * @returns {ShootSystemRule}
+     */
+    static from(options?: Partial<ShootSystemRule>): ShootSystemRule;
+    /**
+     * Carrier branch generator index into `TreeSpeciesConfig.branches`.
+     * @type {number}
+     */
+    source: number;
+    /**
+     * Generator index of the long shoots, which shapes how they look (radial segments, bark, tropisms). Greater than
+     * `source`.
+     * @type {number}
+     */
+    target: number;
+    /**
+     * Generator index of the short shoots, so foliage rules can tell them apart (`FoliageSpawnRule.short_shoot`).
+     * Greater than `source`. Used by zones whose buds grow short shoots.
+     * @type {number}
+     */
+    short_target: number;
+    /**
+     * Highest branching order a shoot may reach within the system [BB2000 p. 15].
+     * @type {number}
+     */
+    max_order: number;
+    /**
+     * Branching order of the carrier, in the numbering of the rule's per-order lists: where a source counts orders
+     * from the stem, a carrier deep in the framework starts deep in its lists. Oak's are counted from the branch
+     * measured [BB2000 p. 7], so its carriers are order 1.
+     * @type {number}
+     */
+    carrier_order: number;
+    /**
+     * Mean length (m) of an axis's terminal extension unit, before {@link terminal_length_slope}, per order of the
+     * axis: 11.7 cm at the first order [BB2000 p. 11], shorter by 0.644 an order [BB2000 p. 9].
+     * @type {number[]}
+     */
+    terminal_length: number[];
+    /**
+     * Mean length of a terminal extension unit per metre of the axis's previous unit, per order of the axis: a
+     * terminal unit is `terminal_length + terminal_length_slope * previous unit` long on average. Oak's do not
+     * follow their previous unit.
+     * @type {number[]}
+     */
+    terminal_length_slope: number[];
+    /**
+     * Longest extension unit (m) per order: 30 cm at the first order, falling to 8 cm at the fourth [BB2000 p. 9].
+     * @type {number[]}
+     */
+    max_unit_length: number[];
+    /**
+     * Probability of failure `p` of the negative binomial count of centimetres a unit grows past its first, per
+     * order; orders past the list are Poisson [BB2000 p. 10-11, Fig. 6].
+     * @type {number[]}
+     */
+    length_negative_binomial_p: number[];
+    /**
+     * Mean length (m) of an extension unit, at which a living shoot's yield of new shoots is counted
+     * ({@link shoot_expected_yield}), and against which a shoot's length ranks it for shedding: 5.9 cm on branch o1b1
+     * [BB2000 Table 4], where oak's outgrowth shares were counted.
+     * @type {number}
+     */
+    mean_unit_length: number;
+    /**
+     * Lateral bud zones along an extension unit. Oak's: the pseudo-whorl of "almost always four" subapical buds at
+     * 0.8-0.99 of the unit [BB2000 p. 7, 11, 17], 1.17 of which grow out on branch o1b1 [BB2000 p. 11]; and the
+     * median buds at 0.3-0.55, as many as `l = 0.98 m - 2.70` (cm) gives over all orders [BB2000 Table 5], 0.38 of
+     * whose 8.5 grow out [BB2000 p. 11, Tables 4, 5]. Their laterals average 6.2 and 5.2 cm at the first order
+     * [BB2000 p. 11].
+     * @type {ShootBudZone[]}
+     */
+    zones: ShootBudZone[];
+    /**
+     * Length (m) a short shoot grows a year. Used by zones whose buds grow short shoots.
+     * @type {number}
+     */
+    short_shoot_growth: number;
+    /**
+     * Share of short shoots alive one year that are alive the next. Used by zones whose buds grow short shoots.
+     * @type {number}
+     */
+    short_shoot_survival: number;
+    /**
+     * Angle (radians) between a lateral and its mother shoot, per mother order.
+     * @type {number[]}
+     */
+    insertion_angle: number[];
+    /**
+     * How a mother's buds turn around it, node to node.
+     * @type {PhyllotaxisMode|number}
+     */
+    phyllotaxis_mode: PhyllotaxisMode | number;
+    /**
+     * @param {Partial<ShootSystemRule>} [overrides]
+     * @returns {this}
+     */
+    applyOverrides(overrides?: Partial<ShootSystemRule>): this;
+    /**
+     * @param {ShootSystemRule} other
+     * @returns {this}
+     */
+    copy(other: ShootSystemRule): this;
+    /**
+     * @returns {ShootSystemRule}
+     */
+    clone(): ShootSystemRule;
+    /**
+     * @param {ShootSystemRule} other
+     * @returns {boolean}
+     */
+    equals(other: ShootSystemRule): boolean;
+    /**
+     * @returns {number}
+     */
+    hash(): number;
+    /**
+     * @readonly
+     * @type {boolean}
+     */
+    readonly isShootSystemRule: boolean;
+}
+import { ShootBudZone } from "./ShootBudZone.js";
+import { PhyllotaxisMode } from "./PhyllotaxisMode.js";
+//# sourceMappingURL=ShootSystemRule.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ShootSystemRule.d.ts","sourceRoot":"","sources":["../../../../../src/generation/foliage/config/ShootSystemRule.js"],"names":[],"mappings":"AAoCA;;;;;;;;;;;;;;;;GAgBG;AACH;IAyHI;;;OAGG;IACH,sBAHW,QAAQ,eAAe,CAAC,GACtB,eAAe,CAM3B;IAhID;;;OAGG;IACH,QAFU,MAAM,CAEL;IAEX;;;;OAIG;IACH,QAFU,MAAM,CAEL;IAEX;;;;OAIG;IACH,cAFU,MAAM,CAEC;IAEjB;;;OAGG;IACH,WAFU,MAAM,CAEU;IAE1B;;;;;OAKG;IACH,eAFU,MAAM,CAEE;IAElB;;;;OAIG;IACH,iBAFU,MAAM,EAAE,CAEuB;IAEzC;;;;;OAKG;IACH,uBAFU,MAAM,EAAE,CAEU;IAE5B;;;OAGG;IACH,iBAFU,MAAM,EAAE,CAEsB;IAExC;;;;OAIG;IACH,4BAFU,MAAM,EAAE,CAEwB;IAE1C;;;;;OAKG;IACH,kBAFU,MAAM,CAES;IAEzB;;;;;;;OAOG;IACH,OAFU,YAAY,EAAE,CAkBtB;IAEF;;;OAGG;IACH,oBAFU,MAAM,CAEW;IAE3B;;;OAGG;IACH,sBAFU,MAAM,CAEW;IAE3B;;;OAGG;IACH,iBAFU,MAAM,EAAE,CAEO;IAEzB;;;OAGG;IACH,kBAFU,eAAe,GAAC,MAAM,CAEgB;IAYhD;;;OAGG;IACH,2BAHW,QAAQ,eAAe,CAAC,GACtB,IAAI,CA4BhB;IAED;;;OAGG;IACH,YAHW,eAAe,GACb,IAAI,CAoBhB;IAED;;OAEG;IACH,SAFa,eAAe,CAM3B;IAED;;;OAGG;IACH,cAHW,eAAe,GACb,OAAO,CAuBnB;IAED;;OAEG;IACH,QAFa,MAAM,CAoBlB;IAGL;;;OAGG;IACH,4BAFU,OAAO,CAE0B;CAN1C;6BApS4B,mBAAmB;gCADhB,sBAAsB"}

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

@@ -0,0 +1,316 @@
+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";
+import { PhyllotaxisMode } from "./PhyllotaxisMode.js";
+import { ShootBudZone } from "./ShootBudZone.js";
+
+/**
+ * Factor on oak shoot length per branching order: the longest shoot falls from 30 cm at order 1 to 8 cm at order 4
+ * [BB2000 p. 9], (8 / 30)^(1/3).
+ * @type {number}
+ */
+const OAK_ORDER_LENGTH_RATIO = 0.644;
+
+/**
+ * Highest branching order of the oak's twig system: up to 7 orders were found on a branch [BB2000 p. 15].
+ * @type {number}
+ */
+const OAK_MAX_ORDER = 7;
+
+/**
+ * `value * 0.644^(order - 1 + offset)` for orders 1 to 7: the oak's per-order lengths, which shrink by
+ * {@link OAK_ORDER_LENGTH_RATIO} an order [BB2000 p. 9].
+ * @param {number} value
+ * @param {number} offset
+ * @returns {number[]}
+ */
+function oak_by_order(value, offset) {
+    const out = [];
+    for (let k = 0; k < OAK_MAX_ORDER; k++) {
+        out.push(value * Math.pow(OAK_ORDER_LENGTH_RATIO, k + offset));
+    }
+    return out;
+}
+
+/**
+ * Peripheral shoot system edge of the generator graph: every living branch grown by generator `source` carries a
+ * twig system grown year by year from its own buds, each axis of which is a branch of generator `target` (see
+ * `tree_skeleton_grow_shoots`).
+ *
+ * The model is the oak's [BB2000, BB1998], generalised: each year every living axis grows a terminal extension unit,
+ * and the buds on its units grow into long shoots (the spring after, or the same season), short shoots, or nothing,
+ * by bud zone and branching order. How many seasons, and how many new shoots survive in the light they get, is the
+ * species' `ShootGrowthConfig`. Per-order lists are indexed from order 1 (the carrier is `carrier_order`), and
+ * orders past their end take their last value.
+ *
+ * The defaults are pedunculate and sessile oak, from the peripheral branches of mature crowns measured by
+ * Buck-Sorlin & Bell (2000), Models of crown architecture in Quercus petraea and Q. robur: shoot lengths and bud
+ * numbers, Forestry 73(1): 1-19 [BB2000], and the shoot shedding of a free-standing Q. robur measured by
+ * Buck-Sorlin & Bell (1998), A quantification of shoot shedding in pedunculate oak (Quercus robur L.), Botanical
+ * Journal of the Linnean Society 127: 371-391 [BB1998].
+ */
+export class ShootSystemRule {
+    /**
+     * Carrier branch generator index into `TreeSpeciesConfig.branches`.
+     * @type {number}
+     */
+    source = 2;
+
+    /**
+     * Generator index of the long shoots, which shapes how they look (radial segments, bark, tropisms). Greater than
+     * `source`.
+     * @type {number}
+     */
+    target = 3;
+
+    /**
+     * Generator index of the short shoots, so foliage rules can tell them apart (`FoliageSpawnRule.short_shoot`).
+     * Greater than `source`. Used by zones whose buds grow short shoots.
+     * @type {number}
+     */
+    short_target = 3;
+
+    /**
+     * Highest branching order a shoot may reach within the system [BB2000 p. 15].
+     * @type {number}
+     */
+    max_order = OAK_MAX_ORDER;
+
+    /**
+     * Branching order of the carrier, in the numbering of the rule's per-order lists: where a source counts orders
+     * from the stem, a carrier deep in the framework starts deep in its lists. Oak's are counted from the branch
+     * measured [BB2000 p. 7], so its carriers are order 1.
+     * @type {number}
+     */
+    carrier_order = 1;
+
+    /**
+     * Mean length (m) of an axis's terminal extension unit, before {@link terminal_length_slope}, per order of the
+     * axis: 11.7 cm at the first order [BB2000 p. 11], shorter by 0.644 an order [BB2000 p. 9].
+     * @type {number[]}
+     */
+    terminal_length = oak_by_order(0.117, 0);
+
+    /**
+     * Mean length of a terminal extension unit per metre of the axis's previous unit, per order of the axis: a
+     * terminal unit is `terminal_length + terminal_length_slope * previous unit` long on average. Oak's do not
+     * follow their previous unit.
+     * @type {number[]}
+     */
+    terminal_length_slope = [0];
+
+    /**
+     * Longest extension unit (m) per order: 30 cm at the first order, falling to 8 cm at the fourth [BB2000 p. 9].
+     * @type {number[]}
+     */
+    max_unit_length = oak_by_order(0.30, 0);
+
+    /**
+     * Probability of failure `p` of the negative binomial count of centimetres a unit grows past its first, per
+     * order; orders past the list are Poisson [BB2000 p. 10-11, Fig. 6].
+     * @type {number[]}
+     */
+    length_negative_binomial_p = [0.58, 0.60];
+
+    /**
+     * Mean length (m) of an extension unit, at which a living shoot's yield of new shoots is counted
+     * ({@link shoot_expected_yield}), and against which a shoot's length ranks it for shedding: 5.9 cm on branch o1b1
+     * [BB2000 Table 4], where oak's outgrowth shares were counted.
+     * @type {number}
+     */
+    mean_unit_length = 0.059;
+
+    /**
+     * Lateral bud zones along an extension unit. Oak's: the pseudo-whorl of "almost always four" subapical buds at
+     * 0.8-0.99 of the unit [BB2000 p. 7, 11, 17], 1.17 of which grow out on branch o1b1 [BB2000 p. 11]; and the
+     * median buds at 0.3-0.55, as many as `l = 0.98 m - 2.70` (cm) gives over all orders [BB2000 Table 5], 0.38 of
+     * whose 8.5 grow out [BB2000 p. 11, Tables 4, 5]. Their laterals average 6.2 and 5.2 cm at the first order
+     * [BB2000 p. 11].
+     * @type {ShootBudZone[]}
+     */
+    zones = [
+        ShootBudZone.from({
+            u_min: 0.8,
+            u_max: 0.99,
+            buds: [4],
+            long: [0.29],
+            length: oak_by_order(0.062, 1)
+        }),
+        ShootBudZone.from({
+            u_min: 0.3,
+            u_max: 0.55,
+            buds: [2.70 / 0.98],
+            buds_per_metre: [100 / 0.98],
+            long: [0.045],
+            length: oak_by_order(0.052, 1)
+        })
+    ];
+
+    /**
+     * Length (m) a short shoot grows a year. Used by zones whose buds grow short shoots.
+     * @type {number}
+     */
+    short_shoot_growth = 0.002;
+
+    /**
+     * Share of short shoots alive one year that are alive the next. Used by zones whose buds grow short shoots.
+     * @type {number}
+     */
+    short_shoot_survival = 0.6;
+
+    /**
+     * Angle (radians) between a lateral and its mother shoot, per mother order.
+     * @type {number[]}
+     */
+    insertion_angle = [0.75];
+
+    /**
+     * How a mother's buds turn around it, node to node.
+     * @type {PhyllotaxisMode|number}
+     */
+    phyllotaxis_mode = PhyllotaxisMode.SpiralGolden;
+
+    /**
+     * @param {Partial<ShootSystemRule>} [options]
+     * @returns {ShootSystemRule}
+     */
+    static from(options = {}) {
+        const r = new ShootSystemRule();
+        r.applyOverrides(options);
+        return r;
+    }
+
+    /**
+     * @param {Partial<ShootSystemRule>} [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.short_target !== undefined) this.short_target = overrides.short_target | 0;
+        if (overrides.max_order !== undefined) this.max_order = Math.max(1, overrides.max_order | 0);
+        if (overrides.carrier_order !== undefined) this.carrier_order = Math.max(1, overrides.carrier_order | 0);
+        if (overrides.terminal_length !== undefined) this.terminal_length = list(overrides.terminal_length, 0);
+        if (overrides.terminal_length_slope !== undefined) this.terminal_length_slope = list(overrides.terminal_length_slope, 0);
+        if (overrides.max_unit_length !== undefined) this.max_unit_length = list(overrides.max_unit_length, 0.01);
+        if (overrides.length_negative_binomial_p !== undefined) {
+            assert.isArray(overrides.length_negative_binomial_p, 'length_negative_binomial_p');
+            this.length_negative_binomial_p = overrides.length_negative_binomial_p.map(p => Math.min(0.999, Math.max(0.001, p)));
+        }
+        if (overrides.mean_unit_length !== undefined) this.mean_unit_length = Math.max(1e-3, overrides.mean_unit_length);
+        if (overrides.zones !== undefined) {
+            assert.isArray(overrides.zones, 'zones');
+            this.zones = overrides.zones.map(z => ShootBudZone.from(z));
+        }
+        if (overrides.short_shoot_growth !== undefined) this.short_shoot_growth = Math.max(1e-4, overrides.short_shoot_growth);
+        if (overrides.short_shoot_survival !== undefined) this.short_shoot_survival = Math.min(1, Math.max(0, overrides.short_shoot_survival));
+        if (overrides.insertion_angle !== undefined) this.insertion_angle = list(overrides.insertion_angle, 0);
+        if (overrides.phyllotaxis_mode !== undefined) this.phyllotaxis_mode = overrides.phyllotaxis_mode;
+        return this;
+    }
+
+    /**
+     * @param {ShootSystemRule} other
+     * @returns {this}
+     */
+    copy(other) {
+        assert.defined(other, 'other');
+        this.source = other.source;
+        this.target = other.target;
+        this.short_target = other.short_target;
+        this.max_order = other.max_order;
+        this.carrier_order = other.carrier_order;
+        this.terminal_length = other.terminal_length.slice();
+        this.terminal_length_slope = other.terminal_length_slope.slice();
+        this.max_unit_length = other.max_unit_length.slice();
+        this.length_negative_binomial_p = other.length_negative_binomial_p.slice();
+        this.mean_unit_length = other.mean_unit_length;
+        this.zones = other.zones.map(z => z.clone());
+        this.short_shoot_growth = other.short_shoot_growth;
+        this.short_shoot_survival = other.short_shoot_survival;
+        this.insertion_angle = other.insertion_angle.slice();
+        this.phyllotaxis_mode = other.phyllotaxis_mode;
+        return this;
+    }
+
+    /**
+     * @returns {ShootSystemRule}
+     */
+    clone() {
+        const r = new ShootSystemRule();
+        r.copy(this);
+        return r;
+    }
+
+    /**
+     * @param {ShootSystemRule} other
+     * @returns {boolean}
+     */
+    equals(other) {
+        if (this === other) return true;
+        if (!other || !other.isShootSystemRule) return false;
+        if (this.zones.length !== other.zones.length) return false;
+        for (let i = 0; i < this.zones.length; i++) {
+            if (!this.zones[i].equals(other.zones[i])) return false;
+        }
+        return this.source === other.source
+            && this.target === other.target
+            && this.short_target === other.short_target
+            && this.max_order === other.max_order
+            && this.carrier_order === other.carrier_order
+            && isArrayEqualStrict(this.terminal_length, other.terminal_length)
+            && isArrayEqualStrict(this.terminal_length_slope, other.terminal_length_slope)
+            && isArrayEqualStrict(this.max_unit_length, other.max_unit_length)
+            && isArrayEqualStrict(this.length_negative_binomial_p, other.length_negative_binomial_p)
+            && this.mean_unit_length === other.mean_unit_length
+            && this.short_shoot_growth === other.short_shoot_growth
+            && this.short_shoot_survival === other.short_shoot_survival
+            && isArrayEqualStrict(this.insertion_angle, other.insertion_angle)
+            && this.phyllotaxis_mode === other.phyllotaxis_mode;
+    }
+
+    /**
+     * @returns {number}
+     */
+    hash() {
+        let h = hash_mix2(this.source, this.target);
+        h = hash_mix2(h, this.short_target);
+        h = hash_mix2(h, this.max_order);
+        h = hash_mix2(h, this.carrier_order);
+        h = hash_mix2(h, computeHashFloatArray(this.terminal_length));
+        h = hash_mix2(h, computeHashFloatArray(this.terminal_length_slope));
+        h = hash_mix2(h, computeHashFloatArray(this.max_unit_length));
+        h = hash_mix2(h, computeHashFloatArray(this.length_negative_binomial_p));
+        h = hash_mix2(h, computeHashFloat(this.mean_unit_length));
+        for (let i = 0; i < this.zones.length; i++) {
+            h = hash_mix2(h, this.zones[i].hash());
+        }
+        h = hash_mix2(h, computeHashFloat(this.short_shoot_growth));
+        h = hash_mix2(h, computeHashFloat(this.short_shoot_survival));
+        h = hash_mix2(h, computeHashFloatArray(this.insertion_angle));
+        h = hash_mix2(h, this.phyllotaxis_mode | 0);
+        return h;
+    }
+}
+
+/**
+ * @readonly
+ * @type {boolean}
+ */
+ShootSystemRule.prototype.isShootSystemRule = true;
+
+/**
+ * @param {number[]} values
+ * @param {number} min
+ * @returns {number[]}
+ */
+function 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/TreeLODConfig.d.ts

@@ -50,7 +50,7 @@ export class TreeLODConfig {
      */
     foliage_area_compensation_exponent: number;
     /**
-     * If true, complex cards (`TriStarCluster`, `RibbedFrond`, `OctagonalCutoutHull`) collapse
+     * If true, complex cards (`TriStarCluster`, `RibbedFrond`, `CutoutHull`) collapse
      * to simpler low-triangle `FoldedVCard` or single quad representations.
      * @type {boolean}
      */

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

@@ -50,7 +50,7 @@ export class TreeLODConfig {
     foliage_area_compensation_exponent = 0.42;
 
     /**
-     * If true, complex cards (`TriStarCluster`, `RibbedFrond`, `OctagonalCutoutHull`) collapse
+     * If true, complex cards (`TriStarCluster`, `RibbedFrond`, `CutoutHull`) collapse
      * to simpler low-triangle `FoldedVCard` or single quad representations.
      * @type {boolean}
      */

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

@@ -3,10 +3,15 @@
  */
 export class TreeSpeciesConfig {
     /**
-     * Creates a default 3-level branch hierarchy (trunk, primary boughs, secondary branches).
-     * @returns {BranchLevelConfig[]}
+     * Default trunk -> primary bough -> secondary branch spawning.
+     * @returns {BranchSpawnRule[]}
      */
-    static createDefaultLevels(): BranchLevelConfig[];
+    static createDefaultBranchRules(): BranchSpawnRule[];
+    /**
+     * Default branch generators: trunk, primary boughs, secondary branches.
+     * @returns {BranchGeneratorConfig[]}
+     */
+    static createDefaultBranches(): BranchGeneratorConfig[];
     /**
      * @param {Partial<TreeSpeciesConfig>} [options]
      * @returns {TreeSpeciesConfig}
@@ -33,15 +38,38 @@ export class TreeSpeciesConfig {
      */
     crown: CrownConfig;
     /**
-     * Recursive branch level configurations (`levels[0]` = trunk, `levels[1]` = boughs, etc.).
-     * @type {BranchLevelConfig[]}
+     * Branch generators. `branches[0]` grows the trunk; every other generator grows only where a
+     * `branch_rules` entry targets it.
+     * @type {BranchGeneratorConfig[]}
      */
-    levels: BranchLevelConfig[];
+    branches: BranchGeneratorConfig[];
     /**
-     * Phyllotactic foliage card placement and geometry configuration.
+     * Edges of the generator graph: which generator spawns which, where and how many.
+     * Each rule has `source < target`, so the graph is acyclic and the trunk is its only root.
+     * @type {BranchSpawnRule[]}
+     */
+    branch_rules: BranchSpawnRule[];
+    /**
+     * Leaf card / frond geometry shared by all foliage of the tree.
      * @type {FoliageConfig}
      */
     foliage: FoliageConfig;
+    /**
+     * Which branch generators carry foliage. How densely is derived (`foliage_cards_per_metre`). Empty = a bare tree.
+     * @type {FoliageSpawnRule[]}
+     */
+    foliage_rules: FoliageSpawnRule[];
+    /**
+     * Which branch generators carry a peripheral twig system grown year by year from their buds, and which generator
+     * its shoots are (`tree_skeleton_grow_shoots`). Empty = none.
+     * @type {ShootSystemRule[]}
+     */
+    shoot_rules: ShootSystemRule[];
+    /**
+     * How the twig systems of `shoot_rules` grow together: seasons, and vigour in the light they make for each other.
+     * @type {ShootGrowthConfig}
+     */
+    shoot_growth: ShootGrowthConfig;
     /**
      * Procedural bark PBR material configuration.
      * @type {BarkMaterialConfig}
@@ -100,8 +128,12 @@ export class TreeSpeciesConfig {
 }
 import { TreePreset } from "./TreePreset.js";
 import { CrownConfig } from "./CrownConfig.js";
-import { BranchLevelConfig } from "./BranchLevelConfig.js";
+import { BranchGeneratorConfig } from "./BranchGeneratorConfig.js";
+import { BranchSpawnRule } from "./BranchSpawnRule.js";
 import { FoliageConfig } from "./FoliageConfig.js";
+import { FoliageSpawnRule } from "./FoliageSpawnRule.js";
+import { ShootSystemRule } from "./ShootSystemRule.js";
+import { ShootGrowthConfig } from "./ShootGrowthConfig.js";
 import { BarkMaterialConfig } from "./BarkMaterialConfig.js";
 import { FoliageMaterialConfig } from "./FoliageMaterialConfig.js";
 import { TreeWindConfig } from "./TreeWindConfig.js";

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

@@ -1 +1 @@
-{"version":3,"file":"TreeSpeciesConfig.d.ts","sourceRoot":"","sources":["../../../../../src/generation/foliage/config/TreeSpeciesConfig.js"],"names":[],"mappings":"AAaA;;GAEG;AACH;IAyEI;;;OAGG;IACH,8BAFa,iBAAiB,EAAE,CA2H/B;IAED;;;OAGG;IACH,sBAHW,QAAQ,iBAAiB,CAAC,GACxB,iBAAiB,CAS7B;IAlND;;;OAGG;IACH,MAFU,MAAM,CAEH;IAEb;;;OAGG;IACH,QAFU,UAAU,GAAC,MAAM,CAEH;IAExB;;;OAGG;IACH,MAFU,MAAM,CAEJ;IAEZ;;;OAGG;IACH,OAFU,WAAW,CAEK;IAE1B;;;OAGG;IACH,QAFU,iBAAiB,EAAE,CAEjB;IAEZ;;;OAGG;IACH,SAFU,aAAa,CAEO;IAE9B;;;OAGG;IACH,eAFU,kBAAkB,CAEa;IAEzC;;;OAGG;IACH,kBAFU,qBAAqB,CAEgB;IAE/C;;;OAGG;IACH,MAFU,cAAc,CAEI;IAE5B;;;OAGG;IACH,MAFU,aAAa,EAAE,CAEf;IAEV;;;;OAIG;IACH,aAFU,MAAM,UAAU,MAAM,CAAC,CAAC,cAAU,IAAI,CAE7B;IAmJnB;;;;OAIG;IACH,iCAFa,IAAI,CAuDhB;IAED;;;OAGG;IACH,YAHW,iBAAiB,GACf,IAAI,CAkBhB;IAED;;OAEG;IACH,SAFa,iBAAiB,CAM7B;IAED;;;OAGG;IACH,cAHW,iBAAiB,GACf,OAAO,CA0CnB;IAED;;OAEG;IACH,QAFa,MAAM,CAyBlB;IAGL;;;OAGG;IACH,8BAFU,OAAO,CAE8B;CAN9C;2BA/X0B,iBAAiB;4BAJhB,kBAAkB;kCADZ,wBAAwB;8BAE5B,oBAAoB;mCAHf,yBAAyB;sCAItB,4BAA4B;+BAGnC,qBAAqB;8BAFtB,oBAAoB"}
+{"version":3,"file":"TreeSpeciesConfig.d.ts","sourceRoot":"","sources":["../../../../../src/generation/foliage/config/TreeSpeciesConfig.js"],"names":[],"mappings":"AAiBA;;GAEG;AACH;IAsGI;;;OAGG;IACH,mCAFa,eAAe,EAAE,CAwB7B;IAED;;;OAGG;IACH,gCAFa,qBAAqB,EAAE,CAmGnC;IAED;;;OAGG;IACH,sBAHW,QAAQ,iBAAiB,CAAC,GACxB,iBAAiB,CAS7B;IAnPD;;;OAGG;IACH,MAFU,MAAM,CAEH;IAEb;;;OAGG;IACH,QAFU,UAAU,GAAC,MAAM,CAEH;IAExB;;;OAGG;IACH,MAFU,MAAM,CAEJ;IAEZ;;;OAGG;IACH,OAFU,WAAW,CAEK;IAE1B;;;;OAIG;IACH,UAFU,qBAAqB,EAAE,CAEnB;IAEd;;;;OAIG;IACH,cAFU,eAAe,EAAE,CAET;IAElB;;;OAGG;IACH,SAFU,aAAa,CAEO;IAE9B;;;OAGG;IACH,eAFU,gBAAgB,EAAE,CAET;IAEnB;;;;OAIG;IACH,aAFU,eAAe,EAAE,CAEV;IAEjB;;;OAGG;IACH,cAFU,iBAAiB,CAEY;IAEvC;;;OAGG;IACH,eAFU,kBAAkB,CAEa;IAEzC;;;OAGG;IACH,kBAFU,qBAAqB,CAEgB;IAE/C;;;OAGG;IACH,MAFU,cAAc,CAEI;IAE5B;;;OAGG;IACH,MAFU,aAAa,EAAE,CAEf;IAEV;;;;OAIG;IACH,aAFU,MAAM,UAAU,MAAM,CAAC,CAAC,cAAU,IAAI,CAE7B;IAyJnB;;;;OAIG;IACH,iCAFa,IAAI,CA6ChB;IAED;;;OAGG;IACH,YAHW,iBAAiB,GACf,IAAI,CAsBhB;IAED;;OAEG;IACH,SAFa,iBAAiB,CAM7B;IAED;;;OAGG;IACH,cAHW,iBAAiB,GACf,OAAO,CAyDnB;IAED;;OAEG;IACH,QAFa,MAAM,CAmClB;IAGL;;;OAGG;IACH,8BAFU,OAAO,CAE8B;CAN9C;2BAnb0B,iBAAiB;4BAPhB,kBAAkB;sCAFR,4BAA4B;gCAClC,sBAAsB;8BAExB,oBAAoB;iCAEjB,uBAAuB;gCAExB,sBAAsB;kCADpB,wBAAwB;mCAPvB,yBAAyB;sCAKtB,4BAA4B;+BAMnC,qBAAqB;8BAFtB,oBAAoB"}